outputs

Documentation

Index

• Constants
• func Collect(stack types.Stack, required, optional map[string]Collector) error
• func Exists(stack types.Stack, key string) bool
• type Collector
• type CollectorSet
  • func NewCollectorSet(set map[string]Collector) *CollectorSet
  • func (c *CollectorSet) Define(template *gfn.Template, name string, value interface{}, export bool, ...)
  • func (c *CollectorSet) DefineFromAtt(template *gfn.Template, name, logicalName, att string, export bool, ...)
  • func (c *CollectorSet) DefineJoined(template *gfn.Template, name string, values []*gfnt.Value, export bool, ...)
  • func (c *CollectorSet) DefineWithoutCollector(template *gfn.Template, name string, value interface{}, export bool)
  • func (c *CollectorSet) MustCollect(stack types.Stack) error

Constants

const (
	// outputs from cluster stack
	ClusterVPC                    = "VPC"
	ClusterDefaultSecurityGroup   = "ClusterSecurityGroupId"
	ClusterSecurityGroup          = "SecurityGroup"
	ClusterSubnetsPrivate         = string("Subnets" + api.SubnetTopologyPrivate)
	ClusterSubnetsPublic          = string("Subnets" + api.SubnetTopologyPublic)
	ClusterSubnetsPrivateLocal    = string("SubnetsLocalZone" + api.SubnetTopologyPrivate)
	ClusterSubnetsPublicLocal     = string("SubnetsLocalZone" + api.SubnetTopologyPublic)
	ClusterSubnetsPrivateExtended = ClusterSubnetsPrivate + "Extended"
	ClusterSubnetsPublicExtended  = ClusterSubnetsPublic + "Extended"
	ClusterFullyPrivate           = "ClusterFullyPrivate"

	ClusterSubnetsPublicLegacy = "Subnets"

	ClusterCertificateAuthorityData = "CertificateAuthorityData"
	ClusterEndpoint                 = "Endpoint"
	ClusterARN                      = "ARN"
	ClusterStackName                = "ClusterStackName"
	ClusterSharedNodeSecurityGroup  = "SharedNodeSecurityGroup"
	ClusterServiceRoleARN           = "ServiceRoleARN"
	ClusterFeatureNATMode           = "FeatureNATMode"

	// outputs for remote nodes
	RemoteNodesRoleARN             = "RemoteNodesRoleARN"
	RemoteNodesIntermediateRoleARN = "RemoteNodesIntermediateRoleARN"
	RemoteNodesTrustAnchorARN      = "RemoteNodesTrustAnchorARN"
	RemoteNodesAnywhereProfileARN  = "RemoteNodesAnywhereProfileARN"

	// outputs from nodegroup stack
	NodeGroupInstanceRoleARN    = "InstanceRoleARN"
	NodeGroupInstanceProfileARN = "InstanceProfileARN"

	// outputs to indicate configuration attributes that may have critical effect
	// on critical effect on forward-compatibility with respect to overall functionality
	// and integrity, e.g. networking
	NodeGroupFeaturePrivateNetworking   = "FeaturePrivateNetworking"
	NodeGroupFeatureSharedSecurityGroup = "FeatureSharedSecurityGroup"
	NodeGroupFeatureLocalSecurityGroup  = "FeatureLocalSecurityGroup"
	NodeGroupUsesAccessEntry            = "NodeGroupUsesAccessEntry"

	// outputs from Fargate stack:
	FargatePodExecutionRoleARN = "FargatePodExecutionRoleARN"

	// IAMServiceAccountRoleName is the name of iamserviceaccount role resource and output.
	IAMServiceAccountRoleName = "Role1"
)

Stack output names

Functions

func Collect

func Collect(stack types.Stack, required, optional map[string]Collector) error

Collect the outputs of a stack using required and optional CollectorSets

func Exists

func Exists(stack types.Stack, key string) bool

Exists checks if the stack has given output key

Types

type Collector

type Collector func(string) error

Collector is a callback function that takes an output value and may return an error

type CollectorSet

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

CollectorSet is a wrapper to define methods for collectors

func NewCollectorSet

func NewCollectorSet(set map[string]Collector) *CollectorSet

NewCollectorSet creates a new CollectorSet based on a map of output names to Collector callbacks

func (*CollectorSet) Define

func (c *CollectorSet) Define(template *gfn.Template, name string, value interface{}, export bool, fn Collector)

Define a new output, if template is given it will be declared in the it and optionally export too

func (*CollectorSet) DefineFromAtt

func (c *CollectorSet) DefineFromAtt(template *gfn.Template, name, logicalName, att string, export bool, fn Collector)

DefineFromAtt - a new output from an attributes

func (*CollectorSet) DefineJoined

func (c *CollectorSet) DefineJoined(template *gfn.Template, name string, values []*gfnt.Value, export bool, fn Collector)

DefineJoined - a new output as comma-separated list

func (*CollectorSet) DefineWithoutCollector

func (c *CollectorSet) DefineWithoutCollector(template *gfn.Template, name string, value interface{}, export bool)

DefineWithoutCollector allows bare outputs

func (*CollectorSet) MustCollect

func (c *CollectorSet) MustCollect(stack types.Stack) error

MustCollect will error if any of the outputs are missing