Documentation ¶
Overview ¶
Package resource contains resource types.
Index ¶
- func CtyType(t reflect.Type) cty.Type
- func FieldName(f reflect.StructField) string
- type AuthProvider
- type CreateRequest
- type Definition
- type DeleteRequest
- type Dependency
- type Deployed
- type Desired
- type EvalContext
- type ExprLiteral
- type ExprReference
- type Expression
- type Field
- type FieldSet
- type Graph
- func (g *Graph) AddDependency(dep *Dependency) error
- func (g *Graph) AddResource(res *Desired) error
- func (g *Graph) DependenciesOf(child string) []*Dependency
- func (g *Graph) LeafResources() []*Desired
- func (g *Graph) ParentResources(child string) []*Desired
- func (g *Graph) Resource(name string) *Desired
- type Registry
- type SourceCode
- type UpdateRequest
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func CtyType ¶
CtyType converts a reflect type to the cty type system.
The function is essentially the same as gocty.ImpliedType, except nested structs do not require a cty struct tag. Instead, Fields() is used to get the fields of the nested struct.
Panics if the type cannot be converted. In practice this only applies to more complex types, such as functions and slices.
func FieldName ¶
func FieldName(f reflect.StructField) string
FieldName returns the user-facing name of a field.
If the field has a `name:"<fieldname>"` struct tag set, it is returned. Otherwise, the field name is derived from the struct field name by converting it to lower snake case.
Example (Camel) ¶
package main import ( "fmt" "reflect" "github.com/func/func/resource" ) func main() { field := reflect.StructField{ Name: "DeadLetterConfig", } got := resource.FieldName(field) fmt.Println(got) }
Output: dead_letter_config
Example (Camel2) ¶
package main import ( "fmt" "reflect" "github.com/func/func/resource" ) func main() { field := reflect.StructField{ Name: "KMSKeyArn", } got := resource.FieldName(field) fmt.Println(got) }
Output: kms_key_arn
Example (WithCustom) ¶
package main import ( "fmt" "reflect" "github.com/func/func/resource" ) func main() { field := reflect.StructField{ Name: "RestAPIID", Tag: reflect.StructTag(`name:"rest_api_id"`), } got := resource.FieldName(field) fmt.Println(got) }
Output: rest_api_id
Example (WithoutCustom) ¶
package main import ( "fmt" "reflect" "github.com/func/func/resource" ) func main() { field := reflect.StructField{ Name: "RestAPIID", // Will not split before ID } got := resource.FieldName(field) fmt.Println(got) }
Output: rest_apiid
Types ¶
type AuthProvider ¶
type AuthProvider interface {
AWS() (aws.CredentialsProvider, error)
}
An AuthProvider provides authentication information for provisioning a resource.
type CreateRequest ¶
type CreateRequest struct { Auth AuthProvider Source []SourceCode }
A CreateRequest is passed to a resource's Create method when a new resource is being created.
type Definition ¶
type Definition interface { Create(ctx context.Context, req *CreateRequest) error Update(ctx context.Context, req *UpdateRequest) error Delete(ctx context.Context, req *DeleteRequest) error }
A Definition describes a resource.
All resources must implement this interface.
type DeleteRequest ¶
type DeleteRequest struct {
Auth AuthProvider
}
A DeleteRequest is passed to a resource when it is being deleted.
type Dependency ¶
type Dependency struct { // Child is the name of the child resource with the dependency. Child string // Field is the path to the field within the child resource. The Field is // relative to the resource's Data. Field cty.Path // Expression is the expression value to resolve. The expression may refer // to multiple parent resources. Expression Expression }
A Dependency is a dependency for a single field between two resources.
func (Dependency) Equals ¶
func (d Dependency) Equals(other Dependency) bool
Equals returns true if two expression are equal.
func (Dependency) Parents ¶
func (d Dependency) Parents() []string
Parents returns the names of the parent resources in the dependency's expression.
type Deployed ¶
type Deployed struct { // Desired state that resulted in the deployed resource. *Desired // ID is a unique id that is assigned to the resource when it has been // deployed. The ID uniquely identifies the resource. ID string // Output contains the outputs from the resource. The value is set after // the resource has been provisioned. Output cty.Value // Deps contains the names of the resources that are dependencies of this // resources, that is, one or more field refers to an input or an output in // it. // // Deps are used for traversing the graph backwards when deleting resources. Deps []string }
Deployed is a deployed resource.
type Desired ¶
type Desired struct { // Name used in resource config. // // The Name uniquely identifies the resource within the user's desired // resource graph. Name string // Type used in resource config. // // The Type determines how to process the resource. Type string // Input is the user specified static configuration for the resource. The // shape of this field will depend on the Type. When creating resources, // the creator is responsible for only setting data that is valid for the // given resource type. Input cty.Value // Sources contain the source code hashes that were provided to the // resource. The value is only set for resources that have been created. Sources []string }
Desired represents the desired state of a resource.
type EvalContext ¶
type EvalContext struct { // Variable values for resolving reference values in the expression. Variables map[string]cty.Value }
An EvalContext provides context for evaluating an expression. See Value() for more details.
type ExprLiteral ¶
ExprLiteral is a literal value in an expression.
type ExprReference ¶
ExprReference is a part in an expression that has a reference to another field.
type Expression ¶
type Expression []exprPart
An Expression describes a value for a field.
The Expression may consist of any combination of literals and references. The exprPart interface is closed, only ExprLiteral and ExprReference are allowed.
Example (ForTest) ¶
package main import ( "github.com/func/func/resource" "github.com/zclconf/go-cty/cty" ) // Dummy variable to hold the value from Example var expr resource.Expression func main() { // Construct a new expression for test expr = resource.Expression{ resource.ExprLiteral{Value: cty.StringVal("hello")}, resource.ExprReference{Path: cty.GetAttrPath("other").GetAttr("output")}, resource.ExprLiteral{Value: cty.NumberIntVal(123)}, } // expr is equivalent to "hello${other.output}123" }
Output:
func (Expression) Equals ¶
func (expr Expression) Equals(other Expression) bool
Equals returns true if the expression is equivalent to the other expression.
func (Expression) MergeLiterals ¶
func (expr Expression) MergeLiterals() Expression
MergeLiterals merges consecutive literal values into a single literal. Parts of the expression that are not literals are returned in place as-is.
Example ¶
package main import ( "fmt" "github.com/func/func/resource" "github.com/zclconf/go-cty/cty" ) func main() { input := resource.Expression{ resource.ExprLiteral{Value: cty.StringVal("foo")}, resource.ExprLiteral{Value: cty.StringVal("bar")}, resource.ExprReference{Path: cty.GetAttrPath("abc")}, resource.ExprLiteral{Value: cty.StringVal("baz")}, resource.ExprLiteral{Value: cty.StringVal("qux")}, } merged := input.MergeLiterals() output := resource.Expression{ resource.ExprLiteral{Value: cty.StringVal("foobar")}, resource.ExprReference{Path: cty.GetAttrPath("abc")}, resource.ExprLiteral{Value: cty.StringVal("bazqux")}, } fmt.Println(output.Equals(merged)) }
Output: true
func (Expression) References ¶
func (expr Expression) References() []cty.Path
References returns all referenced paths that are found in the expression.
If the returned slice is empty, the expression contains no dynamic references. Such an expression can be evaluated with expr.Value(nil).
func (Expression) Value ¶
func (expr Expression) Value(ctx *EvalContext) (cty.Value, error)
Value evaluates the expression value with the given variables.
The following rules apply:
- If the expression contains a single literal value, it is returned.
- If the expression contains a single reference values, the referenced value is extracted from vars and returned.
- If the expression contains a combination of values, they are concatenated to a string value. Every value in vars must be convertible to string.
- I an unknown value is encountered, an unknown value is returned. If it was the only part in the expression, the type will match this part. Otherwise, the returned value will be an unknown string.
If the expression contains a reference to a variable that was not set in the ctx, an error is returned.
A nil ctx is equivalent to an EvalContext with no variables, meaning only expressions with static literals can be evaluated.
type Field ¶
type Field struct { Index int // The field's index, relative to the parent struct. Type reflect.Type // The field's type. Tags map[string]string // Struct tags set on the field, excluding func and name tags. // contains filtered or unexported fields }
A Field represents an extracted field from a struct.
type FieldSet ¶
A FieldSet contains extracted schema fields.
func Fields ¶
Fields extracts fields from target. Unexported fields are ignored.
All fields are extracted, regardless if they are marked as an input, output or neither. The returned FieldSet may be further filtered to get the desired fields. The func struct tag is excluded from the Tags in the returned fields.
The name of the field is derived from the struct field name. For example, ExampleField becomes example_field. This can be overridden by setting a `name:"<override>"` tag.
Panics if target is not a struct or a pointer to a struct.
func (FieldSet) CtyType ¶
CtyType converts the FieldSet to a cty object type.
The type is processed deeply, nested structs or pointers to structs are included.
Fields that have interface types are not included as they cannot be represented in the cty type system.
Panics if a field cannot be converted. See ImpliedType() for details.
type Graph ¶
type Graph struct { Resources []*Desired Dependencies []*Dependency }
A Graph contains a resources and relationships between resources.
func (*Graph) AddDependency ¶
func (g *Graph) AddDependency(dep *Dependency) error
AddDependency adds a dependency to a resource.
The dependency is checked for invalid references to resources (that do not exist). Failing this precondition will return an error. Beyond that, no validation is done on the dependency (such as ensuring the field exists).
func (*Graph) AddResource ¶
AddResource adds a new resource to the graph.
Returns an error if another resource with an identical name already exists.
func (*Graph) DependenciesOf ¶
func (g *Graph) DependenciesOf(child string) []*Dependency
DependenciesOf returns the dependencies for a given child.
func (*Graph) LeafResources ¶
LeafResources returns all resources that have no children.
func (*Graph) ParentResources ¶
ParentResources returns the parent resources that are are a dependency to the given child resource. In case multiple references exist to the parent resource, it is included only once.
type Registry ¶
type Registry struct { // Types contains the types registered in the registry. // Outside of tests, the Types map should not be directly accessed. Types map[string]reflect.Type }
A Registry maintains a list of registered resources.
func RegistryFromDefinitions ¶
func RegistryFromDefinitions(defs map[string]Definition) *Registry
RegistryFromDefinitions creates a new registry from a predefined list of resources. It should primarily used in tests to set up a registry.
func (*Registry) Register ¶
func (r *Registry) Register(typename string, def Definition)
Register adds a new resource type.
The graph.Resource interface must be implemented on a pointer receiver on a struct. Panics otherwise. If another resource with the same type is already registered, it is overwritten.
Not safe for concurrent access.
type SourceCode ¶
type SourceCode interface { // Digest returns a hash digest. Key() string // Reader returns a reader to the source tarball. Reader(ctx context.Context) (targz io.ReadCloser, err error) }
SourceCode contains one set of source code, matching a single source entry for the resource.
type UpdateRequest ¶
type UpdateRequest struct { Auth AuthProvider Source []SourceCode Previous Definition SourceChanged bool ConfigChanged bool }
An UpdateRequest is passed to a resource's Update method when a new resource is being updated.
Previous contains the previous version of the resource. The type for Previous will match the resource type.
func (*UpdateRequest) CreateRequest ¶
func (r *UpdateRequest) CreateRequest() *CreateRequest
CreateRequest converts the update to a Create Request.
func (*UpdateRequest) DeleteRequest ¶
func (r *UpdateRequest) DeleteRequest() *DeleteRequest
DeleteRequest converts the update to a Delete Request.
Source Files ¶
Directories ¶
Path | Synopsis |
---|---|
Package hcldecoder provides a decoder for hcl2 resources that define a graph.
|
Package hcldecoder provides a decoder for hcl2 resources that define a graph. |
Package reconciler reconciles resources in a graph.
|
Package reconciler reconciles resources in a graph. |
internal/task
Package task provides mechanics for de-duplicating task execution.
|
Package task provides mechanics for de-duplicating task execution. |
Package validation provides input validation for resources.
|
Package validation provides input validation for resources. |