path: root/account.go

// SPDX-FileCopyrightText: 2018 Stefan Majewsky <majewsky@gmx.net>
// SPDX-License-Identifier: Apache-2.0

package schwift

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"regexp"
	"sync"
)

// Account represents a Swift account. Instances are usually obtained by
// connecting to a backend (see package-level documentation), or by traversing
// upwards from a container with Container.Account().
type Account struct {
	backend Backend
	// URL parts
	baseURL string
	name    string
	// cache
	headers      *AccountHeaders
	headersMutex sync.Mutex
	caps         *Capabilities
	modifyCaps   func(*Capabilities)
	capsMutex    sync.Mutex
}

// IsEqualTo returns true if both Account instances refer to the same account.
func (a *Account) IsEqualTo(other *Account) bool {
	return other.baseURL == a.baseURL && other.name == a.name
}

var endpointURLRegexp = regexp.MustCompile(`^(.*/)v1/(.*)/$`)

// InitializeAccount takes something that implements the Backend interface, and
// returns the Account instance corresponding to the account/project that this
// backend is connected to.
func InitializeAccount(backend Backend) (*Account, error) {
	match := endpointURLRegexp.FindStringSubmatch(backend.EndpointURL())
	if match == nil {
		return nil, fmt.Errorf(`schwift.InitializeAccount(): invalid Swift endpoint URL: cannot find "/v1/" in %q`, backend.EndpointURL())
	}
	return &Account{
		backend: backend,
		baseURL: match[1],
		name:    match[2],
	}, nil
}

// SwitchAccount returns a handle to a different account on the same server. Note
// that you need reseller permissions to access accounts other than that where
// you originally authenticated. This method does not check whether the account
// actually exists.
//
// The account name is usually the Keystone project ID with an additional "AUTH_"
// prefix.
func (a *Account) SwitchAccount(accountName string) *Account {
	newEndpointURL := a.baseURL + "v1/" + accountName + "/"
	return &Account{
		backend: a.backend.Clone(newEndpointURL),
		baseURL: a.baseURL,
		name:    accountName,
	}
}

// Name returns the name of the account (usually the prefix "AUTH_" followed by
// the Keystone project ID).
func (a *Account) Name() string {
	return a.name
}

// Backend returns the backend which is used to make requests against this
// account.
func (a *Account) Backend() Backend {
	return a.backend
}

// Headers returns the AccountHeaders for this account. If the AccountHeaders
// has not been cached yet, a HEAD request is issued on the account.
//
// This operation fails with http.StatusNotFound if the account does not exist.
func (a *Account) Headers(ctx context.Context) (AccountHeaders, error) {
	a.headersMutex.Lock()
	defer a.headersMutex.Unlock()
	if a.headers != nil {
		return *a.headers, nil
	}

	resp, err := Request{
		Method:            http.MethodHead,
		ExpectStatusCodes: []int{204},
	}.Do(ctx, a.backend)
	if err != nil {
		return AccountHeaders{}, err
	}
	defer resp.Body.Close()

	headers := AccountHeaders{headersFromHTTP(resp.Header)}
	err = headers.Validate()
	if err != nil {
		return headers, err
	}
	a.headers = &headers
	return *a.headers, nil
}

// Invalidate clears the internal cache of this Account instance. The next call
// to Headers() on this instance will issue a HEAD request on the account.
func (a *Account) Invalidate() {
	a.headersMutex.Lock()
	defer a.headersMutex.Unlock()
	a.headers = nil
}

// Update updates the account using a POST request. The headers in the headers
// attribute take precedence over those in opts.Headers.
//
// A successful POST request implies Invalidate() since it may change metadata.
func (a *Account) Update(ctx context.Context, headers AccountHeaders, opts *RequestOptions) error {
	resp, err := Request{
		Method:            http.MethodPost,
		Options:           cloneRequestOptions(opts, headers.Headers),
		ExpectStatusCodes: []int{204},
	}.Do(ctx, a.backend)
	if err == nil {
		a.Invalidate()
		resp.Body.Close()
	}
	return err
}

// Create creates the account using a PUT request. This operation is only
// available to reseller admins, not to regular users.
//
// A successful PUT request implies Invalidate() since it may change metadata.
func (a *Account) Create(ctx context.Context, opts *RequestOptions) error {
	resp, err := Request{
		Method:            http.MethodPut,
		Options:           opts,
		ExpectStatusCodes: []int{201, 202},
		DrainResponseBody: true,
	}.Do(ctx, a.backend)
	if err == nil {
		a.Invalidate()
		resp.Body.Close()
	}
	return err
}

// Containers returns a ContainerIterator that lists the containers in this
// account. The most common use case is:
//
//	containers, err := account.Containers().Collect()
//
// You can extend this by configuring the iterator before collecting the results:
//
//	iter := account.Containers()
//	iter.Prefix = "test-"
//	containers, err := iter.Collect()
//
// Or you can use a different iteration method:
//
//	err := account.Containers().ForeachDetailed(func (ci ContainerInfo) error {
//		log.Printf("container %s contains %d objects!\n",
//			ci.Container.Name(), ci.ObjectCount)
//	})
func (a *Account) Containers() *ContainerIterator {
	return &ContainerIterator{Account: a}
}

// Capabilities queries the GET /info endpoint of the Swift server providing
// this account. Capabilities are cached, so the GET request will only be sent
// once during the first call to this method.
func (a *Account) Capabilities(ctx context.Context) (Capabilities, error) {
	a.capsMutex.Lock()
	defer a.capsMutex.Unlock()

	if a.caps != nil {
		return *a.caps, nil
	}

	buf, err := a.RawCapabilities(ctx)
	if err != nil {
		return Capabilities{}, err
	}

	var caps Capabilities
	err = json.Unmarshal(buf, &caps)
	if err != nil {
		return caps, err
	}
	if a.modifyCaps != nil {
		a.modifyCaps(&caps)
	}

	a.caps = &caps
	return caps, nil
}

// ModifyReportedCapabilities allows the caller to tamper with the capabilities reported by [Account.Capabilities].
// This is necessary when dealing with non-compliant server implementations that do not report their capabilities correctly
// (e.g. Ceph does not report "tempurl.allowed_digests", which breaks [Object.TempURL]).
//
// This call impacts all calls to [Account.Capabilities] that are made after this call succeeds.
// Calls to [Account.RawCapabilities] are not affected by this modification.
// Calls to this method do not stack: If this method is called multiple times, only the last modification will take effect.
func (a *Account) ModifyReportedCapabilities(modify func(*Capabilities)) {
	a.capsMutex.Lock()
	defer a.capsMutex.Unlock()
	a.caps = nil // to force refetch+modify during next Capabilities() call
	a.modifyCaps = modify
}

// RawCapabilities queries the GET /info endpoint of the Swift server providing
// this account, and returns the response body. Unlike Account.Capabilities,
// this method does not employ any caching.
func (a *Account) RawCapabilities(ctx context.Context) ([]byte, error) {
	// This method is the only one in Schwift that bypasses struct Request since
	// the request URL is not below the endpoint URL.
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, a.baseURL+"info", http.NoBody)
	if err != nil {
		return nil, err
	}
	resp, err := a.backend.Do(req)
	if err != nil {
		return nil, err
	}
	return collectResponseBody(resp)
}