core

type AssetManager interface {
	pluggable.Plugin

	// Init is called before all other interface methods, and can be used by the
	// AssetManager to receive a reference to the ProviderClient, as well as
	// perform any first-time initialization.
	//
	// The supplied ProviderClient should be stored inside the AssetManager
	// instance for later usage and/or used to query OpenStack capabilities.
	Init(provider ProviderClient) error

	// If this asset type is supported by this asset manager, return information
	// about it. Otherwise return nil.
	InfoForAssetType(assetType db.AssetType) *AssetTypeInfo

	// A non-nil return value makes the API deny any attempts to create a resource
	// with that scope and asset type with that error.
	//
	// This can perform multiple types of validations:
	//- allowing resources for some scopes, but not others (e.g. only projects
	//  with a specific marker)
	//- validating plugin-specific configuration in `configJSON`
	//- allowing resources depending on which other resources exist in the same
	// scope, by checking `existingResources`
	//
	// Simple implementations should return nil for empty `configJSON` and
	// `core.ErrNoConfigurationAllowed` otherwise.
	CheckResourceAllowed(assetType db.AssetType, scopeUUID string, configJSON string, existingResources map[db.AssetType]struct{}) error

	ListAssets(ctx context.Context, res db.Resource) ([]string, error)
	// The returned Outcome should be either Succeeded, Failed or Errored, but not Cancelled.
	// The returned error should be nil if and only if the outcome is Succeeded.
	SetAssetSize(res db.Resource, assetUUID string, oldSize, newSize uint64) (castellum.OperationOutcome, error)
	// previousStatus will be nil when this function is called for the first time
	// for the given asset.
	GetAssetStatus(ctx context.Context, res db.Resource, assetUUID string, previousStatus *AssetStatus) (AssetStatus, error)
}

type AssetManagerTeam []AssetManager

type AssetNotFoundError struct {
	InnerError error
}

type AssetStatus struct {
	Size              uint64
	Usage             castellum.UsageValues
	StrictMinimumSize *uint64
	StrictMaximumSize *uint64
}

type AssetTypeInfo struct {
	AssetType    db.AssetType
	UsageMetrics []castellum.UsageMetric
}

type CachedDomain struct {
	Name string
}

type CachedProject struct {
	Name     string
	DomainID string
}

type Config struct {
	MaxAssetSizeRules []MaxAssetSizeRule `yaml:"max_asset_sizes"`
	ProjectSeeds      []ProjectSeed      `yaml:"project_seeds"`
}

type MaxAssetSizeRule struct {
	AssetTypeRx regexpext.BoundedRegexp `yaml:"asset_type"`
	ScopeUUID   string                  `yaml:"scope_uuid"` // leave empty to have the rule apply to all scopes
	Value       uint64                  `yaml:"value"`
}

type ProjectScope struct {
	// The ID of the project to scope into.
	ID string
	// Before scoping into the project, assign these roles to ourselves.
	RoleNames []string
}

type ProjectSeed struct {
	ProjectName             string                              `yaml:"project_name"`
	DomainName              string                              `yaml:"domain_name"`
	Resources               map[db.AssetType]castellum.Resource `yaml:"resources"`
	DisabledResourceRegexps []regexpext.BoundedRegexp           `yaml:"disabled_resources"`
}

type ProviderClient interface {
	// CloudAdminClient returns a service client in the provider client's default scope.
	// The argument is a function like `openstack.NewIdentityV3`.
	CloudAdminClient(factory ServiceClientFactory) (*gophercloud.ServiceClient, error)
	// ProjectScopedClient authenticates into the specified project scope.
	ProjectScopedClient(scope ProjectScope) (*gophercloud.ProviderClient, gophercloud.EndpointOpts, error)

	// GetAuthResult has the same semantics as gophercloud.ProviderClient.GetAuthResult.
	GetAuthResult() gophercloud.AuthResult
	// GetProject queries the given project ID in Keystone, unless it is already cached.
	// When the project does not exist, nil is returned instead of an error.
	GetProject(projectID string) (*CachedProject, error)
	// GetDomain queries the given domain ID in Keystone, unless it is already cached.
	// When the project does not exist, nil is returned instead of an error.
	GetDomain(domainID string) (*CachedDomain, error)

	// FindProjectID searches for a project with the given name and domain name.
	// When the project does not exist, "" is returned instead of an error.
	FindProjectID(projectName, projectDomainName string) (string, error)
}

type ResourceLogic struct {
	UsageMetrics             []castellum.UsageMetric
	LowThresholdPercent      castellum.UsageValues
	HighThresholdPercent     castellum.UsageValues
	CriticalThresholdPercent castellum.UsageValues

	SizeStepPercent float64
	SingleStep      bool

	MinimumSize     *uint64
	MaximumSize     *uint64
	MinimumFreeSize *uint64
}

type ServiceClientFactory func(*gophercloud.ProviderClient, gophercloud.EndpointOpts) (*gophercloud.ServiceClient, error)