resource

package
v0.12.3 Latest Latest
Warning

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

Go to latest
Published: Jun 5, 2018 License: Apache-2.0 Imports: 24 Imported by: 0

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.
)
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 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 SigKey = PropertyKey("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,
}

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 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    string                 `json:"4dabf18193072939515e22adb298388d" yaml:"4dabf18193072939515e22adb298388d"` // the unique asset signature (see properties.go).
	Hash   string                 `json:"hash,omitempty" yaml:"hash,omitempty"`                                     // the SHA256 hash of the archive contents.
	Assets map[string]interface{} `json:"assets,omitempty" yaml:"assets,omitempty"`                                 // a collection of other assets/archives.
	Path   string                 `json:"path,omitempty" yaml:"path,omitempty"`                                     // a file on the current filesystem.
	URI    string                 `json:"uri,omitempty" yaml:"uri,omitempty"`                                       // a remote URI (file://, http://, https://, etc).
}

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. nolint: lll

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  string `json:"4dabf18193072939515e22adb298388d" yaml:"4dabf18193072939515e22adb298388d"` // the unique asset signature (see properties.go).
	Hash string `json:"hash,omitempty" yaml:"hash,omitempty"`                                     // the SHA256 hash of the asset contents.
	Text string `json:"text,omitempty" yaml:"text,omitempty"`                                     // a textual asset.
	Path string `json:"path,omitempty" yaml:"path,omitempty"`                                     // a file on the current filesystem.
	URI  string `json:"uri,omitempty" yaml:"uri,omitempty"`                                       // a URI (file://, http://, https://, or custom).
}

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. nolint: lll

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 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.
}

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) *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 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 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) 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) *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) Merge

func (m PropertyMap) Merge(other PropertyMap) PropertyMap

Merge simply merges in another map atop another, and returns the result.

func (PropertyMap) StableKeys

func (m PropertyMap) StableKeys() []PropertyKey

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

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 MakeComputed

func MakeComputed(v PropertyValue) PropertyValue

func MakeOutput

func MakeOutput(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 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) 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) *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) 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) 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 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).
	Dependencies []URN       // the resource's dependencies
}

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.

func NewState

func NewState(t tokens.Type, urn URN, custom bool, del bool, id ID,
	inputs PropertyMap, outputs PropertyMap, parent URN, protect bool, dependencies []URN) *State

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

func (*State) All

func (s *State) All() PropertyMap

All returns all resource state, including the inputs and outputs, overlaid in that order.

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
	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 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) 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.

Directories

Path Synopsis
Package stack contains the serialized and configurable state associated with an stack; or, in other words, a deployment target.
Package stack contains the serialized and configurable state associated with an stack; or, in other words, a deployment target.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL