rgw

package
v1.0.0 Latest Latest
Warning

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

Go to latest
Published: Nov 16, 2026 License: MIT Imports: 30 Imported by: 0

README

Ceph RGW

Import github.com/JSYoo5B/ceph-testcontainers-go/rgw to give an application that uses S3 (or Swift) a disposable Ceph cluster with one or more gateways and the server-side state its integration test needs: an S3 endpoint the test can reach (optionally native HTTPS), users with explicit Admin Ops capabilities, tenants, quotas and suspension, STS roles with their policies, rate limits, and storage counters. Accounts and their root users are in rgw/account, placement targets with storage classes in rgw/placement, and the persistent queues of bucket notification topics in rgw/notification; a test that needs one gateway and an S3 user reads this package alone. Object operations belong to the S3 client under test; the package adds no S3 SDK. See API purpose and purpose tags.

go get github.com/JSYoo5B/ceph-testcontainers-go/rgw

Order of use

  1. Start a cluster with a gateway: rgw.Run(ctx, ceph.DefaultImage, opts...); rgw.WithGateways(rgw.Config{...}) selects other gateways (also on ceph.Run, rbd.Run and cephfs.Run), and rgw.Start adds one to a running cluster. When the test needs server-side RGW options (lifecycle clock, usage log, STS key, KMS backend), start with ceph.Run, apply them with override.SetConfig, then call rgw.Start: gateways read them at start.
  2. Prepare the identities the scenario needs on a *rgw.Gateway (from Gateways or Start): CreateUser (with tenant, Admin Ops caps, bucket limit), User.SetQuota / SetBucketQuota, User.Suspend, and User.CreateS3Key / S3Key.Revoke for credential rotation, and CreateRole for a role that the SUT assumes with STS. For an account, create it with account.Create(ctx, gateway, cfg) and its root user with CreateUser and UserConfig.Account; for a placement target, use placement.Create(ctx, gateway, cfg), then Placement.Apply and Placement.SetUserDefault.
  3. Hand the endpoint to the SUT: S3Endpoint (or S3SecureEndpoint) for a client on the test host, DaemonEndpoint for a client in the cluster network, with User.CreationKey().Credentials() or the credentials of a key from CreateS3Key (or the gateway's own AccessKey / SecretKey) and Gateway.Region, path-style addressing. For STS, hand off Role.ARN() as well: the SUT calls AssumeRole on the same endpoint.
  4. Throttle the SUT when the scenario tests its reaction to 503 SlowDown: User.OverrideRateLimit applies a rgw.RateLimit to the user (rgw.RateLimitScope{}) or to one bucket it owns (RateLimitScope{Bucket: ...}, such as a bucket the SUT created), and the returned handle's Restore puts the prior policy back. The user scope needs Ceph 20: on Squid it returns ceph.ErrUnsupported, because a Squid gateway never applies a user's policy to requests its S3 keys sign. A user that stored no policy is restored to the stored native default, every budget zero and disabled, because radosgw-admin cannot delete a policy; on Umbrella, where ratelimit get reports such a user as ENOENT, it then reports the default (see Known release issues).
  5. Replace the certificate when the scenario tests how the SUT meets a renewed certificate or a changed CA: Gateway.ReplaceTLS installs a new rgw.TLSConfig and restarts the gateway; resolve S3SecureEndpoint again and give the SUT the new CA the way it reads its configuration.
  6. Observe and verify: User.Info, User.Usage, notification.Queue for a persistent notification topic, and Gateway.Admin for anything without a typed API. rgw/expect evaluates one captured User.Usage observation against a stated owner and totals.
  7. Clean up: terminate the cluster; gateways, users and data go with it. Gateway.Remove, User.Remove and Role.Remove are for tests of those steps.

The smallest S3 fixture keeps one daemon of each kind and single-copy pools:

cluster, err := rgw.Run(ctx, ceph.DefaultImage,
	ceph.WithClusterConfig(ceph.ClusterConfig{}.WithMonitorCount(1).WithManagerCount(1).WithOSDCount(1).WithPoolDefaults(1, 1)),
)
testcontainers.CleanupContainer(t, cluster)
if err != nil {
	t.Fatal(err)
}
gateways, err := rgw.Gateways(ctx, cluster.Container)
if err != nil {
	t.Fatal(err)
}
gateway := gateways[0]
endpoint, err := gateway.S3Endpoint(ctx)
if err != nil {
	t.Fatal(err)
}
// Use endpoint, gateway.AccessKey, gateway.SecretKey and gateway.Region with a
// path-style S3 client. Keep the keys out of test logs.

It runs four containers (MON with the Ceph CLIs, MGR, OSD, gateway). With one OSD and one copy nothing recovers from an OSD failure; tests of OSD faults or recovery need the default two OSDs or more.

Concepts and limits

  • Everything in ceph applies to the cluster. Multisite (one realm across clusters, zones, zonegroups, sync policy) is in rgw/multisite.
  • Images: gateways use the cluster's RGW role. That is the Run image, such as the aggregate ceph.DefaultImage, unless ceph.ImageOptions.WithImageSet selects an ImageSet whose RGW role differs, and ceph.ImageOptions.WithRGWImage replaces either. The gateway image must contain radosgw and radosgw-admin (Gateway.Admin runs inside the gateway). Keep every role on the same Ceph release and architecture. ceph.DefaultImage is Tentacle 20.2.4; Squid 19.2.5 is supported. See Releases and images.
  • Identities belong to the cluster and scope that created them, not to one gateway: user handles, and the account and placement handles of the feature packages, run through any running gateway of their scope, and a gateway can be removed without removing them. Copies of a handle share its state.
  • An account's root user is an ordinary *rgw.User created with UserConfig.Account; the gateway must belong to the account's cluster and scope, and every later operation on the user checks the account's native lifetime again.
  • Credential rotation keeps the user and its data: User.CreateS3Key adds a key pair, and S3Key.Revoke removes one irreversibly (nothing restores it). Each *rgw.S3Key names one key pair for good, so creating a key never changes what an earlier handle or copied credentials mean, and a revoked handle still returns its credentials for refusal checks. The fixture touches only the keys it created: keys added with Gateway.Admin stay as they are. The last active fixture-created key of a user cannot be revoked, because it identifies the owned user; create its replacement first. A failed CreateS3Key is never retried by the fixture: a returned key whose outcome is unknown is only revocable, and its Revoke settles and removes it.
  • Creating or revoking a key changes what RGW accepts, not what the SUT uses: it does not show that the SUT reloaded its configuration or dropped a cached credential. Hand the new key to the SUT the way it reads its configuration, and assert with requests the SUT makes afterwards. RGW refuses a revoked key once its metadata caches see the removal, so poll with new requests.
  • A role is created with its trust policy and inline permission policies, in the empty tenant and outside any account, and the fixture hands off its ARN only; AssumeRole, temporary credentials and their use belong to the SUT, and the package adds no STS client. STS needs rgw_sts_key (a session-token key, such as the output of ceph-authtool --gen-print-key) and rgw_s3_auth_use_sts=true, set with override.SetConfig before rgw.Start; without them the role exists but AssumeRole fails. An existing role of the same name is refused, never adopted, and Role.Remove deletes only the fixture's policies and role: it refuses a role that was replaced, whose trust policy, tags or metadata changed, or that holds a policy the fixture did not put, and leaves it as it is. A failed CreateRole is never retried: a returned role whose outcome is unknown is only removable, and a role whose policy RGW refused is returned with the error so that its Remove cleans it up. Policy and trust edits reach RGW through metadata caches, so poll with new requests.
  • Endpoints change on restart: in bridge mode a restarted gateway can get a new mapped host port. Resolve S3Endpoint again after any restart, including the ones done by Gateway.ReplaceTLS, Placement.Apply, Placement.Reload and multisite changes. A test whose SUT must keep one URL while gateways stop or move uses the stable endpoint recipe.
  • Quota enforcement, suspension, placement defaults, rate limits and usage counters go through caches and asynchronous accounting: poll with new requests instead of asserting right after a change. Usage log persistence is asynchronous too.
  • A rate limit is a per-minute budget that every gateway process counts on its own: two gateways serving the same bucket admit up to twice the budget, so it is not a cluster-wide request budget. A bucket scope throttles every request to that bucket, whoever signs it; a user scope throttles every request the user signs. The handle only references a bucket: it never deletes it, and a bucket the SUT deletes and creates again is a different bucket, whose restoration the handle refuses.
  • HTTPS is native Beast TLS without a proxy; clients must trust the CA. NetworkConfig.WithMessengerMode encrypts Ceph messenger traffic only.
  • Beast loads its certificate only when the gateway starts; replacing the file is not reloaded. Gateway.ReplaceTLS therefore restarts the gateway: it refuses connections meanwhile, connections established before are closed (not moved to the new certificate), and a request in flight can fail with an unknown outcome. Only new connections see the new certificate, and every later start of the container, including a caller's own Stop and Start, is ready only when it serves that certificate. A failed restart leaves the new certificate installed; nothing rolls it back.
  • Printing a handle never writes keys; Gateway.Admin output can contain keys, and a failed call never includes native output. Every key the fixture created or tried to create, revoked ones included, is masked in diagnostics reports.
  • Gateways run 4 worker threads: functional tests, not load tests. Docker exec cancellation does not stop a native worker already running (such as bucket sync run).
  • Out of scope: managing a KMS (see Server-side encryption with an external KMS for wiring a test-owned Vault), other KMS backends, Swift large objects, temporary URLs and Keystone catalogues.

Stable endpoint across gateways

The package has no load balancer. A test that needs the SUT to keep one URL while the gateway behind it stops or changes composes one from what the package already hands off: start two gateways in the same zone with the same TLSConfig, read each one's S3SecureEndpoint, and run a test-owned TCP forwarder that listens on one fixed address and connects every new client connection to the gateway the test currently selects. The forwarder copies bytes only, so TLS runs end to end and the SUT verifies the gateway's own certificate. The test switches the selection, stops the first gateway with Stop, and asserts with new requests of the SUT.

Use the stable endpoint integration test as the working example. It checks both gateway starts and secure endpoint lookups before creating the forwarder. It confirms a write through A, selects B, checks that stopping A succeeds, then reads the object through the unchanged URL and checks the connections to B.

The forwarder chooses a backend when a connection opens and never checks health, retries or replays a request, or moves an established connection, so a request in flight when a gateway stops has an unknown outcome and the SUT's own retry decides what happens next. In bridge mode, read the endpoints again after any gateway restart, because the forwarder addresses mapped host ports. Both gateways serve the same cluster storage: this is gateway failover, not replicated storage.

Server-side encryption with an external KMS

The package has no KMS type. The test owns the KMS (a Vault container, its keys, policies and tokens) and wires RGW to it with what the package already has: override.SetConfig for the RGW options and testcontainers.WithFiles on rgw.Start for the token and CA files.

cluster, err := ceph.Run(ctx, ceph.DefaultImage)
testcontainers.CleanupContainer(t, cluster)
if err != nil {
	t.Fatal(err)
}
// Vault runs on the cluster bridge with the alias "vault", which is also in
// its certificate. kmsToken may read one KV-v2 key; sseS3Token manages keys of
// one Transit mount.
for _, s := range []ceph.ConfigSetting{
	{Section: "client.admin", Name: "rgw_crypt_s3_kms_backend", Value: "vault"},
	{Section: "client.admin", Name: "rgw_crypt_vault_auth", Value: "token"},
	{Section: "client.admin", Name: "rgw_crypt_vault_token_file", Value: "/tc/kms-token"},
	{Section: "client.admin", Name: "rgw_crypt_vault_addr", Value: "https://vault:8200"},
	{Section: "client.admin", Name: "rgw_crypt_vault_prefix", Value: "/v1/kv/data"},
	{Section: "client.admin", Name: "rgw_crypt_vault_secret_engine", Value: "kv"},
	{Section: "client.admin", Name: "rgw_crypt_vault_verify_ssl", Value: "true"},
	{Section: "client.admin", Name: "rgw_crypt_vault_ssl_cacert", Value: "/tc/vault-ca.pem"},
	// SSE-S3 has its own rgw_crypt_sse_s3_* options of the same names,
	// with the transit engine and its own token file.
} {
	change, err := override.SetConfig(ctx, cluster, s)
	t.Cleanup(func() {
		cleanup, cancel := context.WithTimeout(context.Background(), time.Minute)
		defer cancel()
		if err := change.Restore(cleanup); err != nil {
			t.Errorf("restore %s: %v", s.Name, err)
		}
	})
	if err != nil {
		t.Fatal(err)
	}
}
gateway, err := rgw.Start(ctx, cluster, rgw.Config{Name: "s3", TLS: material},
	testcontainers.WithFiles(
		testcontainers.ContainerFile{Reader: bytes.NewReader(kmsToken), ContainerFilePath: "/tc/kms-token", FileMode: 0o600},
		testcontainers.ContainerFile{Reader: bytes.NewReader(vaultCA), ContainerFilePath: "/tc/vault-ca.pem", FileMode: 0o600},
	))
if err != nil {
	t.Fatal(err)
}

TestRGWExternalKMS in internal/integration/rgw runs the recipe for both modes. What the recipe relies on:

  • There are two TLS connections. TLSConfig secures the SUT's connection to RGW; rgw_crypt_vault_verify_ssl and rgw_crypt_vault_ssl_cacert (and their sse_s3 twins) secure RGW's connection to Vault. With rgw_crypt_require_ssl left at true, RGW refuses SSE requests over plain HTTP.
  • Every gateway runs as client.admin, so the options apply to every gateway of the cluster and are read when a gateway starts: set them before rgw.Start. Gateways differ only in the files at those paths. A gateway given an unrelated CA answers an encrypted GET with 500, while its sibling with the right CA reads the exact bytes and the unrelated one still serves listings and unencrypted objects.
  • To change a gateway's CA, replace the file and restart the gateway (Stop, Start, then resolve its endpoint again). A running gateway need not read the CA file again: on Umbrella it keeps answering 500 after the file is replaced, while Tentacle reads the new file on the next request.
  • RGW reads the token file on every Vault request, so a test replaces a token by writing the new one next to the file and renaming it over the same path (keep mode 0600), without restarting the gateway.
  • RGW keeps its connection to Vault open, so a cut KMS surfaces only when libcurl's low-speed limit aborts a request: lower rgw_curl_low_speed_time (5 minutes by default) for a test that cuts the KMS. Reattaching Vault's endpoint can publish its port on another host port; resolve PortEndpoint again before the next management request.
  • With SSE-S3, a bucket DELETE is no proof that RGW removed the bucket's Transit key; check the key in Vault and delete an orphan as the KMS operator.

What RGW answers when the token is revoked or the KMS is cut, and how key deletion differs between releases, is recorded by the experiment case rgw_kms_failure_modes.

Reference

Documentation

Overview

Package rgw prepares RADOS Gateway fixtures in disposable Ceph clusters: gateways, S3 users with tenants, Admin Ops capabilities, quotas, S3 key rotation, STS roles, reversible rate limits and storage counters, and native TLS with certificate replacement. Accounts are in package rgw/account, placement targets and storage classes in package rgw/placement, persistent notification queue observations in package rgw/notification, and multisite orchestration across clusters in package rgw/multisite; this package imports none of them.

Run starts a cluster with at least one gateway. Start adds a gateway to a cluster created by ceph.Run or another service package's Run, and WithGateways selects gateways for any of those Run functions.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func WithGateways

func WithGateways(configs ...Config) ceph.Option

WithGateways starts named gateways during Run. No arguments starts one default gateway. Repeated options replace the list. All gateways share this cluster's backing zone; multisite scope is configured separately by multisite.Run.

Types

type AdminCapability

type AdminCapability struct {
	Type       string `json:"type"`
	Permission string `json:"perm"`
}

AdminCapability is one admin capability of a user. Type is the capability type, such as users, usage, ratelimit or buckets; Permission is read, write, or * when both were granted (* does not mean global admin).

type Config

type Config struct {
	Name, Realm, Zonegroup, Zone, Region string
	SkipUserCreation                     bool
	TLS                                  *TLSConfig
}

Config selects a gateway instance and optional native RGW multisite scope. Name defaults to default; different names allow multiple gateways in one zone. Realm, Zonegroup and Zone must already exist when supplied. Region defaults to us-east-1. SkipUserCreation is useful when sharing existing S3 credentials or configuring multisite users through radosgw-admin.

type Container

type Container struct {
	*ceph.Container
}

Container is a cluster started by Run. It embeds *ceph.Container, so every cluster method is available on it; pass its Container field to functions that take a *ceph.Container, such as those of this and the other service packages.

func Run

Run starts a disposable cluster for S3 and Swift clients. It accepts every ceph.Run option and the options of other service packages. When no WithGateways option is given, it starts the default gateway and creates its test user. Bootstrap options that leave the cluster without OSDs or managers for the gateway, such as ceph.ClusterConfig.WithNoInitialOSDs, are rejected; use ceph.Run for those stages. A non-nil Container returned with an error must still be terminated.

Example
package main

import (
	"context"
	"log"

	"github.com/JSYoo5B/ceph-testcontainers-go/ceph"
	"github.com/JSYoo5B/ceph-testcontainers-go/rgw"
	"github.com/testcontainers/testcontainers-go"
)

func main() {
	ctx := context.Background()
	cluster, err := rgw.Run(ctx, ceph.DefaultImage,
		rgw.WithGateways(rgw.Config{Name: "s3", SkipUserCreation: true}),
	)
	defer func() {
		if err := testcontainers.TerminateContainer(cluster); err != nil {
			log.Printf("failed to terminate container: %s", err)
		}
	}()
	if err != nil {
		panic(err)
	}
	gateways, err := rgw.Gateways(ctx, cluster.Container)
	if err != nil {
		panic(err)
	}
	gateway := gateways[0]
	user, err := gateway.CreateUser(ctx, rgw.UserConfig{ID: "app"})
	if err != nil {
		panic(err)
	}
	endpoint, err := gateway.S3Endpoint(ctx)
	if err != nil {
		panic(err)
	}
	// Sign S3 requests to endpoint with user.CreationKey().Credentials().
	_, _ = user, endpoint
}

type Gateway

type Gateway struct {
	testcontainers.Container

	GatewayName string
	AccessKey   string
	SecretKey   string
	// Region is the SigV4 signing region: Config.Region, which defaults to
	// us-east-1, or for a multisite gateway its zonegroup name. RGW itself
	// is not configured with it.
	Region string
	// contains filtered or unexported fields
}

Gateway is an optional S3 gateway owned by its Ceph cluster. AccessKey and SecretKey belong to a generated ordinary S3 user for trusted tests.

Gateway embeds testcontainers.Container, so Stop, Start, Logs, Exec and Inspect act on the gateway container. Formatting a Gateway, User or TLSConfig with any fmt verb, including %+v and %#v, prints only an identifying label such as "RGW gateway s3"; credentials and TLS keys are read explicitly from the fields or User.CreationKey().Credentials(). A gateway runs with 4 worker threads: enough for functional tests, not for load tests. Rate limits are enforced by each gateway separately. Copies of a Gateway share its identity; Remove accepts only the descriptor that Start or Gateways returned.

func Gateways

func Gateways(ctx context.Context, c *ceph.Container) ([]*Gateway, error)

Gateways returns sorted owned gateway descriptors, including partial startup attempts, while bounding the wait for fixture topology by ctx.

func Start

Start starts an independently owned, named gateway on an existing cluster. A zero config starts the default gateway and creates its test user. Customizers are applied last; preserve the required command, network and listener settings. A non-nil result returned with an error remains owned by the cluster for cleanup.

In host mode the port is reserved on the Docker host and released just before the daemon binds it; if another process takes it in between, startup is retried with a new port, up to five attempts. Server-side RGW options are read when a gateway starts: set them with override.SetConfig on a cluster from ceph.Run, then call Start. RGW runs as client.admin, so options in a ceph.WithConfigFile file belong in [client] or [client.admin].

func (*Gateway) Admin

func (g *Gateway) Admin(ctx context.Context, args ...string) ([]byte, error)

Admin invokes radosgw-admin inside this running gateway, preserving its realm, zonegroup, zone, Ceph configuration and keyring. The RGW role image supplies the CLI. Native arguments are passed individually, without a shell. Success output may contain credentials; failed command output is redacted. This is an explicit escape hatch for native operations beyond typed helpers; do not race raw user edits with owned-user creation or mutation.

--format json is always added. Arguments must not contain control characters, so pass JSON documents (policies, trust documents) as single-line strings. Arguments that would change the scope or connection are refused with ceph.ErrInvalidRequest: --rgw-realm, --rgw-zonegroup, --rgw-zone and their ID and name variants, --conf/-c, --keyring/-k, --name/-n, --id, --mon-host/-m, --cluster and similar flags.

The call is bounded by ctx alone, like Container.Ceph: the cluster's startup timeout bounds bootstrap, readiness and the typed operations, not a native command whose duration the caller chooses, so give ctx the deadline the command needs. No radosgw-admin outlives the call: a small sh supervisor in the gateway container stops the command with SIGTERM, then SIGKILL after 2 s, 15 s before ctx's deadline (at half the remaining time for a short one; ceph.ErrNativeFailure, "radosgw-admin still ran after Ns and was stopped"), when ctx ends first (Admin then stops it under its own budget of about 10 s and returns ctx's error only after the command is gone; a call that ends before Docker started the command makes sure it never starts), or when the cluster's Terminate starts. When Admin cannot confirm the stop, for example because the gateway is paused or the engine is unreachable, it returns a *ceph.NativeCommandUnstoppedError whose Stop retries; Terminate retries too. Stopping radosgw-admin does not undo a request it already sent: the outcome of a stopped mutation is unknown and Admin never repeats it.

A failure keeps a *ceph.NativeFailure with the exit code and errno but no reason, so errors.Is(err, fs.ErrNotExist) works; run the same command with Exec to see the native text. When radosgw-admin reports a fatal signal, the error text also names the signal, its thread and the first backtrace frames, and says how many bytes of standard output it wrote and whether they are one complete JSON document, never what they say.

func (*Gateway) CreateRole added in v0.5.0

func (g *Gateway) CreateRole(ctx context.Context, config RoleConfig) (*Role, error)

CreateRole creates a fresh native role with its trust policy through this gateway, with radosgw-admin role create, then puts its permission policies in order with role-policy put, so a test can hand the role's ARN to the SUT. An existing role of the same name is refused, never adopted or changed, and so is a name that another role handle of this cluster still tracks. Each mutation gets a separate role get to read back its outcome even if ctx ends after dispatch. The read keeps the admin operation deadline, with at least ten seconds for readback. No mutation is replayed:

  • a nil error returns the role with all its policies;
  • a non-nil role with an error is tracked and its Remove removes what the fixture created: when native state showed the role, ARN returns it and the error says what failed, such as a policy whose outcome is unknown; otherwise whether the role exists is unknown and ARN refuses it;
  • a nil role with an error means that RGW shows that no role was created, or that nothing was attempted.

Native role edits of the same name from Admin or external clients must not race this operation.

func (*Gateway) CreateUser

func (g *Gateway) CreateUser(ctx context.Context, config UserConfig) (*User, error)

CreateUser creates a fresh S3 identity and, optionally, explicit Admin Ops capabilities. Existing IDs are rejected without changing their keys or policy. A non-nil handle with an error records an attempted or partial creation. If the generated credentials were confirmed, the handle supports Info and Remove even after a later capability setup failure. If the creation response is malformed, truncated or missing keys, credentials and ownership cannot be confirmed. Remove can establish absence after the create command has ended. A user still present requires inspection through Admin or termination of the disposable cluster. Native user edits from external clients must not race this operation.

With UserConfig.Account the user is that account's root user. The account must be active and created through a gateway of this gateway's cluster and scope; its native metadata lifetime is captured, and every later operation on the root user checks it again.

func (*Gateway) DaemonEndpoint

func (c *Gateway) DaemonEndpoint(ctx context.Context) (string, error)

DaemonEndpoint returns the HTTP address used by peers in the gateway's Docker network or daemon-host namespace. Host mode returns the advertised address; bridge mode returns the gateway's IP in its Ceph cluster network. The caller must share or reach that network. Use S3Endpoint for host application clients.

On a ceph.AddressDualStack cluster it returns the gateway's IPv4 address; the gateway listens on 0.0.0.0:7480 and [::]:7480, so clients in the cluster network reach it over its IPv6 address on port 7480 too.

func (Gateway) Format added in v0.4.0

func (g Gateway) Format(f fmt.State, _ rune)

Format prints String for every verb and flag, so no verb, such as %d or %t, walks the fields.

func (Gateway) GoString

func (g Gateway) GoString() string

GoString formats the gateway like String, so %#v does not print its credentials.

func (*Gateway) Remove added in v0.4.0

func (g *Gateway) Remove(ctx context.Context) error

Remove removes this owned gateway container. Zone configuration, S3 users, buckets and data remain available through other gateways or a replacement. Multisite period endpoints are not changed automatically. The last gateway can be removed because RGW is optional. Failed cleanup remains tracked. A gateway that Remove already removed, or that is not the one the cluster owns for its name, returns an error.

func (*Gateway) ReplaceTLS added in v0.5.0

func (g *Gateway) ReplaceTLS(ctx context.Context, config TLSConfig) error

ReplaceTLS replaces the certificate chain and private key that this gateway's native HTTPS listener serves, for a test of how the SUT meets a renewed certificate or a changed CA. Beast loads them only when the gateway starts, so ReplaceTLS installs them in the gateway container and restarts it: the gateway refuses connections while it restarts, connections established before are closed rather than moved to the new certificate, and requests in flight can fail with an unknown outcome. Only connections made afterwards see the new certificate. The restart completes when the listener presents the new leaf certificate, and every later start of the container expects it too.

In bridge mode the restarted gateway can get new mapped host ports: call S3SecureEndpoint and S3Endpoint again afterwards. In host mode it keeps its selected ports. The gateway must be running, and config must hold a valid PEM chain and its unencrypted private key; the bytes are copied. Trust is the SUT's own: ReplaceTLS changes no client configuration, so a test supplies the new CA to the SUT the way it reads its configuration. When the gateway does not stop, the previous material is put back; when it stopped and fails to start, the error is returned with the new material installed and no rollback, which would need another restart. To return to the previous certificate, call ReplaceTLS with it again; that restarts the gateway once more.

func (*Gateway) S3Endpoint

func (c *Gateway) S3Endpoint(ctx context.Context) (string, error)

S3Endpoint returns the HTTP endpoint for host S3 clients. Bridge mode uses its mapped port; host mode uses the selected daemon port. The default 127.0.0.1 address uses the Docker provider host, while a custom host address is returned directly, matching the gateway's bind address. Configure clients to use path-style addressing and the test credentials.

Sign with Gateway.Region. In bridge mode the mapped port can change whenever the gateway container restarts (placement activation of package rgw/placement, multisite sync group and zone changes, or the caller's own Stop and Start): call S3Endpoint again afterwards.

func (*Gateway) S3SecureEndpoint

func (g *Gateway) S3SecureEndpoint(ctx context.Context) (string, error)

S3SecureEndpoint returns the native HTTPS listener's mapped or selected host endpoint. It returns an error when TLS was not configured. This method does not disable certificate verification or alter application TLS settings.

func (Gateway) String

func (g Gateway) String() string

String names the gateway without its S3 credentials or TLS key.

type Quota

type Quota struct {
	Enabled      bool
	MaxSizeBytes int64
	MaxObjects   int64
}

Quota uses bytes, matching modern radosgw-admin output. For each limit, -1 disables that limit; zero is an actual zero limit. Enabled controls whether the configured limits are enforced. Native RGW quota caches and asynchronous accounting can delay enforcement; reading this policy does not flush caches.

type RateLimit added in v0.5.0

type RateLimit struct {
	Enabled                                              bool
	MaxReadOps, MaxWriteOps, MaxReadBytes, MaxWriteBytes int64
}

RateLimit is one native RGW rate-limit policy, applied as a whole: the enabled flag and four budgets. Each budget counts requests (MaxReadOps, MaxWriteOps) or payload bytes (MaxReadBytes, MaxWriteBytes) per minute, and zero leaves that dimension unlimited; negative values are refused. GET and HEAD count as reads, every other method as a write.

Every gateway process enforces the budgets on its own, with its own counters: two gateways that serve the same user or bucket admit up to twice the budget between them. A policy is not a cluster-wide request budget.

type RateLimitOverrideHandle added in v0.5.0

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

RateLimitOverrideHandle manages the restoration of one rate-limit scope of an owned user, retaining the prior native policy, the identity of the scope and possibly uncertain application. Copies share restoration state.

User.OverrideRateLimit returns a non-nil handle for every outcome. A handle of a call that was refused before any native change owns nothing: its Restore returns nil and changes nothing. A handle returned with an error after the first native change records an uncertain outcome; keep it and call Restore with a fresh context, or terminate the disposable cluster.

The handle never owns a bucket: a bucket that the SUT created stays the SUT's, and the handle neither deletes it nor keeps it from being deleted. There is no expiry and no restoration at scope exit or Terminate.

func (*RateLimitOverrideHandle) Restore added in v0.5.0

func (change *RateLimitOverrideHandle) Restore(ctx context.Context) error

Restore returns the scope to the policy it had before the override, after confirming the same user and, for a bucket scope, the same bucket instance and owner. For a user that stored no policy it stores the native default, as OverrideRateLimit describes. A scope that already holds that policy needs no command. It refuses a scope whose identity changed and a policy that is neither that one nor one this override left, rather than overwriting an outside edit. It is idempotent across copies; after an uncertain failure, retry with a fresh context. A handle of a refused call returns nil.

Gateways see the restored policy after their metadata caches update; poll with new requests before relying on unthrottled access.

type RateLimitScope added in v0.5.0

type RateLimitScope struct {
	Bucket string
}

RateLimitScope selects the native rate-limit scope that User.OverrideRateLimit changes. The zero value selects the user itself: the policy throttles every request that the user's credentials sign. Bucket names one existing bucket that the user natively owns, in the user's tenant, and the policy throttles every request to that bucket, whoever signs it; the user's other buckets are not affected.

The user scope needs Ceph 20 or later. A Ceph 19 gateway stores and reports a user's policy but never applies it to a request that the user's S3 keys sign, so OverrideRateLimit refuses it there; the bucket scope works on both.

type Role added in v0.5.0

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

Role is a native RGW role that CreateRole created, with the permission policies the fixture put on it. It names one native role for good: its role ID, read back after creation, so a role deleted and created again under the same name outside the fixture is a different role, which the handle refuses. Copies of a role handle share its state. Roles remain in Ceph when a gateway is removed, until Remove or the disposable cluster's termination; Remove runs through the first running registered gateway of the scope of the gateway that created the role.

The fixture creates the role and hands off its ARN; the SUT, or a test client playing it, calls STS AssumeRole and uses the temporary credentials. The gateways need STS enabled before they start (rgw_sts_key and rgw_s3_auth_use_sts, applied with override.SetConfig).

func (*Role) ARN added in v0.5.0

func (r *Role) ARN() (string, error)

ARN returns the role's native ARN, read back after its creation, which the SUT passes to STS AssumeRole as RoleArn. It stays the same after Remove, so a test can hand a removed role to the SUT to check that STS refuses it. A role whose creation was not confirmed when CreateRole returned returns an error.

func (Role) Format added in v0.5.0

func (r Role) Format(f fmt.State, _ rune)

Format prints String for every verb and flag, so no verb, such as %d or %t, walks the fields.

func (Role) GoString added in v0.5.0

func (r Role) GoString() string

GoString formats the role like String, so %#v does not walk its state.

func (*Role) Name added in v0.5.0

func (r *Role) Name() string

Name returns the role's name, the one CreateRole generated when RoleConfig left it empty.

func (*Role) Remove added in v0.5.0

func (r *Role) Remove(ctx context.Context) error

Remove deletes the fixture's permission policies of this role, with role-policy delete, and then the role, with role delete. It removes only what the fixture created: a role whose role ID, trust policy, tags or other metadata changed, that holds a permission policy the fixture did not put, or whose fixture policy changed outside the fixture, is refused with ceph.ErrInvalidRequest and left as it is. A role that native state no longer holds, and a role already removed, return nil.

A role whose creation outcome was unknown is settled first: a command of it that may still run is stopped, and the role is removed when native state holds the role the fixture requested. When a removal fails, its outcome is read back: what is gone stays removed, what is still present stays tracked, and Remove can be called again.

Removing a role does not revoke temporary credentials already issued for it in RGW's caches at once; poll with new requests.

func (Role) String added in v0.5.0

func (r Role) String() string

String names the role.

type RoleConfig added in v0.5.0

type RoleConfig struct {
	Name, Path  string
	TrustPolicy string
	Policies    []RolePolicy
}

RoleConfig describes a new native RGW role that a principal assumes with STS AssumeRole. Empty Name generates a unique name; Path defaults to "/". The role is created in the empty tenant, outside any account.

TrustPolicy is the role's assume-role policy document: which principals may assume it, such as {"Effect":"Allow","Principal":{"AWS": ["arn:aws:iam:::user/<user ID>"]},"Action":["sts:AssumeRole"]} in a statement list. Policies are the inline permission policies of the role, put in order, which bound what temporary credentials of the role may do. Documents are single-line JSON strings, stored as given.

type RolePolicy added in v0.5.0

type RolePolicy struct {
	Name, Document string
}

RolePolicy is one inline permission policy of a role: its name, unique in the role, and its JSON document.

type RootAccount added in v0.5.0

type RootAccount interface {
	// contains filtered or unexported methods
}

RootAccount is an owned account that UserConfig.Account names. It is sealed: only *account.Account, created by package rgw/account, satisfies it.

type S3Key added in v0.5.0

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

S3Key is one S3 access and secret key pair that the fixture created for an owned user: the key pair of the user's creation, from User.CreationKey, or one from User.CreateS3Key. A key handle names one key pair and never changes which: creating another key does not change what an existing handle, or credentials copied from it, mean. Copies of a key handle share its state. Formatting a key handle never includes its keys.

Creating a key or revoking one changes what RGW accepts; it does not show that the system under test reloaded its configuration or dropped a cached credential. Hand the new key to the SUT the way it reads its configuration, and assert its behavior with requests it makes after that.

func (*S3Key) Credentials added in v0.5.0

func (k *S3Key) Credentials() (accessKey, secretKey string, err error)

Credentials returns the access and secret keys of this key pair as explicit copies. They stay the same after the key is revoked or the user removed, so a test can hand a revoked key to the SUT to check that RGW refuses it; revocation does not erase copies. A key whose creation was not confirmed returns an error.

func (S3Key) Format added in v0.5.0

func (k S3Key) Format(f fmt.State, _ rune)

Format prints String for every verb and flag, so no verb, such as %d or %t, walks the fields.

func (S3Key) GoString added in v0.5.0

func (k S3Key) GoString() string

GoString formats the key like String, so %#v does not print its keys.

func (*S3Key) Revoke added in v0.5.0

func (k *S3Key) Revoke(ctx context.Context) error

Revoke removes this key pair from its user, irreversibly: RGW refuses new requests signed with it once its metadata caches see the removal, so poll with new requests. Nothing restores a revoked key; create another with User.CreateS3Key. The user, its data and its other keys stay.

Revoke refuses, with ceph.ErrInvalidRequest, the user's last active fixture-created key, which identifies the owned user to later operations, and a key whose secret changed outside the fixture. A key that native state no longer holds, a key of a removed user and a key already revoked return nil. A key whose creation outcome was unknown is settled first: a native command of it that may still run is stopped, and the key is removed when native state holds it.

When the removal fails, its outcome is read back: a key that is gone is revoked and Revoke returns nil; a key still present stays tracked and usable, and Revoke can be called again; an unknown outcome is settled by the next Revoke.

func (S3Key) String added in v0.5.0

func (k S3Key) String() string

String names the key's user without the keys.

type TLSConfig

type TLSConfig struct {
	CertificatePEM, PrivateKeyPEM []byte
}

TLSConfig enables a native Beast HTTPS listener alongside HTTP. Supply a PEM certificate chain and matching unencrypted private key. No proxy is involved. Clients must explicitly trust its CA and use a matching hostname. Files live only in the owned RGW container; descriptors never log key bytes.

The bytes are copied; the certificate and key are written to /tc/rgw-tls.pem with mode 0600 inside the gateway container only. In bridge mode container ports 7480 (HTTP) and 7481 (HTTPS) are mapped to random host ports; in host mode two free host ports are reserved. Startup verifies that the gateway process owns the HTTPS socket and that the listener presents the configured certificate. ceph.NetworkConfig.WithMessengerMode does not enable HTTPS. Gateway.ReplaceTLS replaces the material of a running gateway.

func (TLSConfig) Format added in v0.4.0

func (c TLSConfig) Format(f fmt.State, _ rune)

Format prints String for every verb and flag, so no verb, such as %d or %t, walks the fields.

func (TLSConfig) GoString

func (c TLSConfig) GoString() string

GoString formats the configuration like String, so %#v does not print the key.

func (TLSConfig) String

func (TLSConfig) String() string

String describes the configuration without the certificate or key.

type User

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

User is an identity created through a gateway. Its S3 credentials are key handles: CreationKey for the key pair its creation generated and CreateS3Key for more; formatting this handle never includes secrets. Users remain in Ceph when a gateway is removed, until explicitly removed or the disposable cluster is terminated. Its operations run through the first running registered gateway, by name, in the scope of the gateway that created it, so they keep working after that gateway is removed if another one serves it. Copies of a user handle share its lifecycle state.

Every operation on the user checks the keys the fixture created for it: each active one must still be present with its secret, no revoked one may be present again, and at least one active one must remain. Keys created outside the fixture are neither checked nor changed.

func (*User) CreateS3Key added in v0.5.0

func (u *User) CreateS3Key(ctx context.Context) (*S3Key, error)

CreateS3Key creates one more S3 key pair for this owned user, keeping the user, its data and its other keys, so a test can hand the SUT a replacement credential and later revoke the old one with S3Key.Revoke. The fixture generates the access key and RGW the secret, and the new key is tracked as the fixture's before the native command runs. The user must be active, and its fixture-created keys must be as the fixture recorded them.

After dispatch, a read checks the outcome even if ctx ends. It keeps the admin operation deadline, with at least ten seconds for readback. The fixture sends the key creation command only once:

  • a nil error returns the confirmed key;
  • a non-nil key with an error is tracked: when native state showed the key, its Credentials work and the error keeps the call's failure, such as its context's; otherwise whether the key exists is unknown, Credentials refuses it, and its Revoke settles and removes it;
  • a nil key with an error means that RGW shows that no key was created.

A new call always creates a different key; it does not retry an earlier one. Native key edits of this user from Admin or external clients must not race this operation.

func (*User) CreationKey added in v0.5.0

func (u *User) CreationKey() *S3Key

CreationKey returns the handle of the S3 key pair that this user's creation generated; nil when the creation response did not confirm one. It names that key pair even after it is revoked or after other keys were created.

func (User) Format added in v0.4.0

func (u User) Format(f fmt.State, _ rune)

Format prints String for every verb and flag, so no verb, such as %d or %t, walks the fields.

func (User) GoString

func (u User) GoString() string

GoString formats the user like String, so %#v does not print its keys.

func (*User) ID

func (u *User) ID() string

ID returns the canonical native ID, tenant$localID for a tenanted user. Empty-tenant identities retain their existing unprefixed IDs.

func (*User) Info added in v0.4.0

func (u *User) Info(ctx context.Context) (UserInfo, error)

Info reads an owned user's quota, capabilities, suspension and placement defaults/tags. Placement tags control new bucket placement, not object access. It verifies the created key, original native user type and original account association remain present before returning the policy. Account roots also require the creation-owned account's native metadata lifetime to remain valid.

func (*User) OverrideRateLimit added in v0.5.0

func (u *User) OverrideRateLimit(ctx context.Context, scope RateLimitScope, limit RateLimit) (*RateLimitOverrideHandle, error)

OverrideRateLimit applies limit, as a whole, to one native rate-limit scope of this owned user and returns the handle that restores the prior policy. It binds the scope's native identity first: the user's created key, type and account association, and for a bucket scope the bucket's instance ID, marker, tenant and native owner, which must be this user. It reads the prior policy of that scope, changes it with radosgw-admin ratelimit set and enable or disable, and reads it back. Policy fields that RateLimit does not name are kept as they are. A second override of the same scope is refused while the first is not restored, even for the same policy.

A user that stores no policy of its own enforces the native default: every budget zero and disabled. Ceph 20 reports such a user's policy as that default; a Ceph 21 radosgw-admin ratelimit get fails with ENOENT instead, exactly as for a missing user. OverrideRateLimit takes the ENOENT as an unset prior policy only when the user's native metadata, read in the same call, names the user without a stored policy and the user is still the identity it created; otherwise it fails. radosgw-admin cannot delete a stored policy, so Restore of an unset prior policy stores the native default: the scope enforces what it did before, and ratelimit get then reports that default instead of failing.

The commands never pass through a policy that enforces a mix of the prior and requested budgets: limits are stored before the policy is enabled, and the policy is disabled before limits are stored.

Gateways learn the change through their metadata caches, and each gateway counts its own budget, so poll with new requests when testing rejection (503 SlowDown) or recovery after Restore. With a bucket scope, use a bucket that the SUT does not delete and create again while the handle is active.

Outcomes, as the handle it returns and the error:

  • Applied and read back: real handle; nil.
  • Invalid limit or bucket name: not applied handle; ceph.ErrInvalidRequest.
  • User scope on a Ceph 19 cluster: not applied handle; ceph.ErrUnsupported, a *ceph.OperationError that names the release.
  • Bucket not owned by this user: not applied handle; ceph.ErrInvalidRequest.
  • The user is no longer the identity it created or is missing (also when a Ceph 21 ratelimit get reports ENOENT), the bucket is missing, the scope is already overridden, the context ended, or a read failed: not applied handle; the original error.
  • A failure from the first native change on (command, readback, canceled context): real handle (uncertain); the original error.

func (*User) Remove added in v0.4.0

func (u *User) Remove(ctx context.Context) error

Remove removes an owned identity without purging buckets or objects. Deleting a present user requires its confirmed generated credentials. After an uncertain creation, Remove first settles the create command and checks the creation scope. Absence completes cleanup. A present identity whose creation was never confirmed stays untouched and Remove returns an error. Ceph refuses ordinary users that still own buckets; remove those through the S3 client first. Account buckets belong to the account and may outlive a root user's removal; removing the account independently refuses a nonempty one. Success is idempotent across copies of a handle. After an uncertain native failure, an absent user is accepted as completed removal; a user still present remains tracked and its fixture-created keys are verified before retrying. Removing the user removes all of its keys, so a later Revoke of one of its S3Key handles returns nil.

func (*User) SetBucketQuota added in v0.4.0

func (u *User) SetBucketQuota(ctx context.Context, quota Quota) error

SetBucketQuota configures the per-bucket limits for all buckets owned by this user. Use Gateway.Admin for a policy on a single named bucket.

The limits apply to each bucket the user owns, individually. Quota enforcement depends on native statistics and caches, so a write right after a quota change, or right after the quota is reached, may still be accepted: poll with new writes when testing rejection.

func (*User) SetQuota added in v0.4.0

func (u *User) SetQuota(ctx context.Context, quota Quota) error

SetQuota replaces both user limits and the enabled state. If a later native command fails, a policy change may already have persisted; Info reads the authoritative state and the same request can safely be retried.

func (User) String

func (u User) String() string

String names the user without its keys.

func (*User) Suspend added in v0.4.0

func (u *User) Suspend(ctx context.Context, suspended bool) error

Suspend disables or re-enables S3 access for an owned user and reads back native state. Gateway metadata caches may delay the observed HTTP response; callers should poll new requests when testing suspension or re-enablement.

func (*User) Usage added in v0.4.0

func (u *User) Usage(ctx context.Context) (UserUsage, error)

Usage reads current storage counters for an owned user's effective native owner. For an account root it returns the account aggregate with Scope account and OwnerID equal to the originally owned account ID. It rechecks the user key, type, account lifetime and scope before returning; no user, account, bucket or statistics are created, changed, synchronized, reset or adopted.

Poll until the expected values appear. For an explicit synchronisation step run gateway.Admin(ctx, "user", "stats", "--uid", user.ID(), "--sync-stats") as separate setup.

type UserConfig

type UserConfig struct {
	ID, DisplayName, Email string
	Tenant                 string
	AdminCaps              string
	MaxBuckets             *int
	Account                RootAccount
}

UserConfig describes a new S3 identity. Empty ID generates a unique ID; DisplayName defaults to Testcontainers. AdminCaps is an explicit native expression such as "users=read;usage=read" for the RGW Admin Ops REST API. Neither the global admin nor the multisite system flag is granted. MaxBuckets nil preserves Ceph's default; zero allows unlimited buckets and -1 forbids creating buckets. Tenant selects a native namespace; empty preserves the legacy namespace. ID is the local user ID, without a tenant prefix.

Tenant is letters, digits and underscores and must not look like an account ID; a tenant user's canonical ID is tenant$id, and buckets with the same name can exist in different tenants.

Account, when set, makes the new user the root user of that owned account, which package rgw/account created through a gateway of the same cluster and scope. Empty Tenant inherits the account tenant; a different tenant is rejected, and DisplayName must be a valid IAM user name. Account root grants permissions within the account; global admin and multisite system flags remain false. IAM operations remain on the consuming client.

type UserInfo

type UserInfo struct {
	ID, DisplayName, Email                      string
	Tenant, LocalID, Namespace, Type, AccountID string
	Suspended, Admin, System                    bool
	MaxBuckets                                  int
	AdminCaps                                   []AdminCapability
	UserQuota, BucketQuota                      Quota
	DefaultPlacement, DefaultStorageClass       string
	PlacementTags                               []string
}

UserInfo is a current native policy snapshot, deliberately excluding keys. BucketQuota applies individually to every bucket owned by this user. DefaultStorageClass preserves native representation: STANDARD on a named default placement is persisted and later read back as an empty string.

Type is rgw (or empty) for ordinary users and root for account root users. The fixture never sets Admin or System. PlacementTags allow the user to create buckets in tagged placement targets and grant no object access; package rgw/placement sets the placement default and tags.

type UserUsage

type UserUsage struct {
	UserID, Tenant, Scope, OwnerID string
	// SizeBytes is native size; SizeActualBytes is native size_actual (rounded
	// accounting bytes), not physical allocation or replica/billing bytes.
	SizeBytes, SizeActualBytes, NumObjects uint64
	// Preserve native timestamp strings, including native zero timestamps.
	LastStatsSync, LastStatsUpdate string
}

UserUsage is a native storage-accounting snapshot, not dated request or bandwidth usage. Scope is "user" for an ordinary user and "account" for an account identity. OwnerID identifies that effective aggregation owner; account stats cover all of the account's users, roles and buckets, not only UserID. Native accounting updates asynchronously; this snapshot does not force sync, flush quota caches, prove quota enforcement or verify object content.

Directories

Path Synopsis
Package account prepares native RGW accounts through an existing gateway: fresh accounts with their tenant, limits and quotas, whose root users are created by rgw.Gateway.CreateUser with rgw.UserConfig.Account.
Package account prepares native RGW accounts through an existing gateway: fresh accounts with their tenant, limits and quotas, whose root users are created by rgw.Gateway.CreateUser with rgw.UserConfig.Account.
Package expect evaluates captured observations of RGW fixtures against the conditions a test states, and explains each mismatch.
Package expect evaluates captured observations of RGW fixtures against the conditions a test states, and explains each mismatch.
internal
gwbase
Package gwbase is the foundation that package rgw and its feature packages (rgw/account, rgw/placement, rgw/notification and rgw/multisite) share for one gateway and the resources created through it: the gateway identity (its cluster, name, configured scope, listener and container), the admin command transport, the selection of the gateway that runs a resource handle's operations, the native runtime scope of a running gateway, and the private state of owned users and accounts.
Package gwbase is the foundation that package rgw and its feature packages (rgw/account, rgw/placement, rgw/notification and rgw/multisite) share for one gateway and the resources created through it: the gateway identity (its cluster, name, configured scope, listener and container), the admin command transport, the selection of the gateway that runs a resource handle's operations, the native runtime scope of a running gateway, and the private state of owned users and accounts.
gwtest
Package gwtest holds the unit-test fixtures that the tests of package rgw and its feature packages share: the supervisor framing of radosgw-admin calls, canned native user documents, a synthetic cluster, a foundation core over a gateway container for the feature packages, which cannot construct an rgw.Gateway, and small models of the native zone, placement, period, user and account state that the typed operations read and change.
Package gwtest holds the unit-test fixtures that the tests of package rgw and its feature packages share: the supervisor framing of radosgw-admin calls, canned native user documents, a synthetic cluster, a foundation core over a gateway container for the feature packages, which cannot construct an rgw.Gateway, and small models of the native zone, placement, period, user and account state that the typed operations read and change.
Package multisite orchestrates RGW multisite fixtures across independent Ceph clusters: one realm, zones and zonegroups, period transfer, sync status and sync policies.
Package multisite orchestrates RGW multisite fixtures across independent Ceph clusters: one realm, zones and zonegroups, period transfer, sync status and sync policies.
Package notification observes the persistent queue of one RGW bucket notification topic through an existing gateway: the topic's native identity and delivery limits, its queue statistics and an optional bounded sample of the pending entries.
Package notification observes the persistent queue of one RGW bucket notification topic through an existing gateway: the topic's native identity and delivery limits, its queue statistics and an optional bounded sample of the pending entries.
Package placement prepares bucket placement targets and storage classes through an existing gateway: a fresh, non-default placement target with its index, multipart and per-class data pools, its activation in a standalone gateway or a realm period, and a user's default placement.
Package placement prepares bucket placement targets and storage classes through an existing gateway: a fresh, non-default placement target with its index, multipart and per-class data pools, its activation in a standalone gateway or a realm period, and a user's default placement.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL