madmin

package
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 20, 2020 License: Apache-2.0 Imports: 37 Imported by: 0

README

Golang Admin Client API Reference Slack

The MinIO Admin Golang Client SDK provides APIs to manage MinIO services.

This quickstart guide will show you how to install the MinIO Admin client SDK, connect to MinIO admin service, and provide a walkthrough of a simple file uploader.

This document assumes that you have a working Golang setup.

Initialize MinIO Admin Client object.

MinIO


package main

import (
    "fmt"

    "github.com/RTradeLtd/s3x/pkg/madmin"
)

func main() {
    // Use a secure connection.
    ssl := true

    // Initialize minio client object.
    mdmClnt, err := madmin.New("your-minio.example.com:9000", "YOUR-ACCESSKEYID", "YOUR-SECRETKEY", ssl)
    if err != nil {
        fmt.Println(err)
        return
    }

    // Fetch service status.
    st, err := mdmClnt.ServerInfo()
    if err != nil {
        fmt.Println(err)
        return
    }
	for _, peerInfo := range serversInfo {
		log.Printf("Node: %s, Info: %v\n", peerInfo.Addr, peerInfo.Data)
	}
}
Service operations Info operations Healing operations Config operations Top operations IAM operations Misc KMS
ServiceRestart ServerInfo Heal GetConfig TopLocks AddUser GetKeyStatus
ServiceStop ServerCPULoadInfo SetConfig SetUserPolicy StartProfiling
ServerMemUsageInfo ListUsers DownloadProfilingData
ServiceTrace ServerDrivesPerfInfo AddCannedPolicy ServerUpdate
NetPerfInfo
ServerCPUHardwareInfo
ServerNetworkHardwareInfo
StorageInfo

1. Constructor

New(endpoint string, accessKeyID string, secretAccessKey string, ssl bool) (*AdminClient, error)

Initializes a new admin client object.

Parameters

Param Type Description
endpoint string MinIO endpoint.
accessKeyID string Access key for the object storage endpoint.
secretAccessKey string Secret key for the object storage endpoint.
ssl bool Set this value to 'true' to enable secure (HTTPS) access.

2. Service operations

ServiceStatus() (ServiceStatusMetadata, error)

Fetch service status, replies disk space used, backend type and total disks offline/online (applicable in distributed mode).

Param Type Description
serviceStatus ServiceStatusMetadata Represents current server status info in following format:
Param Type Description
st.ServerVersion.Version string Server version.
st.ServerVersion.CommitID string Server commit id.
st.Uptime time.Duration Server uptime duration in seconds.

Example


   st, err := madmClnt.ServiceStatus()
   if err != nil {
   	log.Fatalln(err)
   }
   log.Printf("%#v\n", st)

ServiceRestart() error

Sends a service action restart command to MinIO server.

Example

   // To restart the service, restarts all servers in the cluster.
   err := madmClnt.ServiceRestart()
   if err != nil {
       log.Fatalln(err)
   }
   log.Println("Success")

ServiceStop() error

Sends a service action stop command to MinIO server.

Example

   // To stop the service, stops all servers in the cluster.
   err := madmClnt.ServiceStop()
   if err != nil {
       log.Fatalln(err)
   }
   log.Println("Success")

ServiceTrace(allTrace bool, doneCh <-chan struct{}) <-chan TraceInfo

Enable HTTP request tracing on all nodes in a MinIO cluster

Example

    doneCh := make(chan struct{})
    defer close(doneCh)
    // listen to all trace including internal API calls
    allTrace := true
    // Start listening on all trace activity.
    traceCh := madmClnt.ServiceTrace(allTrace, doneCh)
    for traceInfo := range traceCh {
        fmt.Println(traceInfo.String())
    }

3. Info operations

ServerInfo() ([]ServerInfo, error)

Fetches information for all cluster nodes, such as server properties, storage information, network statistics, etc.

Param Type Description
si.Addr string Address of the server the following information is retrieved from.
si.ConnStats ServerConnStats Connection statistics from the given server.
si.HTTPStats ServerHTTPStats HTTP connection statistics from the given server.
si.Properties ServerProperties Server properties such as region, notification targets.
Param Type Description
ServerProperties.Uptime time.Duration Total duration in seconds since server is running.
ServerProperties.Version string Current server version.
ServerProperties.CommitID string Current server commitID.
ServerProperties.Region string Configured server region.
ServerProperties.SQSARN []string List of notification target ARNs.
Param Type Description
ServerConnStats.TotalInputBytes uint64 Total bytes received by the server.
ServerConnStats.TotalOutputBytes uint64 Total bytes sent by the server.
Param Type Description
ServerHTTPStats.TotalHEADStats ServerHTTPMethodStats Total statistics regarding HEAD operations
ServerHTTPStats.SuccessHEADStats ServerHTTPMethodStats Total statistics regarding successful HEAD operations
ServerHTTPStats.TotalGETStats ServerHTTPMethodStats Total statistics regarding GET operations
ServerHTTPStats.SuccessGETStats ServerHTTPMethodStats Total statistics regarding successful GET operations
ServerHTTPStats.TotalPUTStats ServerHTTPMethodStats Total statistics regarding PUT operations
ServerHTTPStats.SuccessPUTStats ServerHTTPMethodStats Total statistics regarding successful PUT operations
ServerHTTPStats.TotalPOSTStats ServerHTTPMethodStats Total statistics regarding POST operations
ServerHTTPStats.SuccessPOSTStats ServerHTTPMethodStats Total statistics regarding successful POST operations
ServerHTTPStats.TotalDELETEStats ServerHTTPMethodStats Total statistics regarding DELETE operations
ServerHTTPStats.SuccessDELETEStats ServerHTTPMethodStats Total statistics regarding successful DELETE operations
Param Type Description
ServerHTTPMethodStats.Count uint64 Total number of operations.
ServerHTTPMethodStats.AvgDuration string Average duration of Count number of operations.
Param Type Description
DriveInfo.UUID string Unique ID for each disk provisioned by server format.
DriveInfo.Endpoint string Endpoint location of the remote/local disk.
DriveInfo.State string Current state of the disk at endpoint.

Example


   serversInfo, err := madmClnt.ServerInfo()
   if err != nil {
   	log.Fatalln(err)
   }

   for _, peerInfo := range serversInfo {
   	log.Printf("Node: %s, Info: %v\n", peerInfo.Addr, peerInfo.Data)
   }

ServerDrivesPerfInfo() ([]ServerDrivesPerfInfo, error)

Fetches drive performance information for all cluster nodes.

Param Type Description
di.Addr string Address of the server the following information is retrieved from.
di.Error string Errors (if any) encountered while reaching this node
di.DrivesPerf disk.Performance Path of the drive mount on above server and read, write speed.
Param Type Description
disk.Performance.Path string Path of drive mount.
disk.Performance.Error string Error (if any) encountered while accessing this drive.
disk.Performance.WriteSpeed float64 Write speed on above path in Bytes/s.
disk.Performance.ReadSpeed float64 Read speed on above path in Bytes/s.

ServerCPULoadInfo() ([]ServerCPULoadInfo, error)

Fetches CPU utilization for all cluster nodes.

Param Type Description
cpui.Addr string Address of the server the following information is retrieved from.
cpui.Error string Errors (if any) encountered while reaching this node
cpui.CPULoad cpu.Load The load on the CPU.
Param Type Description
cpu.Load.Avg float64 The average utilization of the CPU measured in a 200ms interval
cpu.Load.Min float64 The minimum utilization of the CPU measured in a 200ms interval
cpu.Load.Max float64 The maximum utilization of the CPU measured in a 200ms interval
cpu.Load.Error string Error (if any) encountered while accessing the CPU info

ServerMemUsageInfo() ([]ServerMemUsageInfo, error)

Fetches Mem utilization for all cluster nodes.

Param Type Description
memi.Addr string Address of the server the following information is retrieved from.
memi.Error string Errors (if any) encountered while reaching this node
memi.MemUsage mem.Usage The utilitzation of Memory
Param Type Description
mem.Usage.Mem uint64 The total number of bytes obtained from the OS
mem.Usage.Error string Error (if any) encountered while accessing the CPU info

NetPerfInfo(int size) (map[string][]NetPerfInfo, error)

Fetches network performance of all cluster nodes using given sized payload. Returned value is a map containing each node indexed list of performance of other nodes.

Param Type Description
Addr string Address of the server the following information is retrieved from.
Error string Errors (if any) encountered while reaching this node
ReadThroughput uint64 Network read throughput of the server in bytes per second

ServerCPUHardwareInfo() ([]ServerCPUHardwareInfo, error)

Fetches hardware information of CPU.

Param Type Description
hwi.Addr string Address of the server the following information is retrieved from.
hwi.Error string Errors (if any) encountered while reaching this node
hwi.CPUInfo []cpu.InfoStat The CPU hardware info.
Param Type Description
CPUInfo.CPU int32 CPU
CPUInfo.VendorID string Vendor Id
CPUInfo.Family string CPU Family
CPUInfo.Model string Model
CPUInfo.Stepping int32 Stepping
CPUInfo.PhysicalId string Physical Id
CPUInfo.CoreId string Core Id
CPUInfo.Cores int32 Cores
CPUInfo.ModelName string Model Name
CPUInfo.Mhz float64 Mhz
CPUInfo.CacheZSize int32 cache sizes
CPUInfo.Flags []string Flags
CPUInfo.Microcode string Micro codes

ServerNetworkHardwareInfo() ([]ServerNetworkHardwareInfo, error)

Fetches hardware information of CPU.

Param Type Description
hwi.Addr string Address of the server the following information is retrieved from.
hwi.Error string Errors (if any) encountered while reaching this node
hwi.NetworkInfo []net.Interface The network hardware info
Param Type Description
NetworkInfo.Index int32 positive integer that starts at one, zero is never used.
NetworkInfo.MTU int32 maximum transmission unit
NetworkInfo.Name string e.g., "en0", "lo0", "eth0.100"
NetworkInfo.HardwareAddr []byte IEEE MAC-48, EUI-48 and EUI-64 form
NetworkInfo.Flags uint32 e.g., FlagUp, FlagLoopback, FlagMulticast

StorageInfo() (StorageInfo, error)

Fetches Storage information for all cluster nodes.

Param Type Description
storageInfo.Used []int64 Used disk spaces.
storageInfo.Total []int64 Total disk spaces.
storageInfo.Available []int64 Available disk spaces.
StorageInfo.Backend struct{} Represents backend type embedded structure.
Param Type Description
Backend.Type BackendType Type of backend used by the server currently only FS or Erasure.
Backend.OnlineDisks BackendDisks Total number of disks online per node (only applies to Erasure backend) represented in map[string]int, is empty for FS.
Backend.OfflineDisks BackendDisks Total number of disks offline per node (only applies to Erasure backend) represented in map[string]int, is empty for FS.
Backend.StandardSCData int Data disks set for standard storage class, is empty for FS.
Backend.StandardSCParity int Parity disks set for standard storage class, is empty for FS.
Backend.RRSCData int Data disks set for reduced redundancy storage class, is empty for FS.
Backend.RRSCParity int Parity disks set for reduced redundancy storage class, is empty for FS.
Backend.Sets [][]DriveInfo Represents topology of drives in erasure coded sets.

Example


   storageInfo, err := madmClnt.StorageInfo()
   if err != nil {
   	log.Fatalln(err)
   }

   log.Println(storageInfo)

5. Heal operations

Heal(bucket, prefix string, healOpts HealOpts, clientToken string, forceStart bool, forceStop bool) (start HealStartSuccess, status HealTaskStatus, err error)

Start a heal sequence that scans data under given (possible empty) bucket and prefix. The recursive bool turns on recursive traversal under the given path. dryRun does not mutate on-disk data, but performs data validation.

Two heal sequences on overlapping paths may not be initiated.

The progress of a heal should be followed using the same API Heal by providing the clientToken previously obtained from a Heal API. The server accumulates results of the heal traversal and waits for the client to receive and acknowledge them using the status request by providing clientToken.

Example


    opts := madmin.HealOpts{
            Recursive: true,
            DryRun:    false,
    }
    forceStart := false
    forceStop := false
    healPath, err := madmClnt.Heal("", "", opts, "", forceStart, forceStop)
    if err != nil {
        log.Fatalln(err)
    }
    log.Printf("Heal sequence started at %s", healPath)
HealStartSuccess structure
Param Type Description
s.ClientToken string A unique token for a successfully started heal operation, this token is used to request realtime progress of the heal operation.
s.ClientAddress string Address of the client which initiated the heal operation, the client address has the form "host:port".
s.StartTime time.Time Time when heal was initially started.
HealTaskStatus structure
Param Type Description
s.Summary string Short status of heal sequence
s.FailureDetail string Error message in case of heal sequence failure
s.HealSettings HealOpts Contains the booleans set in the HealStart call
s.Items []HealResultItem Heal records for actions performed by server
HealResultItem structure
Param Type Description
ResultIndex int64 Index of the heal-result record
Type HealItemType Represents kind of heal operation in the heal record
Bucket string Bucket name
Object string Object name
Detail string Details about heal operation
DiskInfo.AvailableOn []int List of disks on which the healed entity is present and healthy
DiskInfo.HealedOn []int List of disks on which the healed entity was restored

6. Config operations

GetConfig() ([]byte, error)

Get current config.json of a MinIO server.

Example

    configBytes, err := madmClnt.GetConfig()
    if err != nil {
        log.Fatalf("failed due to: %v", err)
    }

    // Pretty-print config received as json.
    var buf bytes.Buffer
    err = json.Indent(buf, configBytes, "", "\t")
    if err != nil {
        log.Fatalf("failed due to: %v", err)
    }

    log.Println("config received successfully: ", string(buf.Bytes()))

SetConfig(config io.Reader) error

Set a new config.json for a MinIO server.

Example

    config := bytes.NewReader([]byte(`config.json contents go here`))
    if err := madmClnt.SetConfig(config); err != nil {
        log.Fatalf("failed due to: %v", err)
    }
    log.Println("SetConfig was successful")

7. Top operations

TopLocks() (LockEntries, error)

Get the oldest locks from MinIO server.

Example

    locks, err := madmClnt.TopLocks()
    if err != nil {
        log.Fatalf("failed due to: %v", err)
    }

    out, err := json.Marshal(locks)
    if err != nil {
        log.Fatalf("Marshal failed due to: %v", err)
    }

    log.Println("TopLocks received successfully: ", string(out))

8. IAM operations

AddCannedPolicy(policyName string, policy string) error

Create a new canned policy on MinIO server.

Example

	policy := `{"Version": "2012-10-17","Statement": [{"Action": ["s3:GetObject"],"Effect": "Allow","Resource": ["arn:aws:s3:::my-bucketname/*"],"Sid": ""}]}`

    if err = madmClnt.AddCannedPolicy("get-only", policy); err != nil {
		log.Fatalln(err)
	}

AddUser(user string, secret string) error

Add a new user on a MinIO server.

Example

	if err = madmClnt.AddUser("newuser", "newstrongpassword"); err != nil {
		log.Fatalln(err)
	}

SetUserPolicy(user string, policyName string) error

Enable a canned policy get-only for a given user on MinIO server.

Example

	if err = madmClnt.SetUserPolicy("newuser", "get-only"); err != nil {
		log.Fatalln(err)
	}

ListUsers() (map[string]UserInfo, error)

Lists all users on MinIO server.

Example

	users, err := madmClnt.ListUsers();
    if err != nil {
		log.Fatalln(err)
	}
    for k, v := range users {
        fmt.Printf("User %s Status %s\n", k, v.Status)
    }

9. Misc operations

ServerUpdate(updateURL string) (ServerUpdateStatus, error)

Sends a update command to MinIO server, to update MinIO server to latest release. In distributed setup it updates all servers atomically.

Example

   // Updates all servers and restarts all the servers in the cluster.
   // optionally takes an updateURL, which is used to update the binary.
   us, err := madmClnt.ServerUpdate(updateURL)
   if err != nil {
       log.Fatalln(err)
   }
   if us.CurrentVersion != us.UpdatedVersion {
       log.Printf("Updated server version from %s to %s successfully", us.CurrentVersion, us.UpdatedVersion)
   }

StartProfiling(profiler string) error

Ask all nodes to start profiling using the specified profiler mode

Example

    startProfilingResults, err = madmClnt.StartProfiling("cpu")
    if err != nil {
            log.Fatalln(err)
    }
    for _, result := range startProfilingResults {
        if !result.Success {
            log.Printf("Unable to start profiling on node `%s`, reason = `%s`\n", result.NodeName, result.Error)
        } else {
            log.Printf("Profiling successfully started on node `%s`\n", result.NodeName)
        }
    }

DownloadProfilingData() ([]byte, error)

Download profiling data of all nodes in a zip format.

Example

    profilingData, err := madmClnt.DownloadProfilingData()
    if err != nil {
            log.Fatalln(err)
    }

    profilingFile, err := os.Create("/tmp/profiling-data.zip")
    if err != nil {
            log.Fatal(err)
    }

    if _, err := io.Copy(profilingFile, profilingData); err != nil {
            log.Fatal(err)
    }

    if err := profilingFile.Close(); err != nil {
            log.Fatal(err)
    }

    if err := profilingData.Close(); err != nil {
            log.Fatal(err)
    }

    log.Println("Profiling data successfully downloaded.")

11. KMS

GetKeyStatus(keyID string) (*KMSKeyStatus, error)

Requests status information about one particular KMS master key from a MinIO server. The keyID is optional and the server will use the default master key (configured via MINIO_KMS_VAULT_KEY_NAME or MINIO_KMS_MASTER_KEY) if the keyID is empty.

Example

    keyInfo, err := madmClnt.GetKeyStatus("my-minio-key")
    if err != nil {
       log.Fatalln(err)
    }
    if keyInfo.EncryptionErr != "" {
       log.Fatalf("Failed to perform encryption operation using '%s': %v\n", keyInfo.KeyID, keyInfo.EncryptionErr)
    }
    if keyInfo.UpdateErr != "" {
       log.Fatalf("Failed to perform key re-wrap operation using '%s': %v\n", keyInfo.KeyID, keyInfo.UpdateErr)
    }
    if keyInfo.DecryptionErr != "" {
       log.Fatalf("Failed to perform decryption operation using '%s': %v\n", keyInfo.KeyID, keyInfo.DecryptionErr)
    }

Documentation

Index

Constants

View Source 
const (
	HealItemMetadata       HealItemType = "metadata"
	HealItemBucket                      = "bucket"
	HealItemBucketMetadata              = "bucket-metadata"
	HealItemObject                      = "object"
)

HealItemType constants

View Source 
const (
	DriveStateOk      string = "ok"
	DriveStateOffline        = "offline"
	DriveStateCorrupt        = "corrupt"
	DriveStateMissing        = "missing"
)

Drive state constants

View Source 
const (
	// DefaultNetPerfSize - default payload size used for network performance.
	DefaultNetPerfSize = 100 * humanize.MiByte
	// DefaultDrivePerfSize - default file size for testing drive performance
	DefaultDrivePerfSize = 100 * humanize.MiByte
)
View Source 
const (
	// FsType - Backend is FS Type
	FsType = backendType("FS")
	// ErasureType - Backend is Erasure type
	ErasureType = backendType("Erasure")
)
View Source 
const (
	EnableKey  = "enable"
	CommentKey = "comment"

	// Enable values
	EnableOn  = "on"
	EnableOff = "off"
)

Standard config keys and values.

View Source 
const (
	SubSystemSeparator = `:`
	KvSeparator        = `=`
	KvComment          = `#`
	KvSpaceSeparator   = ` `
	KvNewline          = "\n"
	KvDoubleQuote      = `"`
	KvSingleQuote      = `'`

	Default = `_`
)

Constant separators

View Source 
const (
	// AdminAPIVersion - admin api version used in the request.
	AdminAPIVersion = "v2"
)
View Source 
const DefaultRetryCap = time.Second * 30

DefaultRetryCap - Each retry attempt never waits no longer than this maximum time duration.

View Source 
const DefaultRetryUnit = time.Second

DefaultRetryUnit - default unit multiplicative per retry. defaults to 1 second.

View Source 
const MaxJitter = 1.0

MaxJitter will randomize over the full exponential backoff time

View Source 
const NoJitter = 0.0

NoJitter disables the use of jitter for randomizing the exponential backoff time

Variables

View Source 
var ErrMaliciousData = sio.NotAuthentic

ErrMaliciousData indicates that the stream cannot be decrypted by provided credentials.

View Source 
var MaxRetry = 10

MaxRetry is the maximum number of retries before stopping.

View Source 
var ObjectsHistogramIntervals = []objectHistogramInterval{
	{"LESS_THAN_1024_B", -1, 1024 - 1},
	{"BETWEEN_1024_B_AND_1_MB", 1024, 1024*1024 - 1},
	{"BETWEEN_1_MB_AND_10_MB", 1024 * 1024, 1024*1024*10 - 1},
	{"BETWEEN_10_MB_AND_64_MB", 1024 * 1024 * 10, 1024*1024*64 - 1},
	{"BETWEEN_64_MB_AND_128_MB", 1024 * 1024 * 64, 1024*1024*128 - 1},
	{"BETWEEN_128_MB_AND_512_MB", 1024 * 1024 * 128, 1024*1024*512 - 1},
	{"GREATER_THAN_512_MB", 1024 * 1024 * 512, math.MaxInt64},
}

ObjectsHistogramIntervals contains the list of intervals of an histogram analysis of objects sizes.

Functions

func DecryptData 

func DecryptData(password string, data io.Reader) ([]byte, error)

DecryptData decrypts the data with the key derived from the salt (part of data) and the password using the PBKDF used in EncryptData. DecryptData returns the decrypted plaintext on success.

The data must be a valid ciphertext produced by EncryptData. Otherwise, the decryption will fail.

func EncryptData 

func EncryptData(password string, data []byte) ([]byte, error)

EncryptData encrypts the data with an unique key derived from password using the Argon2id PBKDF.

The returned ciphertext data consists of: 

salt | AEAD ID | nonce | encrypted data
 32      1         8      ~ len(data)

func ErrInvalidArgument 

func ErrInvalidArgument(message string) error

ErrInvalidArgument - Invalid argument response.

func HasSpace 

func HasSpace(s string) bool

HasSpace - returns if given string has space.

func SanitizeValue 

func SanitizeValue(v string) string

SanitizeValue - this function is needed, to trim off single or double quotes, creeping into the values.

Types

type AccountAccess added in v0.0.3 

type AccountAccess struct {
	AccountName string `json:"accountName"`
	Read        bool   `json:"read"`
	Write       bool   `json:"write"`
	Custom      bool   `json:"custom"`
}

AccountAccess contains information about

type AccountStatus 

type AccountStatus string

AccountStatus - account status. 

const (
	AccountEnabled  AccountStatus = "enabled"
	AccountDisabled AccountStatus = "disabled"
)

Account status per user.

type AddServiceAccountReq added in v0.0.5 

type AddServiceAccountReq struct {
	Parent string `json:"parent"`
	Policy string `json:"policy"`
}

AddServiceAccountReq is the request body of the add service account admin call

type AddServiceAccountResp added in v0.0.5 

type AddServiceAccountResp struct {
	Credentials auth.Credentials `json:"credentials"`
}

AddServiceAccountResp is the response body of the add service account admin call

type AdminClient 

type AdminClient struct {
	// contains filtered or unexported fields
}

AdminClient implements Amazon S3 compatible methods.

func New 

func New(endpoint string, accessKeyID, secretAccessKey string, secure bool) (*AdminClient, error)

New - instantiate minio client Client, adds automatic verification of signature.

func (*AdminClient) AccountingUsageInfo added in v0.0.3 

func (adm *AdminClient) AccountingUsageInfo() (map[string]BucketAccountingUsage, error)

AccountingUsageInfo returns the accounting usage info, currently it returns the type of access of different accounts to the different buckets.

func (*AdminClient) AddCannedPolicy 

func (adm *AdminClient) AddCannedPolicy(policyName, policy string) error

AddCannedPolicy - adds a policy for a canned.

func (*AdminClient) AddServiceAccount added in v0.0.5 

func (adm *AdminClient) AddServiceAccount(parentUser string, policy string) (auth.Credentials, error)

AddServiceAccount - creates a new service account belonging to the given parent user while restricting the service account permission by the given policy document.

func (*AdminClient) AddUser 

func (adm *AdminClient) AddUser(accessKey, secretKey string) error

AddUser - adds a user.

func (*AdminClient) BackgroundHealStatus 

func (adm *AdminClient) BackgroundHealStatus() (BgHealState, error)

BackgroundHealStatus returns the background heal status of the current server or cluster.

func (*AdminClient) ClearConfigHistoryKV 

func (adm *AdminClient) ClearConfigHistoryKV(restoreID string) (err error)

ClearConfigHistoryKV - clears the config entry represented by restoreID. optionally allows setting `all` as a special keyword to automatically erase all config set history entires.

func (*AdminClient) DataUsageInfo 

func (adm *AdminClient) DataUsageInfo() (DataUsageInfo, error)

DataUsageInfo - returns data usage of the current object API

func (*AdminClient) DelConfigKV 

func (adm *AdminClient) DelConfigKV(k string) (err error)

DelConfigKV - delete key from server config.

func (*AdminClient) DownloadProfilingData 

func (adm *AdminClient) DownloadProfilingData() (io.ReadCloser, error)

DownloadProfilingData makes an admin call to download profiling data of a standalone server or of the whole cluster in case of a distributed setup.

func (*AdminClient) GetConfig 

func (adm *AdminClient) GetConfig() ([]byte, error)

GetConfig - returns the config.json of a minio setup, incoming data is encrypted.

func (*AdminClient) GetConfigKV 

func (adm *AdminClient) GetConfigKV(key string) (Targets, error)

GetConfigKV - returns the key, value of the requested key, incoming data is encrypted.

func (*AdminClient) GetGroupDescription 

func (adm *AdminClient) GetGroupDescription(group string) (*GroupDesc, error)

GetGroupDescription - fetches information on a group.

func (*AdminClient) GetKeyStatus 

func (adm *AdminClient) GetKeyStatus(keyID string) (*KMSKeyStatus, error)

GetKeyStatus requests status information about the key referenced by keyID from the KMS connected to a MinIO by performing a Admin-API request. It basically hits the `/minio/admin/v2/kms/key/status` API endpoint.

func (AdminClient) GetLogs 

func (adm AdminClient) GetLogs(node string, lineCnt int, logKind string, doneCh <-chan struct{}) <-chan LogInfo

GetLogs - listen on console log messages.

func (*AdminClient) GetServiceAccount added in v0.0.5 

func (adm *AdminClient) GetServiceAccount(serviceAccountAccessKey string) (auth.Credentials, error)

GetServiceAccount returns the credential of the service account

func (*AdminClient) GetUserInfo 

func (adm *AdminClient) GetUserInfo(name string) (u UserInfo, err error)

GetUserInfo - get info on a user

func (*AdminClient) Heal 

func (adm *AdminClient) Heal(bucket, prefix string, healOpts HealOpts,
	clientToken string, forceStart, forceStop bool) (
	healStart HealStartSuccess, healTaskStatus HealTaskStatus, err error)

Heal - API endpoint to start heal and to fetch status forceStart and forceStop are mutually exclusive, you can either set one of them to 'true'. If both are set 'forceStart' will be honored.

func (*AdminClient) HelpConfigKV 

func (adm *AdminClient) HelpConfigKV(subSys, key string, envOnly bool) (Help, error)

HelpConfigKV - return help for a given sub-system.

func (*AdminClient) InfoCannedPolicy 

func (adm *AdminClient) InfoCannedPolicy(policyName string) ([]byte, error)

InfoCannedPolicy - expand canned policy into JSON structure.

func (*AdminClient) ListCannedPolicies 

func (adm *AdminClient) ListCannedPolicies() (map[string][]byte, error)

ListCannedPolicies - list all configured canned policies.

func (*AdminClient) ListConfigHistoryKV 

func (adm *AdminClient) ListConfigHistoryKV(count int) ([]ConfigHistoryEntry, error)

ListConfigHistoryKV - lists a slice of ConfigHistoryEntries sorted by createTime.

func (*AdminClient) ListGroups 

func (adm *AdminClient) ListGroups() ([]string, error)

ListGroups - lists all groups names present on the server.

func (*AdminClient) ListUsers 

func (adm *AdminClient) ListUsers() (map[string]UserInfo, error)

ListUsers - list all users.

func (*AdminClient) NetPerfInfo 

func (adm *AdminClient) NetPerfInfo(size int) (map[string][]NetPerfInfo, error)

NetPerfInfo - Returns network performance information of all cluster nodes.

func (*AdminClient) RemoveCannedPolicy 

func (adm *AdminClient) RemoveCannedPolicy(policyName string) error

RemoveCannedPolicy - remove a policy for a canned.

func (*AdminClient) RemoveUser 

func (adm *AdminClient) RemoveUser(accessKey string) error

RemoveUser - remove a user.

func (*AdminClient) RestoreConfigHistoryKV 

func (adm *AdminClient) RestoreConfigHistoryKV(restoreID string) (err error)

RestoreConfigHistoryKV - Restore a previous config set history. Input is a unique id which represents the previous setting.

func (*AdminClient) ServerCPUHardwareInfo 

func (adm *AdminClient) ServerCPUHardwareInfo() ([]ServerCPUHardwareInfo, error)

ServerCPUHardwareInfo - Returns cpu hardware information

func (*AdminClient) ServerCPULoadInfo 

func (adm *AdminClient) ServerCPULoadInfo() ([]ServerCPULoadInfo, error)

ServerCPULoadInfo - Returns cpu utilization information

func (*AdminClient) ServerDrivesPerfInfo 

func (adm *AdminClient) ServerDrivesPerfInfo(size int64) ([]ServerDrivesPerfInfo, error)

ServerDrivesPerfInfo - Returns drive's read and write performance information

func (*AdminClient) ServerInfo 

func (adm *AdminClient) ServerInfo() (InfoMessage, error)

ServerInfo - Connect to a minio server and call Server Admin Info Management API to fetch server's information represented by infoMessage structure

func (*AdminClient) ServerMemUsageInfo 

func (adm *AdminClient) ServerMemUsageInfo() ([]ServerMemUsageInfo, error)

ServerMemUsageInfo - Returns mem utilization information

func (*AdminClient) ServerNetworkHardwareInfo 

func (adm *AdminClient) ServerNetworkHardwareInfo() ([]ServerNetworkHardwareInfo, error)

ServerNetworkHardwareInfo - Returns network hardware information

func (*AdminClient) ServerUpdate 

func (adm *AdminClient) ServerUpdate(updateURL string) (us ServerUpdateStatus, err error)

ServerUpdate - updates and restarts the MinIO cluster to latest version. optionally takes an input URL to specify a custom update binary link

func (*AdminClient) ServiceRestart 

func (adm *AdminClient) ServiceRestart() error

ServiceRestart - restarts the MinIO cluster

func (*AdminClient) ServiceStop 

func (adm *AdminClient) ServiceStop() error

ServiceStop - stops the MinIO cluster

func (AdminClient) ServiceTrace 

func (adm AdminClient) ServiceTrace(allTrace, errTrace bool, doneCh <-chan struct{}) <-chan ServiceTraceInfo

ServiceTrace - listen on http trace notifications.

func (*AdminClient) SetAppInfo 

func (adm *AdminClient) SetAppInfo(appName string, appVersion string)

SetAppInfo - add application details to user agent.

func (*AdminClient) SetConfig 

func (adm *AdminClient) SetConfig(config io.Reader) (err error)

SetConfig - set config supplied as config.json for the setup.

func (*AdminClient) SetConfigKV 

func (adm *AdminClient) SetConfigKV(kv string) (err error)

SetConfigKV - set key value config to server.

func (*AdminClient) SetCustomTransport 

func (adm *AdminClient) SetCustomTransport(customHTTPTransport http.RoundTripper)

SetCustomTransport - set new custom transport.

func (*AdminClient) SetGroupStatus 

func (adm *AdminClient) SetGroupStatus(group string, status GroupStatus) error

SetGroupStatus - sets the status of a group.

func (*AdminClient) SetPolicy 

func (adm *AdminClient) SetPolicy(policyName, entityName string, isGroup bool) error

SetPolicy - sets the policy for a user or a group.

func (*AdminClient) SetUser 

func (adm *AdminClient) SetUser(accessKey, secretKey string, status AccountStatus) error

SetUser - sets a user info.

func (*AdminClient) SetUserStatus 

func (adm *AdminClient) SetUserStatus(accessKey string, status AccountStatus) error

SetUserStatus - adds a status for a user.

func (*AdminClient) StartProfiling 

func (adm *AdminClient) StartProfiling(profiler ProfilerType) ([]StartProfilingResult, error)

StartProfiling makes an admin call to remotely start profiling on a standalone server or the whole cluster in case of a distributed setup.

func (*AdminClient) StorageInfo 

func (adm *AdminClient) StorageInfo() (StorageInfo, error)

StorageInfo - Connect to a minio server and call Storage Info Management API to fetch server's information represented by StorageInfo structure

func (*AdminClient) TopLocks 

func (adm *AdminClient) TopLocks() (LockEntries, error)

TopLocks - returns the oldest locks in a minio setup.

func (*AdminClient) TraceOff 

func (adm *AdminClient) TraceOff()

TraceOff - disable HTTP tracing.

func (*AdminClient) TraceOn 

func (adm *AdminClient) TraceOn(outputStream io.Writer)

TraceOn - enable HTTP tracing.

func (*AdminClient) UpdateGroupMembers 

func (adm *AdminClient) UpdateGroupMembers(g GroupAddRemove) error

UpdateGroupMembers - adds/removes users to/from a group. Server creates the group as needed. Group is removed if remove request is made on empty group.

type Audit 

type Audit map[string]Status

Audit contains audit logger status

type BackendDisks 

type BackendDisks map[string]int

BackendDisks - represents the map of endpoint-disks.

func (BackendDisks) Merge 

func (d1 BackendDisks) Merge(d2 BackendDisks) BackendDisks

Merge - Reduces two endpoint-disk maps.

func (BackendDisks) Sum 

func (d1 BackendDisks) Sum() (sum int)

Sum - Return the sum of the disks in the endpoint-disk map.

type BackendType 

type BackendType int

BackendType - represents different backend types. 

const (
	Unknown BackendType = iota
	// Filesystem backend.
	FS
	// Multi disk Erasure (single, distributed) backend.
	Erasure
)

Enum for different backend types.

type BgHealState 

type BgHealState struct {
	ScannedItemsCount int64
	LastHealActivity  time.Time
	NextHealRound     time.Time
}

BgHealState represents the status of the background heal

type BucketAccountingUsage added in v0.0.3 

type BucketAccountingUsage struct {
	Size       uint64          `json:"size"`
	AccessList []AccountAccess `json:"accessList"`
}

BucketAccountingUsage represents the accounting usage of a particular bucket

type Buckets 

type Buckets struct {
	Count uint64 `json:"count,omitempty"`
}

Buckets contains the number of buckets

type ConfigHistoryEntry 

type ConfigHistoryEntry struct {
	RestoreID  string    `json:"restoreId"`
	CreateTime time.Time `json:"createTime"`
	Data       string    `json:"data"`
}

ConfigHistoryEntry - captures config set history with a unique restore ID and createTime

func (ConfigHistoryEntry) CreateTimeFormatted 

func (ch ConfigHistoryEntry) CreateTimeFormatted() string

CreateTimeFormatted is used to print formatted time for CreateTime.

type DataUsageInfo 

type DataUsageInfo struct {
	// LastUpdate is the timestamp of when the data usage info was last updated.
	// This does not indicate a full scan.
	LastUpdate       time.Time `json:"lastUpdate"`
	ObjectsCount     uint64    `json:"objectsCount"`
	ObjectsTotalSize uint64    `json:"objectsTotalSize"`

	// ObjectsSizesHistogram contains information on objects across all buckets.
	// See ObjectsHistogramIntervals.
	ObjectsSizesHistogram map[string]uint64 `json:"objectsSizesHistogram"`

	BucketsCount uint64 `json:"bucketsCount"`

	// BucketsSizes is "bucket name" -> size.
	BucketsSizes map[string]uint64 `json:"bucketsSizes"`
}

DataUsageInfo represents data usage of an Object API

type Disk 

type Disk struct {
	DrivePath       string  `json:"path,omitempty"`
	State           string  `json:"state,omitempty"`
	UUID            string  `json:"uuid,omitempty"`
	Model           string  `json:"model,omitempty"`
	TotalSpace      uint64  `json:"totalspace,omitempty"`
	UsedSpace       uint64  `json:"usedspace,omitempty"`
	ReadThroughput  float64 `json:"readthroughput,omitempty"`
	WriteThroughPut float64 `json:"writethroughput,omitempty"`
	ReadLatency     float64 `json:"readlatency,omitempty"`
	WriteLatency    float64 `json:"writelatency,omitempty"`
	Utilization     float64 `json:"utilization,omitempty"`
}

Disk holds Disk information

type DriveInfo 

type DriveInfo HealDriveInfo

DriveInfo - represents each drive info, describing status, uuid and endpoint.

type ErrorResponse 

type ErrorResponse struct {
	XMLName    xml.Name `xml:"Error" json:"-"`
	Code       string
	Message    string
	BucketName string
	Key        string
	RequestID  string `xml:"RequestId"`
	HostID     string `xml:"HostId"`

	// Region where the bucket is located. This header is returned
	// only in HEAD bucket and ListObjects response.
	Region string
}

ErrorResponse - Is the typed error returned by all API operations.

func ToErrorResponse 

func ToErrorResponse(err error) ErrorResponse

ToErrorResponse - Returns parsed ErrorResponse struct from body and http headers.

For example: 

import admin "github.com/RTradeLtd/s3x/pkg/madmin"
...
...
ss, err := adm.ServiceStatus(...)
if err != nil {
   resp := admin.ToErrorResponse(err)
}
...

func (ErrorResponse) Error 

func (e ErrorResponse) Error() string

Error - Returns HTTP error string

type FsBackend 

type FsBackend struct {
	Type backendType `json:"backendType,omitempty"`
}

FsBackend contains specific FS storage information

type GroupAddRemove 

type GroupAddRemove struct {
	Group    string   `json:"group"`
	Members  []string `json:"members"`
	IsRemove bool     `json:"isRemove"`
}

GroupAddRemove is type for adding/removing members to/from a group.

type GroupDesc 

type GroupDesc struct {
	Name    string   `json:"name"`
	Status  string   `json:"status"`
	Members []string `json:"members"`
	Policy  string   `json:"policy"`
}

GroupDesc is a type that holds group info along with the policy attached to it.

type GroupStatus 

type GroupStatus string

GroupStatus - group status. 

const (
	GroupEnabled  GroupStatus = "enabled"
	GroupDisabled GroupStatus = "disabled"
)

GroupStatus values.

type HardwareType 

type HardwareType string

HardwareType - type to hardware 

const (
	// HARDWARE represents hardware type
	HARDWARE = "hwType"
	// CPU represents hardware as cpu
	CPU HardwareType = "cpu"
	// NETWORK hardware Info
	NETWORK HardwareType = "network"
)

type HealDriveInfo 

type HealDriveInfo struct {
	UUID     string `json:"uuid"`
	Endpoint string `json:"endpoint"`
	State    string `json:"state"`
}

HealDriveInfo - struct for an individual drive info item.

type HealItemType 

type HealItemType string

HealItemType - specify the type of heal operation in a healing result

type HealOpts 

type HealOpts struct {
	Recursive bool         `json:"recursive"`
	DryRun    bool         `json:"dryRun"`
	Remove    bool         `json:"remove"`
	ScanMode  HealScanMode `json:"scanMode"`
}

HealOpts - collection of options for a heal sequence

type HealResultItem 

type HealResultItem struct {
	ResultIndex  int64        `json:"resultId"`
	Type         HealItemType `json:"type"`
	Bucket       string       `json:"bucket"`
	Object       string       `json:"object"`
	Detail       string       `json:"detail"`
	ParityBlocks int          `json:"parityBlocks,omitempty"`
	DataBlocks   int          `json:"dataBlocks,omitempty"`
	DiskCount    int          `json:"diskCount"`
	SetCount     int          `json:"setCount"`
	// below slices are from drive info.
	Before struct {
		Drives []HealDriveInfo `json:"drives"`
	} `json:"before"`
	After struct {
		Drives []HealDriveInfo `json:"drives"`
	} `json:"after"`
	ObjectSize int64 `json:"objectSize"`
}

HealResultItem - struct for an individual heal result item

func (*HealResultItem) GetCorruptedCounts 

func (hri *HealResultItem) GetCorruptedCounts() (b, a int)

GetCorruptedCounts - returns the number of corrupted disks before and after heal

func (*HealResultItem) GetMissingCounts 

func (hri *HealResultItem) GetMissingCounts() (b, a int)

GetMissingCounts - returns the number of missing disks before and after heal

func (*HealResultItem) GetOfflineCounts 

func (hri *HealResultItem) GetOfflineCounts() (b, a int)

GetOfflineCounts - returns the number of offline disks before and after heal

func (*HealResultItem) GetOnlineCounts 

func (hri *HealResultItem) GetOnlineCounts() (b, a int)

GetOnlineCounts - returns the number of online disks before and after heal

type HealScanMode 

type HealScanMode int

HealScanMode represents the type of healing scan 

const (
	// HealNormalScan checks if parts are present and not outdated
	HealNormalScan HealScanMode = iota
	// HealDeepScan checks for parts bitrot checksums
	HealDeepScan
)

type HealStartSuccess 

type HealStartSuccess struct {
	ClientToken   string    `json:"clientToken"`
	ClientAddress string    `json:"clientAddress"`
	StartTime     time.Time `json:"startTime"`
}

HealStartSuccess - holds information about a successfully started heal operation

type HealStopSuccess 

type HealStopSuccess HealStartSuccess

HealStopSuccess - holds information about a successfully stopped heal operation.

type HealTaskStatus 

type HealTaskStatus struct {
	Summary       string    `json:"summary"`
	FailureDetail string    `json:"detail"`
	StartTime     time.Time `json:"startTime"`
	HealSettings  HealOpts  `json:"settings"`
	NumDisks      int       `json:"numDisks"`

	Items []HealResultItem `json:"items,omitempty"`
}

HealTaskStatus - status struct for a heal task

type Help 

type Help struct {
	SubSys          string  `json:"subSys"`
	Description     string  `json:"description"`
	MultipleTargets bool    `json:"multipleTargets"`
	KeysHelp        HelpKVS `json:"keysHelp"`
}

Help - return sub-system level help

type HelpKV 

type HelpKV struct {
	Key             string `json:"key"`
	Description     string `json:"description"`
	Optional        bool   `json:"optional"`
	Type            string `json:"type"`
	MultipleTargets bool   `json:"multipleTargets"`
}

HelpKV - implements help messages for keys with value as description of the keys.

type HelpKVS 

type HelpKVS []HelpKV

HelpKVS - implement order of keys help messages.

type InfoMessage 

type InfoMessage struct {
	Mode         string             `json:"mode,omitempty"`
	Domain       []string           `json:"domain,omitempty"`
	Region       string             `json:"region,omitempty"`
	SQSARN       []string           `json:"sqsARN,omitempty"`
	DeploymentID string             `json:"deploymentID,omitempty"`
	Buckets      Buckets            `json:"buckets,omitempty"`
	Objects      Objects            `json:"objects,omitempty"`
	Usage        Usage              `json:"usage,omitempty"`
	Services     Services           `json:"services,omitempty"`
	Backend      interface{}        `json:"backend,omitempty"`
	Servers      []ServerProperties `json:"servers,omitempty"`
}

InfoMessage container to hold server admin related information.

type KMSKeyStatus 

type KMSKeyStatus struct {
	KeyID         string `json:"key-id"`
	EncryptionErr string `json:"encryption-error,omitempty"` // An empty error == success
	DecryptionErr string `json:"decryption-error,omitempty"` // An empty error == success
}

KMSKeyStatus contains some status information about a KMS master key. The MinIO server tries to access the KMS and perform encryption and decryption operations. If the MinIO server can access the KMS and all master key operations succeed it returns a status containing only the master key ID but no error.

type KV 

type KV struct {
	Key   string `json:"key"`
	Value string `json:"value"`
}

KV - is a shorthand of each key value.

type KVS 

type KVS []KV

KVS - is a shorthand for some wrapper functions to operate on list of key values.

func (KVS) Empty 

func (kvs KVS) Empty() bool

Empty - return if kv is empty

func (KVS) Get 

func (kvs KVS) Get(key string) string

Get - returns the value of a key, if not found returns empty.

func (KVS) Lookup 

func (kvs KVS) Lookup(key string) (string, bool)

Lookup - lookup a key in a list of KVS

func (*KVS) Set 

func (kvs *KVS) Set(key, value string)

Set sets a value, if not sets a default value.

func (KVS) String 

func (kvs KVS) String() string

type LDAP 

type LDAP struct {
	Status string `json:"status,omitempty"`
}

LDAP contains ldap status

type LockEntries 

type LockEntries []LockEntry

LockEntries - To sort the locks

func (LockEntries) Len 

func (l LockEntries) Len() int

func (LockEntries) Less 

func (l LockEntries) Less(i, j int) bool

func (LockEntries) Swap 

func (l LockEntries) Swap(i, j int)

type LockEntry 

type LockEntry struct {
	Timestamp  time.Time `json:"time"`       // Timestamp set at the time of initialization.
	Resource   string    `json:"resource"`   // Resource contains info like bucket, object etc
	Type       string    `json:"type"`       // Bool whether write or read lock.
	Source     string    `json:"source"`     // Source which created the lock
	ServerList []string  `json:"serverlist"` // RPC path of servers issuing the lock.
	Owner      string    `json:"owner"`      // RPC path of client claiming lock.
	ID         string    `json:"id"`         // UID to uniquely identify request of client.
}

LockEntry holds information about client requesting the lock, servers holding the lock, source on the client machine, ID, type(read or write) and time stamp.

type LogInfo 

type LogInfo struct {
	log.Entry
	ConsoleMsg string
	NodeName   string `json:"node"`
	Err        error  `json:"-"`
}

LogInfo holds console log messages

func (LogInfo) SendLog 

func (l LogInfo) SendLog(node, logKind string) bool

SendLog returns true if log pertains to node specified in args.

type Logger 

type Logger map[string]Status

Logger contains logger status

type NetPerfInfo 

type NetPerfInfo struct {
	Addr           string `json:"addr"`
	ReadThroughput uint64 `json:"readThroughput"`
	Error          string `json:"error,omitempty"`
}

NetPerfInfo network performance information.

type Objects 

type Objects struct {
	Count uint64 `json:"count,omitempty"`
}

Objects contains the number of objects

type ProfilerType 

type ProfilerType string

ProfilerType represents the profiler type passed to the profiler subsystem. 

const (
	ProfilerCPU        ProfilerType = "cpu"        // represents CPU profiler type
	ProfilerMEM        ProfilerType = "mem"        // represents MEM profiler type
	ProfilerBlock      ProfilerType = "block"      // represents Block profiler type
	ProfilerMutex      ProfilerType = "mutex"      // represents Mutex profiler type
	ProfilerTrace      ProfilerType = "trace"      // represents Trace profiler type
	ProfilerThreads    ProfilerType = "threads"    // represents ThreadCreate profiler type
	ProfilerGoroutines ProfilerType = "goroutines" // represents Goroutine dumps.
)

Different supported profiler types.

type ServerCPUHardwareInfo 

type ServerCPUHardwareInfo struct {
	Addr    string         `json:"addr"`
	Error   string         `json:"error,omitempty"`
	CPUInfo []cpu.InfoStat `json:"cpu"`
}

ServerCPUHardwareInfo holds informantion about cpu hardware

type ServerCPULoadInfo 

type ServerCPULoadInfo struct {
	Addr         string     `json:"addr"`
	Error        string     `json:"error,omitempty"`
	Load         []cpu.Load `json:"load"`
	HistoricLoad []cpu.Load `json:"historicLoad"`
}

ServerCPULoadInfo holds information about address and cpu load of a single server node

type ServerDrivesPerfInfo 

type ServerDrivesPerfInfo struct {
	Addr  string             `json:"addr"`
	Error string             `json:"error,omitempty"`
	Perf  []disk.Performance `json:"perf"`
	Size  int64              `json:"size,omitempty"`
}

ServerDrivesPerfInfo holds informantion about address and write speed of all drives in a single server node

type ServerMemUsageInfo 

type ServerMemUsageInfo struct {
	Addr          string      `json:"addr"`
	Error         string      `json:"error,omitempty"`
	Usage         []mem.Usage `json:"usage"`
	HistoricUsage []mem.Usage `json:"historicUsage"`
}

ServerMemUsageInfo holds information about address and memory utilization of a single server node

type ServerNetworkHardwareInfo 

type ServerNetworkHardwareInfo struct {
	Addr        string          `json:"addr"`
	Error       string          `json:"error,omitempty"`
	NetworkInfo []net.Interface `json:"network"`
}

ServerNetworkHardwareInfo holds informantion about cpu hardware

type ServerProperties 

type ServerProperties struct {
	State    string            `json:"state,omitempty"`
	Endpoint string            `json:"endpoint,omitempty"`
	Uptime   int64             `json:"uptime,omitempty"`
	Version  string            `json:"version,omitempty"`
	CommitID string            `json:"commitID,omitempty"`
	Network  map[string]string `json:"network,omitempty"`
	Disks    []Disk            `json:"disks,omitempty"`
}

ServerProperties holds server information

type ServerUpdateStatus 

type ServerUpdateStatus struct {
	CurrentVersion string `json:"currentVersion"`
	UpdatedVersion string `json:"updatedVersion"`
}

ServerUpdateStatus - contains the response of service update API

type ServiceAction 

type ServiceAction string

ServiceAction - type to restrict service-action values 

const (
	// ServiceActionRestart represents restart action
	ServiceActionRestart ServiceAction = "restart"
	// ServiceActionStop represents stop action
	ServiceActionStop = "stop"
)

type ServiceTraceInfo 

type ServiceTraceInfo struct {
	Trace trace.Info
	Err   error `json:"-"`
}

ServiceTraceInfo holds http trace

type Services 

type Services struct {
	Vault         Vault                         `json:"vault,omitempty"`
	LDAP          LDAP                          `json:"ldap,omitempty"`
	Logger        []Logger                      `json:"logger,omitempty"`
	Audit         []Audit                       `json:"audit,omitempty"`
	Notifications []map[string][]TargetIDStatus `json:"notifications,omitempty"`
}

Services contains different services information

type StartProfilingResult 

type StartProfilingResult struct {
	NodeName string `json:"nodeName"`
	Success  bool   `json:"success"`
	Error    string `json:"error"`
}

StartProfilingResult holds the result of starting profiler result in a given node.

type Status 

type Status struct {
	Status string `json:"status,omitempty"`
}

Status of endpoint

type StorageInfo 

type StorageInfo struct {
	Used []uint64 // Used total used per disk.

	Total []uint64 // Total disk space per disk.

	Available []uint64 // Total disk space available per disk.

	MountPaths []string // Disk mountpoints

	// Backend type.
	Backend struct {
		// Represents various backend types, currently on FS and Erasure.
		Type BackendType

		// Following fields are only meaningful if BackendType is Erasure.
		OnlineDisks      BackendDisks // Online disks during server startup.
		OfflineDisks     BackendDisks // Offline disks during server startup.
		StandardSCData   int          // Data disks for currently configured Standard storage class.
		StandardSCParity int          // Parity disks for currently configured Standard storage class.
		RRSCData         int          // Data disks for currently configured Reduced Redundancy storage class.
		RRSCParity       int          // Parity disks for currently configured Reduced Redundancy storage class.

		// List of all disk status, this is only meaningful if BackendType is Erasure.
		Sets [][]DriveInfo
	}
}

StorageInfo - represents total capacity of underlying storage.

type Target 

type Target struct {
	SubSystem string `json:"subSys"`
	KVS       KVS    `json:"kvs"`
}

Target signifies an individual target

type TargetIDStatus 

type TargetIDStatus map[string]Status

TargetIDStatus containsid and status

type Targets 

type Targets []Target

Targets sub-system targets

func ParseSubSysTarget 

func ParseSubSysTarget(buf []byte) (Targets, error)

ParseSubSysTarget - parse sub-system target

func (*Targets) AddTarget 

func (t *Targets) AddTarget(s string) error

AddTarget - adds new targets, by parsing the input string s.

func (Targets) Count 

func (t Targets) Count() int

Count - returns total numbers of target

func (Targets) String 

func (t Targets) String() string

type Usage 

type Usage struct {
	Size uint64 `json:"size,omitempty"`
}

Usage contains the tottal size used

type UserInfo 

type UserInfo struct {
	SecretKey  string        `json:"secretKey,omitempty"`
	PolicyName string        `json:"policyName,omitempty"`
	Status     AccountStatus `json:"status"`
	MemberOf   []string      `json:"memberOf,omitempty"`
}

UserInfo carries information about long term users.

type Vault 

type Vault struct {
	Status  string `json:"status,omitempty"`
	Encrypt string `json:"encryp,omitempty"`
	Decrypt string `json:"decrypt,omitempty"`
}

Vault - Fetches the Vault status

type XlBackend 

type XlBackend struct {
	Type         backendType `json:"backendType,omitempty"`
	OnlineDisks  int         `json:"onlineDisks,omitempty"`
	OfflineDisks int         `json:"offlineDisks,omitempty"`
	// Data disks for currently configured Standard storage class.
	StandardSCData int `json:"standardSCData,omitempty"`
	// Parity disks for currently configured Standard storage class.
	StandardSCParity int `json:"standardSCParity,omitempty"`
	// Data disks for currently configured Reduced Redundancy storage class.
	RRSCData int `json:"rrSCData,omitempty"`
	// Parity disks for currently configured Reduced Redundancy storage class.
	RRSCParity int `json:"rrSCParity,omitempty"`
}

XlBackend contains specific erasure storage information

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.