resource

package
v2.25.2 Latest Latest
Warning

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

 Go to latest Published: Apr 17, 2021 License: Apache-2.0 Imports: 25 Imported by: 61

Documentation

Index

Constants

View Source 
const (
	AssetSig          = "c44067f5952c0a294b673a41bacd8c17" // a randomly assigned type hash for assets.
	AssetHashProperty = "hash"                             // the dynamic property for an asset's hash.
	AssetTextProperty = "text"                             // the dynamic property for an asset's text.
	AssetPathProperty = "path"                             // the dynamic property for an asset's path.
	AssetURIProperty  = "uri"                              // the dynamic property for an asset's URI.
)
View Source 
const (
	ArchiveSig            = "0def7320c3a5731c473e5ecbe6d01bc7" // a randomly assigned archive type signature.
	ArchiveHashProperty   = "hash"                             // the dynamic property for an archive's hash.
	ArchiveAssetsProperty = "assets"                           // the dynamic property for an archive's assets.
	ArchivePathProperty   = "path"                             // the dynamic property for an archive's path.
	ArchiveURIProperty    = "uri"                              // the dynamic property for an archive's URI.
)
View Source 
const (
	NotArchive     = iota // not an archive.
	TarArchive            // a POSIX tar archive.
	TarGZIPArchive        // a POSIX tar archive that has been subsequently compressed using GZip.
	ZIPArchive            // a multi-file ZIP archive.
	JARArchive            // a Java JAR file
)
View Source 
const (
	URNPrefix        = "urn:" + URNNamespaceID + ":" // the standard URN prefix
	URNNamespaceID   = "pulumi"                      // the URN namespace
	URNNameDelimiter = "::"                          // the delimiter between URN name elements
	URNTypeDelimiter = "$"                           // the delimiter between URN type elements
)
View Source 
const (
	// BookkeepingDir is the name of our bookkeeping folder, we store state here (like .git for git).
	// Copied from workspace.BookkeepingDir to break import cycle.
	BookkeepingDir = ".pulumi"
)
View Source 
const ResourceReferenceSig = "5cf8f73096256a8f31e491e813e4eb8e"

ResourceReferenceSig is the unique resource reference signature.

View Source 
const RootStackType tokens.Type = "pulumi:pulumi:Stack"

RootStackType is the type name that will be used for the root component in the Pulumi resource tree.

View Source 
const SecretSig = "1b47061264138c4ac30d75fd1eb44270"

SecretSig is the unique secret signature.

View Source 
const SigKey = "4dabf18193072939515e22adb298388d"

SigKey is sometimes used to encode type identity inside of a map. This is required when flattening into ordinary maps, like we do when performing serialization, to ensure recoverability of type identities later on.

Variables

View Source 
var ArchiveExts = map[string]ArchiveFormat{
	".tar":    TarArchive,
	".tgz":    TarGZIPArchive,
	".tar.gz": TarGZIPArchive,
	".zip":    ZIPArchive,
	".jar":    JARArchive,
}

ArchiveExts maps from a file extension and its associated archive and/or compression format.

Functions

func HasSig 

func HasSig(obj PropertyMap, match string) bool

HasSig checks to see if the given property map contains the specific signature match.

func IDStrings 

func IDStrings(ids []ID) []string

IDStrings turns an array of resource IDs into an array of strings.

func IsInternalPropertyKey 

func IsInternalPropertyKey(key PropertyKey) bool

IsInternalPropertyKey returns true if the given property key is an internal key that should not be displayed to users.

func IsReqError 

func IsReqError(err error) bool

func NewErrors 

func NewErrors(errs []error) error

NewErrors creates a new error list pertaining to a resource. Note that it just turns around and defers to the same mapping infrastructure used for serialization and deserialization, but it presents a nicer interface.

func NewPropertyError 

func NewPropertyError(typ string, property string, err error) error

NewPropertyError creates a new error pertaining to a resource's property. Note that it just turns around and defers to the same mapping infrastructure used for serialization and deserialization, but it presents a nicer interface.

func NewUniqueHex 

func NewUniqueHex(prefix string, randlen, maxlen int) (string, error)

NewUniqueHex generates a new "random" hex string for use by resource providers. It will take the optional prefix and append randlen random characters (defaulting to 8 if not > 0). The result must not exceed maxlen total characterss (if > 0). Note that capping to maxlen necessarily increases the risk of collisions.

Types

type Archive 

type Archive struct {
	// Sig is the unique archive type signature (see properties.go).
	Sig string `json:"4dabf18193072939515e22adb298388d" yaml:"4dabf18193072939515e22adb298388d"`
	// Hash contains the SHA256 hash of the archive's contents.
	Hash string `json:"hash,omitempty" yaml:"hash,omitempty"`
	// Assets, when non-nil, is a collection of other assets/archives.
	Assets map[string]interface{} `json:"assets,omitempty" yaml:"assets,omitempty"`
	// Path is a non-empty string representing a path to a file on the current filesystem, for file archives.
	Path string `json:"path,omitempty" yaml:"path,omitempty"`
	// URI is a non-empty URI (file://, http://, https://, etc), for URI-backed archives.
	URI string `json:"uri,omitempty" yaml:"uri,omitempty"`
}

Archive is a serialized archive reference. It is a union: thus, only one of its fields will be non-nil. Several helper routines exist as members in order to easily interact with archives of different kinds.

func DeserializeArchive 

func DeserializeArchive(obj map[string]interface{}) (*Archive, bool, error)

DeserializeArchive checks to see if the map contains an archive, using its signature, and if so deserializes it.

func NewAssetArchive 

func NewAssetArchive(assets map[string]interface{}) (*Archive, error)

func NewPathArchive 

func NewPathArchive(path string) (*Archive, error)

func NewURIArchive 

func NewURIArchive(uri string) (*Archive, error)

func (*Archive) Archive 

func (a *Archive) Archive(format ArchiveFormat, w io.Writer) error

Archive produces a single archive stream in the desired format. It prefers to return the archive with as little copying as is feasible, however if the desired format is different from the source, it will need to translate.

func (*Archive) Bytes 

func (a *Archive) Bytes(format ArchiveFormat) ([]byte, error)

Bytes fetches the archive contents as a byte slices. This is almost certainly the least efficient way to deal with the underlying streaming capabilities offered by assets and archives, but can be used in a pinch to interact with APIs that demand []bytes.

func (*Archive) EnsureHash 

func (a *Archive) EnsureHash() error

EnsureHash computes the SHA256 hash of the archive's contents and stores it on the object.

func (*Archive) Equals 

func (a *Archive) Equals(other *Archive) bool

Equals returns true if a is value-equal to other. In this case, value equality is determined only by the hash: even if the contents of two archives come from different sources, they are treated as equal if their hashes match. Similarly, if the contents of two archives come from the same source but the archives have different hashes, the archives are not equal.

func (*Archive) GetAssets 

func (a *Archive) GetAssets() (map[string]interface{}, bool)

func (*Archive) GetPath 

func (a *Archive) GetPath() (string, bool)

func (*Archive) GetURI 

func (a *Archive) GetURI() (string, bool)

func (*Archive) GetURIURL 

func (a *Archive) GetURIURL() (*url.URL, bool, error)

GetURIURL returns the underlying URI as a parsed URL, provided it is one. If there was an error parsing the URI, it will be returned as a non-nil error object.

func (*Archive) HasContents 

func (a *Archive) HasContents() bool

HasContents indicates whether or not an archive's contents can be read.

func (*Archive) IsAssets 

func (a *Archive) IsAssets() bool

func (*Archive) IsPath 

func (a *Archive) IsPath() bool

func (*Archive) IsURI 

func (a *Archive) IsURI() bool

func (*Archive) Open 

func (a *Archive) Open() (ArchiveReader, error)

Open returns an ArchiveReader that can be used to iterate over the named blobs that comprise the archive.

func (*Archive) ReadSourceArchive 

func (a *Archive) ReadSourceArchive() (ArchiveFormat, io.ReadCloser, error)

ReadSourceArchive returns a stream to the underlying archive, if there is one.

func (*Archive) Serialize 

func (a *Archive) Serialize() map[string]interface{}

Serialize returns a weakly typed map that contains the right signature for serialization purposes.

type ArchiveFormat 

type ArchiveFormat int

ArchiveFormat indicates what archive and/or compression format an archive uses.

type ArchiveReader 

type ArchiveReader interface {
	// Next returns the name and contents of the next member of the archive. If there are no more members in the
	// archive, this function returns ("", nil, io.EOF). The blob returned by a call to Next() must be read in full
	// before the next call to Next().
	Next() (string, *Blob, error)

	// Close terminates the stream.
	Close() error
}

ArchiveReader presents the contents of an archive as a stream of named blobs.

type ArrayDiff 

type ArrayDiff struct {
	Adds    map[int]PropertyValue // elements added in the new.
	Deletes map[int]PropertyValue // elements deleted in the new.
	Sames   map[int]PropertyValue // elements the same in both.
	Updates map[int]ValueDiff     // elements that have changed in the new.
}

ArrayDiff holds the results of diffing two arrays of property values.

func (*ArrayDiff) Len 

func (diff *ArrayDiff) Len() int

Len computes the length of this array, taking into account adds, deletes, sames, and updates.

type Asset 

type Asset struct {
	// Sig is the unique asset type signature (see properties.go).
	Sig string `json:"4dabf18193072939515e22adb298388d" yaml:"4dabf18193072939515e22adb298388d"`
	// Hash is the SHA256 hash of the asset's contents.
	Hash string `json:"hash,omitempty" yaml:"hash,omitempty"`
	// Text is set to a non-empty value for textual assets.
	Text string `json:"text,omitempty" yaml:"text,omitempty"`
	// Path will contain a non-empty path to the file on the current filesystem for file assets.
	Path string `json:"path,omitempty" yaml:"path,omitempty"`
	// URI will contain a non-empty URI (file://, http://, https://, or custom) for URI-backed assets.
	URI string `json:"uri,omitempty" yaml:"uri,omitempty"`
}

Asset is a serialized asset reference. It is a union: thus, only one of its fields will be non-nil. Several helper routines exist as members in order to easily interact with the assets referenced by an instance of this type.

func DeserializeAsset 

func DeserializeAsset(obj map[string]interface{}) (*Asset, bool, error)

DeserializeAsset checks to see if the map contains an asset, using its signature, and if so deserializes it.

func MassageIfUserProgramCodeAsset 

func MassageIfUserProgramCodeAsset(asset *Asset, debug bool) *Asset

MassageIfUserProgramCodeAsset takes the text for a function and cleans it up a bit to make the user visible diffs less noisy. Specifically:

  1. it tries to condense things by changling multiple blank lines into a single blank line.
  2. it normalizs the sha hashes we emit so that changes to them don't appear in the diff.
  3. it elides the with-capture headers, as changes there are not generally meaningful.

TODO(https://github.com/pulumi/pulumi/issues/592) this is baking in a lot of knowledge about pulumi serialized functions. We should try to move to an alternative mode that isn't so brittle. Options include:

  1. Have a documented delimeter format that plan.go will look for. Have the function serializer emit those delimeters around code that should be ignored.
  2. Have our resource generation code supply not just the resource, but the "user presentable" resource that cuts out a lot of cruft. We could then just diff that content here.

func NewPathAsset 

func NewPathAsset(path string) (*Asset, error)

NewPathAsset produces a new asset and its corresponding SHA256 hash from the given filesystem path.

func NewTextAsset 

func NewTextAsset(text string) (*Asset, error)

NewTextAsset produces a new asset and its corresponding SHA256 hash from the given text.

func NewURIAsset 

func NewURIAsset(uri string) (*Asset, error)

NewURIAsset produces a new asset and its corresponding SHA256 hash from the given network URI.

func (*Asset) Bytes 

func (a *Asset) Bytes() ([]byte, error)

Bytes returns the contents of the asset as a byte slice.

func (*Asset) EnsureHash 

func (a *Asset) EnsureHash() error

EnsureHash computes the SHA256 hash of the asset's contents and stores it on the object.

func (*Asset) Equals 

func (a *Asset) Equals(other *Asset) bool

Equals returns true if a is value-equal to other. In this case, value equality is determined only by the hash: even if the contents of two assets come from different sources, they are treated as equal if their hashes match. Similarly, if the contents of two assets come from the same source but the assets have different hashes, the assets are not equal.

func (*Asset) GetPath 

func (a *Asset) GetPath() (string, bool)

func (*Asset) GetText 

func (a *Asset) GetText() (string, bool)

func (*Asset) GetURI 

func (a *Asset) GetURI() (string, bool)

func (*Asset) GetURIURL 

func (a *Asset) GetURIURL() (*url.URL, bool, error)

GetURIURL returns the underlying URI as a parsed URL, provided it is one. If there was an error parsing the URI, it will be returned as a non-nil error object.

func (*Asset) HasContents 

func (a *Asset) HasContents() bool

HasContents indicates whether or not an asset's contents can be read.

func (*Asset) IsPath 

func (a *Asset) IsPath() bool

func (*Asset) IsText 

func (a *Asset) IsText() bool

func (*Asset) IsURI 

func (a *Asset) IsURI() bool

func (*Asset) IsUserProgramCode 

func (a *Asset) IsUserProgramCode() bool

IsUserProgramCode checks to see if this is the special asset containing the users's code

func (*Asset) Read 

func (a *Asset) Read() (*Blob, error)

Read begins reading an asset.

func (*Asset) Serialize 

func (a *Asset) Serialize() map[string]interface{}

Serialize returns a weakly typed map that contains the right signature for serialization purposes.

type Blob 

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

Blob is a blob that implements ReadCloser and offers Len functionality.

func NewByteBlob 

func NewByteBlob(data []byte) *Blob

NewByteBlob creates a new byte blob.

func NewFileBlob 

func NewFileBlob(f *os.File) (*Blob, error)

NewFileBlob creates a new asset blob whose size is known thanks to stat.

func NewReadCloserBlob 

func NewReadCloserBlob(r io.ReadCloser) (*Blob, error)

NewReadCloserBlob turn any old ReadCloser into an Blob, usually by making a copy.

func (*Blob) Close 

func (blob *Blob) Close() error

func (*Blob) Read 

func (blob *Blob) Read(p []byte) (int, error)

func (*Blob) Size 

func (blob *Blob) Size() int64

type Computed 

type Computed struct {
	Element PropertyValue // the eventual value (type) of the computed property.
}

Computed represents the absence of a property value, because it will be computed at some point in the future. It contains a property value which represents the underlying expected type of the eventual property value.

type CustomTimeouts 

type CustomTimeouts struct {
	Create float64 `json:"create,omitempty" yaml:"create,omitempty"`
	Update float64 `json:"update,omitempty" yaml:"update,omitempty"`
	Delete float64 `json:"delete,omitempty" yaml:"delete,omitempty"`
}

func (*CustomTimeouts) IsNotEmpty 

func (c *CustomTimeouts) IsNotEmpty() bool

type Goal 

type Goal struct {
	Type                    tokens.Type           // the type of resource.
	Name                    tokens.QName          // the name for the resource's URN.
	Custom                  bool                  // true if this resource is custom, managed by a plugin.
	Properties              PropertyMap           // the resource's property state.
	Parent                  URN                   // an optional parent URN for this resource.
	Protect                 bool                  // true to protect this resource from deletion.
	Dependencies            []URN                 // dependencies of this resource object.
	Provider                string                // the provider to use for this resource.
	InitErrors              []string              // errors encountered as we attempted to initialize the resource.
	PropertyDependencies    map[PropertyKey][]URN // the set of dependencies that affect each property.
	DeleteBeforeReplace     *bool                 // true if this resource should be deleted prior to replacement.
	IgnoreChanges           []string              // a list of property names to ignore during changes.
	AdditionalSecretOutputs []PropertyKey         // outputs that should always be treated as secrets.
	Aliases                 []URN                 // additional URNs that should be aliased to this resource.
	ID                      ID                    // the expected ID of the resource, if any.
	CustomTimeouts          CustomTimeouts        // an optional config object for resource options
}

Goal is a desired state for a resource object. Normally it represents a subset of the resource's state expressed by a program, however if Output is true, it represents a more complete, post-deployment view of the state.

func NewGoal 

func NewGoal(t tokens.Type, name tokens.QName, custom bool, props PropertyMap,
	parent URN, protect bool, dependencies []URN, provider string, initErrors []string,
	propertyDependencies map[PropertyKey][]URN, deleteBeforeReplace *bool, ignoreChanges []string,
	additionalSecretOutputs []PropertyKey, aliases []URN, id ID, customTimeouts *CustomTimeouts) *Goal

NewGoal allocates a new resource goal state.

type ID 

type ID string

ID is a unique resource identifier; it is managed by the provider and is mostly opaque.

func MaybeID 

func MaybeID(s *string) *ID

MaybeID turns an optional string into an optional resource ID.

func NewUniqueHexID 

func NewUniqueHexID(prefix string, randlen, maxlen int) (ID, error)

NewUniqueHexID generates a new "random" hex string for use by resource providers. It will take the optional prefix and append randlen random characters (defaulting to 8 if not > 0). The result must not exceed maxlen total characterss (if > 0). Note that capping to maxlen necessarily increases the risk of collisions.

func (ID) String 

func (id ID) String() string

String converts a resource ID into a string.

func (*ID) StringPtr 

func (id *ID) StringPtr() *string

StringPtr converts an optional ID into an optional string.

type IgnoreKeyFunc 

type IgnoreKeyFunc func(key PropertyKey) bool

IgnoreKeyFunc is the callback type for Diff's ignore option.

type ObjectDiff 

type ObjectDiff struct {
	Adds    PropertyMap               // properties in this map are created in the new.
	Deletes PropertyMap               // properties in this map are deleted from the new.
	Sames   PropertyMap               // properties in this map are the same.
	Updates map[PropertyKey]ValueDiff // properties in this map are changed in the new.
}

ObjectDiff holds the results of diffing two object property maps.

func (*ObjectDiff) Added 

func (diff *ObjectDiff) Added(k PropertyKey) bool

Added returns true if the property 'k' has been added in the new property set.

func (*ObjectDiff) Changed 

func (diff *ObjectDiff) Changed(k PropertyKey) bool

Changed returns true if the property 'k' is known to be different between old and new.

func (*ObjectDiff) Deleted 

func (diff *ObjectDiff) Deleted(k PropertyKey) bool

Deleted returns true if the property 'k' has been deleted from the new property set.

func (*ObjectDiff) Keys 

func (diff *ObjectDiff) Keys() []PropertyKey

Keys returns a stable snapshot of all keys known to this object, across adds, deletes, sames, and updates.

func (*ObjectDiff) Same 

func (diff *ObjectDiff) Same(k PropertyKey) bool

Same returns true if the property 'k' is *not* known to be different; note that this isn't the same as looking up in the Sames map, because it is possible the key is simply missing altogether (as is the case for nulls).

func (*ObjectDiff) Updated 

func (diff *ObjectDiff) Updated(k PropertyKey) bool

Updated returns true if the property 'k' has been changed between new and old property sets.

type Operation 

type Operation struct {
	Resource *State
	Type     OperationType
}

Operation represents an operation that the engine has initiated but has not yet completed. It is essentially just a tuple of a resource and a string identifying the operation.

func NewOperation 

func NewOperation(state *State, op OperationType) Operation

NewOperation constructs a new Operation from a state and an operation name.

type OperationType 

type OperationType string

OperationType is the type of operations issued by the engine. 

const (
	// OperationTypeCreating is the state of resources that are being created.
	OperationTypeCreating OperationType = "creating"
	// OperationTypeUpdating is the state of resources that are being updated.
	OperationTypeUpdating OperationType = "updating"
	// OperationTypeDeleting is the state of resources that are being deleted.
	OperationTypeDeleting OperationType = "deleting"
	// OperationTypeReading is the state of resources that are being read.
	OperationTypeReading OperationType = "reading"
	// OperationTypeImporting is the state of resources that are being imported.
	OperationTypeImporting OperationType = "importing"
)

type Output 

type Output struct {
	Element PropertyValue // the eventual value (type) of the output property.
}

Output is a property value that will eventually be computed by the resource provider. If an output property is encountered, it means the resource has not yet been created, and so the output value is unavailable. Note that an output property is a special case of computed, but carries additional semantic meaning.

type Property 

type Property struct {
	Key   PropertyKey
	Value PropertyValue
}

Property is a pair of key and value.

type PropertyKey 

type PropertyKey tokens.Name

PropertyKey is the name of a property.

type PropertyMap 

type PropertyMap map[PropertyKey]PropertyValue

PropertyMap is a simple map keyed by property name with "JSON-like" values.

func NewPropertyMap 

func NewPropertyMap(s interface{}) PropertyMap

NewPropertyMap turns a struct into a property map, using any JSON tags inside to determine naming.

func NewPropertyMapFromMap 

func NewPropertyMapFromMap(m map[string]interface{}) PropertyMap

NewPropertyMapFromMap creates a resource map from a regular weakly typed JSON-like map.

func NewPropertyMapFromMapRepl 

func NewPropertyMapFromMapRepl(m map[string]interface{},
	replk func(string) (PropertyKey, bool), replv func(interface{}) (PropertyValue, bool)) PropertyMap

NewPropertyMapFromMapRepl optionally replaces keys/values in an existing map while creating a new resource map.

func NewPropertyMapRepl 

func NewPropertyMapRepl(s interface{},
	replk func(string) (PropertyKey, bool), replv func(interface{}) (PropertyValue, bool)) PropertyMap

NewPropertyMapRepl turns a struct into a property map, using any JSON tags inside to determine naming. If non-nil replk or replv function(s) are provided, key and/or value transformations are performed during the mapping.

func (PropertyMap) ContainsSecrets 

func (m PropertyMap) ContainsSecrets() bool

ContainsSecrets returns true if the property map contains at least one secret value.

func (PropertyMap) ContainsUnknowns 

func (m PropertyMap) ContainsUnknowns() bool

ContainsUnknowns returns true if the property map contains at least one unknown value.

func (PropertyMap) Copy 

func (m PropertyMap) Copy() PropertyMap

Copy makes a shallow copy of the map.

func (PropertyMap) DeepEquals 

func (props PropertyMap) DeepEquals(other PropertyMap) bool

DeepEquals returns true if this property map is deeply equal to the other property map; and false otherwise.

func (PropertyMap) Diff 

func (props PropertyMap) Diff(other PropertyMap, ignoreKeys ...IgnoreKeyFunc) *ObjectDiff

Diff returns a diffset by comparing the property map to another; it returns nil if there are no diffs.

func (PropertyMap) HasValue 

func (m PropertyMap) HasValue(k PropertyKey) bool

HasValue returns true if the slot associated with the given property key contains a real value. It returns false if a value is null or an output property that is awaiting a value to be assigned. That is to say, HasValue indicates a semantically meaningful value is present (even if it's a computed one whose concrete value isn't yet evaluated).

func (PropertyMap) MapRepl 

func (m PropertyMap) MapRepl(replk func(string) (string, bool),
	replv func(PropertyValue) (interface{}, bool)) map[string]interface{}

MapRepl returns a mapper-compatible object map, suitable for deserialization into structures. A key and/or value replace function, replk/replv, may be passed that will replace elements using custom logic if appropriate.

func (PropertyMap) Mappable 

func (m PropertyMap) Mappable() map[string]interface{}

Mappable returns a mapper-compatible object map, suitable for deserialization into structures.

func (PropertyMap) StableKeys 

func (m PropertyMap) StableKeys() []PropertyKey

StableKeys returns all of the map's keys in a stable order.

type PropertyPath 

type PropertyPath []interface{}

PropertyPath represents a path to a nested property. The path may be composed of strings (which access properties in ObjectProperty values) and integers (which access elements of ArrayProperty values).

func ParsePropertyPath 

func ParsePropertyPath(path string) (PropertyPath, error)

ParsePropertyPath parses a property path into a PropertyPath value.

A property path string is essentially a Javascript property access expression in which all elements are literals. Valid property paths obey the following EBNF-ish grammar: 

propertyName := [a-zA-Z_$] { [a-zA-Z0-9_$] }
quotedPropertyName := '"' ( '\' '"' | [^"] ) { ( '\' '"' | [^"] ) } '"'
arrayIndex := { [0-9] }

propertyIndex := '[' ( quotedPropertyName | arrayIndex ) ']'
rootProperty := ( propertyName | propertyIndex )
propertyAccessor := ( ( '.' propertyName ) |  propertyIndex )
path := rootProperty { propertyAccessor }

Examples of valid paths: - root - root.nested - root["nested"] - root.double.nest - root["double"].nest - root["double"]["nest"] - root.array[0] - root.array[100] - root.array[0].nested - root.array[0][1].nested - root.nested.array[0].double[1] - root["key with \"escaped\" quotes"] - root["key with a ."] - ["root key with \"escaped\" quotes"].nested - ["root key with a ."][100]

func (PropertyPath) Add added in v2.6.0 

func (p PropertyPath) Add(dest, v PropertyValue) (PropertyValue, bool)

Add sets the location inside a PropertyValue indicated by the PropertyPath to the given value. Any components referred to by the path that do not exist will be created. If there is a mismatch between the type of an existing component and a key that traverses that component, this function will return false. If the destination is a null property value, this function will create and return a new property value.

func (PropertyPath) Delete 

func (p PropertyPath) Delete(dest PropertyValue) bool

Delete attempts to delete the value located by the PropertyPath inside the given PropertyValue. If any component of the path does not exist, this function will return false.

func (PropertyPath) Get 

func (p PropertyPath) Get(v PropertyValue) (PropertyValue, bool)

Get attempts to get the value located by the PropertyPath inside the given PropertyValue. If any component of the path does not exist, this function will return (NullPropertyValue, false).

func (PropertyPath) Set 

func (p PropertyPath) Set(dest, v PropertyValue) bool

Set attempts to set the location inside a PropertyValue indicated by the PropertyPath to the given value. If any component of the path besides the last component does not exist, this function will return false.

type PropertySet 

type PropertySet map[PropertyKey]bool

PropertySet is a simple set keyed by property name.

type PropertyValue 

type PropertyValue struct {
	V interface{}
}

PropertyValue is the value of a property, limited to a select few types (see below).

func MakeComponentResourceReference added in v2.18.0 

func MakeComponentResourceReference(urn URN, packageVersion string) PropertyValue

MakeComponentResourceReference creates a reference to a component resource.

func MakeComputed 

func MakeComputed(v PropertyValue) PropertyValue

func MakeCustomResourceReference added in v2.18.0 

func MakeCustomResourceReference(urn URN, id ID, packageVersion string) PropertyValue

MakeCustomResourceReference creates a reference to a custom resource. If the resource's ID is the empty string, it will be treated as unknown.

func MakeOutput 

func MakeOutput(v PropertyValue) PropertyValue

func MakeSecret 

func MakeSecret(v PropertyValue) PropertyValue

func NewArchiveProperty 

func NewArchiveProperty(v *Archive) PropertyValue

func NewArrayProperty 

func NewArrayProperty(v []PropertyValue) PropertyValue

func NewAssetProperty 

func NewAssetProperty(v *Asset) PropertyValue

func NewBoolProperty 

func NewBoolProperty(v bool) PropertyValue

func NewComputedProperty 

func NewComputedProperty(v Computed) PropertyValue

func NewNullProperty 

func NewNullProperty() PropertyValue

func NewNumberProperty 

func NewNumberProperty(v float64) PropertyValue

func NewObjectProperty 

func NewObjectProperty(v PropertyMap) PropertyValue

func NewOutputProperty 

func NewOutputProperty(v Output) PropertyValue

func NewPropertyValue 

func NewPropertyValue(v interface{}) PropertyValue

NewPropertyValue turns a value into a property value, provided it is of a legal "JSON-like" kind.

func NewPropertyValueRepl 

func NewPropertyValueRepl(v interface{},
	replk func(string) (PropertyKey, bool), replv func(interface{}) (PropertyValue, bool)) PropertyValue

NewPropertyValueRepl turns a value into a property value, provided it is of a legal "JSON-like" kind. The replacement functions, replk and replv, may be supplied to transform keys and/or values as the mapping takes place.

func NewResourceReferenceProperty added in v2.13.0 

func NewResourceReferenceProperty(v ResourceReference) PropertyValue

func NewSecretProperty 

func NewSecretProperty(v *Secret) PropertyValue

func NewStringProperty 

func NewStringProperty(v string) PropertyValue

func (PropertyValue) ArchiveValue 

func (v PropertyValue) ArchiveValue() *Archive

ArchiveValue fetches the underlying archive value (panicking if it isn't an archive).

func (PropertyValue) ArrayValue 

func (v PropertyValue) ArrayValue() []PropertyValue

ArrayValue fetches the underlying array value (panicking if it isn't a array).

func (PropertyValue) AssetValue 

func (v PropertyValue) AssetValue() *Asset

AssetValue fetches the underlying asset value (panicking if it isn't an asset).

func (PropertyValue) BoolValue 

func (v PropertyValue) BoolValue() bool

BoolValue fetches the underlying bool value (panicking if it isn't a bool).

func (PropertyValue) ContainsSecrets 

func (v PropertyValue) ContainsSecrets() bool

ContainsSecrets returns true if the property value contains at least one secret (deeply).

func (PropertyValue) ContainsUnknowns 

func (v PropertyValue) ContainsUnknowns() bool

ContainsUnknowns returns true if the property value contains at least one unknown (deeply).

func (PropertyValue) DeepEquals 

func (v PropertyValue) DeepEquals(other PropertyValue) bool

DeepEquals returns true if this property map is deeply equal to the other property map; and false otherwise.

func (PropertyValue) Diff 

func (v PropertyValue) Diff(other PropertyValue, ignoreKeys ...IgnoreKeyFunc) *ValueDiff

Diff returns a diff by comparing a single property value to another; it returns nil if there are no diffs.

func (PropertyValue) HasValue 

func (v PropertyValue) HasValue() bool

HasValue returns true if a value is semantically meaningful.

func (PropertyValue) Input 

func (v PropertyValue) Input() Computed

Input fetches the underlying computed value (panicking if it isn't a computed).

func (PropertyValue) IsArchive 

func (v PropertyValue) IsArchive() bool

IsArchive returns true if the underlying value is an object.

func (PropertyValue) IsArray 

func (v PropertyValue) IsArray() bool

IsArray returns true if the underlying value is an array.

func (PropertyValue) IsAsset 

func (v PropertyValue) IsAsset() bool

IsAsset returns true if the underlying value is an object.

func (PropertyValue) IsBool 

func (v PropertyValue) IsBool() bool

IsBool returns true if the underlying value is a bool.

func (PropertyValue) IsComputed 

func (v PropertyValue) IsComputed() bool

IsComputed returns true if the underlying value is a computed value.

func (PropertyValue) IsNull 

func (v PropertyValue) IsNull() bool

IsNull returns true if the underlying value is a null.

func (PropertyValue) IsNumber 

func (v PropertyValue) IsNumber() bool

IsNumber returns true if the underlying value is a number.

func (PropertyValue) IsObject 

func (v PropertyValue) IsObject() bool

IsObject returns true if the underlying value is an object.

func (PropertyValue) IsOutput 

func (v PropertyValue) IsOutput() bool

IsOutput returns true if the underlying value is an output value.

func (PropertyValue) IsResourceReference added in v2.13.0 

func (v PropertyValue) IsResourceReference() bool

IsResourceReference returns true if the underlying value is a resource reference value.

func (PropertyValue) IsSecret 

func (v PropertyValue) IsSecret() bool

IsSecret returns true if the underlying value is a secret value.

func (PropertyValue) IsString 

func (v PropertyValue) IsString() bool

IsString returns true if the underlying value is a string.

func (PropertyValue) MapRepl 

func (v PropertyValue) MapRepl(replk func(string) (string, bool),
	replv func(PropertyValue) (interface{}, bool)) interface{}

MapRepl returns a mapper-compatible object map, suitable for deserialization into structures. A key and/or value replace function, replk/replv, may be passed that will replace elements using custom logic if appropriate.

func (PropertyValue) Mappable 

func (v PropertyValue) Mappable() interface{}

Mappable returns a mapper-compatible value, suitable for deserialization into structures.

func (PropertyValue) NumberValue 

func (v PropertyValue) NumberValue() float64

NumberValue fetches the underlying number value (panicking if it isn't a number).

func (PropertyValue) ObjectValue 

func (v PropertyValue) ObjectValue() PropertyMap

ObjectValue fetches the underlying object value (panicking if it isn't a object).

func (PropertyValue) OutputValue 

func (v PropertyValue) OutputValue() Output

OutputValue fetches the underlying output value (panicking if it isn't a output).

func (PropertyValue) ResourceReferenceValue added in v2.13.0 

func (v PropertyValue) ResourceReferenceValue() ResourceReference

ResourceReferenceValue fetches the underlying resource reference value (panicking if it isn't a resource reference).

func (PropertyValue) SecretValue 

func (v PropertyValue) SecretValue() *Secret

SecretValue fetches the underlying secret value (panicking if it isn't a secret).

func (PropertyValue) String 

func (v PropertyValue) String() string

String implements the fmt.Stringer interface to add slightly more information to the output.

func (PropertyValue) StringValue 

func (v PropertyValue) StringValue() string

StringValue fetches the underlying string value (panicking if it isn't a string).

func (PropertyValue) TypeString 

func (v PropertyValue) TypeString() string

TypeString returns a type representation of the property value's holder type.

type ReqError 

type ReqError struct {
	K PropertyKey
}

func (*ReqError) Error 

func (err *ReqError) Error() string

type ResourceReference added in v2.13.0 

type ResourceReference struct {
	URN            URN
	ID             PropertyValue
	PackageVersion string
}

ResourceReference is a property value that represents a reference to a Resource. The reference captures the resource's URN, ID, and the version of its containing package. Note that there are several cases to consider with respect to the ID:

  • The reference may not contain an ID if the referenced resource is a component resource. In this case, the ID will be null.
  • The ID may be unknown (in which case it will be the unknown property value)
  • Otherwise, the ID must be a string.

nolint: golint

func (ResourceReference) IDString added in v2.18.0 

func (ref ResourceReference) IDString() (value string, hasID bool)

type Secret 

type Secret struct {
	Element PropertyValue
}

Secret indicates that the underlying value should be persisted securely.

In order to facilitate the ability to distinguish secrets with identical plaintext in downstream code that may want to cache a secret's ciphertext, secret PropertyValues hold the address of the Secret. If a secret must be copied, its value--not its address--should be copied.

type State 

type State struct {
	Type                    tokens.Type           // the resource's type.
	URN                     URN                   // the resource's object urn, a human-friendly, unique name for the resource.
	Custom                  bool                  // true if the resource is custom, managed by a plugin.
	Delete                  bool                  // true if this resource is pending deletion due to a replacement.
	ID                      ID                    // the resource's unique ID, assigned by the resource provider (or blank if none/uncreated).
	Inputs                  PropertyMap           // the resource's input properties (as specified by the program).
	Outputs                 PropertyMap           // the resource's complete output state (as returned by the resource provider).
	Parent                  URN                   // an optional parent URN that this resource belongs to.
	Protect                 bool                  // true to "protect" this resource (protected resources cannot be deleted).
	External                bool                  // true if this resource is "external" to Pulumi and we don't control the lifecycle
	Dependencies            []URN                 // the resource's dependencies
	InitErrors              []string              // the set of errors encountered in the process of initializing resource.
	Provider                string                // the provider to use for this resource.
	PropertyDependencies    map[PropertyKey][]URN // the set of dependencies that affect each property.
	PendingReplacement      bool                  // true if this resource was deleted and is awaiting replacement.
	AdditionalSecretOutputs []PropertyKey         // an additional set of outputs that should be treated as secrets.
	Aliases                 []URN                 // TODO
	CustomTimeouts          CustomTimeouts        // A config block that will be used to configure timeouts for CRUD operations
	ImportID                ID                    // the resource's import id, if this was an imported resource.
}

State is a structure containing state associated with a resource. This resource may have been serialized and deserialized, or snapshotted from a live graph of resource objects. The value's state is not, however, associated with any runtime objects in memory that may be actively involved in ongoing computations. nolint: lll

func NewState 

func NewState(t tokens.Type, urn URN, custom bool, del bool, id ID,
	inputs PropertyMap, outputs PropertyMap, parent URN, protect bool,
	external bool, dependencies []URN, initErrors []string, provider string,
	propertyDependencies map[PropertyKey][]URN, pendingReplacement bool,
	additionalSecretOutputs []PropertyKey, aliases []URN, timeouts *CustomTimeouts,
	importID ID) *State

NewState creates a new resource value from existing resource state information.

type Status 

type Status int

Status is returned when an error has occurred during a resource provider operation. It indicates whether the operation could be rolled back cleanly (OK). If not, it means the resource was left in an indeterminate state. 

const (
	StatusOK Status = iota
	StatusPartialFailure
	StatusUnknown
)

type URN 

type URN string

URN is a friendly, but unique, URN for a resource, most often auto-assigned by Pulumi. These are used as unique IDs for objects, and help us to perform graph diffing and resolution of resource objects.

In theory, we could support manually assigned URIs in the future. For the time being, however, we have opted to simplify developers' lives by mostly automating the generation of them algorithmically. The one caveat where it isn't truly automatic is that a developer -- or resource provider -- must provide a semi-unique name part.

Each resource URN is of the form: 

urn:pulumi:<Stack>::<Project>::<Qualified$Type$Name>::<Name>

wherein each element is the following: 

<Stack>                 The stack being deployed into
<Project>               The project being evaluated
<Qualified$Type$Name>   The object type's qualified type token (including the parent type)
<Name>                  The human-friendly name identifier assigned by the developer or provider

In the future, we may add elements to the URN; it is more important that it is unique than it is human-typable.

func DefaultRootStackURN 

func DefaultRootStackURN(stack tokens.QName, proj tokens.PackageName) URN

DefaultRootStackURN constructs a default root stack URN for the given stack and project.

func NewURN 

func NewURN(stack tokens.QName, proj tokens.PackageName, parentType, baseType tokens.Type, name tokens.QName) URN

NewURN creates a unique resource URN for the given resource object.

func (URN) IsValid 

func (urn URN) IsValid() bool

IsValid returns true if the URN is well-formed.

func (URN) Name 

func (urn URN) Name() tokens.QName

Name returns the resource name part of a URN.

func (URN) Project 

func (urn URN) Project() tokens.PackageName

Project returns the project name part of a URN.

func (URN) QualifiedType 

func (urn URN) QualifiedType() tokens.Type

QualifiedType returns the resource type part of a URN including the parent type

func (URN) Stack 

func (urn URN) Stack() tokens.QName

Stack returns the resource stack part of a URN.

func (URN) Type 

func (urn URN) Type() tokens.Type

Type returns the resource type part of a URN

func (URN) URNName 

func (urn URN) URNName() string

URNName returns the URN name part of a URN (i.e., strips off the prefix).

type ValueDiff 

type ValueDiff struct {
	Old    PropertyValue // the old value.
	New    PropertyValue // the new value.
	Array  *ArrayDiff    // the array's detailed diffs (only for arrays).
	Object *ObjectDiff   // the object's detailed diffs (only for objects).
}

ValueDiff holds the results of diffing two property values.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.