Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Container

type Container struct {

	// The Amazon Resource Name (ARN) of the container. The ARN has the following
	// format: arn:aws:::container/ For example:
	// arn:aws:mediastore:us-west-2:111122223333:container/movies
	ARN *string

	// The state of access logging on the container. This value is false by default,
	// indicating that AWS Elemental MediaStore does not send access logs to Amazon
	// CloudWatch Logs. When you enable access logging on the container, MediaStore
	// changes this value to true, indicating that the service delivers access logs for
	// objects stored in that container to CloudWatch Logs.
	AccessLoggingEnabled *bool

	// Unix timestamp.
	CreationTime *time.Time

	// The DNS endpoint of the container. Use the endpoint to identify the specific
	// container when sending requests to the data plane. The service assigns this
	// value when the container is created. Once the value has been assigned, it does
	// not change.
	Endpoint *string

	// The name of the container.
	Name *string

	// The status of container creation or deletion. The status is one of the
	// following: CREATING, ACTIVE, or DELETING. While the service is creating the
	// container, the status is CREATING. When the endpoint is available, the status
	// changes to ACTIVE.
	Status ContainerStatus
}

    This section describes operations that you can perform on an AWS Elemental MediaStore container.

    type ContainerInUseException

    type ContainerInUseException struct {
    	Message *string
    }

      The container that you specified in the request already exists or is being updated.

      func (*ContainerInUseException) Error

      func (e *ContainerInUseException) Error() string

      func (*ContainerInUseException) ErrorCode

      func (e *ContainerInUseException) ErrorCode() string

      func (*ContainerInUseException) ErrorFault

      func (e *ContainerInUseException) ErrorFault() smithy.ErrorFault

      func (*ContainerInUseException) ErrorMessage

      func (e *ContainerInUseException) ErrorMessage() string

      type ContainerLevelMetrics

      type ContainerLevelMetrics string
      const (
      	ContainerLevelMetricsEnabled  ContainerLevelMetrics = "ENABLED"
      	ContainerLevelMetricsDisabled ContainerLevelMetrics = "DISABLED"
      )

        Enum values for ContainerLevelMetrics

        func (ContainerLevelMetrics) Values

          Values returns all known values for ContainerLevelMetrics. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

          type ContainerNotFoundException

          type ContainerNotFoundException struct {
          	Message *string
          }

            The container that you specified in the request does not exist.

            func (*ContainerNotFoundException) Error

            func (*ContainerNotFoundException) ErrorCode

            func (e *ContainerNotFoundException) ErrorCode() string

            func (*ContainerNotFoundException) ErrorFault

            func (*ContainerNotFoundException) ErrorMessage

            func (e *ContainerNotFoundException) ErrorMessage() string

            type ContainerStatus

            type ContainerStatus string
            const (
            	ContainerStatusActive   ContainerStatus = "ACTIVE"
            	ContainerStatusCreating ContainerStatus = "CREATING"
            	ContainerStatusDeleting ContainerStatus = "DELETING"
            )

              Enum values for ContainerStatus

              func (ContainerStatus) Values

              func (ContainerStatus) Values() []ContainerStatus

                Values returns all known values for ContainerStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                type CorsPolicyNotFoundException

                type CorsPolicyNotFoundException struct {
                	Message *string
                }

                  The CORS policy that you specified in the request does not exist.

                  func (*CorsPolicyNotFoundException) Error

                  func (*CorsPolicyNotFoundException) ErrorCode

                  func (e *CorsPolicyNotFoundException) ErrorCode() string

                  func (*CorsPolicyNotFoundException) ErrorFault

                  func (*CorsPolicyNotFoundException) ErrorMessage

                  func (e *CorsPolicyNotFoundException) ErrorMessage() string

                  type CorsRule

                  type CorsRule struct {
                  
                  	// Specifies which headers are allowed in a preflight OPTIONS request through the
                  	// Access-Control-Request-Headers header. Each header name that is specified in
                  	// Access-Control-Request-Headers must have a corresponding entry in the rule. Only
                  	// the headers that were requested are sent back. This element can contain only one
                  	// wildcard character (*).
                  	//
                  	// This member is required.
                  	AllowedHeaders []string
                  
                  	// One or more response headers that you want users to be able to access from their
                  	// applications (for example, from a JavaScript XMLHttpRequest object). Each CORS
                  	// rule must have at least one AllowedOrigins element. The string value can include
                  	// only one wildcard character (*), for example, http://*.example.com.
                  	// Additionally, you can specify only one wildcard character to allow cross-origin
                  	// access for all origins.
                  	//
                  	// This member is required.
                  	AllowedOrigins []string
                  
                  	// Identifies an HTTP method that the origin that is specified in the rule is
                  	// allowed to execute. Each CORS rule must contain at least one AllowedMethods and
                  	// one AllowedOrigins element.
                  	AllowedMethods []MethodName
                  
                  	// One or more headers in the response that you want users to be able to access
                  	// from their applications (for example, from a JavaScript XMLHttpRequest object).
                  	// This element is optional for each rule.
                  	ExposeHeaders []string
                  
                  	// The time in seconds that your browser caches the preflight response for the
                  	// specified resource. A CORS rule can have only one MaxAgeSeconds element.
                  	MaxAgeSeconds int32
                  }

                    A rule for a CORS policy. You can add up to 100 rules to a CORS policy. If more than one rule applies, the service uses the first applicable rule listed.

                    type InternalServerError

                    type InternalServerError struct {
                    	Message *string
                    }

                      The service is temporarily unavailable.

                      func (*InternalServerError) Error

                      func (e *InternalServerError) Error() string

                      func (*InternalServerError) ErrorCode

                      func (e *InternalServerError) ErrorCode() string

                      func (*InternalServerError) ErrorFault

                      func (e *InternalServerError) ErrorFault() smithy.ErrorFault

                      func (*InternalServerError) ErrorMessage

                      func (e *InternalServerError) ErrorMessage() string

                      type LimitExceededException

                      type LimitExceededException struct {
                      	Message *string
                      }

                        A service limit has been exceeded.

                        func (*LimitExceededException) Error

                        func (e *LimitExceededException) Error() string

                        func (*LimitExceededException) ErrorCode

                        func (e *LimitExceededException) ErrorCode() string

                        func (*LimitExceededException) ErrorFault

                        func (e *LimitExceededException) ErrorFault() smithy.ErrorFault

                        func (*LimitExceededException) ErrorMessage

                        func (e *LimitExceededException) ErrorMessage() string

                        type MethodName

                        type MethodName string
                        const (
                        	MethodNamePut    MethodName = "PUT"
                        	MethodNameGet    MethodName = "GET"
                        	MethodNameDelete MethodName = "DELETE"
                        	MethodNameHead   MethodName = "HEAD"
                        )

                          Enum values for MethodName

                          func (MethodName) Values

                          func (MethodName) Values() []MethodName

                            Values returns all known values for MethodName. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                            type MetricPolicy

                            type MetricPolicy struct {
                            
                            	// A setting to enable or disable metrics at the container level.
                            	//
                            	// This member is required.
                            	ContainerLevelMetrics ContainerLevelMetrics
                            
                            	// A parameter that holds an array of rules that enable metrics at the object
                            	// level. This parameter is optional, but if you choose to include it, you must
                            	// also include at least one rule. By default, you can include up to five rules.
                            	// You can also request a quota increase
                            	// (https://console.aws.amazon.com/servicequotas/home?region=us-east-1#!/services/mediastore/quotas)
                            	// to allow up to 300 rules per policy.
                            	MetricPolicyRules []MetricPolicyRule
                            }

                              The metric policy that is associated with the container. A metric policy allows AWS Elemental MediaStore to send metrics to Amazon CloudWatch. In the policy, you must indicate whether you want MediaStore to send container-level metrics. You can also include rules to define groups of objects that you want MediaStore to send object-level metrics for. To view examples of how to construct a metric policy for your use case, see Example Metric Policies (https://docs.aws.amazon.com/mediastore/latest/ug/policies-metric-examples.html).

                              type MetricPolicyRule

                              type MetricPolicyRule struct {
                              
                              	// A path or file name that defines which objects to include in the group.
                              	// Wildcards (*) are acceptable.
                              	//
                              	// This member is required.
                              	ObjectGroup *string
                              
                              	// A name that allows you to refer to the object group.
                              	//
                              	// This member is required.
                              	ObjectGroupName *string
                              }

                                A setting that enables metrics at the object level. Each rule contains an object group and an object group name. If the policy includes the MetricPolicyRules parameter, you must include at least one rule. Each metric policy can include up to five rules by default. You can also request a quota increase (https://console.aws.amazon.com/servicequotas/home?region=us-east-1#!/services/mediastore/quotas) to allow up to 300 rules per policy.

                                type PolicyNotFoundException

                                type PolicyNotFoundException struct {
                                	Message *string
                                }

                                  The policy that you specified in the request does not exist.

                                  func (*PolicyNotFoundException) Error

                                  func (e *PolicyNotFoundException) Error() string

                                  func (*PolicyNotFoundException) ErrorCode

                                  func (e *PolicyNotFoundException) ErrorCode() string

                                  func (*PolicyNotFoundException) ErrorFault

                                  func (e *PolicyNotFoundException) ErrorFault() smithy.ErrorFault

                                  func (*PolicyNotFoundException) ErrorMessage

                                  func (e *PolicyNotFoundException) ErrorMessage() string

                                  type Tag

                                  type Tag struct {
                                  
                                  	// Part of the key:value pair that defines a tag. You can use a tag key to describe
                                  	// a category of information, such as "customer." Tag keys are case-sensitive.
                                  	//
                                  	// This member is required.
                                  	Key *string
                                  
                                  	// Part of the key:value pair that defines a tag. You can use a tag value to
                                  	// describe a specific value within a category, such as "companyA" or "companyB."
                                  	// Tag values are case-sensitive.
                                  	Value *string
                                  }

                                    A collection of tags associated with a container. Each tag consists of a key:value pair, which can be anything you define. Typically, the tag key represents a category (such as "environment") and the tag value represents a specific value within that category (such as "test," "development," or "production"). You can add up to 50 tags to each container. For more information about tagging, including naming and usage conventions, see Tagging Resources in MediaStore (https://docs.aws.amazon.com/mediastore/latest/ug/tagging.html).