wrapper

Documentation

Index

• Constants
• Variables
• func DefaultExecutor(c *exec.Cmd) error
• type ModuleDefinition
  • func (module *ModuleDefinition) Inputs() ([]string, error)
  • func (module *ModuleDefinition) Outputs() ([]string, error)
  • func (module *ModuleDefinition) Validate() (errs *validation.FieldError)
• type ModuleInstance
  • func (instance *ModuleInstance) MarshalDefinition() (json.RawMessage, error)
• type TerraformExecutor
  • func CustomEnvironmentExecutor(environment map[string]string, wrapped TerraformExecutor) TerraformExecutor
  • func CustomTerraformExecutor(tfBinaryPath, tfPluginDir string, wrapped TerraformExecutor) TerraformExecutor
• type TerraformWorkspace
  • func DeserializeWorkspace(definition string) (*TerraformWorkspace, error)
  • func NewWorkspace(templateVars map[string]interface{}, terraformTemplate string) (*TerraformWorkspace, error)
  • func (workspace *TerraformWorkspace) Apply() error
  • func (workspace *TerraformWorkspace) Destroy() error
  • func (workspace *TerraformWorkspace) Outputs(instance string) (map[string]interface{}, error)
  • func (workspace *TerraformWorkspace) Serialize() (string, error)
  • func (workspace *TerraformWorkspace) String() string
  • func (workspace *TerraformWorkspace) Validate() error
• type Tfstate
  • func NewTfstate(stateFile []byte) (*Tfstate, error)
  • func (state *Tfstate) GetModule(path ...string) *TfstateModule
• type TfstateModule
  • func (module *TfstateModule) GetOutputs() map[string]interface{}
  • func (module *TfstateModule) String() string

Examples

• ModuleDefinition.Inputs
• ModuleDefinition.Outputs
• ModuleInstance.MarshalDefinition
• Tfstate.GetModule

Constants

const (
	DefaultInstanceName = "instance"
)

DefaultInstanceName is the default name of an instance of a particular module.

Variables

var (
	FsInitializationErr = errors.New("Filesystem must first be initialized.")
)

Functions

func DefaultExecutor

func DefaultExecutor(c *exec.Cmd) error

DefaultExecutor is the default executor that shells out to Terraform and logs results to stdout.

Types

type ModuleDefinition

type ModuleDefinition struct {
	Name       string
	Definition string
}

ModuleDefinition represents a module in a Terraform workspace.

func (*ModuleDefinition) Inputs

func (module *ModuleDefinition) Inputs() ([]string, error)

Inputs gets the input parameter names for the module.

Example

module := ModuleDefinition{
	Name: "cloud_storage",
	Definition: `
    variable name {type = "string"}
    variable storage_class {type = "string"}

    resource "google_storage_bucket" "bucket" {
      name     = "${var.name}"
      storage_class = "${var.storage_class}"
    }
`,
}

inputs, err := module.Inputs()
if err != nil {
	panic(err)
}
fmt.Printf("%v\n", inputs)

Output:

[name storage_class]

func (*ModuleDefinition) Outputs

func (module *ModuleDefinition) Outputs() ([]string, error)

Outputs gets the output parameter names for the module.

Example

module := ModuleDefinition{
	Name: "cloud_storage",
	Definition: `
    resource "google_storage_bucket" "bucket" {
      name     = "my-bucket"
      storage_class = "STANDARD"
    }

    output id {value = "${google_storage_bucket.bucket.id}"}
    output bucket_name {value = "my-bucket"}
`,
}

outputs, err := module.Outputs()
if err != nil {
	panic(err)
}
fmt.Printf("%v\n", outputs)

Output:

[bucket_name id]

func (*ModuleDefinition) Validate

func (module *ModuleDefinition) Validate() (errs *validation.FieldError)

Validate checks the validity of the ModuleDefinition struct.

type ModuleInstance

type ModuleInstance struct {
	ModuleName    string                 `json:"module_name"`
	InstanceName  string                 `json:"instance_name"`
	Configuration map[string]interface{} `json:"configuration"`
}

ModuleInstance represents the configuration of a single instance of a module.

func (*ModuleInstance) MarshalDefinition

func (instance *ModuleInstance) MarshalDefinition() (json.RawMessage, error)

MarshalDefinition converts the module instance definition into a JSON definition that can be fed to Terraform to be created/destroyed.

Example

instance := ModuleInstance{
	ModuleName:    "foo-module",
	InstanceName:  "instance",
	Configuration: map[string]interface{}{"foo": "bar"},
}

defnJson, err := instance.MarshalDefinition()
fmt.Println(err)
fmt.Printf("%s\n", string(defnJson))

Output:

<nil>
{"module":{"instance":{"foo":"bar","source":"foo-module"}}}

type TerraformExecutor

type TerraformExecutor func(*exec.Cmd) error

TerraformExecutor is the function that shells out to Terraform. It can intercept, modify or retry the given command.

func CustomEnvironmentExecutor

func CustomEnvironmentExecutor(environment map[string]string, wrapped TerraformExecutor) TerraformExecutor

CustomEnvironmentExecutor sets custom environment variables on the Terraform execution.

func CustomTerraformExecutor

func CustomTerraformExecutor(tfBinaryPath, tfPluginDir string, wrapped TerraformExecutor) TerraformExecutor

CustomTerraformExecutor executes a custom Terraform binary that uses plugins from a given plugin directory rather than the Terraform that's on the PATH which will download provider binaries from the web.

type TerraformWorkspace

type TerraformWorkspace struct {
	Modules   []ModuleDefinition `json:"modules"`
	Instances []ModuleInstance   `json:"instances"`
	State     []byte             `json:"tfstate"`

	// Executor is a function that gets invoked to shell out to Terraform.
	// If left nil, the default executor is used.
	Executor TerraformExecutor `json:"-"`
	// contains filtered or unexported fields
}

TerraformWorkspace represents the directory layout of a Terraform execution. The structure is strict, consiting of several Terraform modules and instances of those modules. The strictness is artificial, but maintains a clear separation between data and code.

It manages the directory structure needed for the commands, serializing and deserializing Terraform state, and all the flags necessary to call Terraform.

All public functions that shell out to Terraform maintain the following invariants: - The function blocks if another terraform shell is running. - The function updates the tfstate once finished. - The function creates and destroys its own dir.

func DeserializeWorkspace

func DeserializeWorkspace(definition string) (*TerraformWorkspace, error)

DeserializeWorkspace creates a new TerraformWorkspace from a given JSON serialization of one.

func NewWorkspace

func NewWorkspace(templateVars map[string]interface{}, terraformTemplate string) (*TerraformWorkspace, error)

NewWorkspace creates a new TerraformWorkspace from a given template and variables to populate an instance of it. The created instance will have the name specified by the DefaultInstanceName constant.

func (*TerraformWorkspace) Apply

func (workspace *TerraformWorkspace) Apply() error

Apply runs `terraform apply` on this workspace. This funciton blocks if another Terraform command is running on this workspace.

func (*TerraformWorkspace) Destroy

func (workspace *TerraformWorkspace) Destroy() error

Destroy runs `terraform destroy` on this workspace. This funciton blocks if another Terraform command is running on this workspace.

func (*TerraformWorkspace) Outputs

func (workspace *TerraformWorkspace) Outputs(instance string) (map[string]interface{}, error)

Outputs gets the Terraform outputs from the state for the instance with the given name. This function DOES NOT invoke Terraform and instead uses the stored state. If no instance exists with the given name, it could be that Terraform pruned it due to having no contents so a blank map is returned.

func (*TerraformWorkspace) Serialize

func (workspace *TerraformWorkspace) Serialize() (string, error)

Serialize converts the TerraformWorkspace into a JSON string.

func (*TerraformWorkspace) String

func (workspace *TerraformWorkspace) String() string

String returns a human-friendly representation of the workspace suitable for printing to the console.

func (*TerraformWorkspace) Validate

func (workspace *TerraformWorkspace) Validate() error

Validate runs `terraform Validate` on this workspace. This funciton blocks if another Terraform command is running on this workspace.

type Tfstate

type Tfstate struct {
	Version int             `json:"version"`
	Modules []TfstateModule `json:"modules"`
}

Tfstate is a struct that can help us deserialize the tfstate JSON file.

func NewTfstate

func NewTfstate(stateFile []byte) (*Tfstate, error)

NewTfstate deserializes a tfstate file.

func (*Tfstate) GetModule

func (state *Tfstate) GetModule(path ...string) *TfstateModule

GetModule gets a module at a given path or nil if none exists for that path.

Example

state := `{
    "version": 3,
    "terraform_version": "0.11.10",
    "serial": 2,
    "modules": [
        {
            "path": ["root", "instance"],
            "outputs": {
                "Name": {
                    "sensitive": false,
                    "type": "string",
                    "value": "pcf-binding-ex351277"
                }
            },
            "resources": {},
            "depends_on": []
        }
    ]
  }`

tfstate, _ := NewTfstate([]byte(state))
fmt.Printf("%v\n", tfstate.GetModule("does-not-exist"))
fmt.Printf("%v\n", tfstate.GetModule("root", "instance"))

Output:

<nil>
[module: root/instance with 1 outputs]

type TfstateModule

type TfstateModule struct {
	Path    []string `json:"path"`
	Outputs map[string]struct {
		Type  string      `json:"type"`
		Value interface{} `json:"value"`
	} `json:"outputs"`
}

func (*TfstateModule) GetOutputs

func (module *TfstateModule) GetOutputs() map[string]interface{}

GetOutputs gets the key/value outputs defined for a module.

func (*TfstateModule) String

func (module *TfstateModule) String() string