Initial transfer of provider code

6 files changed, 898 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/terraform/plugin/plugin.go b/vendor/github.com/hashicorp/terraform/plugin/plugin.go
new file mode 100644
index 0000000..00fa7b2
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/plugin/plugin.go
@@ -0,0 +1,13 @@
+package plugin
+
+import (
+        "github.com/hashicorp/go-plugin"
+)
+
+// See serve.go for serving plugins
+
+// PluginMap should be used by clients for the map of plugins.
+var PluginMap = map[string]plugin.Plugin{
+        "provider":    &ResourceProviderPlugin{},
+        "provisioner": &ResourceProvisionerPlugin{},
+}
diff --git a/vendor/github.com/hashicorp/terraform/plugin/resource_provider.go b/vendor/github.com/hashicorp/terraform/plugin/resource_provider.go
new file mode 100644
index 0000000..473f786
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/plugin/resource_provider.go
@@ -0,0 +1,578 @@
+package plugin
+
+import (
+        "net/rpc"
+
+        "github.com/hashicorp/go-plugin"
+        "github.com/hashicorp/terraform/terraform"
+)
+
+// ResourceProviderPlugin is the plugin.Plugin implementation.
+type ResourceProviderPlugin struct {
+        F func() terraform.ResourceProvider
+}
+
+func (p *ResourceProviderPlugin) Server(b *plugin.MuxBroker) (interface{}, error) {
+        return &ResourceProviderServer{Broker: b, Provider: p.F()}, nil
+}
+
+func (p *ResourceProviderPlugin) Client(
+        b *plugin.MuxBroker, c *rpc.Client) (interface{}, error) {
+        return &ResourceProvider{Broker: b, Client: c}, nil
+}
+
+// ResourceProvider is an implementation of terraform.ResourceProvider
+// that communicates over RPC.
+type ResourceProvider struct {
+        Broker *plugin.MuxBroker
+        Client *rpc.Client
+}
+
+func (p *ResourceProvider) Stop() error {
+        var resp ResourceProviderStopResponse
+        err := p.Client.Call("Plugin.Stop", new(interface{}), &resp)
+        if err != nil {
+                return err
+        }
+        if resp.Error != nil {
+                err = resp.Error
+        }
+
+        return err
+}
+
+func (p *ResourceProvider) Input(
+        input terraform.UIInput,
+        c *terraform.ResourceConfig) (*terraform.ResourceConfig, error) {
+        id := p.Broker.NextId()
+        go p.Broker.AcceptAndServe(id, &UIInputServer{
+                UIInput: input,
+        })
+
+        var resp ResourceProviderInputResponse
+        args := ResourceProviderInputArgs{
+                InputId: id,
+                Config:  c,
+        }
+
+        err := p.Client.Call("Plugin.Input", &args, &resp)
+        if err != nil {
+                return nil, err
+        }
+        if resp.Error != nil {
+                err = resp.Error
+                return nil, err
+        }
+
+        return resp.Config, nil
+}
+
+func (p *ResourceProvider) Validate(c *terraform.ResourceConfig) ([]string, []error) {
+        var resp ResourceProviderValidateResponse
+        args := ResourceProviderValidateArgs{
+                Config: c,
+        }
+
+        err := p.Client.Call("Plugin.Validate", &args, &resp)
+        if err != nil {
+                return nil, []error{err}
+        }
+
+        var errs []error
+        if len(resp.Errors) > 0 {
+                errs = make([]error, len(resp.Errors))
+                for i, err := range resp.Errors {
+                        errs[i] = err
+                }
+        }
+
+        return resp.Warnings, errs
+}
+
+func (p *ResourceProvider) ValidateResource(
+        t string, c *terraform.ResourceConfig) ([]string, []error) {
+        var resp ResourceProviderValidateResourceResponse
+        args := ResourceProviderValidateResourceArgs{
+                Config: c,
+                Type:   t,
+        }
+
+        err := p.Client.Call("Plugin.ValidateResource", &args, &resp)
+        if err != nil {
+                return nil, []error{err}
+        }
+
+        var errs []error
+        if len(resp.Errors) > 0 {
+                errs = make([]error, len(resp.Errors))
+                for i, err := range resp.Errors {
+                        errs[i] = err
+                }
+        }
+
+        return resp.Warnings, errs
+}
+
+func (p *ResourceProvider) Configure(c *terraform.ResourceConfig) error {
+        var resp ResourceProviderConfigureResponse
+        err := p.Client.Call("Plugin.Configure", c, &resp)
+        if err != nil {
+                return err
+        }
+        if resp.Error != nil {
+                err = resp.Error
+        }
+
+        return err
+}
+
+func (p *ResourceProvider) Apply(
+        info *terraform.InstanceInfo,
+        s *terraform.InstanceState,
+        d *terraform.InstanceDiff) (*terraform.InstanceState, error) {
+        var resp ResourceProviderApplyResponse
+        args := &ResourceProviderApplyArgs{
+                Info:  info,
+                State: s,
+                Diff:  d,
+        }
+
+        err := p.Client.Call("Plugin.Apply", args, &resp)
+        if err != nil {
+                return nil, err
+        }
+        if resp.Error != nil {
+                err = resp.Error
+        }
+
+        return resp.State, err
+}
+
+func (p *ResourceProvider) Diff(
+        info *terraform.InstanceInfo,
+        s *terraform.InstanceState,
+        c *terraform.ResourceConfig) (*terraform.InstanceDiff, error) {
+        var resp ResourceProviderDiffResponse
+        args := &ResourceProviderDiffArgs{
+                Info:   info,
+                State:  s,
+                Config: c,
+        }
+        err := p.Client.Call("Plugin.Diff", args, &resp)
+        if err != nil {
+                return nil, err
+        }
+        if resp.Error != nil {
+                err = resp.Error
+        }
+
+        return resp.Diff, err
+}
+
+func (p *ResourceProvider) ValidateDataSource(
+        t string, c *terraform.ResourceConfig) ([]string, []error) {
+        var resp ResourceProviderValidateResourceResponse
+        args := ResourceProviderValidateResourceArgs{
+                Config: c,
+                Type:   t,
+        }
+
+        err := p.Client.Call("Plugin.ValidateDataSource", &args, &resp)
+        if err != nil {
+                return nil, []error{err}
+        }
+
+        var errs []error
+        if len(resp.Errors) > 0 {
+                errs = make([]error, len(resp.Errors))
+                for i, err := range resp.Errors {
+                        errs[i] = err
+                }
+        }
+
+        return resp.Warnings, errs
+}
+
+func (p *ResourceProvider) Refresh(
+        info *terraform.InstanceInfo,
+        s *terraform.InstanceState) (*terraform.InstanceState, error) {
+        var resp ResourceProviderRefreshResponse
+        args := &ResourceProviderRefreshArgs{
+                Info:  info,
+                State: s,
+        }
+
+        err := p.Client.Call("Plugin.Refresh", args, &resp)
+        if err != nil {
+                return nil, err
+        }
+        if resp.Error != nil {
+                err = resp.Error
+        }
+
+        return resp.State, err
+}
+
+func (p *ResourceProvider) ImportState(
+        info *terraform.InstanceInfo,
+        id string) ([]*terraform.InstanceState, error) {
+        var resp ResourceProviderImportStateResponse
+        args := &ResourceProviderImportStateArgs{
+                Info: info,
+                Id:   id,
+        }
+
+        err := p.Client.Call("Plugin.ImportState", args, &resp)
+        if err != nil {
+                return nil, err
+        }
+        if resp.Error != nil {
+                err = resp.Error
+        }
+
+        return resp.State, err
+}
+
+func (p *ResourceProvider) Resources() []terraform.ResourceType {
+        var result []terraform.ResourceType
+
+        err := p.Client.Call("Plugin.Resources", new(interface{}), &result)
+        if err != nil {
+                // TODO: panic, log, what?
+                return nil
+        }
+
+        return result
+}
+
+func (p *ResourceProvider) ReadDataDiff(
+        info *terraform.InstanceInfo,
+        c *terraform.ResourceConfig) (*terraform.InstanceDiff, error) {
+        var resp ResourceProviderReadDataDiffResponse
+        args := &ResourceProviderReadDataDiffArgs{
+                Info:   info,
+                Config: c,
+        }
+
+        err := p.Client.Call("Plugin.ReadDataDiff", args, &resp)
+        if err != nil {
+                return nil, err
+        }
+        if resp.Error != nil {
+                err = resp.Error
+        }
+
+        return resp.Diff, err
+}
+
+func (p *ResourceProvider) ReadDataApply(
+        info *terraform.InstanceInfo,
+        d *terraform.InstanceDiff) (*terraform.InstanceState, error) {
+        var resp ResourceProviderReadDataApplyResponse
+        args := &ResourceProviderReadDataApplyArgs{
+                Info: info,
+                Diff: d,
+        }
+
+        err := p.Client.Call("Plugin.ReadDataApply", args, &resp)
+        if err != nil {
+                return nil, err
+        }
+        if resp.Error != nil {
+                err = resp.Error
+        }
+
+        return resp.State, err
+}
+
+func (p *ResourceProvider) DataSources() []terraform.DataSource {
+        var result []terraform.DataSource
+
+        err := p.Client.Call("Plugin.DataSources", new(interface{}), &result)
+        if err != nil {
+                // TODO: panic, log, what?
+                return nil
+        }
+
+        return result
+}
+
+func (p *ResourceProvider) Close() error {
+        return p.Client.Close()
+}
+
+// ResourceProviderServer is a net/rpc compatible structure for serving
+// a ResourceProvider. This should not be used directly.
+type ResourceProviderServer struct {
+        Broker   *plugin.MuxBroker
+        Provider terraform.ResourceProvider
+}
+
+type ResourceProviderStopResponse struct {
+        Error *plugin.BasicError
+}
+
+type ResourceProviderConfigureResponse struct {
+        Error *plugin.BasicError
+}
+
+type ResourceProviderInputArgs struct {
+        InputId uint32
+        Config  *terraform.ResourceConfig
+}
+
+type ResourceProviderInputResponse struct {
+        Config *terraform.ResourceConfig
+        Error  *plugin.BasicError
+}
+
+type ResourceProviderApplyArgs struct {
+        Info  *terraform.InstanceInfo
+        State *terraform.InstanceState
+        Diff  *terraform.InstanceDiff
+}
+
+type ResourceProviderApplyResponse struct {
+        State *terraform.InstanceState
+        Error *plugin.BasicError
+}
+
+type ResourceProviderDiffArgs struct {
+        Info   *terraform.InstanceInfo
+        State  *terraform.InstanceState
+        Config *terraform.ResourceConfig
+}
+
+type ResourceProviderDiffResponse struct {
+        Diff  *terraform.InstanceDiff
+        Error *plugin.BasicError
+}
+
+type ResourceProviderRefreshArgs struct {
+        Info  *terraform.InstanceInfo
+        State *terraform.InstanceState
+}
+
+type ResourceProviderRefreshResponse struct {
+        State *terraform.InstanceState
+        Error *plugin.BasicError
+}
+
+type ResourceProviderImportStateArgs struct {
+        Info *terraform.InstanceInfo
+        Id   string
+}
+
+type ResourceProviderImportStateResponse struct {
+        State []*terraform.InstanceState
+        Error *plugin.BasicError
+}
+
+type ResourceProviderReadDataApplyArgs struct {
+        Info *terraform.InstanceInfo
+        Diff *terraform.InstanceDiff
+}
+
+type ResourceProviderReadDataApplyResponse struct {
+        State *terraform.InstanceState
+        Error *plugin.BasicError
+}
+
+type ResourceProviderReadDataDiffArgs struct {
+        Info   *terraform.InstanceInfo
+        Config *terraform.ResourceConfig
+}
+
+type ResourceProviderReadDataDiffResponse struct {
+        Diff  *terraform.InstanceDiff
+        Error *plugin.BasicError
+}
+
+type ResourceProviderValidateArgs struct {
+        Config *terraform.ResourceConfig
+}
+
+type ResourceProviderValidateResponse struct {
+        Warnings []string
+        Errors   []*plugin.BasicError
+}
+
+type ResourceProviderValidateResourceArgs struct {
+        Config *terraform.ResourceConfig
+        Type   string
+}
+
+type ResourceProviderValidateResourceResponse struct {
+        Warnings []string
+        Errors   []*plugin.BasicError
+}
+
+func (s *ResourceProviderServer) Stop(
+        _ interface{},
+        reply *ResourceProviderStopResponse) error {
+        err := s.Provider.Stop()
+        *reply = ResourceProviderStopResponse{
+                Error: plugin.NewBasicError(err),
+        }
+
+        return nil
+}
+
+func (s *ResourceProviderServer) Input(
+        args *ResourceProviderInputArgs,
+        reply *ResourceProviderInputResponse) error {
+        conn, err := s.Broker.Dial(args.InputId)
+        if err != nil {
+                *reply = ResourceProviderInputResponse{
+                        Error: plugin.NewBasicError(err),
+                }
+                return nil
+        }
+        client := rpc.NewClient(conn)
+        defer client.Close()
+
+        input := &UIInput{Client: client}
+
+        config, err := s.Provider.Input(input, args.Config)
+        *reply = ResourceProviderInputResponse{
+                Config: config,
+                Error:  plugin.NewBasicError(err),
+        }
+
+        return nil
+}
+
+func (s *ResourceProviderServer) Validate(
+        args *ResourceProviderValidateArgs,
+        reply *ResourceProviderValidateResponse) error {
+        warns, errs := s.Provider.Validate(args.Config)
+        berrs := make([]*plugin.BasicError, len(errs))
+        for i, err := range errs {
+                berrs[i] = plugin.NewBasicError(err)
+        }
+        *reply = ResourceProviderValidateResponse{
+                Warnings: warns,
+                Errors:   berrs,
+        }
+        return nil
+}
+
+func (s *ResourceProviderServer) ValidateResource(
+        args *ResourceProviderValidateResourceArgs,
+        reply *ResourceProviderValidateResourceResponse) error {
+        warns, errs := s.Provider.ValidateResource(args.Type, args.Config)
+        berrs := make([]*plugin.BasicError, len(errs))
+        for i, err := range errs {
+                berrs[i] = plugin.NewBasicError(err)
+        }
+        *reply = ResourceProviderValidateResourceResponse{
+                Warnings: warns,
+                Errors:   berrs,
+        }
+        return nil
+}
+
+func (s *ResourceProviderServer) Configure(
+        config *terraform.ResourceConfig,
+        reply *ResourceProviderConfigureResponse) error {
+        err := s.Provider.Configure(config)
+        *reply = ResourceProviderConfigureResponse{
+                Error: plugin.NewBasicError(err),
+        }
+        return nil
+}
+
+func (s *ResourceProviderServer) Apply(
+        args *ResourceProviderApplyArgs,
+        result *ResourceProviderApplyResponse) error {
+        state, err := s.Provider.Apply(args.Info, args.State, args.Diff)
+        *result = ResourceProviderApplyResponse{
+                State: state,
+                Error: plugin.NewBasicError(err),
+        }
+        return nil
+}
+
+func (s *ResourceProviderServer) Diff(
+        args *ResourceProviderDiffArgs,
+        result *ResourceProviderDiffResponse) error {
+        diff, err := s.Provider.Diff(args.Info, args.State, args.Config)
+        *result = ResourceProviderDiffResponse{
+                Diff:  diff,
+                Error: plugin.NewBasicError(err),
+        }
+        return nil
+}
+
+func (s *ResourceProviderServer) Refresh(
+        args *ResourceProviderRefreshArgs,
+        result *ResourceProviderRefreshResponse) error {
+        newState, err := s.Provider.Refresh(args.Info, args.State)
+        *result = ResourceProviderRefreshResponse{
+                State: newState,
+                Error: plugin.NewBasicError(err),
+        }
+        return nil
+}
+
+func (s *ResourceProviderServer) ImportState(
+        args *ResourceProviderImportStateArgs,
+        result *ResourceProviderImportStateResponse) error {
+        states, err := s.Provider.ImportState(args.Info, args.Id)
+        *result = ResourceProviderImportStateResponse{
+                State: states,
+                Error: plugin.NewBasicError(err),
+        }
+        return nil
+}
+
+func (s *ResourceProviderServer) Resources(
+        nothing interface{},
+        result *[]terraform.ResourceType) error {
+        *result = s.Provider.Resources()
+        return nil
+}
+
+func (s *ResourceProviderServer) ValidateDataSource(
+        args *ResourceProviderValidateResourceArgs,
+        reply *ResourceProviderValidateResourceResponse) error {
+        warns, errs := s.Provider.ValidateDataSource(args.Type, args.Config)
+        berrs := make([]*plugin.BasicError, len(errs))
+        for i, err := range errs {
+                berrs[i] = plugin.NewBasicError(err)
+        }
+        *reply = ResourceProviderValidateResourceResponse{
+                Warnings: warns,
+                Errors:   berrs,
+        }
+        return nil
+}
+
+func (s *ResourceProviderServer) ReadDataDiff(
+        args *ResourceProviderReadDataDiffArgs,
+        result *ResourceProviderReadDataDiffResponse) error {
+        diff, err := s.Provider.ReadDataDiff(args.Info, args.Config)
+        *result = ResourceProviderReadDataDiffResponse{
+                Diff:  diff,
+                Error: plugin.NewBasicError(err),
+        }
+        return nil
+}
+
+func (s *ResourceProviderServer) ReadDataApply(
+        args *ResourceProviderReadDataApplyArgs,
+        result *ResourceProviderReadDataApplyResponse) error {
+        newState, err := s.Provider.ReadDataApply(args.Info, args.Diff)
+        *result = ResourceProviderReadDataApplyResponse{
+                State: newState,
+                Error: plugin.NewBasicError(err),
+        }
+        return nil
+}
+
+func (s *ResourceProviderServer) DataSources(
+        nothing interface{},
+        result *[]terraform.DataSource) error {
+        *result = s.Provider.DataSources()
+        return nil
+}
diff --git a/vendor/github.com/hashicorp/terraform/plugin/resource_provisioner.go b/vendor/github.com/hashicorp/terraform/plugin/resource_provisioner.go
new file mode 100644
index 0000000..8fce9d8
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/plugin/resource_provisioner.go
@@ -0,0 +1,173 @@
+package plugin
+
+import (
+        "net/rpc"
+
+        "github.com/hashicorp/go-plugin"
+        "github.com/hashicorp/terraform/terraform"
+)
+
+// ResourceProvisionerPlugin is the plugin.Plugin implementation.
+type ResourceProvisionerPlugin struct {
+        F func() terraform.ResourceProvisioner
+}
+
+func (p *ResourceProvisionerPlugin) Server(b *plugin.MuxBroker) (interface{}, error) {
+        return &ResourceProvisionerServer{Broker: b, Provisioner: p.F()}, nil
+}
+
+func (p *ResourceProvisionerPlugin) Client(
+        b *plugin.MuxBroker, c *rpc.Client) (interface{}, error) {
+        return &ResourceProvisioner{Broker: b, Client: c}, nil
+}
+
+// ResourceProvisioner is an implementation of terraform.ResourceProvisioner
+// that communicates over RPC.
+type ResourceProvisioner struct {
+        Broker *plugin.MuxBroker
+        Client *rpc.Client
+}
+
+func (p *ResourceProvisioner) Validate(c *terraform.ResourceConfig) ([]string, []error) {
+        var resp ResourceProvisionerValidateResponse
+        args := ResourceProvisionerValidateArgs{
+                Config: c,
+        }
+
+        err := p.Client.Call("Plugin.Validate", &args, &resp)
+        if err != nil {
+                return nil, []error{err}
+        }
+
+        var errs []error
+        if len(resp.Errors) > 0 {
+                errs = make([]error, len(resp.Errors))
+                for i, err := range resp.Errors {
+                        errs[i] = err
+                }
+        }
+
+        return resp.Warnings, errs
+}
+
+func (p *ResourceProvisioner) Apply(
+        output terraform.UIOutput,
+        s *terraform.InstanceState,
+        c *terraform.ResourceConfig) error {
+        id := p.Broker.NextId()
+        go p.Broker.AcceptAndServe(id, &UIOutputServer{
+                UIOutput: output,
+        })
+
+        var resp ResourceProvisionerApplyResponse
+        args := &ResourceProvisionerApplyArgs{
+                OutputId: id,
+                State:    s,
+                Config:   c,
+        }
+
+        err := p.Client.Call("Plugin.Apply", args, &resp)
+        if err != nil {
+                return err
+        }
+        if resp.Error != nil {
+                err = resp.Error
+        }
+
+        return err
+}
+
+func (p *ResourceProvisioner) Stop() error {
+        var resp ResourceProvisionerStopResponse
+        err := p.Client.Call("Plugin.Stop", new(interface{}), &resp)
+        if err != nil {
+                return err
+        }
+        if resp.Error != nil {
+                err = resp.Error
+        }
+
+        return err
+}
+
+func (p *ResourceProvisioner) Close() error {
+        return p.Client.Close()
+}
+
+type ResourceProvisionerValidateArgs struct {
+        Config *terraform.ResourceConfig
+}
+
+type ResourceProvisionerValidateResponse struct {
+        Warnings []string
+        Errors   []*plugin.BasicError
+}
+
+type ResourceProvisionerApplyArgs struct {
+        OutputId uint32
+        State    *terraform.InstanceState
+        Config   *terraform.ResourceConfig
+}
+
+type ResourceProvisionerApplyResponse struct {
+        Error *plugin.BasicError
+}
+
+type ResourceProvisionerStopResponse struct {
+        Error *plugin.BasicError
+}
+
+// ResourceProvisionerServer is a net/rpc compatible structure for serving
+// a ResourceProvisioner. This should not be used directly.
+type ResourceProvisionerServer struct {
+        Broker      *plugin.MuxBroker
+        Provisioner terraform.ResourceProvisioner
+}
+
+func (s *ResourceProvisionerServer) Apply(
+        args *ResourceProvisionerApplyArgs,
+        result *ResourceProvisionerApplyResponse) error {
+        conn, err := s.Broker.Dial(args.OutputId)
+        if err != nil {
+                *result = ResourceProvisionerApplyResponse{
+                        Error: plugin.NewBasicError(err),
+                }
+                return nil
+        }
+        client := rpc.NewClient(conn)
+        defer client.Close()
+
+        output := &UIOutput{Client: client}
+
+        err = s.Provisioner.Apply(output, args.State, args.Config)
+        *result = ResourceProvisionerApplyResponse{
+                Error: plugin.NewBasicError(err),
+        }
+        return nil
+}
+
+func (s *ResourceProvisionerServer) Validate(
+        args *ResourceProvisionerValidateArgs,
+        reply *ResourceProvisionerValidateResponse) error {
+        warns, errs := s.Provisioner.Validate(args.Config)
+        berrs := make([]*plugin.BasicError, len(errs))
+        for i, err := range errs {
+                berrs[i] = plugin.NewBasicError(err)
+        }
+        *reply = ResourceProvisionerValidateResponse{
+                Warnings: warns,
+                Errors:   berrs,
+        }
+        return nil
+}
+
+func (s *ResourceProvisionerServer) Stop(
+        _ interface{},
+        reply *ResourceProvisionerStopResponse) error {
+        err := s.Provisioner.Stop()
+        *reply = ResourceProvisionerStopResponse{
+                Error: plugin.NewBasicError(err),
+        }
+
+        return nil
+}
diff --git a/vendor/github.com/hashicorp/terraform/plugin/serve.go b/vendor/github.com/hashicorp/terraform/plugin/serve.go
new file mode 100644
index 0000000..2028a61
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/plugin/serve.go
@@ -0,0 +1,54 @@
+package plugin
+
+import (
+        "github.com/hashicorp/go-plugin"
+        "github.com/hashicorp/terraform/terraform"
+)
+
+// The constants below are the names of the plugins that can be dispensed
+// from the plugin server.
+const (
+        ProviderPluginName    = "provider"
+        ProvisionerPluginName = "provisioner"
+)
+
+// Handshake is the HandshakeConfig used to configure clients and servers.
+var Handshake = plugin.HandshakeConfig{
+        // The ProtocolVersion is the version that must match between TF core
+        // and TF plugins. This should be bumped whenever a change happens in
+        // one or the other that makes it so that they can't safely communicate.
+        // This could be adding a new interface value, it could be how
+        // helper/schema computes diffs, etc.
+        ProtocolVersion: 4,
+
+        // The magic cookie values should NEVER be changed.
+        MagicCookieKey:   "TF_PLUGIN_MAGIC_COOKIE",
+        MagicCookieValue: "d602bf8f470bc67ca7faa0386276bbdd4330efaf76d1a219cb4d6991ca9872b2",
+}
+
+type ProviderFunc func() terraform.ResourceProvider
+type ProvisionerFunc func() terraform.ResourceProvisioner
+
+// ServeOpts are the configurations to serve a plugin.
+type ServeOpts struct {
+        ProviderFunc    ProviderFunc
+        ProvisionerFunc ProvisionerFunc
+}
+
+// Serve serves a plugin. This function never returns and should be the final
+// function called in the main function of the plugin.
+func Serve(opts *ServeOpts) {
+        plugin.Serve(&plugin.ServeConfig{
+                HandshakeConfig: Handshake,
+                Plugins:         pluginMap(opts),
+        })
+}
+
+// pluginMap returns the map[string]plugin.Plugin to use for configuring a plugin
+// server or client.
+func pluginMap(opts *ServeOpts) map[string]plugin.Plugin {
+        return map[string]plugin.Plugin{
+                "provider":    &ResourceProviderPlugin{F: opts.ProviderFunc},
+                "provisioner": &ResourceProvisionerPlugin{F: opts.ProvisionerFunc},
+        }
+}
diff --git a/vendor/github.com/hashicorp/terraform/plugin/ui_input.go b/vendor/github.com/hashicorp/terraform/plugin/ui_input.go
new file mode 100644
index 0000000..493efc0
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/plugin/ui_input.go
@@ -0,0 +1,51 @@
+package plugin
+
+import (
+        "net/rpc"
+
+        "github.com/hashicorp/go-plugin"
+        "github.com/hashicorp/terraform/terraform"
+)
+
+// UIInput is an implementatin of terraform.UIInput that communicates
+// over RPC.
+type UIInput struct {
+        Client *rpc.Client
+}
+
+func (i *UIInput) Input(opts *terraform.InputOpts) (string, error) {
+        var resp UIInputInputResponse
+        err := i.Client.Call("Plugin.Input", opts, &resp)
+        if err != nil {
+                return "", err
+        }
+        if resp.Error != nil {
+                err = resp.Error
+                return "", err
+        }
+
+        return resp.Value, nil
+}
+
+type UIInputInputResponse struct {
+        Value string
+        Error *plugin.BasicError
+}
+
+// UIInputServer is a net/rpc compatible structure for serving
+// a UIInputServer. This should not be used directly.
+type UIInputServer struct {
+        UIInput terraform.UIInput
+}
+
+func (s *UIInputServer) Input(
+        opts *terraform.InputOpts,
+        reply *UIInputInputResponse) error {
+        value, err := s.UIInput.Input(opts)
+        *reply = UIInputInputResponse{
+                Value: value,
+                Error: plugin.NewBasicError(err),
+        }
+
+        return nil
+}
diff --git a/vendor/github.com/hashicorp/terraform/plugin/ui_output.go b/vendor/github.com/hashicorp/terraform/plugin/ui_output.go
new file mode 100644
index 0000000..c222b00
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/plugin/ui_output.go
@@ -0,0 +1,29 @@
+package plugin
+
+import (
+        "net/rpc"
+
+        "github.com/hashicorp/terraform/terraform"
+)
+
+// UIOutput is an implementatin of terraform.UIOutput that communicates
+// over RPC.
+type UIOutput struct {
+        Client *rpc.Client
+}
+
+func (o *UIOutput) Output(v string) {
+        o.Client.Call("Plugin.Output", v, new(interface{}))
+}
+
+// UIOutputServer is the RPC server for serving UIOutput.
+type UIOutputServer struct {
+        UIOutput terraform.UIOutput
+}
+
+func (s *UIOutputServer) Output(
+        v string,
+        reply *interface{}) error {
+        s.UIOutput.Output(v)
+        return nil
+}