mirror of
https://github.com/hanzos3/madmin-go.git
synced 2026-10-30 20:35:32 +00:00
1430 lines
46 KiB
Go
1430 lines
46 KiB
Go
//
|
|
// Copyright (c) 2015-2024 MinIO, Inc.
|
|
//
|
|
// This file is part of MinIO Object Storage stack
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
|
|
package madmin
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/minio/minio-go/v7/pkg/replication"
|
|
)
|
|
|
|
// SiteReplAPIVersion holds the supported version of the server Replication API
|
|
const SiteReplAPIVersion = "1"
|
|
|
|
// PeerSite - represents a cluster/site to be added to the set of replicated
|
|
// sites.
|
|
type PeerSite struct {
|
|
Name string `json:"name"`
|
|
Endpoint string `json:"endpoints"`
|
|
AccessKey string `json:"accessKey"`
|
|
SecretKey string `json:"secretKey"`
|
|
}
|
|
|
|
// Meaningful values for ReplicateAddStatus.Status
|
|
const (
|
|
ReplicateAddStatusSuccess = "Requested sites were configured for replication successfully."
|
|
ReplicateAddStatusPartial = "Some sites could not be configured for replication."
|
|
)
|
|
|
|
// ReplicateAddStatus - returns status of add request.
|
|
type ReplicateAddStatus struct {
|
|
Success bool `json:"success"`
|
|
Status string `json:"status"`
|
|
ErrDetail string `json:"errorDetail,omitempty"`
|
|
InitialSyncErrorMessage string `json:"initialSyncErrorMessage,omitempty"`
|
|
}
|
|
|
|
// SRAddOptions holds SR Add options
|
|
type SRAddOptions struct {
|
|
ReplicateILMExpiry bool
|
|
Force bool
|
|
}
|
|
|
|
func (o *SRAddOptions) getURLValues() url.Values {
|
|
urlValues := make(url.Values)
|
|
urlValues.Set("replicateILMExpiry", strconv.FormatBool(o.ReplicateILMExpiry))
|
|
urlValues.Set("force", strconv.FormatBool(o.Force))
|
|
|
|
return urlValues
|
|
}
|
|
|
|
// SiteReplicationAdd - sends the SR add API call.
|
|
func (adm *AdminClient) SiteReplicationAdd(ctx context.Context, sites []PeerSite, opts SRAddOptions) (ReplicateAddStatus, error) {
|
|
sitesBytes, err := json.Marshal(sites)
|
|
if err != nil {
|
|
return ReplicateAddStatus{}, nil
|
|
}
|
|
encBytes, err := EncryptData(adm.getSecretKey(), sitesBytes)
|
|
if err != nil {
|
|
return ReplicateAddStatus{}, err
|
|
}
|
|
|
|
q := opts.getURLValues()
|
|
q.Set("api-version", SiteReplAPIVersion)
|
|
|
|
reqData := requestData{
|
|
relPath: adminAPIPrefix + "/site-replication/add",
|
|
content: encBytes,
|
|
queryValues: q,
|
|
}
|
|
|
|
resp, err := adm.executeMethod(ctx, http.MethodPut, reqData)
|
|
defer closeResponse(resp)
|
|
if err != nil {
|
|
return ReplicateAddStatus{}, err
|
|
}
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return ReplicateAddStatus{}, httpRespToErrorResponse(resp)
|
|
}
|
|
|
|
b, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return ReplicateAddStatus{}, err
|
|
}
|
|
|
|
var res ReplicateAddStatus
|
|
if err = json.Unmarshal(b, &res); err != nil {
|
|
return ReplicateAddStatus{}, err
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// SiteReplicationInfo - contains cluster replication information.
|
|
type SiteReplicationInfo struct {
|
|
Enabled bool `json:"enabled"`
|
|
Name string `json:"name,omitempty"`
|
|
Sites []PeerInfo `json:"sites,omitempty"`
|
|
ServiceAccountAccessKey string `json:"serviceAccountAccessKey,omitempty"`
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// SiteReplicationInfo - returns cluster replication information.
|
|
func (adm *AdminClient) SiteReplicationInfo(ctx context.Context) (info SiteReplicationInfo, err error) {
|
|
q := make(url.Values)
|
|
q.Set("api-version", SiteReplAPIVersion)
|
|
|
|
reqData := requestData{
|
|
relPath: adminAPIPrefix + "/site-replication/info",
|
|
queryValues: q,
|
|
}
|
|
|
|
resp, err := adm.executeMethod(ctx, http.MethodGet, reqData)
|
|
defer closeResponse(resp)
|
|
if err != nil {
|
|
return info, err
|
|
}
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return info, httpRespToErrorResponse(resp)
|
|
}
|
|
|
|
b, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return info, err
|
|
}
|
|
|
|
err = json.Unmarshal(b, &info)
|
|
return info, err
|
|
}
|
|
|
|
// SRPeerJoinReq - arg body for SRPeerJoin
|
|
type SRPeerJoinReq struct {
|
|
SvcAcctAccessKey string `json:"svcAcctAccessKey"`
|
|
SvcAcctSecretKey string `json:"svcAcctSecretKey"`
|
|
SvcAcctParent string `json:"svcAcctParent"`
|
|
Peers map[string]PeerInfo `json:"peers"`
|
|
UpdatedAt time.Time `json:"updatedAt"`
|
|
}
|
|
|
|
// PeerInfo - contains some properties of a cluster peer.
|
|
type PeerInfo struct {
|
|
Endpoint string `json:"endpoint"`
|
|
Name string `json:"name"`
|
|
// Deployment ID is useful as it is immutable - though endpoint may
|
|
// change.
|
|
DeploymentID string `json:"deploymentID"`
|
|
SyncState SyncStatus `json:"sync"` // whether to enable| disable synchronous replication
|
|
DefaultBandwidth BucketBandwidth `json:"defaultbandwidth"` // bandwidth limit per bucket in bytes/sec
|
|
ReplicateILMExpiry bool `json:"replicate-ilm-expiry"`
|
|
ObjectNamingMode string `json:"objectNamingMode,omitempty"`
|
|
// TablesReplicaEnabled is true when this peer has the catalog scanner
|
|
// enabled (i.e. is acting as a tables replica site).
|
|
TablesReplicaEnabled bool `json:"tablesReplicaEnabled,omitempty"`
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// BucketBandwidth has default bandwidth limit per bucket in bytes/sec
|
|
type BucketBandwidth struct {
|
|
Limit uint64 `json:"bandwidthLimitPerBucket"`
|
|
IsSet bool `json:"set"`
|
|
UpdatedAt time.Time `json:"updatedAt,omitempty"`
|
|
}
|
|
|
|
type SyncStatus string // change in sync state
|
|
const (
|
|
SyncEnabled SyncStatus = "enable"
|
|
SyncDisabled SyncStatus = "disable"
|
|
)
|
|
|
|
func (s SyncStatus) Empty() bool {
|
|
return s != SyncDisabled && s != SyncEnabled
|
|
}
|
|
|
|
// SRPeerJoin - used only by minio server to send SR join requests to peer
|
|
// servers.
|
|
func (adm *AdminClient) SRPeerJoin(ctx context.Context, r SRPeerJoinReq) error {
|
|
b, err := json.Marshal(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
encBuf, err := EncryptData(adm.getSecretKey(), b)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
q := make(url.Values)
|
|
q.Set("api-version", SiteReplAPIVersion)
|
|
|
|
reqData := requestData{
|
|
relPath: adminAPIPrefix + "/site-replication/peer/join",
|
|
content: encBuf,
|
|
queryValues: q,
|
|
}
|
|
|
|
resp, err := adm.executeMethod(ctx, http.MethodPut, reqData)
|
|
defer closeResponse(resp)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return httpRespToErrorResponse(resp)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// BktOp represents the bucket operation being requested.
|
|
type BktOp string
|
|
|
|
// BktOp value constants.
|
|
const (
|
|
// make bucket and enable versioning
|
|
MakeWithVersioningBktOp BktOp = "make-with-versioning"
|
|
// make an AIStor Tables warehouse bucket and enable versioning; a peer that
|
|
// predates warehouse replication has no route for this op and rejects it, so
|
|
// the warehouse is withheld until that peer is upgraded
|
|
MakeWarehouseBktOp BktOp = "make-warehouse"
|
|
// make an AIStor Memory cortex bucket and enable versioning. A cortex is
|
|
// always also a Tables warehouse (a super-bucket), so this op implies the
|
|
// warehouse capability too. A peer that predates cortex replication has no
|
|
// route for this op and rejects it, so the cortex is withheld until that peer
|
|
// is upgraded.
|
|
MakeCortexBktOp BktOp = "make-cortex"
|
|
// add replication configuration
|
|
ConfigureReplBktOp BktOp = "configure-replication"
|
|
// delete bucket (forceDelete = off)
|
|
DeleteBucketBktOp BktOp = "delete-bucket"
|
|
// delete bucket (forceDelete = on)
|
|
ForceDeleteBucketBktOp BktOp = "force-delete-bucket"
|
|
// purge bucket
|
|
PurgeDeletedBucketOp BktOp = "purge-deleted-bucket"
|
|
)
|
|
|
|
// SRPeerBucketOps - tells peers to create bucket and setup replication.
|
|
func (adm *AdminClient) SRPeerBucketOps(ctx context.Context, bucket string, op BktOp, opts map[string]string) error {
|
|
v := url.Values{}
|
|
v.Add("bucket", bucket)
|
|
v.Add("operation", string(op))
|
|
|
|
// For make-bucket, bucket options may be sent via `opts`
|
|
if op == MakeWithVersioningBktOp || op == MakeWarehouseBktOp || op == MakeCortexBktOp || op == DeleteBucketBktOp {
|
|
for k, val := range opts {
|
|
v.Add(k, val)
|
|
}
|
|
}
|
|
|
|
v.Set("api-version", SiteReplAPIVersion)
|
|
|
|
reqData := requestData{
|
|
queryValues: v,
|
|
relPath: adminAPIPrefix + "/site-replication/peer/bucket-ops",
|
|
}
|
|
|
|
resp, err := adm.executeMethod(ctx, http.MethodPut, reqData)
|
|
defer closeResponse(resp)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return httpRespToErrorResponse(resp)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// SRIAMItem.Type constants.
|
|
const (
|
|
SRIAMItemPolicy = "policy"
|
|
SRIAMItemPolicyMapping = "policy-mapping"
|
|
SRIAMItemGroupInfo = "group-info"
|
|
SRIAMItemCredential = "credential"
|
|
SRIAMItemSvcAcc = "service-account"
|
|
SRIAMItemSTSAcc = "sts-account"
|
|
SRIAMItemIAMUser = "iam-user"
|
|
SRIAMItemExternalUser = "external-user"
|
|
SRIAMItemLDAPUser = "ldap-user"
|
|
)
|
|
|
|
// SRSessionPolicy - represents a session policy to be replicated.
|
|
type SRSessionPolicy json.RawMessage
|
|
|
|
func (s SRSessionPolicy) MarshalJSON() ([]byte, error) {
|
|
return json.RawMessage(s).MarshalJSON()
|
|
}
|
|
|
|
func (s *SRSessionPolicy) UnmarshalJSON(data []byte) error {
|
|
if s == nil {
|
|
return errors.New("json.RawMessage: UnmarshalJSON on nil pointer")
|
|
}
|
|
if bytes.Equal(data, []byte("null")) {
|
|
*s = nil
|
|
} else {
|
|
*s = append((*s)[0:0], data...)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// SRSvcAccCreate - create operation
|
|
type SRSvcAccCreate struct {
|
|
Parent string `json:"parent"`
|
|
AccessKey string `json:"accessKey"`
|
|
SecretKey string `json:"secretKey"`
|
|
Groups []string `json:"groups"`
|
|
Claims map[string]interface{} `json:"claims"`
|
|
SessionPolicy SRSessionPolicy `json:"sessionPolicy"`
|
|
Status string `json:"status"`
|
|
Name string `json:"name"`
|
|
Description string `json:"description"`
|
|
Expiration *time.Time `json:"expiration,omitempty"`
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// SRSvcAccUpdate - update operation
|
|
type SRSvcAccUpdate struct {
|
|
AccessKey string `json:"accessKey"`
|
|
SecretKey string `json:"secretKey"`
|
|
Status string `json:"status"`
|
|
Name string `json:"name"`
|
|
Description string `json:"description"`
|
|
SessionPolicy SRSessionPolicy `json:"sessionPolicy"`
|
|
Expiration *time.Time `json:"expiration,omitempty"`
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// SRSvcAccDelete - delete operation
|
|
type SRSvcAccDelete struct {
|
|
AccessKey string `json:"accessKey"`
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// SRSvcAccChange - sum-type to represent an svc account change.
|
|
type SRSvcAccChange struct {
|
|
Create *SRSvcAccCreate `json:"crSvcAccCreate"`
|
|
Update *SRSvcAccUpdate `json:"crSvcAccUpdate"`
|
|
Delete *SRSvcAccDelete `json:"crSvcAccDelete"`
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// SRPolicyMapping - represents mapping of a policy to a user or group.
|
|
type SRPolicyMapping struct {
|
|
UserOrGroup string `json:"userOrGroup"`
|
|
UserType int `json:"userType"`
|
|
IsGroup bool `json:"isGroup"`
|
|
Policy string `json:"policy"`
|
|
Provider string `json:"provider,omitempty"`
|
|
ConfigID string `json:"configID,omitempty"`
|
|
CreatedAt time.Time `json:"createdAt,omitempty"`
|
|
UpdatedAt time.Time `json:"updatedAt,omitempty"`
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// SRSTSCredential - represents an STS credential to be replicated.
|
|
type SRSTSCredential struct {
|
|
AccessKey string `json:"accessKey"`
|
|
SecretKey string `json:"secretKey"`
|
|
SessionToken string `json:"sessionToken"`
|
|
ParentUser string `json:"parentUser"`
|
|
ParentPolicyMapping string `json:"parentPolicyMapping,omitempty"`
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// OpenIDUserAccessInfo contains information to access and refresh the token
|
|
// that is used to access to UserInfo OpenID endpoint.
|
|
type OpenIDUserAccessInfo struct {
|
|
RefreshToken string `json:"refreshToken,omitempty"`
|
|
AccessToken string `json:"accessToken,omitempty"`
|
|
}
|
|
|
|
// OpenIDUser holds information to maintain an virtual user in OpenID
|
|
type OpenIDUser struct {
|
|
AccessInfo OpenIDUserAccessInfo `json:"accessInfo,omitempty"`
|
|
}
|
|
|
|
// SRExternalUser - represents an external user information to be replicated.
|
|
type SRExternalUser struct {
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
Name string `json:"name"`
|
|
IsDeleteReq bool `json:"isDeleteReq"`
|
|
|
|
OpenIDUser *OpenIDUser `json:"openIDUser,omitempty"`
|
|
}
|
|
|
|
// SRLDAPUser - represents an LDAP user to be replicated.
|
|
type SRLDAPUser struct {
|
|
DN string `json:"dn"`
|
|
Username string `json:"username"`
|
|
ValidatedDN string `json:"validatedDN,omitempty"`
|
|
Groups []string `json:"groups,omitempty"`
|
|
Expiry time.Time `json:"expiry,omitempty"`
|
|
IsDeleteReq bool `json:"isDeleteReq"`
|
|
ConfigName string `json:"configName"`
|
|
UpdatedAt time.Time `json:"updatedAt,omitempty"`
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// SRIAMUser - represents a regular (IAM) user to be replicated. A nil UserReq
|
|
// implies that a user delete operation should be replicated on the peer cluster.
|
|
type SRIAMUser struct {
|
|
AccessKey string `json:"accessKey"`
|
|
IsDeleteReq bool `json:"isDeleteReq"`
|
|
UserReq *AddOrUpdateUserReq `json:"userReq"`
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// SRGroupInfo - represents a regular (IAM) user to be replicated.
|
|
type SRGroupInfo struct {
|
|
UpdateReq GroupAddRemove `json:"updateReq"`
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// SRCredInfo - represents a credential change (create/update/delete) to be
|
|
// replicated. This replaces `SvcAccChange`, `STSCredential` and `IAMUser` and
|
|
// will DEPRECATE them.
|
|
type SRCredInfo struct {
|
|
AccessKey string `json:"accessKey"`
|
|
|
|
// This type corresponds to github.com/minio/minio/cmd.IAMUserType
|
|
IAMUserType int `json:"iamUserType"`
|
|
|
|
IsDeleteReq bool `json:"isDeleteReq,omitempty"`
|
|
|
|
// This is the JSON encoded value of github.com/minio/minio/cmd.UserIdentity
|
|
UserIdentityJSON json.RawMessage `json:"userIdentityJSON"`
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// SRIAMItem - represents an IAM object that will be copied to a peer.
|
|
type SRIAMItem struct {
|
|
Type string `json:"type"`
|
|
|
|
// Name and Policy below are used when Type == SRIAMItemPolicy
|
|
Name string `json:"name"`
|
|
Policy json.RawMessage `json:"policy"`
|
|
|
|
// Used when Type == SRIAMItemPolicyMapping
|
|
PolicyMapping *SRPolicyMapping `json:"policyMapping"`
|
|
|
|
// Used when Type = SRIAMItemGroupInfo
|
|
GroupInfo *SRGroupInfo `json:"groupInfo"`
|
|
|
|
// Used when Type = SRIAMItemCredential
|
|
CredentialInfo *SRCredInfo `json:"credentialChange"`
|
|
|
|
// Used when Type == SRIAMItemSvcAcc
|
|
SvcAccChange *SRSvcAccChange `json:"serviceAccountChange"`
|
|
|
|
// Used when Type = SRIAMItemSTSAcc
|
|
STSCredential *SRSTSCredential `json:"stsCredential"`
|
|
|
|
// Used when Type = SRIAMItemIAMUser
|
|
IAMUser *SRIAMUser `json:"iamUser"`
|
|
|
|
// Used when Type = SRIAMItemExternalUser
|
|
ExternalUser *SRExternalUser `json:"externalUser"`
|
|
|
|
// Used when Type = SRIAMItemLDAPUser
|
|
LDAPUser *SRLDAPUser `json:"ldapUser"`
|
|
|
|
// UpdatedAt - timestamp of last update
|
|
UpdatedAt time.Time `json:"updatedAt,omitempty"`
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// SRPeerReplicateIAMItem - copies an IAM object to a peer cluster.
|
|
func (adm *AdminClient) SRPeerReplicateIAMItem(ctx context.Context, item SRIAMItem) error {
|
|
b, err := json.Marshal(item)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
q := make(url.Values)
|
|
q.Add("api-version", SiteReplAPIVersion)
|
|
|
|
reqData := requestData{
|
|
relPath: adminAPIPrefix + "/site-replication/peer/iam-item",
|
|
content: b,
|
|
queryValues: q,
|
|
}
|
|
|
|
resp, err := adm.executeMethod(ctx, http.MethodPut, reqData)
|
|
defer closeResponse(resp)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return httpRespToErrorResponse(resp)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// SRBucketMeta.Type constants
|
|
const (
|
|
SRBucketMetaTypePolicy = "policy"
|
|
SRBucketMetaTypeTags = "tags"
|
|
SRBucketMetaTypeVersionConfig = "version-config"
|
|
SRBucketMetaTypeObjectLockConfig = "object-lock-config"
|
|
SRBucketMetaTypeSSEConfig = "sse-config"
|
|
SRBucketMetaTypeQuotaConfig = "quota-config"
|
|
SRBucketMetaLCConfig = "lc-config"
|
|
SRBucketMetaTypeCorsConfig = "cors-config"
|
|
)
|
|
|
|
// SRBucketMeta - represents a bucket metadata change that will be copied to a peer.
|
|
type SRBucketMeta struct {
|
|
Type string `json:"type"`
|
|
Bucket string `json:"bucket"`
|
|
Policy json.RawMessage `json:"policy,omitempty"`
|
|
|
|
// Since Versioning config does not have a json representation, we use
|
|
// xml byte presentation directly.
|
|
Versioning *string `json:"versioningConfig,omitempty"`
|
|
|
|
// Since tags does not have a json representation, we use its xml byte
|
|
// representation directly.
|
|
Tags *string `json:"tags,omitempty"`
|
|
|
|
// Since object lock does not have a json representation, we use its xml
|
|
// byte representation.
|
|
ObjectLockConfig *string `json:"objectLockConfig,omitempty"`
|
|
|
|
// Since SSE config does not have a json representation, we use its xml
|
|
// byte respresentation.
|
|
SSEConfig *string `json:"sseConfig,omitempty"`
|
|
|
|
// Quota has a json representation use it as is.
|
|
Quota json.RawMessage `json:"quota,omitempty"`
|
|
|
|
// Since Expiry Lifecycle config does not have a json representation, we use its xml
|
|
// byte respresentation.
|
|
ExpiryLCConfig *string `json:"expLCConfig,omitempty"`
|
|
|
|
// UpdatedAt - timestamp of last update
|
|
UpdatedAt time.Time `json:"updatedAt,omitempty"`
|
|
|
|
// ExpiryUpdatedAt - timestamp of last update of expiry rule
|
|
ExpiryUpdatedAt time.Time `json:"expiryUpdatedAt,omitempty"`
|
|
|
|
// Cors is base64 XML representation of CORS config
|
|
Cors *string `json:"cors,omitempty"`
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// SRPeerReplicateBucketMeta - copies a bucket metadata change to a peer cluster.
|
|
func (adm *AdminClient) SRPeerReplicateBucketMeta(ctx context.Context, item SRBucketMeta) error {
|
|
b, err := json.Marshal(item)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
q := make(url.Values)
|
|
q.Set("api-version", SiteReplAPIVersion)
|
|
|
|
reqData := requestData{
|
|
relPath: adminAPIPrefix + "/site-replication/peer/bucket-meta",
|
|
content: b,
|
|
queryValues: q,
|
|
}
|
|
|
|
resp, err := adm.executeMethod(ctx, http.MethodPut, reqData)
|
|
defer closeResponse(resp)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return httpRespToErrorResponse(resp)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// SRBucketInfo - returns all the bucket metadata available for bucket
|
|
type SRBucketInfo struct {
|
|
Bucket string `json:"bucket"`
|
|
Policy json.RawMessage `json:"policy,omitempty"`
|
|
|
|
// Since Versioning config does not have a json representation, we use
|
|
// xml byte presentation directly.
|
|
Versioning *string `json:"versioningConfig,omitempty"`
|
|
|
|
// Since tags does not have a json representation, we use its xml byte
|
|
// representation directly.
|
|
Tags *string `json:"tags,omitempty"`
|
|
|
|
// Since object lock does not have a json representation, we use its xml
|
|
// byte representation.
|
|
ObjectLockConfig *string `json:"objectLockConfig,omitempty"`
|
|
|
|
// Since SSE config does not have a json representation, we use its xml
|
|
// byte respresentation.
|
|
SSEConfig *string `json:"sseConfig,omitempty"`
|
|
// replication config in json representation
|
|
ReplicationConfig *string `json:"replicationConfig,omitempty"`
|
|
// quota config in json representation
|
|
QuotaConfig *string `json:"quotaConfig,omitempty"`
|
|
|
|
// Since Expiry Licfecycle config does not have a json representation, we use its xml
|
|
// byte representation
|
|
ExpiryLCConfig *string `json:"expLCConfig,omitempty"`
|
|
|
|
CorsConfig *string `json:"corsConfig,omitempty"`
|
|
|
|
// time stamps of bucket metadata updates
|
|
PolicyUpdatedAt time.Time `json:"policyTimestamp,omitempty"`
|
|
TagConfigUpdatedAt time.Time `json:"tagTimestamp,omitempty"`
|
|
ObjectLockConfigUpdatedAt time.Time `json:"olockTimestamp,omitempty"`
|
|
SSEConfigUpdatedAt time.Time `json:"sseTimestamp,omitempty"`
|
|
VersioningConfigUpdatedAt time.Time `json:"versioningTimestamp,omitempty"`
|
|
ReplicationConfigUpdatedAt time.Time `json:"replicationConfigTimestamp,omitempty"`
|
|
QuotaConfigUpdatedAt time.Time `json:"quotaTimestamp,omitempty"`
|
|
ExpiryLCConfigUpdatedAt time.Time `json:"expLCTimestamp,omitempty"`
|
|
CreatedAt time.Time `json:"bucketTimestamp,omitempty"`
|
|
DeletedAt time.Time `json:"bucketDeletedTimestamp,omitempty"`
|
|
CorsConfigUpdatedAt time.Time `json:"corsTimestamp,omitempty"`
|
|
Location string `json:"location,omitempty"`
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// OpenIDProviderSettings contains info on a particular OIDC based provider.
|
|
type OpenIDProviderSettings struct {
|
|
ClaimName string
|
|
ClaimUserinfoEnabled bool
|
|
RolePolicy string
|
|
ClientID string
|
|
HashedClientSecret string
|
|
}
|
|
|
|
// OpenIDSettings contains OpenID configuration info of a cluster.
|
|
type OpenIDSettings struct {
|
|
// Enabled is true iff there is at least one OpenID provider configured.
|
|
Enabled bool
|
|
Region string
|
|
// Map of role ARN to provider info
|
|
Roles map[string]OpenIDProviderSettings
|
|
// Info on the claim based provider (all fields are empty if not
|
|
// present)
|
|
ClaimProvider OpenIDProviderSettings
|
|
}
|
|
|
|
// IDPSettings contains key IDentity Provider settings to validate that all
|
|
// peers have the same configuration.
|
|
type IDPSettings struct {
|
|
LDAP LDAPSettings
|
|
LDAPConfigs LDAPConfigSettings
|
|
OpenID OpenIDSettings
|
|
}
|
|
|
|
// LDAPSettings contains LDAP configuration info of a cluster.
|
|
type LDAPSettings struct {
|
|
IsLDAPEnabled bool
|
|
LDAPUserDNSearchBase string
|
|
LDAPUserDNSearchFilter string
|
|
LDAPGroupSearchBase string
|
|
LDAPGroupSearchFilter string
|
|
}
|
|
|
|
type LDAPProviderSettings struct {
|
|
UserDNSearchBase string
|
|
UserDNSearchFilter string
|
|
GroupSearchBase string
|
|
GroupSearchFilter string
|
|
}
|
|
|
|
// LDAPConfigSettings contains LDAP configuration info of all providers in a cluster.
|
|
type LDAPConfigSettings struct {
|
|
Enabled bool
|
|
Configs map[string]LDAPProviderSettings
|
|
}
|
|
|
|
// SRPeerGetIDPSettings - fetches IDP settings from the server.
|
|
func (adm *AdminClient) SRPeerGetIDPSettings(ctx context.Context) (info IDPSettings, err error) {
|
|
q := make(url.Values)
|
|
q.Set("api-version", SiteReplAPIVersion)
|
|
|
|
reqData := requestData{
|
|
relPath: adminAPIPrefix + "/site-replication/peer/idp-settings",
|
|
queryValues: q,
|
|
}
|
|
|
|
resp, err := adm.executeMethod(ctx, http.MethodGet, reqData)
|
|
defer closeResponse(resp)
|
|
if err != nil {
|
|
return info, err
|
|
}
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return info, httpRespToErrorResponse(resp)
|
|
}
|
|
|
|
b, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return info, err
|
|
}
|
|
|
|
err = json.Unmarshal(b, &info)
|
|
if err != nil {
|
|
// If the server is older version, the IDPSettings was =
|
|
// LDAPSettings, so we try that.
|
|
err2 := json.Unmarshal(b, &info.LDAP)
|
|
if err2 == nil {
|
|
err = nil
|
|
}
|
|
}
|
|
return info, err
|
|
}
|
|
|
|
// SRIAMPolicy - represents an IAM policy.
|
|
type SRIAMPolicy struct {
|
|
Policy json.RawMessage `json:"policy"`
|
|
UpdatedAt time.Time `json:"updatedAt,omitempty"`
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// ILMExpiryRule - represents an ILM expiry rule
|
|
type ILMExpiryRule struct {
|
|
ILMRule string `json:"ilm-rule"`
|
|
Bucket string `json:"bucket"`
|
|
UpdatedAt time.Time `json:"updatedAt,omitempty"`
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// SRInfo gets replication metadata for a site
|
|
type SRInfo struct {
|
|
Enabled bool
|
|
Name string
|
|
DeploymentID string
|
|
Buckets map[string]SRBucketInfo // map of bucket metadata info
|
|
Policies map[string]SRIAMPolicy // map of IAM policy name to content
|
|
UserPolicies map[string]SRPolicyMapping // map of username -> user policy mapping
|
|
UserInfoMap map[string]UserInfo // map of user name to UserInfo
|
|
GroupDescMap map[string]GroupDesc // map of group name to GroupDesc
|
|
GroupPolicies map[string]SRPolicyMapping // map of groupname -> group policy mapping
|
|
ReplicationCfg map[string]replication.Config // map of bucket -> replication config
|
|
ILMExpiryRules map[string]ILMExpiryRule // map of ILM Expiry rule to content
|
|
State SRStateInfo // peer state
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// SRMetaInfo - returns replication metadata info for a site.
|
|
func (adm *AdminClient) SRMetaInfo(ctx context.Context, opts SRStatusOptions) (info SRInfo, err error) {
|
|
q := opts.getURLValues()
|
|
q.Set("api-version", SiteReplAPIVersion)
|
|
|
|
reqData := requestData{
|
|
relPath: adminAPIPrefix + "/site-replication/metainfo",
|
|
queryValues: q,
|
|
}
|
|
|
|
resp, err := adm.executeMethod(ctx, http.MethodGet, reqData)
|
|
defer closeResponse(resp)
|
|
if err != nil {
|
|
return info, err
|
|
}
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return info, httpRespToErrorResponse(resp)
|
|
}
|
|
|
|
err = json.NewDecoder(resp.Body).Decode(&info)
|
|
return info, err
|
|
}
|
|
|
|
// SRStatusInfo returns detailed status on site replication status
|
|
type SRStatusInfo struct {
|
|
Enabled bool
|
|
MaxBuckets int // maximum buckets seen across sites
|
|
MaxUsers int // maximum users seen across sites
|
|
MaxGroups int // maximum groups seen across sites
|
|
MaxPolicies int // maximum policies across sites
|
|
MaxILMExpiryRules int // maxmimum ILM Expiry rules across sites
|
|
Sites map[string]PeerInfo // deployment->sitename
|
|
StatsSummary map[string]SRSiteSummary // map of deployment id -> site stat
|
|
// BucketStats map of bucket to slice of deployment IDs with stats. This is populated only if there are
|
|
// mismatches or if a specific bucket's stats are requested
|
|
BucketStats map[string]map[string]SRBucketStatsSummary
|
|
// PolicyStats map of policy to slice of deployment IDs with stats. This is populated only if there are
|
|
// mismatches or if a specific bucket's stats are requested
|
|
PolicyStats map[string]map[string]SRPolicyStatsSummary
|
|
// UserStats map of user to slice of deployment IDs with stats. This is populated only if there are
|
|
// mismatches or if a specific bucket's stats are requested
|
|
UserStats map[string]map[string]SRUserStatsSummary
|
|
// GroupStats map of group to slice of deployment IDs with stats. This is populated only if there are
|
|
// mismatches or if a specific bucket's stats are requested
|
|
GroupStats map[string]map[string]SRGroupStatsSummary
|
|
// Metrics summary of SRMetrics
|
|
Metrics SRMetricsSummary // metrics summary. This is populated if buckets/bucket entity requested
|
|
// ILMExpiryStats map of ILM Expiry rules to slice of deployment IDs with stats. This is populated if there
|
|
// are mismatches or if a specific ILM expiry rule's stats are requested
|
|
ILMExpiryStats map[string]map[string]SRILMExpiryStatsSummary
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// SRPolicyStatsSummary has status of policy replication misses
|
|
type SRPolicyStatsSummary struct {
|
|
DeploymentID string
|
|
PolicyMismatch bool
|
|
HasPolicy bool
|
|
APIVersion string
|
|
}
|
|
|
|
// SRUserStatsSummary has status of user replication misses
|
|
type SRUserStatsSummary struct {
|
|
DeploymentID string
|
|
PolicyMismatch bool
|
|
UserInfoMismatch bool
|
|
HasUser bool
|
|
HasPolicyMapping bool
|
|
APIVersion string
|
|
}
|
|
|
|
// SRGroupStatsSummary has status of group replication misses
|
|
type SRGroupStatsSummary struct {
|
|
DeploymentID string
|
|
PolicyMismatch bool
|
|
HasGroup bool
|
|
GroupDescMismatch bool
|
|
HasPolicyMapping bool
|
|
APIVersion string
|
|
}
|
|
|
|
// SRBucketStatsSummary has status of bucket metadata replication misses
|
|
type SRBucketStatsSummary struct {
|
|
DeploymentID string
|
|
HasBucket bool
|
|
BucketMarkedDeleted bool
|
|
TagMismatch bool
|
|
VersioningConfigMismatch bool
|
|
OLockConfigMismatch bool
|
|
PolicyMismatch bool
|
|
SSEConfigMismatch bool
|
|
ReplicationCfgMismatch bool
|
|
QuotaCfgMismatch bool
|
|
CorsCfgMismatch bool
|
|
HasTagsSet bool
|
|
HasOLockConfigSet bool
|
|
HasPolicySet bool
|
|
HasSSECfgSet bool
|
|
HasReplicationCfg bool
|
|
HasQuotaCfgSet bool
|
|
HasCorsCfgSet bool
|
|
APIVersion string
|
|
}
|
|
|
|
// SRILMExpiryStatsSummary has status of ILM Expiry rules metadata replication misses
|
|
type SRILMExpiryStatsSummary struct {
|
|
DeploymentID string
|
|
ILMExpiryRuleMismatch bool
|
|
HasILMExpiryRules bool
|
|
APIVersion string
|
|
}
|
|
|
|
// SRSiteSummary holds the count of replicated items in site replication
|
|
type SRSiteSummary struct {
|
|
ReplicatedBuckets int // count of buckets replicated across sites
|
|
ReplicatedTags int // count of buckets with tags replicated across sites
|
|
ReplicatedBucketPolicies int // count of policies replicated across sites
|
|
ReplicatedIAMPolicies int // count of IAM policies replicated across sites
|
|
ReplicatedUsers int // count of users replicated across sites
|
|
ReplicatedGroups int // count of groups replicated across sites
|
|
ReplicatedLockConfig int // count of object lock config replicated across sites
|
|
ReplicatedSSEConfig int // count of SSE config replicated across sites
|
|
ReplicatedVersioningConfig int // count of versioning config replicated across sites
|
|
ReplicatedQuotaConfig int // count of bucket with quota config replicated across sites
|
|
ReplicatedUserPolicyMappings int // count of user policy mappings replicated across sites
|
|
ReplicatedGroupPolicyMappings int // count of group policy mappings replicated across sites
|
|
ReplicatedILMExpiryRules int // count of ILM expiry rules replicated across sites
|
|
ReplicatedCorsConfig int // count of CORS config replicated across sites
|
|
|
|
TotalBucketsCount int // total buckets on this site
|
|
TotalTagsCount int // total count of buckets with tags on this site
|
|
TotalBucketPoliciesCount int // total count of buckets with bucket policies for this site
|
|
TotalIAMPoliciesCount int // total count of IAM policies for this site
|
|
TotalLockConfigCount int // total count of buckets with object lock config for this site
|
|
TotalSSEConfigCount int // total count of buckets with SSE config
|
|
TotalVersioningConfigCount int // total count of bucekts with versioning config
|
|
TotalQuotaConfigCount int // total count of buckets with quota config
|
|
TotalUsersCount int // total number of users seen on this site
|
|
TotalGroupsCount int // total number of groups seen on this site
|
|
TotalUserPolicyMappingCount int // total number of user policy mappings seen on this site
|
|
TotalGroupPolicyMappingCount int // total number of group policy mappings seen on this site
|
|
TotalILMExpiryRulesCount int // total number of ILM expiry rules seen on the site
|
|
TotalCorsConfigCount int // total number of CORS config seen on the site
|
|
APIVersion string
|
|
}
|
|
|
|
// SREntityType specifies type of entity
|
|
type SREntityType int
|
|
|
|
const (
|
|
// Unspecified entity
|
|
Unspecified SREntityType = iota
|
|
|
|
// SRBucketEntity Bucket entity type
|
|
SRBucketEntity
|
|
|
|
// SRPolicyEntity Policy entity type
|
|
SRPolicyEntity
|
|
|
|
// SRUserEntity User entity type
|
|
SRUserEntity
|
|
|
|
// SRGroupEntity Group entity type
|
|
SRGroupEntity
|
|
|
|
// SRILMExpiryRuleEntity ILM expiry rule entity type
|
|
SRILMExpiryRuleEntity
|
|
)
|
|
|
|
// SRStatusOptions holds SR status options
|
|
type SRStatusOptions struct {
|
|
Buckets bool
|
|
Policies bool
|
|
Users bool
|
|
Groups bool
|
|
Metrics bool
|
|
ILMExpiryRules bool
|
|
PeerState bool
|
|
Entity SREntityType
|
|
EntityValue string
|
|
ShowDeleted bool
|
|
APIVersion string
|
|
}
|
|
|
|
// IsEntitySet returns true if entity option is set
|
|
func (o *SRStatusOptions) IsEntitySet() bool {
|
|
switch o.Entity {
|
|
case SRBucketEntity, SRPolicyEntity, SRUserEntity, SRGroupEntity, SRILMExpiryRuleEntity:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// GetSREntityType returns the SREntityType for a key
|
|
func GetSREntityType(name string) SREntityType {
|
|
switch name {
|
|
case "bucket":
|
|
return SRBucketEntity
|
|
case "user":
|
|
return SRUserEntity
|
|
case "group":
|
|
return SRGroupEntity
|
|
case "policy":
|
|
return SRPolicyEntity
|
|
case "ilm-expiry-rule":
|
|
return SRILMExpiryRuleEntity
|
|
default:
|
|
return Unspecified
|
|
}
|
|
}
|
|
|
|
func (o *SRStatusOptions) getURLValues() url.Values {
|
|
urlValues := make(url.Values)
|
|
urlValues.Set("buckets", strconv.FormatBool(o.Buckets))
|
|
urlValues.Set("policies", strconv.FormatBool(o.Policies))
|
|
urlValues.Set("users", strconv.FormatBool(o.Users))
|
|
urlValues.Set("groups", strconv.FormatBool(o.Groups))
|
|
urlValues.Set("showDeleted", strconv.FormatBool(o.ShowDeleted))
|
|
urlValues.Set("metrics", strconv.FormatBool(o.Metrics))
|
|
urlValues.Set("ilm-expiry-rules", strconv.FormatBool(o.ILMExpiryRules))
|
|
urlValues.Set("peer-state", strconv.FormatBool(o.PeerState))
|
|
|
|
if o.IsEntitySet() {
|
|
urlValues.Set("entityvalue", o.EntityValue)
|
|
switch o.Entity {
|
|
case SRBucketEntity:
|
|
urlValues.Set("entity", "bucket")
|
|
case SRPolicyEntity:
|
|
urlValues.Set("entity", "policy")
|
|
case SRUserEntity:
|
|
urlValues.Set("entity", "user")
|
|
case SRGroupEntity:
|
|
urlValues.Set("entity", "group")
|
|
case SRILMExpiryRuleEntity:
|
|
urlValues.Set("entity", "ilm-expiry-rule")
|
|
}
|
|
}
|
|
return urlValues
|
|
}
|
|
|
|
// SRStatusInfo - returns site replication status
|
|
func (adm *AdminClient) SRStatusInfo(ctx context.Context, opts SRStatusOptions) (info SRStatusInfo, err error) {
|
|
q := opts.getURLValues()
|
|
q.Set("api-version", SiteReplAPIVersion)
|
|
|
|
reqData := requestData{
|
|
relPath: adminAPIPrefix + "/site-replication/status",
|
|
queryValues: q,
|
|
}
|
|
|
|
resp, err := adm.executeMethod(ctx, http.MethodGet, reqData)
|
|
defer closeResponse(resp)
|
|
if err != nil {
|
|
return info, err
|
|
}
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return info, httpRespToErrorResponse(resp)
|
|
}
|
|
|
|
err = json.NewDecoder(resp.Body).Decode(&info)
|
|
return info, err
|
|
}
|
|
|
|
// ReplicateEditStatus - returns status of edit request.
|
|
type ReplicateEditStatus struct {
|
|
Success bool `json:"success"`
|
|
Status string `json:"status"`
|
|
ErrDetail string `json:"errorDetail,omitempty"`
|
|
}
|
|
|
|
// SREditOptions holds SR Edit options
|
|
type SREditOptions struct {
|
|
DisableILMExpiryReplication bool
|
|
EnableILMExpiryReplication bool
|
|
}
|
|
|
|
func (o *SREditOptions) getURLValues() url.Values {
|
|
urlValues := make(url.Values)
|
|
urlValues.Set("disableILMExpiryReplication", strconv.FormatBool(o.DisableILMExpiryReplication))
|
|
urlValues.Set("enableILMExpiryReplication", strconv.FormatBool(o.EnableILMExpiryReplication))
|
|
return urlValues
|
|
}
|
|
|
|
// SiteReplicationEdit - sends the SR edit API call.
|
|
func (adm *AdminClient) SiteReplicationEdit(ctx context.Context, site PeerInfo, opts SREditOptions) (ReplicateEditStatus, error) {
|
|
sitesBytes, err := json.Marshal(site)
|
|
if err != nil {
|
|
return ReplicateEditStatus{}, nil
|
|
}
|
|
encBytes, err := EncryptData(adm.getSecretKey(), sitesBytes)
|
|
if err != nil {
|
|
return ReplicateEditStatus{}, err
|
|
}
|
|
|
|
q := opts.getURLValues()
|
|
q.Set("api-version", SiteReplAPIVersion)
|
|
|
|
reqData := requestData{
|
|
relPath: adminAPIPrefix + "/site-replication/edit",
|
|
content: encBytes,
|
|
queryValues: q,
|
|
}
|
|
|
|
resp, err := adm.executeMethod(ctx, http.MethodPut, reqData)
|
|
defer closeResponse(resp)
|
|
if err != nil {
|
|
return ReplicateEditStatus{}, err
|
|
}
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return ReplicateEditStatus{}, httpRespToErrorResponse(resp)
|
|
}
|
|
|
|
var res ReplicateEditStatus
|
|
err = json.NewDecoder(resp.Body).Decode(&res)
|
|
return res, err
|
|
}
|
|
|
|
// SRPeerEdit - used only by minio server to update peer endpoint
|
|
// for a server already in the site replication setup
|
|
func (adm *AdminClient) SRPeerEdit(ctx context.Context, pi PeerInfo) error {
|
|
b, err := json.Marshal(pi)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
q := make(url.Values)
|
|
q.Set("api-version", SiteReplAPIVersion)
|
|
|
|
reqData := requestData{
|
|
relPath: adminAPIPrefix + "/site-replication/peer/edit",
|
|
content: b,
|
|
queryValues: q,
|
|
}
|
|
|
|
resp, err := adm.executeMethod(ctx, http.MethodPut, reqData)
|
|
defer closeResponse(resp)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return httpRespToErrorResponse(resp)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// SRStateEdit - used only by minio server to update peer state
|
|
// for a server already in the site replication setup
|
|
func (adm *AdminClient) SRStateEdit(ctx context.Context, state SRStateEditReq) error {
|
|
b, err := json.Marshal(state)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
q := make(url.Values)
|
|
q.Set("api-version", SiteReplAPIVersion)
|
|
|
|
reqData := requestData{
|
|
relPath: adminAPIPrefix + "/site-replication/state/edit",
|
|
content: b,
|
|
queryValues: q,
|
|
}
|
|
|
|
resp, err := adm.executeMethod(ctx, http.MethodPut, reqData)
|
|
defer closeResponse(resp)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return httpRespToErrorResponse(resp)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// SiteReplicationRemove - unlinks a site from site replication
|
|
func (adm *AdminClient) SiteReplicationRemove(ctx context.Context, removeReq SRRemoveReq) (st ReplicateRemoveStatus, err error) {
|
|
rmvBytes, err := json.Marshal(removeReq)
|
|
if err != nil {
|
|
return st, nil
|
|
}
|
|
q := make(url.Values)
|
|
q.Set("api-version", SiteReplAPIVersion)
|
|
|
|
reqData := requestData{
|
|
relPath: adminAPIPrefix + "/site-replication/remove",
|
|
content: rmvBytes,
|
|
queryValues: q,
|
|
}
|
|
|
|
resp, err := adm.executeMethod(ctx, http.MethodPut, reqData)
|
|
defer closeResponse(resp)
|
|
if err != nil {
|
|
return st, err
|
|
}
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return st, httpRespToErrorResponse(resp)
|
|
}
|
|
var res ReplicateRemoveStatus
|
|
err = json.NewDecoder(resp.Body).Decode(&res)
|
|
return res, err
|
|
}
|
|
|
|
// SRPeerRemove - used only by minio server to unlink cluster replication
|
|
// for a server already in the site replication setup
|
|
func (adm *AdminClient) SRPeerRemove(ctx context.Context, removeReq SRRemoveReq) (st ReplicateRemoveStatus, err error) {
|
|
reqBytes, err := json.Marshal(removeReq)
|
|
if err != nil {
|
|
return st, err
|
|
}
|
|
q := make(url.Values)
|
|
q.Set("api-version", SiteReplAPIVersion)
|
|
|
|
reqData := requestData{
|
|
relPath: adminAPIPrefix + "/site-replication/peer/remove",
|
|
content: reqBytes,
|
|
queryValues: q,
|
|
}
|
|
|
|
resp, err := adm.executeMethod(ctx, http.MethodPut, reqData)
|
|
defer closeResponse(resp)
|
|
if err != nil {
|
|
return st, err
|
|
}
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return st, httpRespToErrorResponse(resp)
|
|
}
|
|
return ReplicateRemoveStatus{}, nil
|
|
}
|
|
|
|
// ReplicateRemoveStatus - returns status of unlink request.
|
|
type ReplicateRemoveStatus struct {
|
|
Status string `json:"status"`
|
|
ErrDetail string `json:"errorDetail,omitempty"`
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
// SRRemoveReq - arg body for SRRemoveReq
|
|
type SRRemoveReq struct {
|
|
RequestingDepID string `json:"requestingDepID"`
|
|
SiteNames []string `json:"sites"`
|
|
RemoveAll bool `json:"all"` // true if all sites are to be removed.
|
|
}
|
|
|
|
// SRStateEditReq - arg body for SRStateEditReq
|
|
type SRStateEditReq struct {
|
|
Peers map[string]PeerInfo `json:"peers"`
|
|
UpdatedAt time.Time `json:"updatedAt"`
|
|
}
|
|
|
|
// SRStateInfo - site replication state information
|
|
type SRStateInfo struct {
|
|
Name string `json:"name"`
|
|
Peers map[string]PeerInfo `json:"peers"`
|
|
UpdatedAt time.Time `json:"updatedAt"`
|
|
APIVersion string `json:"apiVersion,omitempty"`
|
|
}
|
|
|
|
const (
|
|
ReplicateRemoveStatusSuccess = "Requested site(s) were removed from cluster replication successfully."
|
|
ReplicateRemoveStatusPartial = "Some site(s) could not be removed from cluster replication configuration."
|
|
)
|
|
|
|
type ResyncBucketStatus struct {
|
|
Bucket string `json:"bucket"`
|
|
Status string `json:"status"`
|
|
ErrDetail string `json:"errorDetail,omitempty"`
|
|
}
|
|
|
|
// SRResyncOpStatus - returns status of resync start request.
|
|
type SRResyncOpStatus struct {
|
|
OpType string `json:"op"` // one of "start" or "cancel"
|
|
ResyncID string `json:"id"`
|
|
Status string `json:"status"`
|
|
Buckets []ResyncBucketStatus `json:"buckets"`
|
|
ErrDetail string `json:"errorDetail,omitempty"`
|
|
}
|
|
|
|
// SiteResyncOp type of resync operation
|
|
type SiteResyncOp string
|
|
|
|
const (
|
|
// SiteResyncStart starts a site resync operation
|
|
SiteResyncStart SiteResyncOp = "start"
|
|
// SiteResyncCancel cancels ongoing site resync
|
|
SiteResyncCancel SiteResyncOp = "cancel"
|
|
)
|
|
|
|
// SiteReplicationResyncOp - perform a site replication resync operation
|
|
func (adm *AdminClient) SiteReplicationResyncOp(ctx context.Context, site PeerInfo, op SiteResyncOp) (SRResyncOpStatus, error) {
|
|
reqBytes, err := json.Marshal(site)
|
|
if err != nil {
|
|
return SRResyncOpStatus{}, nil
|
|
}
|
|
|
|
v := url.Values{}
|
|
v.Set("operation", string(op))
|
|
v.Set("api-version", SiteReplAPIVersion)
|
|
|
|
reqData := requestData{
|
|
relPath: adminAPIPrefix + "/site-replication/resync/op",
|
|
content: reqBytes,
|
|
queryValues: v,
|
|
}
|
|
|
|
resp, err := adm.executeMethod(ctx, http.MethodPut, reqData)
|
|
defer closeResponse(resp)
|
|
if err != nil {
|
|
return SRResyncOpStatus{}, err
|
|
}
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return SRResyncOpStatus{}, httpRespToErrorResponse(resp)
|
|
}
|
|
|
|
var res SRResyncOpStatus
|
|
err = json.NewDecoder(resp.Body).Decode(&res)
|
|
return res, err
|
|
}
|
|
|
|
// SRMetric - captures replication metrics for a site replication peer
|
|
type SRMetric struct {
|
|
DeploymentID string `json:"deploymentID"`
|
|
Endpoint string `json:"endpoint"`
|
|
TotalDowntime time.Duration `json:"totalDowntime"`
|
|
LastOnline time.Time `json:"lastOnline"`
|
|
Online bool `json:"isOnline"`
|
|
|
|
Latency LatencyStat `json:"latency"`
|
|
|
|
// replication metrics across buckets roll up
|
|
ReplicatedSize int64 `json:"replicatedSize"`
|
|
// Total number of completed operations
|
|
ReplicatedCount int64 `json:"replicatedCount"`
|
|
// ReplicationErrorStats captures replication errors
|
|
Failed TimedErrStats `json:"failed,omitempty"`
|
|
// XferStats captures transfer stats
|
|
XferStats map[replication.MetricName]replication.XferStats `json:"transferSummary"`
|
|
// MRFStats captures current backlog entries in the last 5 minutes
|
|
MRFStats replication.ReplMRFStats `json:"mrfStats"`
|
|
// DowntimeInfo captures the link information
|
|
DowntimeInfo DowntimeInfo `json:"downtimeInfo"`
|
|
}
|
|
|
|
// WorkerStat captures number of replication workers
|
|
type WorkerStat struct {
|
|
Curr int `json:"curr"`
|
|
Avg float32 `json:"avg"`
|
|
Max int `json:"max"`
|
|
}
|
|
|
|
// InQueueMetric holds stats for objects in replication queue
|
|
type InQueueMetric struct {
|
|
Curr QStat `json:"curr" msg:"cq"`
|
|
Avg QStat `json:"avg" msg:"aq"`
|
|
Max QStat `json:"max" msg:"pq"`
|
|
}
|
|
|
|
// InProgressMetric holds stats for objects with replication in progress
|
|
type InProgressMetric InQueueMetric
|
|
|
|
// QStat represents number of objects and bytes in queue
|
|
type QStat struct {
|
|
Count float64 `json:"count"`
|
|
Bytes float64 `json:"bytes"`
|
|
}
|
|
|
|
// Add two QStat
|
|
func (q *QStat) Add(o QStat) QStat {
|
|
return QStat{Bytes: q.Bytes + o.Bytes, Count: q.Count + o.Count}
|
|
}
|
|
|
|
// SRMetricsSummary captures summary of replication counts across buckets on site
|
|
// along with op metrics rollup.
|
|
type SRMetricsSummary struct {
|
|
// op metrics roll up
|
|
ActiveWorkers WorkerStat `json:"activeWorkers"`
|
|
// Total Replica size in bytes
|
|
ReplicaSize int64 `json:"replicaSize"`
|
|
// Total count of replica received
|
|
ReplicaCount int64 `json:"replicaCount"`
|
|
// queue metrics
|
|
Queued InQueueMetric `json:"queued"`
|
|
// in progress metrics
|
|
InProgress InProgressMetric `json:"inProgress"`
|
|
// proxied metrics
|
|
Proxied ReplProxyMetric `json:"proxied"`
|
|
// replication metrics summary for each site replication peer
|
|
Metrics map[string]SRMetric `json:"replMetrics"`
|
|
// uptime of node being queried for site replication metrics
|
|
Uptime int64 `json:"uptime"`
|
|
// represents the retry count
|
|
Retries Counter `json:"retries"`
|
|
// represents the error count
|
|
Errors Counter `json:"errors"`
|
|
// Aggregate windowed replicated stats (outbound to all site peers).
|
|
//
|
|
// Deprecated: this cluster-level rollup is retained for backward
|
|
// compatibility during rolling upgrades. Prefer ReplicatedByDeployment
|
|
// for per-peer data; this field will be removed in a future release.
|
|
Replicated ReplicationWindowedStats `json:"replicated"`
|
|
// Aggregate windowed received stats (inbound from all site peers).
|
|
Received ReplicationWindowedStats `json:"received"`
|
|
// Per-deployment windowed replicated stats, keyed by deployment ID.
|
|
ReplicatedByDeployment map[string]ReplicationWindowedStats `json:"replicatedByDeployment,omitempty"`
|
|
// Per-deployment windowed failed/error stats, keyed by deployment ID.
|
|
FailedByDeployment map[string]ReplicationWindowedStats `json:"failedByDeployment,omitempty"`
|
|
ReceivedByBucket map[string]ReplicationWindowedStats `json:"receivedByBucket,omitempty"`
|
|
ReplicatedByBucketArn map[string]map[string]ReplicationWindowedStats `json:"replicatedByBucketArn,omitempty"`
|
|
FailedByBucketArn map[string]map[string]ReplicationWindowedStats `json:"failedByBucketArn,omitempty"`
|
|
}
|
|
|
|
// ReplicationWindowedStats holds count and bytes across time windows for
|
|
// replication data transfer (both inbound and outbound).
|
|
type ReplicationWindowedStats = ReplicationReceivedStats
|
|
|
|
// Counter denotes the counts
|
|
type Counter struct {
|
|
// Counted last 1hr
|
|
Last1hr uint64 `json:"last1hr"`
|
|
// Counted last 1m
|
|
Last1m uint64 `json:"last1m"`
|
|
// Total count
|
|
Total uint64 `json:"total"`
|
|
}
|
|
|
|
// ReplProxyMetric holds stats for replication proxying
|
|
type ReplProxyMetric struct {
|
|
PutTagTotal uint64 `json:"putTaggingProxyTotal" msg:"ptc"`
|
|
GetTagTotal uint64 `json:"getTaggingProxyTotal" msg:"gtc"`
|
|
RmvTagTotal uint64 `json:"removeTaggingProxyTotal" msg:"rtc"`
|
|
GetTotal uint64 `json:"getProxyTotal" msg:"gc"`
|
|
HeadTotal uint64 `json:"headProxyTotal" msg:"hc"`
|
|
PutTagFailedTotal uint64 `json:"putTaggingProxyFailed" msg:"ptc"`
|
|
GetTagFailedTotal uint64 `json:"getTaggingProxyFailed" msg:"gtc"`
|
|
RmvTagFailedTotal uint64 `json:"removeTaggingProxyFailed" msg:"rtc"`
|
|
GetFailedTotal uint64 `json:"getProxyFailed" msg:"gc"`
|
|
HeadFailedTotal uint64 `json:"headProxyFailed" msg:"hc"`
|
|
}
|
|
|
|
// Add updates proxy metrics
|
|
func (p *ReplProxyMetric) Add(p2 ReplProxyMetric) {
|
|
p.GetTagTotal += p2.GetTagTotal
|
|
p.PutTagTotal += p2.PutTagTotal
|
|
p.RmvTagTotal += p2.RmvTagTotal
|
|
p.GetTotal += p2.GetTotal
|
|
p.HeadTotal += p2.HeadTotal
|
|
p.PutTagFailedTotal += p2.PutTagFailedTotal
|
|
p.GetTagFailedTotal += p2.GetTagFailedTotal
|
|
p.RmvTagFailedTotal += p2.RmvTagFailedTotal
|
|
p.GetFailedTotal += p2.GetFailedTotal
|
|
p.HeadFailedTotal += p2.HeadFailedTotal
|
|
}
|