diff --git a/.gitignore b/.gitignore index 7df3f0de4..6bab8a652 100644 --- a/.gitignore +++ b/.gitignore @@ -48,5 +48,8 @@ doc/ .ruby-version .rvmrc +*.so +*.bundle + # Box storage for spec test/vagrant-spec/boxes/*.box diff --git a/Rakefile b/Rakefile index 2af398a1e..9dbb59508 100644 --- a/Rakefile +++ b/Rakefile @@ -1,5 +1,10 @@ require 'rubygems' require 'bundler/setup' +require 'rake/extensiontask' + +Rake::ExtensionTask.new "go-plugin" do |ext| + ext.lib_dir = "lib/vagrant/go_plugin" +end # Immediately sync all stdout so that tools like buildbot can # immediately load in the output. diff --git a/Vagrantfile b/Vagrantfile index 909bebf66..db1b60eb6 100644 --- a/Vagrantfile +++ b/Vagrantfile @@ -14,6 +14,10 @@ Vagrant.configure("2") do |config| end end + config.vm.provider :vmware_desktop do |v, override| + v.foobar = 'hi' + end + config.vm.provision "shell", inline: $shell config.push.define "www", strategy: "local-exec" do |push| diff --git a/ext/go-plugin/capabilities.go b/ext/go-plugin/capabilities.go new file mode 100644 index 000000000..cf220c060 --- /dev/null +++ b/ext/go-plugin/capabilities.go @@ -0,0 +1,178 @@ +package main + +import ( + "C" + "encoding/json" + "errors" + + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant" + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin" +) + +//export GuestCapabilities +func GuestCapabilities(pluginName, pluginType *C.char) *C.char { + r := vagrant.Response{} + p, err := getGuestCapsPlugin(pluginName, pluginType) + if err != nil { + r.Error = err + return C.CString(r.Dump()) + } + r.Result, r.Error = p.GuestCapabilities.GuestCapabilities() + return C.CString(r.Dump()) +} + +//export GuestCapability +func GuestCapability(pluginName, pluginType, cname, cplatform, cargs, cmachine *C.char) *C.char { + r := vagrant.Response{} + p, err := getGuestCapsPlugin(pluginName, pluginType) + if err != nil { + r.Error = err + return C.CString(r.Dump()) + } + machine, err := vagrant.LoadMachine(C.GoString(cmachine), nil) + if err != nil { + r.Error = err + return C.CString(r.Dump()) + } + var args interface{} + err = json.Unmarshal([]byte(C.GoString(cargs)), &args) + if err != nil { + r.Error = err + return C.CString(r.Dump()) + } + cap := &vagrant.SystemCapability{ + Name: C.GoString(cname), + Platform: C.GoString(cplatform)} + r.Result, r.Error = p.GuestCapabilities.GuestCapability(cap, args, machine) + return C.CString(r.Dump()) +} + +//export HostCapabilities +func HostCapabilities(pluginName, pluginType *C.char) *C.char { + r := vagrant.Response{} + p, err := getHostCapsPlugin(pluginName, pluginType) + if err != nil { + r.Error = err + return C.CString(r.Dump()) + } + r.Result, r.Error = p.HostCapabilities.HostCapabilities() + return C.CString(r.Dump()) +} + +//export HostCapability +func HostCapability(pluginName, pluginType, cname, cplatform, cargs, cenv *C.char) *C.char { + r := vagrant.Response{} + p, err := getHostCapsPlugin(pluginName, pluginType) + if err != nil { + r.Error = err + return C.CString(r.Dump()) + } + env, err := vagrant.LoadEnvironment(C.GoString(cenv), nil) + if err != nil { + r.Error = err + return C.CString(r.Dump()) + } + var args interface{} + err = json.Unmarshal([]byte(C.GoString(cargs)), &args) + if err != nil { + r.Error = err + return C.CString(r.Dump()) + } + cap := &vagrant.SystemCapability{ + Name: C.GoString(cname), + Platform: C.GoString(cplatform)} + r.Result, r.Error = p.HostCapabilities.HostCapability(cap, args, env) + return C.CString(r.Dump()) +} + +//export ProviderCapabilities +func ProviderCapabilities(pluginName, pluginType *C.char) *C.char { + r := vagrant.Response{} + p, err := getProviderCapsPlugin(pluginName, pluginType) + if err != nil { + r.Error = err + return C.CString(r.Dump()) + } + r.Result, r.Error = p.ProviderCapabilities.ProviderCapabilities() + return C.CString(r.Dump()) +} + +//export ProviderCapability +func ProviderCapability(pluginName, pluginType, cname, cprovider, cargs, cmach *C.char) *C.char { + r := vagrant.Response{} + p, err := getProviderCapsPlugin(pluginName, pluginType) + if err != nil { + r.Error = err + return C.CString(r.Dump()) + } + m, err := vagrant.LoadMachine(C.GoString(cmach), nil) + if err != nil { + r.Error = err + return C.CString(r.Dump()) + } + var args interface{} + err = json.Unmarshal([]byte(C.GoString(cargs)), &args) + if err != nil { + r.Error = err + return C.CString(r.Dump()) + } + cap := &vagrant.ProviderCapability{ + Name: C.GoString(cname), + Provider: C.GoString(cprovider)} + r.Result, r.Error = p.ProviderCapabilities.ProviderCapability(cap, args, m) + return C.CString(r.Dump()) +} + +func getProviderCapsPlugin(pluginName, pluginType *C.char) (c *plugin.RemoteProviderCapabilities, err error) { + pname := C.GoString(pluginName) + ptype := C.GoString(pluginType) + + if ptype == "provider" { + p, ok := Plugins.Providers[pname] + if ok { + c = &plugin.RemoteProviderCapabilities{ + Client: p.Client, + ProviderCapabilities: p.Provider} + } + } + if c == nil { + err = errors.New("Failed to locate requested plugin") + } + return +} + +func getGuestCapsPlugin(pluginName, pluginType *C.char) (c *plugin.RemoteGuestCapabilities, err error) { + pname := C.GoString(pluginName) + ptype := C.GoString(pluginType) + + if ptype == "provider" { + p, ok := Plugins.Providers[pname] + if ok { + c = &plugin.RemoteGuestCapabilities{ + Client: p.Client, + GuestCapabilities: p.Provider} + } + } + if c == nil { + err = errors.New("Failed to locate requested plugin") + } + return +} + +func getHostCapsPlugin(pluginName, pluginType *C.char) (c *plugin.RemoteHostCapabilities, err error) { + pname := C.GoString(pluginName) + ptype := C.GoString(pluginType) + + if ptype == "provider" { + p, ok := Plugins.Providers[pname] + if ok { + c = &plugin.RemoteHostCapabilities{ + Client: p.Client, + HostCapabilities: p.Provider} + } + } + if c == nil { + err = errors.New("Failed to locate requested plugin") + } + return +} diff --git a/ext/go-plugin/config.go b/ext/go-plugin/config.go new file mode 100644 index 000000000..d48de4fc3 --- /dev/null +++ b/ext/go-plugin/config.go @@ -0,0 +1,98 @@ +package main + +import ( + "C" + "encoding/json" + "errors" + "fmt" + + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant" + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin" +) + +//export ConfigLoad +func ConfigLoad(pluginName, pluginType, data *C.char) *C.char { + r := vagrant.Response{} + p, err := getConfigPlugin(pluginName, pluginType) + if err != nil { + r.Error = err + return C.CString(r.Dump()) + } + var cdata map[string]interface{} + r.Error = json.Unmarshal([]byte(C.GoString(data)), &cdata) + if r.Error != nil { + return C.CString(r.Dump()) + } + r.Result, r.Error = p.Config.ConfigLoad(cdata) + return C.CString(r.Dump()) +} + +//export ConfigAttributes +func ConfigAttributes(pluginName, pluginType *C.char) *C.char { + r := vagrant.Response{} + p, err := getConfigPlugin(pluginName, pluginType) + if err != nil { + r.Error = err + return C.CString(r.Dump()) + } + r.Result, r.Error = p.Config.ConfigAttributes() + return C.CString(r.Dump()) +} + +//export ConfigValidate +func ConfigValidate(pluginName, pluginType, data, machData *C.char) *C.char { + var m *vagrant.Machine + r := vagrant.Response{} + p, err := getConfigPlugin(pluginName, pluginType) + if err != nil { + r.Error = err + return C.CString(r.Dump()) + } + var cdata map[string]interface{} + r.Error = json.Unmarshal([]byte(C.GoString(data)), &cdata) + if r.Error != nil { + return C.CString(r.Dump()) + } + m, r.Error = vagrant.LoadMachine(C.GoString(machData), nil) + if r.Error != nil { + return C.CString(r.Dump()) + } + r.Result, r.Error = p.Config.ConfigValidate(cdata, m) + return C.CString(r.Dump()) +} + +//export ConfigFinalize +func ConfigFinalize(pluginName, pluginType, data *C.char) *C.char { + r := vagrant.Response{} + p, err := getConfigPlugin(pluginName, pluginType) + if err != nil { + r.Error = err + return C.CString(r.Dump()) + } + var cdata map[string]interface{} + r.Error = json.Unmarshal([]byte(C.GoString(data)), &cdata) + if r.Error == nil { + println("FINALIZE HAS VALID CONFIG") + r.Result, r.Error = p.Config.ConfigFinalize(cdata) + } + fmt.Printf("Full result: %s\n", r.Dump()) + return C.CString(r.Dump()) +} + +func getConfigPlugin(pluginName, pluginType *C.char) (c *plugin.RemoteConfig, err error) { + pname := C.GoString(pluginName) + ptype := C.GoString(pluginType) + + if ptype == "provider" { + p, ok := Plugins.Providers[pname] + if ok { + c = &plugin.RemoteConfig{ + Client: p.Client, + Config: p.Provider} + } + } + if c == nil { + err = errors.New("Failed to locate requested plugin") + } + return +} diff --git a/ext/go-plugin/extconf.rb b/ext/go-plugin/extconf.rb new file mode 100644 index 000000000..e3044dabd --- /dev/null +++ b/ext/go-plugin/extconf.rb @@ -0,0 +1,68 @@ +lib = File.expand_path('./../../../lib', File.expand_path(__FILE__)) +$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib) + +require 'mkmf' +require 'time' + +find_executable('go') + +go_version = /go version go(\d+\.\d+)/.match(`go version`).captures.first +raise "'go' version >=1.5.0 is required, found go #{go_version}" unless Gem::Dependency.new('', '>=1.5.0').match?('', go_version) + +makefile = "Makefile" +makefile_content = < -1 { + line = line[idx+1:] + } + + return line +} + +// ExitError is returned by Wait to indicate and error executing the remote +// command, or a non-zero exit status. +type ExitError struct { + Command string + ExitStatus int + Err error +} + +func (e *ExitError) Error() string { + if e.Err != nil { + return fmt.Sprintf("error executing %q: %v", e.Command, e.Err) + } + return fmt.Sprintf("%q exit status: %d", e.Command, e.ExitStatus) +} diff --git a/ext/go-plugin/vagrant/communicator/command_test.go b/ext/go-plugin/vagrant/communicator/command_test.go new file mode 100644 index 000000000..211f4759e --- /dev/null +++ b/ext/go-plugin/vagrant/communicator/command_test.go @@ -0,0 +1 @@ +package communicator diff --git a/ext/go-plugin/vagrant/communicator/communicator.go b/ext/go-plugin/vagrant/communicator/communicator.go new file mode 100644 index 000000000..1911e6550 --- /dev/null +++ b/ext/go-plugin/vagrant/communicator/communicator.go @@ -0,0 +1,117 @@ +package communicator + +import ( + "context" + "fmt" + "io" + "os" + "sync/atomic" + "time" + + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant" +) + +type Communicator interface { + Connect() error + Disconnect() error + Timeout() time.Duration + Start(*Cmd) error + Download(path string, output io.Writer) error + DownloadDir(dst, src string, excludes []string) error + Upload(dst string, src io.Reader, srcinfo *os.FileInfo) error + UploadDir(dst, src string, excludes []string) error +} + +// maxBackoffDelay is the maximum delay between retry attempts +var maxBackoffDelay = 20 * time.Second +var initialBackoffDelay = time.Second +var logger = vagrant.DefaultLogger().Named("communicator") + +// Fatal is an interface that error values can return to halt Retry +type Fatal interface { + FatalError() error +} + +// Retry retries the function f until it returns a nil error, a Fatal error, or +// the context expires. +func Retry(ctx context.Context, f func() error) error { + // container for atomic error value + type errWrap struct { + E error + } + + // Try the function in a goroutine + var errVal atomic.Value + doneCh := make(chan struct{}) + go func() { + defer close(doneCh) + + delay := time.Duration(0) + for { + // If our context ended, we want to exit right away. + select { + case <-ctx.Done(): + return + case <-time.After(delay): + } + + // Try the function call + err := f() + + // return if we have no error, or a FatalError + done := false + switch e := err.(type) { + case nil: + done = true + case Fatal: + err = e.FatalError() + done = true + } + + errVal.Store(errWrap{err}) + + if done { + return + } + + logger.Warn("retryable error", "error", err) + + delay *= 2 + + if delay == 0 { + delay = initialBackoffDelay + } + + if delay > maxBackoffDelay { + delay = maxBackoffDelay + } + + logger.Info("sleeping for retry", "duration", delay) + } + }() + + // Wait for completion + select { + case <-ctx.Done(): + case <-doneCh: + } + + var lastErr error + // Check if we got an error executing + if ev, ok := errVal.Load().(errWrap); ok { + lastErr = ev.E + } + + // Check if we have a context error to check if we're interrupted or timeout + switch ctx.Err() { + case context.Canceled: + return fmt.Errorf("interrupted - last error: %v", lastErr) + case context.DeadlineExceeded: + return fmt.Errorf("timeout - last error: %v", lastErr) + } + + if lastErr != nil { + return lastErr + } + return nil +} diff --git a/ext/go-plugin/vagrant/communicator/none/communicator.go b/ext/go-plugin/vagrant/communicator/none/communicator.go new file mode 100644 index 000000000..169f01e1f --- /dev/null +++ b/ext/go-plugin/vagrant/communicator/none/communicator.go @@ -0,0 +1,59 @@ +package none + +import ( + "errors" + "io" + "os" + "time" + + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/communicator" +) + +type Communicator struct { + config string +} + +// Creates a null vagrant.Communicator implementation. This takes +// an already existing configuration. +func New(config string) (result *Communicator, err error) { + // Establish an initial connection and connect + result = &Communicator{ + config: config, + } + + return +} + +func (c *Communicator) Connect() (err error) { + return +} + +func (c *Communicator) Disconnect() (err error) { + return +} + +func (c *Communicator) Start(cmd *communicator.Cmd) (err error) { + cmd.Init() + cmd.SetExitStatus(0, nil) + return +} + +func (c *Communicator) Upload(path string, input io.Reader, fi *os.FileInfo) error { + return errors.New("Upload is not implemented when communicator = 'none'") +} + +func (c *Communicator) UploadDir(dst string, src string, excl []string) error { + return errors.New("UploadDir is not implemented when communicator = 'none'") +} + +func (c *Communicator) Download(path string, output io.Writer) error { + return errors.New("Download is not implemented when communicator = 'none'") +} + +func (c *Communicator) DownloadDir(dst string, src string, excl []string) error { + return errors.New("DownloadDir is not implemented when communicator = 'none'") +} + +func (c *Communicator) Timeout() time.Duration { + return 0 +} diff --git a/ext/go-plugin/vagrant/communicator/none/communicator_test.go b/ext/go-plugin/vagrant/communicator/none/communicator_test.go new file mode 100644 index 000000000..89032aad3 --- /dev/null +++ b/ext/go-plugin/vagrant/communicator/none/communicator_test.go @@ -0,0 +1,12 @@ +package none + +import ( + "testing" + + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/communicator" +) + +func TestCommIsCommunicator(t *testing.T) { + // Force failure with explanation of why it's not valid + var _ communicator.Communicator = new(Communicator) +} diff --git a/ext/go-plugin/vagrant/communicator/ssh/communicator.go b/ext/go-plugin/vagrant/communicator/ssh/communicator.go new file mode 100644 index 000000000..1e7edb063 --- /dev/null +++ b/ext/go-plugin/vagrant/communicator/ssh/communicator.go @@ -0,0 +1,949 @@ +package ssh + +import ( + "bufio" + "bytes" + "errors" + "fmt" + "io" + "io/ioutil" + "net" + "os" + "path/filepath" + "strconv" + "strings" + "time" + + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant" + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/communicator" + "github.com/pkg/sftp" + "golang.org/x/crypto/ssh" + "golang.org/x/crypto/ssh/agent" +) + +// ErrHandshakeTimeout is returned from New() whenever we're unable to establish +// an ssh connection within a certain timeframe. By default the handshake time- +// out period is 1 minute. You can change it with Config.HandshakeTimeout. +var ErrHandshakeTimeout = fmt.Errorf("Timeout during SSH handshake") + +var logger = vagrant.DefaultLogger().Named("communicator.ssh") + +type Communicator struct { + client *ssh.Client + config *Config + conn net.Conn + address string +} + +// Config is the structure used to configure the SSH communicator. +type Config struct { + // The configuration of the Go SSH connection + SSHConfig *ssh.ClientConfig + + // Connection returns a new connection. The current connection + // in use will be closed as part of the Close method, or in the + // case an error occurs. + Connection func() (net.Conn, error) + + // Pty, if true, will request a pty from the remote end. + Pty bool + + // DisableAgentForwarding, if true, will not forward the SSH agent. + DisableAgentForwarding bool + + // HandshakeTimeout limits the amount of time we'll wait to handshake before + // saying the connection failed. + HandshakeTimeout time.Duration + + // UseSftp, if true, sftp will be used instead of scp for file transfers + UseSftp bool + + // KeepAliveInterval sets how often we send a channel request to the + // server. A value < 0 disables. + KeepAliveInterval time.Duration + + // Timeout is how long to wait for a read or write to succeed. + Timeout time.Duration +} + +// Creates a new vagrant.Communicator implementation over SSH. This takes +// an already existing TCP connection and SSH configuration. +func New(address string, config *Config) (result *Communicator, err error) { + // Establish an initial connection and connect + result = &Communicator{ + config: config, + address: address, + } + + // reset the logger in case custom default has been set + logger = vagrant.DefaultLogger().Named("communicator.ssh") + + return +} + +func (c *Communicator) Connect() error { + return c.reconnect() +} + +func (c *Communicator) Disconnect() (err error) { + if c.conn != nil { + logger.Info("closing connection") + err = c.conn.Close() + } else { + err = errors.New("No connection currently established to close") + } + return +} + +func (c *Communicator) Timeout() time.Duration { + return c.config.Timeout +} + +func (c *Communicator) Start(cmd *communicator.Cmd) (err error) { + session, err := c.newSession() + if err != nil { + return + } + + // Setup our session + session.Stdin = cmd.Stdin + session.Stdout = cmd.Stdout + session.Stderr = cmd.Stderr + + if c.config.Pty { + // Request a PTY + termModes := ssh.TerminalModes{ + ssh.ECHO: 0, // do not echo + ssh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud + ssh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud + } + + if err = session.RequestPty("xterm", 40, 80, termModes); err != nil { + return + } + } + + logger.Debug("starting remote command", "command", cmd.Command) + err = session.Start(cmd.Command + "\n") + if err != nil { + return + } + + go func() { + if c.config.KeepAliveInterval <= 0 { + return + } + c := time.NewTicker(c.config.KeepAliveInterval) + defer c.Stop() + for range c.C { + _, err := session.SendRequest("keepalive@vagrantup.com", true, nil) + if err != nil { + return + } + } + }() + + // Start a goroutine to wait for the session to end and set the + // exit boolean and status. + go func() { + defer session.Close() + + err := session.Wait() + exitStatus := 0 + if err != nil { + switch err.(type) { + case *ssh.ExitError: + exitStatus = err.(*ssh.ExitError).ExitStatus() + logger.Error("remote command exited non-zero", + "exitcode", exitStatus, "command", cmd.Command) + case *ssh.ExitMissingError: + logger.Error("remote command exited without exit status or exit signal", + "command", cmd.Command) + exitStatus = communicator.CmdDisconnect + default: + logger.Error("error waiting for ssh session", "error", err) + } + } + cmd.SetExitStatus(exitStatus, err) + }() + return +} + +func (c *Communicator) Upload(path string, input io.Reader, fi *os.FileInfo) error { + if c.config.UseSftp { + return c.sftpUploadSession(path, input, fi) + } else { + return c.scpUploadSession(path, input, fi) + } +} + +func (c *Communicator) UploadDir(dst string, src string, excl []string) error { + logger.Debug("uploading directory", "source", src, "destination", dst) + if c.config.UseSftp { + return c.sftpUploadDirSession(dst, src, excl) + } else { + return c.scpUploadDirSession(dst, src, excl) + } +} + +func (c *Communicator) DownloadDir(src string, dst string, excl []string) error { + logger.Debug("downloading directory", "source", src, "destination", dst) + scpFunc := func(w io.Writer, stdoutR *bufio.Reader) error { + dirStack := []string{dst} + for { + fmt.Fprint(w, "\x00") + + // read file info + fi, err := stdoutR.ReadString('\n') + if err != nil { + return err + } + + if len(fi) < 0 { + return fmt.Errorf("empty response from server") + } + + switch fi[0] { + case '\x01', '\x02': + return fmt.Errorf("%s", fi[1:]) + case 'C', 'D': + break + case 'E': + dirStack = dirStack[:len(dirStack)-1] + if len(dirStack) == 0 { + fmt.Fprint(w, "\x00") + return nil + } + continue + default: + return fmt.Errorf("unexpected server response (%x)", fi[0]) + } + + var mode int64 + var size int64 + var name string + logger.Debug("download directory", "str", fi) + n, err := fmt.Sscanf(fi[1:], "%o %d %s", &mode, &size, &name) + if err != nil || n != 3 { + return fmt.Errorf("can't parse server response (%s)", fi) + } + if size < 0 { + return fmt.Errorf("negative file size") + } + + logger.Debug("download directory", "mode", mode, "size", size, "name", name) + + dst = filepath.Join(dirStack...) + switch fi[0] { + case 'D': + err = os.MkdirAll(filepath.Join(dst, name), os.FileMode(mode)) + if err != nil { + return err + } + dirStack = append(dirStack, name) + continue + case 'C': + fmt.Fprint(w, "\x00") + err = scpDownloadFile(filepath.Join(dst, name), stdoutR, size, os.FileMode(mode)) + if err != nil { + return err + } + } + + if err := checkSCPStatus(stdoutR); err != nil { + return err + } + } + } + return c.scpSession("scp -vrf "+src, scpFunc) +} + +func (c *Communicator) Download(path string, output io.Writer) error { + if c.config.UseSftp { + return c.sftpDownloadSession(path, output) + } + return c.scpDownloadSession(path, output) +} + +func (c *Communicator) newSession() (session *ssh.Session, err error) { + logger.Debug("opening new ssh session") + if c.client == nil { + err = errors.New("client not available") + } else { + session, err = c.client.NewSession() + } + + if err != nil { + logger.Error("ssh session open failure", "error", err) + if err := c.reconnect(); err != nil { + return nil, err + } + + if c.client == nil { + return nil, errors.New("client not available") + } else { + return c.client.NewSession() + } + } + + return session, nil +} + +func (c *Communicator) reconnect() (err error) { + // Ignore errors here because we don't care if it fails + c.Disconnect() + // Set the conn and client to nil since we'll recreate it + c.conn = nil + c.client = nil + + logger.Debug("reconnection to tcp connection for ssh") + c.conn, err = c.config.Connection() + if err != nil { + // Explicitly set this to the REAL nil. Connection() can return + // a nil implementation of net.Conn which will make the + // "if c.conn == nil" check fail above. Read here for more information + // on this psychotic language feature: + // + // http://golang.org/doc/faq#nil_error + c.conn = nil + + logger.Error("reconnection failure", "error", err) + return + } + + if c.config.Timeout > 0 { + c.conn = &timeoutConn{c.conn, c.config.Timeout, c.config.Timeout} + } + + logger.Debug("handshaking with ssh") + + // Default timeout to 1 minute if it wasn't specified (zero value). For + // when you need to handshake from low orbit. + var duration time.Duration + if c.config.HandshakeTimeout == 0 { + duration = 1 * time.Minute + } else { + duration = c.config.HandshakeTimeout + } + + connectionEstablished := make(chan struct{}, 1) + + var sshConn ssh.Conn + var sshChan <-chan ssh.NewChannel + var req <-chan *ssh.Request + + go func() { + sshConn, sshChan, req, err = ssh.NewClientConn(c.conn, c.address, c.config.SSHConfig) + close(connectionEstablished) + }() + + select { + case <-connectionEstablished: + // We don't need to do anything here. We just want select to block until + // we connect or timeout. + case <-time.After(duration): + if c.conn != nil { + c.conn.Close() + } + if sshConn != nil { + sshConn.Close() + } + return ErrHandshakeTimeout + } + + if err != nil { + return + } + logger.Debug("handshake complete") + if sshConn != nil { + c.client = ssh.NewClient(sshConn, sshChan, req) + } + c.connectToAgent() + + return +} + +func (c *Communicator) connectToAgent() { + if c.client == nil { + return + } + + if c.config.DisableAgentForwarding { + logger.Info("SSH agent forwarding is disabled") + return + } + + // open connection to the local agent + socketLocation := os.Getenv("SSH_AUTH_SOCK") + if socketLocation == "" { + logger.Info("no local agent socket, will not connect agent") + return + } + agentConn, err := net.Dial("unix", socketLocation) + if err != nil { + logger.Error("could not connect to local agent socket", "path", socketLocation) + return + } + + // create agent and add in auth + forwardingAgent := agent.NewClient(agentConn) + if forwardingAgent == nil { + logger.Error("could not create agent client") + agentConn.Close() + return + } + + // add callback for forwarding agent to SSH config + // XXX - might want to handle reconnects appending multiple callbacks + auth := ssh.PublicKeysCallback(forwardingAgent.Signers) + c.config.SSHConfig.Auth = append(c.config.SSHConfig.Auth, auth) + agent.ForwardToAgent(c.client, forwardingAgent) + + // Setup a session to request agent forwarding + session, err := c.newSession() + if err != nil { + return + } + defer session.Close() + + err = agent.RequestAgentForwarding(session) + if err != nil { + logger.Error("request agent forwarding failed", "error", err) + return + } + + logger.Info("agent forwarding enabled") + return +} + +func (c *Communicator) sftpUploadSession(path string, input io.Reader, fi *os.FileInfo) error { + sftpFunc := func(client *sftp.Client) error { + return c.sftpUploadFile(path, input, client, fi) + } + + return c.sftpSession(sftpFunc) +} + +func (c *Communicator) sftpUploadFile(path string, input io.Reader, client *sftp.Client, fi *os.FileInfo) error { + logger.Debug("sftp uploading", "path", path) + f, err := client.Create(path) + if err != nil { + return err + } + defer f.Close() + + if _, err = io.Copy(f, input); err != nil { + return err + } + + if fi != nil && (*fi).Mode().IsRegular() { + mode := (*fi).Mode().Perm() + err = client.Chmod(path, mode) + if err != nil { + return err + } + } + + return nil +} + +func (c *Communicator) sftpUploadDirSession(dst string, src string, excl []string) error { + sftpFunc := func(client *sftp.Client) error { + rootDst := dst + if src[len(src)-1] != '/' { + logger.Debug("no trailing slash, creating the source directory name") + rootDst = filepath.Join(dst, filepath.Base(src)) + } + walkFunc := func(path string, info os.FileInfo, err error) error { + if err != nil { + return err + } + // Calculate the final destination using the + // base source and root destination + relSrc, err := filepath.Rel(src, path) + if err != nil { + return err + } + finalDst := filepath.Join(rootDst, relSrc) + + // In Windows, Join uses backslashes which we don't want to get + // to the sftp server + finalDst = filepath.ToSlash(finalDst) + + // Skip the creation of the target destination directory since + // it should exist and we might not even own it + if finalDst == dst { + return nil + } + + return c.sftpVisitFile(finalDst, path, info, client) + } + + return filepath.Walk(src, walkFunc) + } + + return c.sftpSession(sftpFunc) +} + +func (c *Communicator) sftpMkdir(path string, client *sftp.Client, fi os.FileInfo) error { + logger.Debug("sftp create directory", "path", path) + + if err := client.Mkdir(path); err != nil { + // Do not consider it an error if the directory existed + remoteFi, fiErr := client.Lstat(path) + if fiErr != nil || !remoteFi.IsDir() { + return err + } + } + + mode := fi.Mode().Perm() + if err := client.Chmod(path, mode); err != nil { + return err + } + return nil +} + +func (c *Communicator) sftpVisitFile(dst string, src string, fi os.FileInfo, client *sftp.Client) error { + if !fi.IsDir() { + f, err := os.Open(src) + if err != nil { + return err + } + defer f.Close() + return c.sftpUploadFile(dst, f, client, &fi) + } else { + err := c.sftpMkdir(dst, client, fi) + return err + } +} + +func (c *Communicator) sftpDownloadSession(path string, output io.Writer) error { + sftpFunc := func(client *sftp.Client) error { + f, err := client.Open(path) + if err != nil { + return err + } + defer f.Close() + + if _, err = io.Copy(output, f); err != nil { + return err + } + + return nil + } + + return c.sftpSession(sftpFunc) +} + +func (c *Communicator) sftpSession(f func(*sftp.Client) error) error { + client, err := c.newSftpClient() + if err != nil { + return fmt.Errorf("sftpSession error: %s", err.Error()) + } + defer client.Close() + + return f(client) +} + +func (c *Communicator) newSftpClient() (*sftp.Client, error) { + session, err := c.newSession() + if err != nil { + return nil, err + } + + if err := session.RequestSubsystem("sftp"); err != nil { + return nil, err + } + + pw, err := session.StdinPipe() + if err != nil { + return nil, err + } + pr, err := session.StdoutPipe() + if err != nil { + return nil, err + } + + // Capture stdout so we can return errors to the user + var stdout bytes.Buffer + tee := io.TeeReader(pr, &stdout) + client, err := sftp.NewClientPipe(tee, pw) + if err != nil && stdout.Len() > 0 { + logger.Error("upload failed", "error", stdout.Bytes()) + } + + return client, err +} + +func (c *Communicator) scpUploadSession(path string, input io.Reader, fi *os.FileInfo) error { + + // The target directory and file for talking the SCP protocol + target_dir := filepath.Dir(path) + target_file := filepath.Base(path) + + // On windows, filepath.Dir uses backslash separators (ie. "\tmp"). + // This does not work when the target host is unix. Switch to forward slash + // which works for unix and windows + target_dir = filepath.ToSlash(target_dir) + + // Escape spaces in remote directory + target_dir = strings.Replace(target_dir, " ", "\\ ", -1) + + scpFunc := func(w io.Writer, stdoutR *bufio.Reader) error { + return scpUploadFile(target_file, input, w, stdoutR, fi) + } + + return c.scpSession("scp -vt "+target_dir, scpFunc) +} + +func (c *Communicator) scpUploadDirSession(dst string, src string, excl []string) error { + scpFunc := func(w io.Writer, r *bufio.Reader) error { + uploadEntries := func() error { + f, err := os.Open(src) + if err != nil { + return err + } + defer f.Close() + + entries, err := f.Readdir(-1) + if err != nil { + return err + } + + return scpUploadDir(src, entries, w, r) + } + + if src[len(src)-1] != '/' { + logger.Debug("no trailing slash, creating the source directory name") + fi, err := os.Stat(src) + if err != nil { + return err + } + return scpUploadDirProtocol(filepath.Base(src), w, r, uploadEntries, fi) + } else { + // Trailing slash, so only upload the contents + return uploadEntries() + } + } + + return c.scpSession("scp -rvt "+dst, scpFunc) +} + +func (c *Communicator) scpDownloadSession(path string, output io.Writer) error { + scpFunc := func(w io.Writer, stdoutR *bufio.Reader) error { + fmt.Fprint(w, "\x00") + + // read file info + fi, err := stdoutR.ReadString('\n') + if err != nil { + return err + } + + if len(fi) < 0 { + return fmt.Errorf("empty response from server") + } + + switch fi[0] { + case '\x01', '\x02': + return fmt.Errorf("%s", fi[1:]) + case 'C': + case 'D': + return fmt.Errorf("remote file is directory") + default: + return fmt.Errorf("unexpected server response (%x)", fi[0]) + } + + var mode string + var size int64 + + n, err := fmt.Sscanf(fi, "%6s %d ", &mode, &size) + if err != nil || n != 2 { + return fmt.Errorf("can't parse server response (%s)", fi) + } + if size < 0 { + return fmt.Errorf("negative file size") + } + + fmt.Fprint(w, "\x00") + + if _, err := io.CopyN(output, stdoutR, size); err != nil { + return err + } + + fmt.Fprint(w, "\x00") + + return checkSCPStatus(stdoutR) + } + + if !strings.Contains(path, " ") { + return c.scpSession("scp -vf "+path, scpFunc) + } + return c.scpSession("scp -vf "+strconv.Quote(path), scpFunc) +} + +func (c *Communicator) scpSession(scpCommand string, f func(io.Writer, *bufio.Reader) error) error { + session, err := c.newSession() + if err != nil { + return err + } + defer session.Close() + + // Get a pipe to stdin so that we can send data down + stdinW, err := session.StdinPipe() + if err != nil { + return err + } + + // We only want to close once, so we nil w after we close it, + // and only close in the defer if it hasn't been closed already. + defer func() { + if stdinW != nil { + stdinW.Close() + } + }() + + // Get a pipe to stdout so that we can get responses back + stdoutPipe, err := session.StdoutPipe() + if err != nil { + return err + } + stdoutR := bufio.NewReader(stdoutPipe) + + // Set stderr to a bytes buffer + stderr := new(bytes.Buffer) + session.Stderr = stderr + + // Start the sink mode on the other side + // TODO(mitchellh): There are probably issues with shell escaping the path + logger.Debug("starting remote scp process", "command", scpCommand) + if err := session.Start(scpCommand); err != nil { + return err + } + + // Call our callback that executes in the context of SCP. We ignore + // EOF errors if they occur because it usually means that SCP prematurely + // ended on the other side. + logger.Debug("started scp session, beginning transfers") + if err := f(stdinW, stdoutR); err != nil && err != io.EOF { + return err + } + + // Close the stdin, which sends an EOF, and then set w to nil so that + // our defer func doesn't close it again since that is unsafe with + // the Go SSH package. + logger.Debug("scp sessiono complete, closing stdin pipe") + stdinW.Close() + stdinW = nil + + // Wait for the SCP connection to close, meaning it has consumed all + // our data and has completed. Or has errored. + logger.Debug("waiting for ssh session to complete") + err = session.Wait() + if err != nil { + if exitErr, ok := err.(*ssh.ExitError); ok { + // Otherwise, we have an ExitError, meaning we can just read + // the exit status + logger.Debug("non-zero exit status", "exitcode", exitErr.ExitStatus()) + stdoutB, err := ioutil.ReadAll(stdoutR) + if err != nil { + return err + } + logger.Debug("scp output", "output", stdoutB) + + // If we exited with status 127, it means SCP isn't available. + // Return a more descriptive error for that. + if exitErr.ExitStatus() == 127 { + return errors.New( + "SCP failed to start. This usually means that SCP is not\n" + + "properly installed on the remote system.") + } + } + + return err + } + + logger.Debug("scp stderr", "length", stderr.Len(), "content", stderr.String()) + return nil +} + +// checkSCPStatus checks that a prior command sent to SCP completed +// successfully. If it did not complete successfully, an error will +// be returned. +func checkSCPStatus(r *bufio.Reader) error { + code, err := r.ReadByte() + if err != nil { + return err + } + + if code != 0 { + // Treat any non-zero (really 1 and 2) as fatal errors + message, _, err := r.ReadLine() + if err != nil { + return fmt.Errorf("Error reading error message: %s", err) + } + + return errors.New(string(message)) + } + + return nil +} + +func scpDownloadFile(dst string, src io.Reader, size int64, mode os.FileMode) error { + f, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, mode) + if err != nil { + return err + } + defer f.Close() + if _, err := io.CopyN(f, src, size); err != nil { + return err + } + return nil +} + +func scpUploadFile(dst string, src io.Reader, w io.Writer, r *bufio.Reader, fi *os.FileInfo) error { + var mode os.FileMode + var size int64 + + if fi != nil && (*fi).Mode().IsRegular() { + mode = (*fi).Mode().Perm() + size = (*fi).Size() + } else { + // Create a temporary file where we can copy the contents of the src + // so that we can determine the length, since SCP is length-prefixed. + tf, err := ioutil.TempFile("", "vagrant-upload") + if err != nil { + return fmt.Errorf("Error creating temporary file for upload: %s", err) + } + defer os.Remove(tf.Name()) + defer tf.Close() + + mode = 0644 + + logger.Debug("copying input data to temporary file to read length") + if _, err := io.Copy(tf, src); err != nil { + return fmt.Errorf("Error copying input data into local temporary "+ + "file. Check that TEMPDIR has enough space. Error: %s", err) + } + + // Sync the file so that the contents are definitely on disk, then + // read the length of it. + if err := tf.Sync(); err != nil { + return fmt.Errorf("Error creating temporary file for upload: %s", err) + } + + // Seek the file to the beginning so we can re-read all of it + if _, err := tf.Seek(0, 0); err != nil { + return fmt.Errorf("Error creating temporary file for upload: %s", err) + } + + tfi, err := tf.Stat() + if err != nil { + return fmt.Errorf("Error creating temporary file for upload: %s", err) + } + + size = tfi.Size() + src = tf + } + + // Start the protocol + perms := fmt.Sprintf("C%04o", mode) + logger.Debug("scp uploading", "path", dst, "perms", perms, "size", size) + + fmt.Fprintln(w, perms, size, dst) + if err := checkSCPStatus(r); err != nil { + return err + } + + if _, err := io.CopyN(w, src, size); err != nil { + return err + } + + fmt.Fprint(w, "\x00") + return checkSCPStatus(r) +} + +func scpUploadDirProtocol(name string, w io.Writer, r *bufio.Reader, f func() error, fi os.FileInfo) error { + logger.Debug("scp directory upload", "path", name) + + mode := fi.Mode().Perm() + + perms := fmt.Sprintf("D%04o 0", mode) + + fmt.Fprintln(w, perms, name) + err := checkSCPStatus(r) + if err != nil { + return err + } + + if err := f(); err != nil { + return err + } + + fmt.Fprintln(w, "E") + return err +} + +func scpUploadDir(root string, fs []os.FileInfo, w io.Writer, r *bufio.Reader) error { + for _, fi := range fs { + realPath := filepath.Join(root, fi.Name()) + + // Track if this is actually a symlink to a directory. If it is + // a symlink to a file we don't do any special behavior because uploading + // a file just works. If it is a directory, we need to know so we + // treat it as such. + isSymlinkToDir := false + if fi.Mode()&os.ModeSymlink == os.ModeSymlink { + symPath, err := filepath.EvalSymlinks(realPath) + if err != nil { + return err + } + + symFi, err := os.Lstat(symPath) + if err != nil { + return err + } + + isSymlinkToDir = symFi.IsDir() + } + + if !fi.IsDir() && !isSymlinkToDir { + // It is a regular file (or symlink to a file), just upload it + f, err := os.Open(realPath) + if err != nil { + return err + } + + err = func() error { + defer f.Close() + return scpUploadFile(fi.Name(), f, w, r, &fi) + }() + + if err != nil { + return err + } + + continue + } + + // It is a directory, recursively upload + err := scpUploadDirProtocol(fi.Name(), w, r, func() error { + f, err := os.Open(realPath) + if err != nil { + return err + } + defer f.Close() + + entries, err := f.Readdir(-1) + if err != nil { + return err + } + + return scpUploadDir(realPath, entries, w, r) + }, fi) + if err != nil { + return err + } + } + + return nil +} diff --git a/ext/go-plugin/vagrant/communicator/ssh/communicator_test.go b/ext/go-plugin/vagrant/communicator/ssh/communicator_test.go new file mode 100644 index 000000000..5533ba696 --- /dev/null +++ b/ext/go-plugin/vagrant/communicator/ssh/communicator_test.go @@ -0,0 +1,235 @@ +// +build !race + +package ssh + +import ( + "bytes" + "fmt" + "net" + "testing" + "time" + + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/communicator" + "golang.org/x/crypto/ssh" +) + +// private key for mock server +const testServerPrivateKey = `-----BEGIN RSA PRIVATE KEY----- +MIIEpAIBAAKCAQEA19lGVsTqIT5iiNYRgnoY1CwkbETW5cq+Rzk5v/kTlf31XpSU +70HVWkbTERECjaYdXM2gGcbb+sxpq6GtXf1M3kVomycqhxwhPv4Cr6Xp4WT/jkFx +9z+FFzpeodGJWjOH6L2H5uX1Cvr9EDdQp9t9/J32/qBFntY8GwoUI/y/1MSTmMiF +tupdMODN064vd3gyMKTwrlQ8tZM6aYuyOPsutLlUY7M5x5FwMDYvnPDSeyT/Iw0z +s3B+NCyqeeMd2T7YzQFnRATj0M7rM5LoSs7DVqVriOEABssFyLj31PboaoLhOKgc +qoM9khkNzr7FHVvi+DhYM2jD0DwvqZLN6NmnLwIDAQABAoIBAQCGVj+kuSFOV1lT ++IclQYA6bM6uY5mroqcSBNegVxCNhWU03BxlW//BE9tA/+kq53vWylMeN9mpGZea +riEMIh25KFGWXqXlOOioH8bkMsqA8S7sBmc7jljyv+0toQ9vCCtJ+sueNPhxQQxH +D2YvUjfzBQ04I9+wn30BByDJ1QA/FoPsunxIOUCcRBE/7jxuLYcpR+JvEF68yYIh +atXRld4W4in7T65YDR8jK1Uj9XAcNeDYNpT/M6oFLx1aPIlkG86aCWRO19S1jLPT +b1ZAKHHxPMCVkSYW0RqvIgLXQOR62D0Zne6/2wtzJkk5UCjkSQ2z7ZzJpMkWgDgN +ifCULFPBAoGBAPoMZ5q1w+zB+knXUD33n1J+niN6TZHJulpf2w5zsW+m2K6Zn62M +MXndXlVAHtk6p02q9kxHdgov34Uo8VpuNjbS1+abGFTI8NZgFo+bsDxJdItemwC4 +KJ7L1iz39hRN/ZylMRLz5uTYRGddCkeIHhiG2h7zohH/MaYzUacXEEy3AoGBANz8 +e/msleB+iXC0cXKwds26N4hyMdAFE5qAqJXvV3S2W8JZnmU+sS7vPAWMYPlERPk1 +D8Q2eXqdPIkAWBhrx4RxD7rNc5qFNcQWEhCIxC9fccluH1y5g2M+4jpMX2CT8Uv+ +3z+NoJ5uDTXZTnLCfoZzgZ4nCZVZ+6iU5U1+YXFJAoGBANLPpIV920n/nJmmquMj +orI1R/QXR9Cy56cMC65agezlGOfTYxk5Cfl5Ve+/2IJCfgzwJyjWUsFx7RviEeGw +64o7JoUom1HX+5xxdHPsyZ96OoTJ5RqtKKoApnhRMamau0fWydH1yeOEJd+TRHhc +XStGfhz8QNa1dVFvENczja1vAoGABGWhsd4VPVpHMc7lUvrf4kgKQtTC2PjA4xoc +QJ96hf/642sVE76jl+N6tkGMzGjnVm4P2j+bOy1VvwQavKGoXqJBRd5Apppv727g +/SM7hBXKFc/zH80xKBBgP/i1DR7kdjakCoeu4ngeGywvu2jTS6mQsqzkK+yWbUxJ +I7mYBsECgYB/KNXlTEpXtz/kwWCHFSYA8U74l7zZbVD8ul0e56JDK+lLcJ0tJffk +gqnBycHj6AhEycjda75cs+0zybZvN4x65KZHOGW/O/7OAWEcZP5TPb3zf9ned3Hl +NsZoFj52ponUM6+99A2CmezFCN16c4mbA//luWF+k3VVqR6BpkrhKw== +-----END RSA PRIVATE KEY-----` + +var serverConfig = &ssh.ServerConfig{ + PasswordCallback: func(c ssh.ConnMetadata, pass []byte) (*ssh.Permissions, error) { + if c.User() == "user" && string(pass) == "pass" { + return nil, nil + } + return nil, fmt.Errorf("password rejected for %q", c.User()) + }, +} + +func init() { + // Parse and set the private key of the server, required to accept connections + signer, err := ssh.ParsePrivateKey([]byte(testServerPrivateKey)) + if err != nil { + panic("unable to parse private key: " + err.Error()) + } + serverConfig.AddHostKey(signer) +} + +func newMockLineServer(t *testing.T) string { + l, err := net.Listen("tcp", "127.0.0.1:0") + if err != nil { + t.Fatalf("Unable to listen for connection: %s", err) + } + + go func() { + defer l.Close() + c, err := l.Accept() + if err != nil { + t.Errorf("Unable to accept incoming connection: %s", err) + } + defer c.Close() + conn, chans, _, err := ssh.NewServerConn(c, serverConfig) + if err != nil { + t.Logf("Handshaking error: %v", err) + } + t.Log("Accepted SSH connection") + for newChannel := range chans { + channel, _, err := newChannel.Accept() + if err != nil { + t.Errorf("Unable to accept channel.") + } + t.Log("Accepted channel") + + go func(channelType string) { + defer channel.Close() + conn.OpenChannel(channelType, nil) + }(newChannel.ChannelType()) + } + conn.Close() + }() + + return l.Addr().String() +} + +func newMockBrokenServer(t *testing.T) string { + l, err := net.Listen("tcp", "127.0.0.1:0") + if err != nil { + t.Fatalf("Unable tp listen for connection: %s", err) + } + + go func() { + defer l.Close() + c, err := l.Accept() + if err != nil { + t.Errorf("Unable to accept incoming connection: %s", err) + } + defer c.Close() + // This should block for a period of time longer than our timeout in + // the test case. That way we invoke a failure scenario. + t.Log("Block on handshaking for SSH connection") + time.Sleep(5 * time.Second) + }() + + return l.Addr().String() +} + +func TestCommIsCommunicator(t *testing.T) { + var raw interface{} + raw = &Communicator{} + if _, ok := raw.(communicator.Communicator); !ok { + t.Fatalf("Communicator must be a communicator") + } +} + +func TestNew_Invalid(t *testing.T) { + clientConfig := &ssh.ClientConfig{ + User: "user", + Auth: []ssh.AuthMethod{ + ssh.Password("i-am-invalid"), + }, + HostKeyCallback: ssh.InsecureIgnoreHostKey(), + } + + address := newMockLineServer(t) + conn := func() (net.Conn, error) { + conn, err := net.Dial("tcp", address) + if err != nil { + t.Errorf("Unable to accept incoming connection: %v", err) + } + return conn, err + } + + config := &Config{ + Connection: conn, + SSHConfig: clientConfig, + } + + comm, err := New(address, config) + if err != nil { + t.Fatalf("Failed to setup communicator: %s", err) + } + err = comm.Connect() + if err == nil { + t.Fatal("should have had an error connecting") + } +} + +func TestStart(t *testing.T) { + clientConfig := &ssh.ClientConfig{ + User: "user", + Auth: []ssh.AuthMethod{ + ssh.Password("pass"), + }, + HostKeyCallback: ssh.InsecureIgnoreHostKey(), + } + + address := newMockLineServer(t) + conn := func() (net.Conn, error) { + conn, err := net.Dial("tcp", address) + if err != nil { + t.Fatalf("unable to dial to remote side: %s", err) + } + return conn, err + } + + config := &Config{ + Connection: conn, + SSHConfig: clientConfig, + } + + client, err := New(address, config) + if err != nil { + t.Fatalf("error connecting to SSH: %s", err) + } + + cmd := &communicator.Cmd{ + Command: "echo foo", + Stdout: new(bytes.Buffer), + } + + client.Start(cmd) +} + +func TestHandshakeTimeout(t *testing.T) { + clientConfig := &ssh.ClientConfig{ + User: "user", + Auth: []ssh.AuthMethod{ + ssh.Password("pass"), + }, + HostKeyCallback: ssh.InsecureIgnoreHostKey(), + } + + address := newMockBrokenServer(t) + conn := func() (net.Conn, error) { + conn, err := net.Dial("tcp", address) + if err != nil { + t.Fatalf("unable to dial to remote side: %s", err) + } + return conn, err + } + + config := &Config{ + Connection: conn, + SSHConfig: clientConfig, + HandshakeTimeout: 50 * time.Millisecond, + } + + comm, err := New(address, config) + if err != nil { + t.Fatalf("Failed to setup communicator: %s", err) + } + err = comm.Connect() + if err != ErrHandshakeTimeout { + // Note: there's another error that can come back from this call: + // ssh: handshake failed: EOF + // This should appear in cases where the handshake fails because of + // malformed (or no) data sent back by the server, but should not happen + // in a timeout scenario. + t.Fatalf("Expected handshake timeout, got: %s", err) + } +} diff --git a/ext/go-plugin/vagrant/communicator/ssh/connect.go b/ext/go-plugin/vagrant/communicator/ssh/connect.go new file mode 100644 index 000000000..80bf0a9f4 --- /dev/null +++ b/ext/go-plugin/vagrant/communicator/ssh/connect.go @@ -0,0 +1,88 @@ +package ssh + +import ( + "fmt" + "net" + "time" + + "golang.org/x/crypto/ssh" + "golang.org/x/net/proxy" +) + +// ConnectFunc is a convenience method for returning a function +// that just uses net.Dial to communicate with the remote end that +// is suitable for use with the SSH communicator configuration. +func ConnectFunc(network, addr string) func() (net.Conn, error) { + return func() (net.Conn, error) { + c, err := net.DialTimeout(network, addr, 15*time.Second) + if err != nil { + return nil, err + } + + if tcpConn, ok := c.(*net.TCPConn); ok { + tcpConn.SetKeepAlive(true) + tcpConn.SetKeepAlivePeriod(5 * time.Second) + } + + return c, nil + } +} + +// ProxyConnectFunc is a convenience method for returning a function +// that connects to a host using SOCKS5 proxy +func ProxyConnectFunc(socksProxy string, socksAuth *proxy.Auth, network, addr string) func() (net.Conn, error) { + return func() (net.Conn, error) { + // create a socks5 dialer + dialer, err := proxy.SOCKS5("tcp", socksProxy, socksAuth, proxy.Direct) + if err != nil { + return nil, fmt.Errorf("Can't connect to the proxy: %s", err) + } + + c, err := dialer.Dial(network, addr) + if err != nil { + return nil, err + } + + return c, nil + } +} + +// BastionConnectFunc is a convenience method for returning a function +// that connects to a host over a bastion connection. +func BastionConnectFunc( + bProto string, + bAddr string, + bConf *ssh.ClientConfig, + proto string, + addr string) func() (net.Conn, error) { + return func() (net.Conn, error) { + // Connect to the bastion + bastion, err := ssh.Dial(bProto, bAddr, bConf) + if err != nil { + return nil, fmt.Errorf("Error connecting to bastion: %s", err) + } + + // Connect through to the end host + conn, err := bastion.Dial(proto, addr) + if err != nil { + bastion.Close() + return nil, err + } + + // Wrap it up so we close both things properly + return &bastionConn{ + Conn: conn, + Bastion: bastion, + }, nil + } +} + +type bastionConn struct { + net.Conn + Bastion *ssh.Client +} + +func (c *bastionConn) Close() error { + c.Conn.Close() + return c.Bastion.Close() +} diff --git a/ext/go-plugin/vagrant/communicator/ssh/connection.go b/ext/go-plugin/vagrant/communicator/ssh/connection.go new file mode 100644 index 000000000..c3df04543 --- /dev/null +++ b/ext/go-plugin/vagrant/communicator/ssh/connection.go @@ -0,0 +1,30 @@ +package ssh + +import ( + "net" + "time" +) + +// timeoutConn wraps a net.Conn, and sets a deadline for every read +// and write operation. +type timeoutConn struct { + net.Conn + ReadTimeout time.Duration + WriteTimeout time.Duration +} + +func (c *timeoutConn) Read(b []byte) (int, error) { + err := c.Conn.SetReadDeadline(time.Now().Add(c.ReadTimeout)) + if err != nil { + return 0, err + } + return c.Conn.Read(b) +} + +func (c *timeoutConn) Write(b []byte) (int, error) { + err := c.Conn.SetWriteDeadline(time.Now().Add(c.WriteTimeout)) + if err != nil { + return 0, err + } + return c.Conn.Write(b) +} diff --git a/ext/go-plugin/vagrant/communicator/ssh/password.go b/ext/go-plugin/vagrant/communicator/ssh/password.go new file mode 100644 index 000000000..b1bfedd64 --- /dev/null +++ b/ext/go-plugin/vagrant/communicator/ssh/password.go @@ -0,0 +1,25 @@ +package ssh + +import ( + "golang.org/x/crypto/ssh" +) + +// An implementation of ssh.KeyboardInteractiveChallenge that simply sends +// back the password for all questions. The questions are logged. +func PasswordKeyboardInteractive(password string) ssh.KeyboardInteractiveChallenge { + return func(user, instruction string, questions []string, echos []bool) ([]string, error) { + logger.Info("keyboard interactive challenge", "user", user, + "instructions", instruction) + for i, question := range questions { + logger.Info("challenge question", "number", i+1, "question", question) + } + + // Just send the password back for all questions + answers := make([]string, len(questions)) + for i := range answers { + answers[i] = password + } + + return answers, nil + } +} diff --git a/ext/go-plugin/vagrant/communicator/ssh/password_test.go b/ext/go-plugin/vagrant/communicator/ssh/password_test.go new file mode 100644 index 000000000..47a4c7782 --- /dev/null +++ b/ext/go-plugin/vagrant/communicator/ssh/password_test.go @@ -0,0 +1,28 @@ +package ssh + +import ( + "reflect" + "testing" + + "golang.org/x/crypto/ssh" +) + +func TestPasswordKeyboardInteractive_Impl(t *testing.T) { + var raw interface{} + raw = PasswordKeyboardInteractive("foo") + if _, ok := raw.(ssh.KeyboardInteractiveChallenge); !ok { + t.Fatal("PasswordKeyboardInteractive must implement KeyboardInteractiveChallenge") + } +} + +func TestPasswordKeyboardInteractive_Challenge(t *testing.T) { + p := PasswordKeyboardInteractive("foo") + result, err := p("foo", "bar", []string{"one", "two"}, nil) + if err != nil { + t.Fatalf("err not nil: %s", err) + } + + if !reflect.DeepEqual(result, []string{"foo", "foo"}) { + t.Fatalf("invalid password: %#v", result) + } +} diff --git a/ext/go-plugin/vagrant/communicator/winrm/communicator.go b/ext/go-plugin/vagrant/communicator/winrm/communicator.go new file mode 100644 index 000000000..a165030bc --- /dev/null +++ b/ext/go-plugin/vagrant/communicator/winrm/communicator.go @@ -0,0 +1,257 @@ +package winrm + +import ( + "encoding/base64" + "fmt" + "io" + "io/ioutil" + "os" + "path/filepath" + "strings" + "sync" + + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant" + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/communicator" + "github.com/masterzen/winrm" + "github.com/packer-community/winrmcp/winrmcp" +) + +var logger = vagrant.DefaultLogger().Named("communicator.winrm") + +// Communicator represents the WinRM communicator +type Communicator struct { + config *Config + client *winrm.Client + endpoint *winrm.Endpoint +} + +// New creates a new communicator implementation over WinRM. +func New(config *Config) (*Communicator, error) { + endpoint := &winrm.Endpoint{ + Host: config.Host, + Port: config.Port, + HTTPS: config.Https, + Insecure: config.Insecure, + + /* + TODO + HTTPS: connInfo.HTTPS, + Insecure: connInfo.Insecure, + CACert: connInfo.CACert, + */ + } + + // Create the client + params := *winrm.DefaultParameters + + if config.TransportDecorator != nil { + params.TransportDecorator = config.TransportDecorator + } + + params.Timeout = formatDuration(config.Timeout) + client, err := winrm.NewClientWithParameters( + endpoint, config.Username, config.Password, ¶ms) + if err != nil { + return nil, err + } + + return &Communicator{ + config: config, + client: client, + endpoint: endpoint, + }, nil +} + +func (c *Communicator) Connect() (err error) { + // Create the shell to verify the connection + logger.Debug("connecting to remote shell") + shell, err := c.client.CreateShell() + if err != nil { + logger.Error("connection failure", "error", err) + return + } + if err = shell.Close(); err != nil { + logger.Error("connection close failure", "error", err) + } + return +} + +// Start implementation of communicator.Communicator interface +func (c *Communicator) Start(rc *communicator.Cmd) error { + shell, err := c.client.CreateShell() + if err != nil { + return err + } + + logger.Info("starting remote command", "commmand", rc.Command) + + rc.Init() + cmd, err := shell.Execute(rc.Command) + if err != nil { + return err + } + + go runCommand(shell, cmd, rc) + return nil +} + +func runCommand(shell *winrm.Shell, cmd *winrm.Command, rc *communicator.Cmd) { + defer shell.Close() + var wg sync.WaitGroup + + copyFunc := func(w io.Writer, r io.Reader) { + defer wg.Done() + io.Copy(w, r) + } + + if rc.Stdout != nil && cmd.Stdout != nil { + wg.Add(1) + go copyFunc(rc.Stdout, cmd.Stdout) + } else { + logger.Warn("failed to read stdout", "command", rc.Command) + } + + if rc.Stderr != nil && cmd.Stderr != nil { + wg.Add(1) + go copyFunc(rc.Stderr, cmd.Stderr) + } else { + logger.Warn("failed to read stderr", "command", rc.Command) + } + + cmd.Wait() + wg.Wait() + + code := cmd.ExitCode() + logger.Info("command complete", "exitcode", code, "command", rc.Command) + rc.SetExitStatus(code, nil) +} + +// Upload implementation of communicator.Communicator interface +func (c *Communicator) Upload(path string, input io.Reader, fi *os.FileInfo) error { + wcp, err := c.newCopyClient() + if err != nil { + return fmt.Errorf("Was unable to create winrm client: %s", err) + } + if strings.HasSuffix(path, `\`) { + // path is a directory + path += filepath.Base((*fi).Name()) + } + logger.Info("uploading file", "path", path) + return wcp.Write(path, input) +} + +// UploadDir implementation of communicator.Communicator interface +func (c *Communicator) UploadDir(dst string, src string, exclude []string) error { + if !strings.HasSuffix(src, "/") { + dst = fmt.Sprintf("%s\\%s", dst, filepath.Base(src)) + } + logger.Info("uploading directory", "source", src, "destination", dst) + wcp, err := c.newCopyClient() + if err != nil { + return err + } + return wcp.Copy(src, dst) +} + +func (c *Communicator) Download(src string, dst io.Writer) error { + client, err := c.newWinRMClient() + if err != nil { + return err + } + + encodeScript := `$file=[System.IO.File]::ReadAllBytes("%s"); Write-Output $([System.Convert]::ToBase64String($file))` + + base64DecodePipe := &Base64Pipe{w: dst} + + cmd := winrm.Powershell(fmt.Sprintf(encodeScript, src)) + _, err = client.Run(cmd, base64DecodePipe, ioutil.Discard) + + return err +} + +func (c *Communicator) DownloadDir(src string, dst string, exclude []string) error { + return fmt.Errorf("WinRM doesn't support download dir.") +} + +func (c *Communicator) getClientConfig() *winrmcp.Config { + return &winrmcp.Config{ + Auth: winrmcp.Auth{ + User: c.config.Username, + Password: c.config.Password, + }, + Https: c.config.Https, + Insecure: c.config.Insecure, + OperationTimeout: c.config.Timeout, + MaxOperationsPerShell: 15, // lowest common denominator + TransportDecorator: c.config.TransportDecorator, + } +} + +func (c *Communicator) newCopyClient() (*winrmcp.Winrmcp, error) { + addr := fmt.Sprintf("%s:%d", c.endpoint.Host, c.endpoint.Port) + clientConfig := c.getClientConfig() + return winrmcp.New(addr, clientConfig) +} + +func (c *Communicator) newWinRMClient() (*winrm.Client, error) { + conf := c.getClientConfig() + + // Shamelessly borrowed from the winrmcp client to ensure + // that the client is configured using the same defaulting behaviors that + // winrmcp uses even we we aren't using winrmcp. This ensures similar + // behavior between upload, download, and copy functions. We can't use the + // one generated by winrmcp because it isn't exported. + var endpoint *winrm.Endpoint + endpoint = &winrm.Endpoint{ + Host: c.endpoint.Host, + Port: c.endpoint.Port, + HTTPS: conf.Https, + Insecure: conf.Insecure, + TLSServerName: conf.TLSServerName, + CACert: conf.CACertBytes, + Timeout: conf.ConnectTimeout, + } + params := winrm.NewParameters( + winrm.DefaultParameters.Timeout, + winrm.DefaultParameters.Locale, + winrm.DefaultParameters.EnvelopeSize, + ) + + params.TransportDecorator = conf.TransportDecorator + params.Timeout = "PT3M" + + client, err := winrm.NewClientWithParameters( + endpoint, conf.Auth.User, conf.Auth.Password, params) + return client, err +} + +type Base64Pipe struct { + w io.Writer // underlying writer (file, buffer) +} + +func (d *Base64Pipe) ReadFrom(r io.Reader) (int64, error) { + b, err := ioutil.ReadAll(r) + if err != nil { + return 0, err + } + + var i int + i, err = d.Write(b) + + if err != nil { + return 0, err + } + + return int64(i), err +} + +func (d *Base64Pipe) Write(p []byte) (int, error) { + dst := make([]byte, base64.StdEncoding.DecodedLen(len(p))) + + decodedBytes, err := base64.StdEncoding.Decode(dst, p) + if err != nil { + return 0, err + } + + return d.w.Write(dst[0:decodedBytes]) +} diff --git a/ext/go-plugin/vagrant/communicator/winrm/communicator_test.go b/ext/go-plugin/vagrant/communicator/winrm/communicator_test.go new file mode 100644 index 000000000..7590ddc31 --- /dev/null +++ b/ext/go-plugin/vagrant/communicator/winrm/communicator_test.go @@ -0,0 +1,123 @@ +package winrm + +import ( + "bytes" + "io" + "strings" + "testing" + "time" + + "github.com/dylanmei/winrmtest" + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/communicator" +) + +const PAYLOAD = "stuff" +const BASE64_ENCODED_PAYLOAD = "c3R1ZmY=" + +func newMockWinRMServer(t *testing.T) *winrmtest.Remote { + wrm := winrmtest.NewRemote() + + wrm.CommandFunc( + winrmtest.MatchText("echo foo"), + func(out, err io.Writer) int { + out.Write([]byte("foo")) + return 0 + }) + + wrm.CommandFunc( + winrmtest.MatchPattern(`^echo c29tZXRoaW5n >> ".*"$`), + func(out, err io.Writer) int { + return 0 + }) + + wrm.CommandFunc( + winrmtest.MatchPattern(`^echo `+BASE64_ENCODED_PAYLOAD+` >> ".*"$`), + func(out, err io.Writer) int { + return 0 + }) + + wrm.CommandFunc( + winrmtest.MatchPattern(`^powershell.exe -EncodedCommand .*$`), + func(out, err io.Writer) int { + out.Write([]byte(BASE64_ENCODED_PAYLOAD)) + return 0 + }) + + wrm.CommandFunc( + winrmtest.MatchText("powershell"), + func(out, err io.Writer) int { + return 0 + }) + wrm.CommandFunc( + winrmtest.MatchText(`powershell -Command "(Get-Item C:/Temp/vagrant.cmd) -is [System.IO.DirectoryInfo]"`), + func(out, err io.Writer) int { + out.Write([]byte("False")) + return 0 + }) + + return wrm +} + +func TestStart(t *testing.T) { + wrm := newMockWinRMServer(t) + defer wrm.Close() + + c, err := New(&Config{ + Host: wrm.Host, + Port: wrm.Port, + Username: "user", + Password: "pass", + Timeout: 30 * time.Second, + }) + if err != nil { + t.Fatalf("error creating communicator: %s", err) + } + + var cmd communicator.Cmd + stdout := new(bytes.Buffer) + cmd.Command = "echo foo" + cmd.Stdout = stdout + + err = c.Start(&cmd) + if err != nil { + t.Fatalf("error executing remote command: %s", err) + } + cmd.Wait() + + if stdout.String() != "foo" { + t.Fatalf("bad command response: expected %q, got %q", "foo", stdout.String()) + } +} + +func TestUpload(t *testing.T) { + wrm := newMockWinRMServer(t) + defer wrm.Close() + + c, err := New(&Config{ + Host: wrm.Host, + Port: wrm.Port, + Username: "user", + Password: "pass", + Timeout: 30 * time.Second, + }) + if err != nil { + t.Fatalf("error creating communicator: %s", err) + } + file := "C:/Temp/vagrant.cmd" + err = c.Upload(file, strings.NewReader(PAYLOAD), nil) + if err != nil { + t.Fatalf("error uploading file: %s", err) + } + + dest := new(bytes.Buffer) + err = c.Download(file, dest) + if err != nil { + t.Fatalf("error downloading file: %s", err) + } + downloadedPayload := dest.String() + + if downloadedPayload != PAYLOAD { + t.Fatalf("files are not equal: expected [%s] length: %v, got [%s] length %v", PAYLOAD, len(PAYLOAD), downloadedPayload, len(downloadedPayload)) + } + +} diff --git a/ext/go-plugin/vagrant/communicator/winrm/config.go b/ext/go-plugin/vagrant/communicator/winrm/config.go new file mode 100644 index 000000000..728336734 --- /dev/null +++ b/ext/go-plugin/vagrant/communicator/winrm/config.go @@ -0,0 +1,19 @@ +package winrm + +import ( + "time" + + "github.com/masterzen/winrm" +) + +// Config is used to configure the WinRM connection +type Config struct { + Host string + Port int + Username string + Password string + Timeout time.Duration + Https bool + Insecure bool + TransportDecorator func() winrm.Transporter +} diff --git a/ext/go-plugin/vagrant/communicator/winrm/time.go b/ext/go-plugin/vagrant/communicator/winrm/time.go new file mode 100644 index 000000000..f8fb6fe8d --- /dev/null +++ b/ext/go-plugin/vagrant/communicator/winrm/time.go @@ -0,0 +1,32 @@ +package winrm + +import ( + "fmt" + "time" +) + +// formatDuration formats the given time.Duration into an ISO8601 +// duration string. +func formatDuration(duration time.Duration) string { + // We're not supporting negative durations + if duration.Seconds() <= 0 { + return "PT0S" + } + + h := int(duration.Hours()) + m := int(duration.Minutes()) - (h * 60) + s := int(duration.Seconds()) - (h*3600 + m*60) + + res := "PT" + if h > 0 { + res = fmt.Sprintf("%s%dH", res, h) + } + if m > 0 { + res = fmt.Sprintf("%s%dM", res, m) + } + if s > 0 { + res = fmt.Sprintf("%s%dS", res, s) + } + + return res +} diff --git a/ext/go-plugin/vagrant/communicator/winrm/time_test.go b/ext/go-plugin/vagrant/communicator/winrm/time_test.go new file mode 100644 index 000000000..4daf4cedf --- /dev/null +++ b/ext/go-plugin/vagrant/communicator/winrm/time_test.go @@ -0,0 +1,36 @@ +package winrm + +import ( + "testing" + "time" +) + +func TestFormatDuration(t *testing.T) { + // Test complex duration with hours, minutes, seconds + d := time.Duration(3701) * time.Second + s := formatDuration(d) + if s != "PT1H1M41S" { + t.Fatalf("bad ISO 8601 duration string: %s", s) + } + + // Test only minutes duration + d = time.Duration(20) * time.Minute + s = formatDuration(d) + if s != "PT20M" { + t.Fatalf("bad ISO 8601 duration string for 20M: %s", s) + } + + // Test only seconds + d = time.Duration(1) * time.Second + s = formatDuration(d) + if s != "PT1S" { + t.Fatalf("bad ISO 8601 duration string for 1S: %s", s) + } + + // Test negative duration (unsupported) + d = time.Duration(-1) * time.Second + s = formatDuration(d) + if s != "PT0S" { + t.Fatalf("bad ISO 8601 duration string for negative: %s", s) + } +} diff --git a/ext/go-plugin/vagrant/config.go b/ext/go-plugin/vagrant/config.go new file mode 100644 index 000000000..5282d8b0d --- /dev/null +++ b/ext/go-plugin/vagrant/config.go @@ -0,0 +1,8 @@ +package vagrant + +type Config interface { + ConfigAttributes() (attrs []string, err error) + ConfigLoad(data map[string]interface{}) (loaddata map[string]interface{}, err error) + ConfigValidate(data map[string]interface{}, m *Machine) (errors []string, err error) + ConfigFinalize(data map[string]interface{}) (finaldata map[string]interface{}, err error) +} diff --git a/ext/go-plugin/vagrant/environment.go b/ext/go-plugin/vagrant/environment.go new file mode 100644 index 000000000..4f7396fe9 --- /dev/null +++ b/ext/go-plugin/vagrant/environment.go @@ -0,0 +1,64 @@ +package vagrant + +import ( + "encoding/json" + "io" + "os" +) + +type Environment struct { + ActiveMachines map[string]string `json:"active_machines,omitempty"` + AliasesPath string `json:"aliases_path,omitempty"` + BoxesPath string `json:"boxes_path,omitempty"` + CWD string `json:"cwd,omitempty"` + DataDir string `json:"data_dir,omitempty"` + DefaultPrivateKeyPath string `json:"default_private_key_path,omitempty"` + GemsPath string `json:"gems_path,omitempty"` + HomePath string `json:"home_path,omitempty"` + LocalDataPath string `json:"local_data_path,omitempty"` + MachineNames []string `json:"machine_names,omitempty"` + PrimaryMachineName string `json:"primary_machine_name,omitempty"` + RootPath string `json:"root_path,omitempty"` + TmpPath string `json:"tmp_path,omitempty"` + VagrantfileName string `json:"vagrantfile_name,omitempty"` + UI Ui `json:"-"` +} + +func DumpEnvironment(e *Environment) (s string, err error) { + DefaultLogger().Debug("dumping environment to serialized data") + b, err := json.Marshal(e) + if err != nil { + DefaultLogger().Error("environment dump failure", "error", err) + return + } + s = string(b) + return +} + +func LoadEnvironment(edata string, ios IOServer) (e *Environment, err error) { + DefaultLogger().Debug("loading environment from serialized data") + e = &Environment{} + err = json.Unmarshal([]byte(edata), e) + if err != nil { + return + } + var stdout io.Writer + var stderr io.Writer + if ios == nil { + stdout = os.Stdout + stderr = os.Stderr + } else { + stdout = &IOWriter{target: "stdout", srv: ios} + stderr = &IOWriter{target: "stderr", srv: ios} + } + e.UI = &TargetedUi{ + Target: "vagrant", + Ui: &ColoredUi{ + ErrorColor: UiColorRed, + Ui: &BasicUi{ + Reader: os.Stdin, + Writer: stdout, + ErrorWriter: stderr}, + }} + return +} diff --git a/ext/go-plugin/vagrant/environment_test.go b/ext/go-plugin/vagrant/environment_test.go new file mode 100644 index 000000000..118902cf6 --- /dev/null +++ b/ext/go-plugin/vagrant/environment_test.go @@ -0,0 +1,63 @@ +package vagrant + +import ( + "strings" + "testing" +) + +func TestLoadEnvironment(t *testing.T) { + env, err := LoadEnvironment("{}", nil) + if err != nil { + t.Fatalf("unexpected load error: %s", err) + } + if env.UI == nil { + t.Fatalf("no UI configured for environment") + } +} + +func TestBadLoadEnvironment(t *testing.T) { + _, err := LoadEnvironment("ack", nil) + if err == nil { + t.Fatalf("expected load error but none provided") + } +} + +func TestLoadEnvironmentUIStdout(t *testing.T) { + iosrv := buildio() + env, err := LoadEnvironment("{}", iosrv) + if err != nil { + t.Fatalf("unexpected load error: %s", err) + } + go func() { env.UI.Info("test string") }() + str := <-iosrv.Streams()["stdout"] + if !strings.Contains(str, "test string") { + t.Fatalf("unexpected output: %s", str) + } +} + +func TestLoadEnvironmentUIStderr(t *testing.T) { + iosrv := buildio() + env, err := LoadEnvironment("{}", iosrv) + if err != nil { + t.Fatalf("unexpected load error: %s", err) + } + go func() { env.UI.Error("test string") }() + str, err := iosrv.Read("stderr") + if !strings.Contains(str, "test string") { + t.Fatalf("unexpected output: %s", str) + } +} + +func TestDumpEnvironment(t *testing.T) { + env, err := LoadEnvironment("{}", nil) + if err != nil { + t.Fatalf("unexpected load error: %s", err) + } + d, err := DumpEnvironment(env) + if err != nil { + t.Fatalf("unexpected dump error: %s", err) + } + if d != "{}" { + t.Fatalf("unexpected dump information: %s", d) + } +} diff --git a/ext/go-plugin/vagrant/global.go b/ext/go-plugin/vagrant/global.go new file mode 100644 index 000000000..5f4c6bc82 --- /dev/null +++ b/ext/go-plugin/vagrant/global.go @@ -0,0 +1,17 @@ +package vagrant + +import ( + hclog "github.com/hashicorp/go-hclog" +) + +var GlobalIOServer *IOServer + +var defaultLogger = hclog.Default().Named("vagrant") + +func DefaultLogger() hclog.Logger { + return defaultLogger +} + +func SetDefaultLogger(l hclog.Logger) { + defaultLogger = l +} diff --git a/ext/go-plugin/vagrant/io.go b/ext/go-plugin/vagrant/io.go new file mode 100644 index 000000000..9c96a37b1 --- /dev/null +++ b/ext/go-plugin/vagrant/io.go @@ -0,0 +1,53 @@ +package vagrant + +import ( + "errors" +) + +type StreamIO interface { + Read(target string) (content string, err error) + Write(content, target string) (n int, err error) +} + +type IOServer interface { + Streams() map[string]chan (string) + StreamIO +} + +type IOSrv struct { + Targets map[string]chan (string) +} + +func (i *IOSrv) Streams() map[string]chan (string) { + return i.Targets +} + +type IOWriter struct { + target string + srv IOServer +} + +func (i *IOWriter) Write(b []byte) (n int, err error) { + content := string(b) + n, err = i.srv.Write(content, i.target) + return +} + +func (i *IOSrv) Read(target string) (content string, err error) { + if _, ok := i.Streams()[target]; !ok { + err = errors.New("Unknown target defined") + return + } + content = <-i.Streams()[target] + return +} + +func (i *IOSrv) Write(content, target string) (n int, err error) { + if _, ok := i.Streams()[target]; !ok { + err = errors.New("Unknown target defined") + return + } + i.Streams()[target] <- content + n = len(content) + return +} diff --git a/ext/go-plugin/vagrant/io_test.go b/ext/go-plugin/vagrant/io_test.go new file mode 100644 index 000000000..c0ae959bb --- /dev/null +++ b/ext/go-plugin/vagrant/io_test.go @@ -0,0 +1,48 @@ +package vagrant + +import ( + "testing" +) + +func buildio() IOServer { + return &IOSrv{ + Targets: map[string]chan (string){ + "stdout": make(chan string), + "stderr": make(chan string)}} +} + +func TestIOSrvWrite(t *testing.T) { + iosrv := buildio() + var i int + go func() { i, _ = iosrv.Write("test string", "stdout") }() + _, _ = iosrv.Read("stdout") + if i != len("test string") { + t.Fatalf("unexpected write bytes %d != %d", + len("test string"), i) + } +} + +func TestIOSrvRead(t *testing.T) { + iosrv := buildio() + go func() { _, _ = iosrv.Write("test string", "stdout") }() + r, _ := iosrv.Read("stdout") + if r != "test string" { + t.Fatalf("unexpected read result: %s", r) + } +} + +func TestIOSrvWriteBadTarget(t *testing.T) { + iosrv := buildio() + _, err := iosrv.Write("test string", "stdno") + if err == nil { + t.Fatalf("expected error on write") + } +} + +func TestIOSrvReadBadTarget(t *testing.T) { + iosrv := buildio() + _, err := iosrv.Read("stdno") + if err == nil { + t.Fatalf("expected error on read") + } +} diff --git a/ext/go-plugin/vagrant/machine.go b/ext/go-plugin/vagrant/machine.go new file mode 100644 index 000000000..a13a060a4 --- /dev/null +++ b/ext/go-plugin/vagrant/machine.go @@ -0,0 +1,59 @@ +package vagrant + +import ( + "encoding/json" + "io" + "os" +) + +type Machine struct { + Box Box `json:"box"` + Config map[string]interface{} `json:"config"` + DataDir string `json:"data_dir,omitempty"` + Env Environment `json:"environment"` + ID string `json:"id,omitempty"` + Name string `json:"name,omitempty"` + ProviderConfig map[string]interface{} `json:"provider_config"` + ProviderName string `json:"provider_name,omitempty"` + ProviderOptions map[string]string `json:"provider_options"` + UI Ui `json:"-"` +} + +func DumpMachine(m *Machine) (s string, err error) { + DefaultLogger().Debug("dumping machine to serialized data") + b, err := json.Marshal(m) + if err != nil { + DefaultLogger().Debug("machine dump failure", "error", err) + return + } + s = string(b) + return +} + +func LoadMachine(mdata string, ios IOServer) (m *Machine, err error) { + DefaultLogger().Debug("loading machine from serialized data") + m = &Machine{} + err = json.Unmarshal([]byte(mdata), m) + if err != nil { + return + } + var stdout io.Writer + var stderr io.Writer + if ios == nil { + stdout = os.Stdout + stderr = os.Stderr + } else { + stdout = &IOWriter{target: "stdout", srv: ios} + stderr = &IOWriter{target: "stderr", srv: ios} + } + m.UI = &TargetedUi{ + Target: m.Name, + Ui: &ColoredUi{ + ErrorColor: UiColorRed, + Ui: &BasicUi{ + Reader: os.Stdin, + Writer: stdout, + ErrorWriter: stderr}, + }} + return +} diff --git a/ext/go-plugin/vagrant/machine_state.go b/ext/go-plugin/vagrant/machine_state.go new file mode 100644 index 000000000..d80349179 --- /dev/null +++ b/ext/go-plugin/vagrant/machine_state.go @@ -0,0 +1,7 @@ +package vagrant + +type MachineState struct { + Id string `json:"id"` + ShortDesc string `json:"short_description"` + LongDesc string `json:"long_description"` +} diff --git a/ext/go-plugin/vagrant/machine_test.go b/ext/go-plugin/vagrant/machine_test.go new file mode 100644 index 000000000..e3675032a --- /dev/null +++ b/ext/go-plugin/vagrant/machine_test.go @@ -0,0 +1,53 @@ +package vagrant + +import ( + "strings" + "testing" +) + +func TestMachineLoad(t *testing.T) { + _, err := LoadMachine("{}", nil) + if err != nil { + t.Fatalf("failed to load machine: %s", err) + } +} + +func TestMachineDump(t *testing.T) { + m, err := LoadMachine("{}", nil) + if err != nil { + t.Fatalf("unexpected load error: %s", err) + } + _, err = DumpMachine(m) + if err != nil { + t.Fatalf("failed to dump machine: %s", err) + } +} + +func TestMachineUI(t *testing.T) { + iosrv := buildio() + m, err := LoadMachine("{}", iosrv) + if err != nil { + t.Fatalf("unexpected load error: %s", err) + } + go func() { m.UI.Info("test string") }() + r, _ := iosrv.Read("stdout") + if !strings.Contains(r, "test string") { + t.Fatalf("unexpected read result: %s", r) + } +} + +func TestMachineUINamed(t *testing.T) { + iosrv := buildio() + m, err := LoadMachine("{\"name\":\"plugintest\"}", iosrv) + if err != nil { + t.Fatalf("unexpected load error: %s", err) + } + go func() { m.UI.Info("test string") }() + r, _ := iosrv.Read("stdout") + if !strings.Contains(r, "test string") { + t.Fatalf("unexpected read result: %s", r) + } + if !strings.Contains(r, "plugintest") { + t.Fatalf("output does not contain name: %s", r) + } +} diff --git a/ext/go-plugin/vagrant/plugin/base.go b/ext/go-plugin/vagrant/plugin/base.go new file mode 100644 index 000000000..0c09fd84b --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/base.go @@ -0,0 +1,186 @@ +package plugin + +import ( + "errors" + "os" + "os/exec" + + hclog "github.com/hashicorp/go-hclog" + go_plugin "github.com/hashicorp/go-plugin" + + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant" +) + +type RemoteConfig struct { + Client *go_plugin.Client + Config vagrant.Config +} + +type RemoteProvider struct { + Client *go_plugin.Client + Provider Provider +} + +type RemoteGuestCapabilities struct { + Client *go_plugin.Client + GuestCapabilities vagrant.GuestCapabilities +} + +type RemoteHostCapabilities struct { + Client *go_plugin.Client + HostCapabilities vagrant.HostCapabilities +} + +type RemoteProviderCapabilities struct { + Client *go_plugin.Client + ProviderCapabilities vagrant.ProviderCapabilities +} + +type RemoteSyncedFolder struct { + Client *go_plugin.Client + SyncedFolder vagrant.SyncedFolder +} + +type VagrantPlugin struct { + Providers map[string]*RemoteProvider + SyncedFolders map[string]*RemoteSyncedFolder + PluginDirectories []string + Logger hclog.Logger +} + +func (v *VagrantPlugin) LoadPlugins(pluginPath string) error { + for _, p := range v.PluginDirectories { + if p == pluginPath { + v.Logger.Error("plugin directory path already loaded", "path", pluginPath) + return errors.New("plugin directory already loaded") + } + } + v.PluginDirectories = append(v.PluginDirectories, pluginPath) + if err := v.LoadProviders(pluginPath); err != nil { + return err + } + if err := v.LoadSyncedFolders(pluginPath); err != nil { + return err + } + return nil +} + +func (v *VagrantPlugin) LoadProviders(pluginPath string) error { + providerPaths, err := go_plugin.Discover("*_provider", pluginPath) + if err != nil { + v.Logger.Error("error during plugin discovery", "type", "provider", + "error", err, "path", pluginPath) + return err + } + for _, providerPath := range providerPaths { + v.Logger.Info("loading provider plugin", "path", providerPath) + + client := go_plugin.NewClient(&go_plugin.ClientConfig{ + AllowedProtocols: []go_plugin.Protocol{go_plugin.ProtocolGRPC}, + Logger: v.Logger, + HandshakeConfig: go_plugin.HandshakeConfig{ + MagicCookieKey: "BASIC_PLUGIN", + MagicCookieValue: "hello", + ProtocolVersion: 1, + }, + Cmd: exec.Command(providerPath), + VersionedPlugins: map[int]go_plugin.PluginSet{ + 2: {"provider": &ProviderPlugin{}}}}) + gclient, err := client.Client() + if err != nil { + v.Logger.Error("error loading provider client", "error", err, "path", providerPath) + return err + } + raw, err := gclient.Dispense("provider") + if err != nil { + v.Logger.Error("error loading provider plugin", "error", err, "path", providerPath) + return err + } + prov := raw.(Provider) + n := prov.Name() + v.Providers[n] = &RemoteProvider{ + Client: client, + Provider: prov} + v.Logger.Info("plugin loaded", "type", "provider", "name", n, "path", providerPath) + go v.StreamIO("stdout", prov, n, "provider") + go v.StreamIO("stderr", prov, n, "provider") + } + return nil +} + +func (v *VagrantPlugin) LoadSyncedFolders(pluginPath string) error { + folderPaths, err := go_plugin.Discover("*_synced_folder", pluginPath) + if err != nil { + v.Logger.Error("error during plugin discovery", "type", "synced_folder", + "error", err, "path", pluginPath) + return err + } + for _, folderPath := range folderPaths { + v.Logger.Info("loading synced_folder plugin", "path", folderPath) + + client := go_plugin.NewClient(&go_plugin.ClientConfig{ + AllowedProtocols: []go_plugin.Protocol{go_plugin.ProtocolGRPC}, + Logger: v.Logger, + HandshakeConfig: go_plugin.HandshakeConfig{ + MagicCookieKey: "BASIC_PLUGIN", + MagicCookieValue: "hello", + ProtocolVersion: 1, + }, + Cmd: exec.Command(folderPath), + VersionedPlugins: map[int]go_plugin.PluginSet{ + 2: {"synced_folders": &SyncedFolderPlugin{}}}}) + gclient, err := client.Client() + if err != nil { + v.Logger.Error("error loading synced_folder client", "error", err, "path", folderPath) + return err + } + raw, err := gclient.Dispense("synced_folder") + if err != nil { + v.Logger.Error("error loading synced_folder plugin", "error", err, "path", folderPath) + return err + } + fold := raw.(SyncedFolder) + n := fold.Name() + v.SyncedFolders[n] = &RemoteSyncedFolder{ + Client: client, + SyncedFolder: fold} + v.Logger.Info("plugin loaded", "type", "synced_folder", "name", n, "path", folderPath) + go v.StreamIO("stdout", fold, n, "synced_folder") + go v.StreamIO("stderr", fold, n, "synced_folder") + } + return nil +} + +func (v *VagrantPlugin) StreamIO(target string, i vagrant.IOServer, name, kind string) { + v.Logger.Info("starting plugin IO streaming", "target", target, "plugin", name, "type", kind) + for { + str, err := i.Read(target) + if err != nil { + v.Logger.Error("plugin IO streaming failure", "target", target, "plugin", name, + "type", kind, "error", err) + break + } + v.Logger.Debug("received plugin IO content", "target", target, "plugin", name, + "type", kind, "content", str) + if target == "stdout" { + os.Stdout.Write([]byte(str)) + } else if target == "stderr" { + os.Stderr.Write([]byte(str)) + } + } + v.Logger.Info("completed plugin IO streaming", "target", target, "plugin", name, "type", kind) +} + +func (v *VagrantPlugin) Kill() { + v.Logger.Debug("killing all running plugins") + for n, p := range v.Providers { + v.Logger.Debug("killing plugin", "name", n, "type", "provider") + p.Client.Kill() + v.Logger.Info("plugin killed", "name", n, "type", "provider") + } + for n, p := range v.SyncedFolders { + v.Logger.Debug("killing plugin", "name", n, "type", "synced_folder") + p.Client.Kill() + v.Logger.Info("plugin killed", "name", n, "type", "synced_folder") + } +} diff --git a/ext/go-plugin/vagrant/plugin/capabilities.go b/ext/go-plugin/vagrant/plugin/capabilities.go new file mode 100644 index 000000000..b4ca6bdf9 --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/capabilities.go @@ -0,0 +1,291 @@ +package plugin + +import ( + "context" + "encoding/json" + "errors" + + go_plugin "github.com/hashicorp/go-plugin" + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant" + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_caps" + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_common" +) + +type GuestCapabilities interface { + vagrant.GuestCapabilities + Meta +} + +type GuestCapabilitiesPlugin struct { + go_plugin.NetRPCUnsupportedPlugin + Impl GuestCapabilities +} + +type GRPCGuestCapabilitiesServer struct { + GRPCIOServer + Impl GuestCapabilities +} + +func (s *GRPCGuestCapabilitiesServer) GuestCapabilities(ctx context.Context, req *vagrant_common.NullRequest) (resp *vagrant_caps.CapabilitiesResponse, err error) { + resp = &vagrant_caps.CapabilitiesResponse{} + r, e := s.Impl.GuestCapabilities() + if e != nil { + resp.Error = e.Error() + return + } + for _, cap := range r { + rcap := &vagrant_caps.Capability{Name: cap.Name, Platform: cap.Platform} + resp.Capabilities = append(resp.Capabilities, rcap) + } + return +} + +func (s *GRPCGuestCapabilitiesServer) GuestCapability(ctx context.Context, req *vagrant_caps.GuestCapabilityRequest) (resp *vagrant_caps.GuestCapabilityResponse, err error) { + resp = &vagrant_caps.GuestCapabilityResponse{} + var args interface{} + err = json.Unmarshal([]byte(req.Arguments), args) + if err != nil { + return + } + machine, err := vagrant.LoadMachine(req.Machine, s.Impl) + if err != nil { + return + } + cap := &vagrant.SystemCapability{ + Name: req.Capability.Name, + Platform: req.Capability.Platform} + r, err := s.Impl.GuestCapability(cap, args, machine) + if err != nil { + return + } + result, err := json.Marshal(r) + if err != nil { + return + } + resp.Result = string(result) + return +} + +type GRPCGuestCapabilitiesClient struct { + client vagrant_caps.GuestCapabilitiesClient +} + +func (c *GRPCGuestCapabilitiesClient) GuestCapabilities() (caps []vagrant.SystemCapability, err error) { + resp, err := c.client.GuestCapabilities(context.Background(), &vagrant_common.NullRequest{}) + if err != nil { + return + } + if resp.Error != "" { + err = errors.New(resp.Error) + return + } + caps = make([]vagrant.SystemCapability, len(resp.Capabilities)) + for i := 0; i < len(resp.Capabilities); i++ { + cap := vagrant.SystemCapability{ + Name: resp.Capabilities[i].Name, + Platform: resp.Capabilities[i].Platform} + caps[i] = cap + } + return +} + +func (c *GRPCGuestCapabilitiesClient) GuestCapability(cap *vagrant.SystemCapability, args interface{}, machine *vagrant.Machine) (result interface{}, err error) { + a, err := json.Marshal(args) + if err != nil { + return + } + m, err := vagrant.DumpMachine(machine) + if err != nil { + return + } + resp, err := c.client.GuestCapability(context.Background(), &vagrant_caps.GuestCapabilityRequest{ + Capability: &vagrant_caps.Capability{Name: cap.Name, Platform: cap.Platform}, + Machine: m, + Arguments: string(a)}) + err = json.Unmarshal([]byte(resp.Result), &result) + return +} + +type HostCapabilities interface { + vagrant.HostCapabilities + Meta +} + +type GRPCHostCapabilitiesServer struct { + GRPCIOServer + Impl HostCapabilities +} + +func (s *GRPCHostCapabilitiesServer) HostCapabilities(ctx context.Context, req *vagrant_common.NullRequest) (resp *vagrant_caps.CapabilitiesResponse, err error) { + resp = &vagrant_caps.CapabilitiesResponse{} + r, e := s.Impl.HostCapabilities() + if e != nil { + resp.Error = e.Error() + return + } + for _, cap := range r { + rcap := &vagrant_caps.Capability{Name: cap.Name, Platform: cap.Platform} + resp.Capabilities = append(resp.Capabilities, rcap) + } + return +} + +func (s *GRPCHostCapabilitiesServer) HostCapability(ctx context.Context, req *vagrant_caps.HostCapabilityRequest) (resp *vagrant_caps.HostCapabilityResponse, err error) { + resp = &vagrant_caps.HostCapabilityResponse{} + var args interface{} + err = json.Unmarshal([]byte(req.Arguments), args) + if err != nil { + return + } + env, err := vagrant.LoadEnvironment(req.Environment, s.Impl) + if err != nil { + return + } + cap := &vagrant.SystemCapability{ + Name: req.Capability.Name, + Platform: req.Capability.Platform} + r, err := s.Impl.HostCapability(cap, args, env) + if err != nil { + return + } + result, err := json.Marshal(r) + if err != nil { + return + } + resp.Result = string(result) + return +} + +type GRPCHostCapabilitiesClient struct { + client vagrant_caps.HostCapabilitiesClient +} + +func (c *GRPCHostCapabilitiesClient) HostCapabilities() (caps []vagrant.SystemCapability, err error) { + resp, err := c.client.HostCapabilities(context.Background(), &vagrant_common.NullRequest{}) + if err != nil { + return + } + if resp.Error != "" { + err = errors.New(resp.Error) + return + } + caps = make([]vagrant.SystemCapability, len(resp.Capabilities)) + for i := 0; i < len(resp.Capabilities); i++ { + cap := vagrant.SystemCapability{ + Name: resp.Capabilities[i].Name, + Platform: resp.Capabilities[i].Platform} + caps[i] = cap + } + return +} + +func (c *GRPCHostCapabilitiesClient) HostCapability(cap *vagrant.SystemCapability, args interface{}, env *vagrant.Environment) (result interface{}, err error) { + a, err := json.Marshal(args) + if err != nil { + return + } + e, err := vagrant.DumpEnvironment(env) + if err != nil { + return + } + resp, err := c.client.HostCapability(context.Background(), &vagrant_caps.HostCapabilityRequest{ + Capability: &vagrant_caps.Capability{ + Name: cap.Name, + Platform: cap.Platform}, + Environment: e, + Arguments: string(a)}) + err = json.Unmarshal([]byte(resp.Result), &result) + return +} + +type ProviderCapabilities interface { + vagrant.ProviderCapabilities + Meta +} + +type GRPCProviderCapabilitiesServer struct { + GRPCIOServer + Impl ProviderCapabilities +} + +func (s *GRPCProviderCapabilitiesServer) ProviderCapabilities(ctx context.Context, req *vagrant_common.NullRequest) (resp *vagrant_caps.ProviderCapabilitiesResponse, err error) { + resp = &vagrant_caps.ProviderCapabilitiesResponse{} + r, e := s.Impl.ProviderCapabilities() + if e != nil { + resp.Error = e.Error() + return + } + for _, cap := range r { + rcap := &vagrant_caps.ProviderCapability{Name: cap.Name, Provider: cap.Provider} + resp.Capabilities = append(resp.Capabilities, rcap) + } + return +} + +func (s *GRPCProviderCapabilitiesServer) ProviderCapability(ctx context.Context, req *vagrant_caps.ProviderCapabilityRequest) (resp *vagrant_caps.ProviderCapabilityResponse, err error) { + resp = &vagrant_caps.ProviderCapabilityResponse{} + var args interface{} + err = json.Unmarshal([]byte(req.Arguments), args) + if err != nil { + return + } + m, err := vagrant.LoadMachine(req.Machine, s.Impl) + if err != nil { + return + } + cap := &vagrant.ProviderCapability{ + Name: req.Capability.Name, + Provider: req.Capability.Provider} + r, err := s.Impl.ProviderCapability(cap, args, m) + if err != nil { + return + } + result, err := json.Marshal(r) + if err != nil { + return + } + resp.Result = string(result) + return +} + +type GRPCProviderCapabilitiesClient struct { + client vagrant_caps.ProviderCapabilitiesClient +} + +func (c *GRPCProviderCapabilitiesClient) ProviderCapabilities() (caps []vagrant.ProviderCapability, err error) { + resp, err := c.client.ProviderCapabilities(context.Background(), &vagrant_common.NullRequest{}) + if err != nil { + return + } + if resp.Error != "" { + err = errors.New(resp.Error) + return + } + caps = make([]vagrant.ProviderCapability, len(resp.Capabilities)) + for i := 0; i < len(resp.Capabilities); i++ { + cap := vagrant.ProviderCapability{ + Name: resp.Capabilities[i].Name, + Provider: resp.Capabilities[i].Provider} + caps[i] = cap + } + return +} + +func (c *GRPCProviderCapabilitiesClient) ProviderCapability(cap *vagrant.ProviderCapability, args interface{}, machine *vagrant.Machine) (result interface{}, err error) { + a, err := json.Marshal(args) + if err != nil { + return + } + m, err := vagrant.DumpMachine(machine) + if err != nil { + return + } + resp, err := c.client.ProviderCapability(context.Background(), &vagrant_caps.ProviderCapabilityRequest{ + Capability: &vagrant_caps.ProviderCapability{ + Name: cap.Name, + Provider: cap.Provider}, + Machine: m, + Arguments: string(a)}) + err = json.Unmarshal([]byte(resp.Result), &result) + return +} diff --git a/ext/go-plugin/vagrant/plugin/config.go b/ext/go-plugin/vagrant/plugin/config.go new file mode 100644 index 000000000..596b19d33 --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/config.go @@ -0,0 +1,179 @@ +package plugin + +import ( + "context" + "encoding/json" + "errors" + + go_plugin "github.com/hashicorp/go-plugin" + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant" + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_common" + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_config" +) + +type Config interface { + vagrant.Config + Meta +} + +type ConfigPlugin struct { + go_plugin.NetRPCUnsupportedPlugin + Impl Config +} + +type GRPCConfigServer struct { + GRPCIOServer + Impl Config +} + +func (s *GRPCConfigServer) ConfigAttributes(ctx context.Context, req *vagrant_common.NullRequest) (resp *vagrant_config.AttributesResponse, err error) { + resp = &vagrant_config.AttributesResponse{} + r, e := s.Impl.ConfigAttributes() + if e != nil { + resp.Error = e.Error() + return + } + resp.Attributes = r + return +} + +func (s *GRPCConfigServer) ConfigLoad(ctx context.Context, req *vagrant_config.LoadRequest) (resp *vagrant_config.LoadResponse, err error) { + resp = &vagrant_config.LoadResponse{} + var data map[string]interface{} + err = json.Unmarshal([]byte(req.Data), &data) + if err != nil { + resp.Error = err.Error() + return + } + r, err := s.Impl.ConfigLoad(data) + if err != nil { + resp.Error = err.Error() + return + } + mdata, err := json.Marshal(r) + if err != nil { + resp.Error = err.Error() + return + } + resp.Data = string(mdata) + return +} + +func (s *GRPCConfigServer) ConfigValidate(ctx context.Context, req *vagrant_config.ValidateRequest) (resp *vagrant_config.ValidateResponse, err error) { + resp = &vagrant_config.ValidateResponse{} + var data map[string]interface{} + err = json.Unmarshal([]byte(req.Data), &data) + if err != nil { + resp.Error = err.Error() + return + } + m, err := vagrant.LoadMachine(req.Machine, s.Impl) + if err != nil { + resp.Error = err.Error() + return + } + r, err := s.Impl.ConfigValidate(data, m) + if err != nil { + resp.Error = err.Error() + return + } + resp.Errors = r + return +} + +func (s *GRPCConfigServer) ConfigFinalize(ctx context.Context, req *vagrant_config.FinalizeRequest) (resp *vagrant_config.FinalizeResponse, err error) { + resp = &vagrant_config.FinalizeResponse{} + var data map[string]interface{} + err = json.Unmarshal([]byte(req.Data), &data) + if err != nil { + resp.Error = err.Error() + return + } + r, err := s.Impl.ConfigFinalize(data) + if err != nil { + resp.Error = err.Error() + return + } + mdata, err := json.Marshal(r) + if err != nil { + resp.Error = err.Error() + return + } + resp.Data = string(mdata) + return +} + +type GRPCConfigClient struct { + client vagrant_config.ConfigClient +} + +func (c *GRPCConfigClient) ConfigAttributes() (attrs []string, err error) { + resp, err := c.client.ConfigAttributes(context.Background(), &vagrant_common.NullRequest{}) + if err != nil { + return + } + if resp.Error != "" { + err = errors.New(resp.Error) + } + attrs = resp.Attributes + return +} + +func (c *GRPCConfigClient) ConfigLoad(data map[string]interface{}) (loaddata map[string]interface{}, err error) { + mdata, err := json.Marshal(data) + if err != nil { + return + } + resp, err := c.client.ConfigLoad(context.Background(), &vagrant_config.LoadRequest{ + Data: string(mdata)}) + if err != nil { + return + } + if resp.Error != "" { + err = errors.New(resp.Error) + return + } + err = json.Unmarshal([]byte(resp.Data), &loaddata) + return +} + +func (c *GRPCConfigClient) ConfigValidate(data map[string]interface{}, m *vagrant.Machine) (errs []string, err error) { + machData, err := vagrant.DumpMachine(m) + if err != nil { + return + } + mdata, err := json.Marshal(data) + if err != nil { + return + } + resp, err := c.client.ConfigValidate(context.Background(), &vagrant_config.ValidateRequest{ + Data: string(mdata), + Machine: machData}) + if err != nil { + return + } + if resp.Error != "" { + err = errors.New(resp.Error) + return + } + errs = resp.Errors + return +} + +func (c *GRPCConfigClient) ConfigFinalize(data map[string]interface{}) (finaldata map[string]interface{}, err error) { + mdata, err := json.Marshal(data) + if err != nil { + return + } + resp, err := c.client.ConfigFinalize(context.Background(), &vagrant_config.FinalizeRequest{ + Data: string(mdata)}) + if err != nil { + return + } + if resp.Error != "" { + err = errors.New(resp.Error) + return + } + err = json.Unmarshal([]byte(resp.Data), &finaldata) + return +} diff --git a/ext/go-plugin/vagrant/plugin/io.go b/ext/go-plugin/vagrant/plugin/io.go new file mode 100644 index 000000000..ff2f199bd --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/io.go @@ -0,0 +1,79 @@ +package plugin + +import ( + "context" + "errors" + + "google.golang.org/grpc" + + go_plugin "github.com/hashicorp/go-plugin" + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant" + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_io" +) + +type IOPlugin struct { + go_plugin.NetRPCUnsupportedPlugin + Impl vagrant.StreamIO +} + +type GRPCIOServer struct { + Impl vagrant.StreamIO +} + +func (s *GRPCIOServer) Read(ctx context.Context, req *vagrant_io.ReadRequest) (*vagrant_io.ReadResponse, error) { + r, e := s.Impl.Read(req.Target) + result := &vagrant_io.ReadResponse{Content: r} + if e != nil { + result.Error = e.Error() + } + return result, nil +} + +func (s *GRPCIOServer) Write(ctx context.Context, req *vagrant_io.WriteRequest) (*vagrant_io.WriteResponse, error) { + n, e := s.Impl.Write(req.Content, req.Target) + result := &vagrant_io.WriteResponse{Length: int32(n)} + if e != nil { + result.Error = e.Error() + } + return result, nil +} + +type GRPCIOClient struct { + client vagrant_io.IOClient +} + +func (c *GRPCIOClient) Read(target string) (content string, err error) { + resp, err := c.client.Read(context.Background(), &vagrant_io.ReadRequest{ + Target: target}) + if err != nil { + return + } + if resp.Error != "" { + err = errors.New(resp.Error) + } + content = resp.Content + return +} + +func (c *GRPCIOClient) Write(content, target string) (length int, err error) { + resp, err := c.client.Write(context.Background(), &vagrant_io.WriteRequest{ + Content: content, + Target: target}) + if err != nil { + return + } + if resp.Error != "" { + err = errors.New(resp.Error) + } + length = int(resp.Length) + return +} + +func (i *IOPlugin) GRPCServer(broker *go_plugin.GRPCBroker, s *grpc.Server) error { + vagrant_io.RegisterIOServer(s, &GRPCIOServer{Impl: i.Impl}) + return nil +} + +func (i *IOPlugin) GRPCClient(ctx context.Context, broker *go_plugin.GRPCBroker, c *grpc.ClientConn) (interface{}, error) { + return &GRPCIOClient{client: vagrant_io.NewIOClient(c)}, nil +} diff --git a/ext/go-plugin/vagrant/plugin/meta.go b/ext/go-plugin/vagrant/plugin/meta.go new file mode 100644 index 000000000..e060af343 --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/meta.go @@ -0,0 +1,39 @@ +package plugin + +import ( + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant" +) + +type Meta interface { + Init() + vagrant.IOServer +} + +type GRPCCoreClient struct{} + +func (c *GRPCCoreClient) Init() {} +func (c *GRPCCoreClient) Streams() (s map[string]chan (string)) { return } + +type Core struct { + vagrant.IOServer + io vagrant.StreamIO +} + +func (c *Core) Init() { + if c.io == nil { + c.io = &vagrant.IOSrv{ + map[string]chan (string){ + "stdout": make(chan string), + "stderr": make(chan string), + }, + } + } +} + +func (c *Core) Read(target string) (string, error) { + return c.io.Read(target) +} + +func (c *Core) Write(content, target string) (int, error) { + return c.io.Write(content, target) +} diff --git a/ext/go-plugin/vagrant/plugin/proto/genproto b/ext/go-plugin/vagrant/plugin/proto/genproto new file mode 100755 index 000000000..c0503d8b1 --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/proto/genproto @@ -0,0 +1,12 @@ +#!/usr/bin/env bash + +echo -n "Parsing proto files and generating go output... " + +for i in * +do + if [ -d "${i}" ]; then + protoc --proto_path=/home/spox/.go/src --proto_path=. --go_out=plugins=grpc:. "${i}"/*.proto; + fi +done + +echo "done!" diff --git a/ext/go-plugin/vagrant/plugin/proto/vagrant_caps/capabilities.pb.go b/ext/go-plugin/vagrant/plugin/proto/vagrant_caps/capabilities.pb.go new file mode 100644 index 000000000..6674130c9 --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/proto/vagrant_caps/capabilities.pb.go @@ -0,0 +1,859 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: vagrant_caps/capabilities.proto + +package vagrant_caps + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import vagrant_common "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_common" + +import ( + context "golang.org/x/net/context" + grpc "google.golang.org/grpc" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + +type Capability struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Platform string `protobuf:"bytes,2,opt,name=platform,proto3" json:"platform,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Capability) Reset() { *m = Capability{} } +func (m *Capability) String() string { return proto.CompactTextString(m) } +func (*Capability) ProtoMessage() {} +func (*Capability) Descriptor() ([]byte, []int) { + return fileDescriptor_591a3013bd09a9cb, []int{0} +} +func (m *Capability) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Capability.Unmarshal(m, b) +} +func (m *Capability) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Capability.Marshal(b, m, deterministic) +} +func (m *Capability) XXX_Merge(src proto.Message) { + xxx_messageInfo_Capability.Merge(m, src) +} +func (m *Capability) XXX_Size() int { + return xxx_messageInfo_Capability.Size(m) +} +func (m *Capability) XXX_DiscardUnknown() { + xxx_messageInfo_Capability.DiscardUnknown(m) +} + +var xxx_messageInfo_Capability proto.InternalMessageInfo + +func (m *Capability) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *Capability) GetPlatform() string { + if m != nil { + return m.Platform + } + return "" +} + +type ProviderCapability struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Provider string `protobuf:"bytes,2,opt,name=provider,proto3" json:"provider,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ProviderCapability) Reset() { *m = ProviderCapability{} } +func (m *ProviderCapability) String() string { return proto.CompactTextString(m) } +func (*ProviderCapability) ProtoMessage() {} +func (*ProviderCapability) Descriptor() ([]byte, []int) { + return fileDescriptor_591a3013bd09a9cb, []int{1} +} +func (m *ProviderCapability) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ProviderCapability.Unmarshal(m, b) +} +func (m *ProviderCapability) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ProviderCapability.Marshal(b, m, deterministic) +} +func (m *ProviderCapability) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProviderCapability.Merge(m, src) +} +func (m *ProviderCapability) XXX_Size() int { + return xxx_messageInfo_ProviderCapability.Size(m) +} +func (m *ProviderCapability) XXX_DiscardUnknown() { + xxx_messageInfo_ProviderCapability.DiscardUnknown(m) +} + +var xxx_messageInfo_ProviderCapability proto.InternalMessageInfo + +func (m *ProviderCapability) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *ProviderCapability) GetProvider() string { + if m != nil { + return m.Provider + } + return "" +} + +type ProviderCapabilitiesResponse struct { + Capabilities []*ProviderCapability `protobuf:"bytes,1,rep,name=capabilities,proto3" json:"capabilities,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ProviderCapabilitiesResponse) Reset() { *m = ProviderCapabilitiesResponse{} } +func (m *ProviderCapabilitiesResponse) String() string { return proto.CompactTextString(m) } +func (*ProviderCapabilitiesResponse) ProtoMessage() {} +func (*ProviderCapabilitiesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_591a3013bd09a9cb, []int{2} +} +func (m *ProviderCapabilitiesResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ProviderCapabilitiesResponse.Unmarshal(m, b) +} +func (m *ProviderCapabilitiesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ProviderCapabilitiesResponse.Marshal(b, m, deterministic) +} +func (m *ProviderCapabilitiesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProviderCapabilitiesResponse.Merge(m, src) +} +func (m *ProviderCapabilitiesResponse) XXX_Size() int { + return xxx_messageInfo_ProviderCapabilitiesResponse.Size(m) +} +func (m *ProviderCapabilitiesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ProviderCapabilitiesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ProviderCapabilitiesResponse proto.InternalMessageInfo + +func (m *ProviderCapabilitiesResponse) GetCapabilities() []*ProviderCapability { + if m != nil { + return m.Capabilities + } + return nil +} + +func (m *ProviderCapabilitiesResponse) GetError() string { + if m != nil { + return m.Error + } + return "" +} + +type ProviderCapabilityRequest struct { + Capability *ProviderCapability `protobuf:"bytes,1,opt,name=capability,proto3" json:"capability,omitempty"` + Machine string `protobuf:"bytes,2,opt,name=machine,proto3" json:"machine,omitempty"` + Arguments string `protobuf:"bytes,3,opt,name=arguments,proto3" json:"arguments,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ProviderCapabilityRequest) Reset() { *m = ProviderCapabilityRequest{} } +func (m *ProviderCapabilityRequest) String() string { return proto.CompactTextString(m) } +func (*ProviderCapabilityRequest) ProtoMessage() {} +func (*ProviderCapabilityRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_591a3013bd09a9cb, []int{3} +} +func (m *ProviderCapabilityRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ProviderCapabilityRequest.Unmarshal(m, b) +} +func (m *ProviderCapabilityRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ProviderCapabilityRequest.Marshal(b, m, deterministic) +} +func (m *ProviderCapabilityRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProviderCapabilityRequest.Merge(m, src) +} +func (m *ProviderCapabilityRequest) XXX_Size() int { + return xxx_messageInfo_ProviderCapabilityRequest.Size(m) +} +func (m *ProviderCapabilityRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ProviderCapabilityRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ProviderCapabilityRequest proto.InternalMessageInfo + +func (m *ProviderCapabilityRequest) GetCapability() *ProviderCapability { + if m != nil { + return m.Capability + } + return nil +} + +func (m *ProviderCapabilityRequest) GetMachine() string { + if m != nil { + return m.Machine + } + return "" +} + +func (m *ProviderCapabilityRequest) GetArguments() string { + if m != nil { + return m.Arguments + } + return "" +} + +type ProviderCapabilityResponse struct { + Result string `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ProviderCapabilityResponse) Reset() { *m = ProviderCapabilityResponse{} } +func (m *ProviderCapabilityResponse) String() string { return proto.CompactTextString(m) } +func (*ProviderCapabilityResponse) ProtoMessage() {} +func (*ProviderCapabilityResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_591a3013bd09a9cb, []int{4} +} +func (m *ProviderCapabilityResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ProviderCapabilityResponse.Unmarshal(m, b) +} +func (m *ProviderCapabilityResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ProviderCapabilityResponse.Marshal(b, m, deterministic) +} +func (m *ProviderCapabilityResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProviderCapabilityResponse.Merge(m, src) +} +func (m *ProviderCapabilityResponse) XXX_Size() int { + return xxx_messageInfo_ProviderCapabilityResponse.Size(m) +} +func (m *ProviderCapabilityResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ProviderCapabilityResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ProviderCapabilityResponse proto.InternalMessageInfo + +func (m *ProviderCapabilityResponse) GetResult() string { + if m != nil { + return m.Result + } + return "" +} + +func (m *ProviderCapabilityResponse) GetError() string { + if m != nil { + return m.Error + } + return "" +} + +type CapabilitiesResponse struct { + Capabilities []*Capability `protobuf:"bytes,1,rep,name=capabilities,proto3" json:"capabilities,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CapabilitiesResponse) Reset() { *m = CapabilitiesResponse{} } +func (m *CapabilitiesResponse) String() string { return proto.CompactTextString(m) } +func (*CapabilitiesResponse) ProtoMessage() {} +func (*CapabilitiesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_591a3013bd09a9cb, []int{5} +} +func (m *CapabilitiesResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CapabilitiesResponse.Unmarshal(m, b) +} +func (m *CapabilitiesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CapabilitiesResponse.Marshal(b, m, deterministic) +} +func (m *CapabilitiesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_CapabilitiesResponse.Merge(m, src) +} +func (m *CapabilitiesResponse) XXX_Size() int { + return xxx_messageInfo_CapabilitiesResponse.Size(m) +} +func (m *CapabilitiesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_CapabilitiesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_CapabilitiesResponse proto.InternalMessageInfo + +func (m *CapabilitiesResponse) GetCapabilities() []*Capability { + if m != nil { + return m.Capabilities + } + return nil +} + +func (m *CapabilitiesResponse) GetError() string { + if m != nil { + return m.Error + } + return "" +} + +type GuestCapabilityRequest struct { + Capability *Capability `protobuf:"bytes,1,opt,name=capability,proto3" json:"capability,omitempty"` + Machine string `protobuf:"bytes,2,opt,name=machine,proto3" json:"machine,omitempty"` + Arguments string `protobuf:"bytes,3,opt,name=arguments,proto3" json:"arguments,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GuestCapabilityRequest) Reset() { *m = GuestCapabilityRequest{} } +func (m *GuestCapabilityRequest) String() string { return proto.CompactTextString(m) } +func (*GuestCapabilityRequest) ProtoMessage() {} +func (*GuestCapabilityRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_591a3013bd09a9cb, []int{6} +} +func (m *GuestCapabilityRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GuestCapabilityRequest.Unmarshal(m, b) +} +func (m *GuestCapabilityRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GuestCapabilityRequest.Marshal(b, m, deterministic) +} +func (m *GuestCapabilityRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GuestCapabilityRequest.Merge(m, src) +} +func (m *GuestCapabilityRequest) XXX_Size() int { + return xxx_messageInfo_GuestCapabilityRequest.Size(m) +} +func (m *GuestCapabilityRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GuestCapabilityRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GuestCapabilityRequest proto.InternalMessageInfo + +func (m *GuestCapabilityRequest) GetCapability() *Capability { + if m != nil { + return m.Capability + } + return nil +} + +func (m *GuestCapabilityRequest) GetMachine() string { + if m != nil { + return m.Machine + } + return "" +} + +func (m *GuestCapabilityRequest) GetArguments() string { + if m != nil { + return m.Arguments + } + return "" +} + +type GuestCapabilityResponse struct { + Result string `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GuestCapabilityResponse) Reset() { *m = GuestCapabilityResponse{} } +func (m *GuestCapabilityResponse) String() string { return proto.CompactTextString(m) } +func (*GuestCapabilityResponse) ProtoMessage() {} +func (*GuestCapabilityResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_591a3013bd09a9cb, []int{7} +} +func (m *GuestCapabilityResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GuestCapabilityResponse.Unmarshal(m, b) +} +func (m *GuestCapabilityResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GuestCapabilityResponse.Marshal(b, m, deterministic) +} +func (m *GuestCapabilityResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GuestCapabilityResponse.Merge(m, src) +} +func (m *GuestCapabilityResponse) XXX_Size() int { + return xxx_messageInfo_GuestCapabilityResponse.Size(m) +} +func (m *GuestCapabilityResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GuestCapabilityResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_GuestCapabilityResponse proto.InternalMessageInfo + +func (m *GuestCapabilityResponse) GetResult() string { + if m != nil { + return m.Result + } + return "" +} + +func (m *GuestCapabilityResponse) GetError() string { + if m != nil { + return m.Error + } + return "" +} + +type HostCapabilityRequest struct { + Capability *Capability `protobuf:"bytes,1,opt,name=capability,proto3" json:"capability,omitempty"` + Environment string `protobuf:"bytes,2,opt,name=environment,proto3" json:"environment,omitempty"` + Arguments string `protobuf:"bytes,3,opt,name=arguments,proto3" json:"arguments,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *HostCapabilityRequest) Reset() { *m = HostCapabilityRequest{} } +func (m *HostCapabilityRequest) String() string { return proto.CompactTextString(m) } +func (*HostCapabilityRequest) ProtoMessage() {} +func (*HostCapabilityRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_591a3013bd09a9cb, []int{8} +} +func (m *HostCapabilityRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_HostCapabilityRequest.Unmarshal(m, b) +} +func (m *HostCapabilityRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_HostCapabilityRequest.Marshal(b, m, deterministic) +} +func (m *HostCapabilityRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_HostCapabilityRequest.Merge(m, src) +} +func (m *HostCapabilityRequest) XXX_Size() int { + return xxx_messageInfo_HostCapabilityRequest.Size(m) +} +func (m *HostCapabilityRequest) XXX_DiscardUnknown() { + xxx_messageInfo_HostCapabilityRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_HostCapabilityRequest proto.InternalMessageInfo + +func (m *HostCapabilityRequest) GetCapability() *Capability { + if m != nil { + return m.Capability + } + return nil +} + +func (m *HostCapabilityRequest) GetEnvironment() string { + if m != nil { + return m.Environment + } + return "" +} + +func (m *HostCapabilityRequest) GetArguments() string { + if m != nil { + return m.Arguments + } + return "" +} + +type HostCapabilityResponse struct { + Result string `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *HostCapabilityResponse) Reset() { *m = HostCapabilityResponse{} } +func (m *HostCapabilityResponse) String() string { return proto.CompactTextString(m) } +func (*HostCapabilityResponse) ProtoMessage() {} +func (*HostCapabilityResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_591a3013bd09a9cb, []int{9} +} +func (m *HostCapabilityResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_HostCapabilityResponse.Unmarshal(m, b) +} +func (m *HostCapabilityResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_HostCapabilityResponse.Marshal(b, m, deterministic) +} +func (m *HostCapabilityResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_HostCapabilityResponse.Merge(m, src) +} +func (m *HostCapabilityResponse) XXX_Size() int { + return xxx_messageInfo_HostCapabilityResponse.Size(m) +} +func (m *HostCapabilityResponse) XXX_DiscardUnknown() { + xxx_messageInfo_HostCapabilityResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_HostCapabilityResponse proto.InternalMessageInfo + +func (m *HostCapabilityResponse) GetResult() string { + if m != nil { + return m.Result + } + return "" +} + +func (m *HostCapabilityResponse) GetError() string { + if m != nil { + return m.Error + } + return "" +} + +func init() { + proto.RegisterType((*Capability)(nil), "vagrant.caps.Capability") + proto.RegisterType((*ProviderCapability)(nil), "vagrant.caps.ProviderCapability") + proto.RegisterType((*ProviderCapabilitiesResponse)(nil), "vagrant.caps.ProviderCapabilitiesResponse") + proto.RegisterType((*ProviderCapabilityRequest)(nil), "vagrant.caps.ProviderCapabilityRequest") + proto.RegisterType((*ProviderCapabilityResponse)(nil), "vagrant.caps.ProviderCapabilityResponse") + proto.RegisterType((*CapabilitiesResponse)(nil), "vagrant.caps.CapabilitiesResponse") + proto.RegisterType((*GuestCapabilityRequest)(nil), "vagrant.caps.GuestCapabilityRequest") + proto.RegisterType((*GuestCapabilityResponse)(nil), "vagrant.caps.GuestCapabilityResponse") + proto.RegisterType((*HostCapabilityRequest)(nil), "vagrant.caps.HostCapabilityRequest") + proto.RegisterType((*HostCapabilityResponse)(nil), "vagrant.caps.HostCapabilityResponse") +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// GuestCapabilitiesClient is the client API for GuestCapabilities service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type GuestCapabilitiesClient interface { + GuestCapabilities(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*CapabilitiesResponse, error) + GuestCapability(ctx context.Context, in *GuestCapabilityRequest, opts ...grpc.CallOption) (*GuestCapabilityResponse, error) +} + +type guestCapabilitiesClient struct { + cc *grpc.ClientConn +} + +func NewGuestCapabilitiesClient(cc *grpc.ClientConn) GuestCapabilitiesClient { + return &guestCapabilitiesClient{cc} +} + +func (c *guestCapabilitiesClient) GuestCapabilities(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*CapabilitiesResponse, error) { + out := new(CapabilitiesResponse) + err := c.cc.Invoke(ctx, "/vagrant.caps.GuestCapabilities/GuestCapabilities", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *guestCapabilitiesClient) GuestCapability(ctx context.Context, in *GuestCapabilityRequest, opts ...grpc.CallOption) (*GuestCapabilityResponse, error) { + out := new(GuestCapabilityResponse) + err := c.cc.Invoke(ctx, "/vagrant.caps.GuestCapabilities/GuestCapability", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// GuestCapabilitiesServer is the server API for GuestCapabilities service. +type GuestCapabilitiesServer interface { + GuestCapabilities(context.Context, *vagrant_common.NullRequest) (*CapabilitiesResponse, error) + GuestCapability(context.Context, *GuestCapabilityRequest) (*GuestCapabilityResponse, error) +} + +func RegisterGuestCapabilitiesServer(s *grpc.Server, srv GuestCapabilitiesServer) { + s.RegisterService(&_GuestCapabilities_serviceDesc, srv) +} + +func _GuestCapabilities_GuestCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.NullRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GuestCapabilitiesServer).GuestCapabilities(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.caps.GuestCapabilities/GuestCapabilities", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GuestCapabilitiesServer).GuestCapabilities(ctx, req.(*vagrant_common.NullRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GuestCapabilities_GuestCapability_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GuestCapabilityRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GuestCapabilitiesServer).GuestCapability(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.caps.GuestCapabilities/GuestCapability", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GuestCapabilitiesServer).GuestCapability(ctx, req.(*GuestCapabilityRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _GuestCapabilities_serviceDesc = grpc.ServiceDesc{ + ServiceName: "vagrant.caps.GuestCapabilities", + HandlerType: (*GuestCapabilitiesServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "GuestCapabilities", + Handler: _GuestCapabilities_GuestCapabilities_Handler, + }, + { + MethodName: "GuestCapability", + Handler: _GuestCapabilities_GuestCapability_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "vagrant_caps/capabilities.proto", +} + +// HostCapabilitiesClient is the client API for HostCapabilities service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type HostCapabilitiesClient interface { + HostCapabilities(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*CapabilitiesResponse, error) + HostCapability(ctx context.Context, in *HostCapabilityRequest, opts ...grpc.CallOption) (*HostCapabilityResponse, error) +} + +type hostCapabilitiesClient struct { + cc *grpc.ClientConn +} + +func NewHostCapabilitiesClient(cc *grpc.ClientConn) HostCapabilitiesClient { + return &hostCapabilitiesClient{cc} +} + +func (c *hostCapabilitiesClient) HostCapabilities(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*CapabilitiesResponse, error) { + out := new(CapabilitiesResponse) + err := c.cc.Invoke(ctx, "/vagrant.caps.HostCapabilities/HostCapabilities", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *hostCapabilitiesClient) HostCapability(ctx context.Context, in *HostCapabilityRequest, opts ...grpc.CallOption) (*HostCapabilityResponse, error) { + out := new(HostCapabilityResponse) + err := c.cc.Invoke(ctx, "/vagrant.caps.HostCapabilities/HostCapability", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// HostCapabilitiesServer is the server API for HostCapabilities service. +type HostCapabilitiesServer interface { + HostCapabilities(context.Context, *vagrant_common.NullRequest) (*CapabilitiesResponse, error) + HostCapability(context.Context, *HostCapabilityRequest) (*HostCapabilityResponse, error) +} + +func RegisterHostCapabilitiesServer(s *grpc.Server, srv HostCapabilitiesServer) { + s.RegisterService(&_HostCapabilities_serviceDesc, srv) +} + +func _HostCapabilities_HostCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.NullRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(HostCapabilitiesServer).HostCapabilities(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.caps.HostCapabilities/HostCapabilities", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(HostCapabilitiesServer).HostCapabilities(ctx, req.(*vagrant_common.NullRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _HostCapabilities_HostCapability_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HostCapabilityRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(HostCapabilitiesServer).HostCapability(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.caps.HostCapabilities/HostCapability", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(HostCapabilitiesServer).HostCapability(ctx, req.(*HostCapabilityRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _HostCapabilities_serviceDesc = grpc.ServiceDesc{ + ServiceName: "vagrant.caps.HostCapabilities", + HandlerType: (*HostCapabilitiesServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "HostCapabilities", + Handler: _HostCapabilities_HostCapabilities_Handler, + }, + { + MethodName: "HostCapability", + Handler: _HostCapabilities_HostCapability_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "vagrant_caps/capabilities.proto", +} + +// ProviderCapabilitiesClient is the client API for ProviderCapabilities service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type ProviderCapabilitiesClient interface { + ProviderCapabilities(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*ProviderCapabilitiesResponse, error) + ProviderCapability(ctx context.Context, in *ProviderCapabilityRequest, opts ...grpc.CallOption) (*ProviderCapabilityResponse, error) +} + +type providerCapabilitiesClient struct { + cc *grpc.ClientConn +} + +func NewProviderCapabilitiesClient(cc *grpc.ClientConn) ProviderCapabilitiesClient { + return &providerCapabilitiesClient{cc} +} + +func (c *providerCapabilitiesClient) ProviderCapabilities(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*ProviderCapabilitiesResponse, error) { + out := new(ProviderCapabilitiesResponse) + err := c.cc.Invoke(ctx, "/vagrant.caps.ProviderCapabilities/ProviderCapabilities", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerCapabilitiesClient) ProviderCapability(ctx context.Context, in *ProviderCapabilityRequest, opts ...grpc.CallOption) (*ProviderCapabilityResponse, error) { + out := new(ProviderCapabilityResponse) + err := c.cc.Invoke(ctx, "/vagrant.caps.ProviderCapabilities/ProviderCapability", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// ProviderCapabilitiesServer is the server API for ProviderCapabilities service. +type ProviderCapabilitiesServer interface { + ProviderCapabilities(context.Context, *vagrant_common.NullRequest) (*ProviderCapabilitiesResponse, error) + ProviderCapability(context.Context, *ProviderCapabilityRequest) (*ProviderCapabilityResponse, error) +} + +func RegisterProviderCapabilitiesServer(s *grpc.Server, srv ProviderCapabilitiesServer) { + s.RegisterService(&_ProviderCapabilities_serviceDesc, srv) +} + +func _ProviderCapabilities_ProviderCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.NullRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderCapabilitiesServer).ProviderCapabilities(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.caps.ProviderCapabilities/ProviderCapabilities", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderCapabilitiesServer).ProviderCapabilities(ctx, req.(*vagrant_common.NullRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ProviderCapabilities_ProviderCapability_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ProviderCapabilityRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderCapabilitiesServer).ProviderCapability(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.caps.ProviderCapabilities/ProviderCapability", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderCapabilitiesServer).ProviderCapability(ctx, req.(*ProviderCapabilityRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _ProviderCapabilities_serviceDesc = grpc.ServiceDesc{ + ServiceName: "vagrant.caps.ProviderCapabilities", + HandlerType: (*ProviderCapabilitiesServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "ProviderCapabilities", + Handler: _ProviderCapabilities_ProviderCapabilities_Handler, + }, + { + MethodName: "ProviderCapability", + Handler: _ProviderCapabilities_ProviderCapability_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "vagrant_caps/capabilities.proto", +} + +func init() { proto.RegisterFile("vagrant_caps/capabilities.proto", fileDescriptor_591a3013bd09a9cb) } + +var fileDescriptor_591a3013bd09a9cb = []byte{ + // 510 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x95, 0xcf, 0x6e, 0xd3, 0x40, + 0x10, 0xc6, 0xb5, 0x14, 0x0a, 0x9d, 0x56, 0xfc, 0x59, 0x85, 0x60, 0x4c, 0x25, 0x22, 0x53, 0x44, + 0x84, 0x84, 0x2d, 0x85, 0x0b, 0x87, 0x1e, 0x90, 0xa8, 0x28, 0xe2, 0x80, 0x50, 0xe0, 0x56, 0x89, + 0x6a, 0x63, 0x16, 0x7b, 0x91, 0xbd, 0x6b, 0x76, 0xd7, 0x11, 0xe5, 0x11, 0xb8, 0x71, 0xe0, 0x8d, + 0xb8, 0xf0, 0x16, 0x3c, 0x0a, 0xb2, 0xbd, 0x71, 0xed, 0x7a, 0x5d, 0x97, 0xd2, 0x53, 0x32, 0x93, + 0x99, 0xf9, 0xe6, 0xfb, 0xd9, 0x9a, 0xc0, 0xfd, 0x25, 0x89, 0x24, 0xe1, 0xfa, 0x30, 0x24, 0x99, + 0x0a, 0x42, 0x92, 0x91, 0x05, 0x4b, 0x98, 0x66, 0x54, 0xf9, 0x99, 0x14, 0x5a, 0xe0, 0x2d, 0x53, + 0xe0, 0x17, 0x05, 0xee, 0x41, 0xc4, 0x74, 0x9c, 0x2f, 0xfc, 0x50, 0xa4, 0x41, 0x4c, 0x54, 0xcc, + 0x42, 0x21, 0xb3, 0xc0, 0x94, 0x04, 0xf4, 0xab, 0x0e, 0x22, 0xf1, 0x24, 0x4b, 0xf2, 0x88, 0xf1, + 0x3a, 0x6b, 0xc2, 0x72, 0x5c, 0x50, 0xcb, 0x89, 0x34, 0x15, 0x3c, 0xa8, 0x3e, 0x2a, 0x29, 0x6f, + 0x17, 0xe0, 0xc5, 0x6a, 0x81, 0x23, 0x8c, 0xe1, 0x32, 0x27, 0x29, 0x75, 0xd0, 0x04, 0x4d, 0x37, + 0xe6, 0xe5, 0x77, 0xec, 0xc2, 0xb5, 0x2c, 0x21, 0xfa, 0x93, 0x90, 0xa9, 0x73, 0xa9, 0xcc, 0xd7, + 0xb1, 0xb7, 0x07, 0xf8, 0xad, 0x14, 0x4b, 0xf6, 0x91, 0xca, 0x33, 0x4c, 0x31, 0x95, 0xf5, 0x14, + 0x13, 0x7b, 0xdf, 0x60, 0xbb, 0x33, 0x85, 0x51, 0x35, 0xa7, 0x2a, 0x13, 0x5c, 0x51, 0xbc, 0x07, + 0x5b, 0x4d, 0x48, 0x0e, 0x9a, 0xac, 0x4d, 0x37, 0x67, 0x13, 0xbf, 0x49, 0xc9, 0xef, 0xee, 0x31, + 0x6f, 0x75, 0xe1, 0x11, 0x5c, 0xa1, 0x52, 0x8a, 0x95, 0x7c, 0x15, 0x78, 0x3f, 0x11, 0xdc, 0xb5, + 0xb4, 0xd2, 0x2f, 0x39, 0x55, 0x1a, 0x3f, 0x07, 0xa8, 0x67, 0x1c, 0x95, 0x7e, 0xce, 0xa2, 0xdb, + 0xe8, 0xc1, 0x0e, 0x5c, 0x4d, 0x49, 0x18, 0x33, 0x4e, 0x8d, 0xee, 0x2a, 0xc4, 0xdb, 0xb0, 0x41, + 0x64, 0x94, 0xa7, 0x94, 0x6b, 0xe5, 0xac, 0x95, 0xbf, 0x1d, 0x27, 0xbc, 0xd7, 0xe0, 0xda, 0xd6, + 0x32, 0x44, 0xc6, 0xb0, 0x2e, 0xa9, 0xca, 0x13, 0x6d, 0x18, 0x9b, 0xa8, 0xc7, 0xe3, 0x67, 0x18, + 0x59, 0xb9, 0xee, 0x5a, 0xb9, 0x3a, 0x6d, 0x7f, 0xff, 0xc8, 0xf3, 0x3b, 0x82, 0xf1, 0x7e, 0xc1, + 0xae, 0x0b, 0xf3, 0x99, 0x05, 0x66, 0xbf, 0xd8, 0x45, 0x40, 0xdc, 0x87, 0x3b, 0x9d, 0x5d, 0xce, + 0x45, 0xf0, 0x07, 0x82, 0xdb, 0xaf, 0xc4, 0xc5, 0x9a, 0x9a, 0xc0, 0x26, 0xe5, 0x4b, 0x26, 0x05, + 0x2f, 0x96, 0x35, 0x7a, 0xcd, 0xd4, 0x80, 0xb9, 0x97, 0x30, 0x3e, 0xb9, 0xd2, 0x79, 0xbc, 0xcd, + 0x7e, 0x23, 0xb8, 0xd5, 0xa6, 0x54, 0x3c, 0xdd, 0xf7, 0xb6, 0xe4, 0xbd, 0x63, 0x63, 0xd5, 0x0d, + 0x79, 0x93, 0x27, 0x89, 0x21, 0xe1, 0x7a, 0x3d, 0xae, 0x9b, 0x6f, 0xdc, 0x07, 0xb8, 0x71, 0xe2, + 0x81, 0xe0, 0x9d, 0x76, 0x9b, 0xfd, 0xdd, 0x71, 0x1f, 0x0e, 0x54, 0x55, 0xf3, 0x67, 0xbf, 0x10, + 0xdc, 0x6c, 0x41, 0x29, 0xb6, 0x7e, 0x67, 0xc9, 0xfd, 0xb7, 0x93, 0x03, 0xb8, 0xde, 0xa6, 0x8f, + 0x1f, 0xb4, 0xbb, 0xac, 0xaf, 0x8b, 0xbb, 0x73, 0x7a, 0x91, 0xb1, 0xf1, 0x07, 0xc1, 0xc8, 0x76, + 0x11, 0xf1, 0x61, 0x4f, 0xfe, 0x54, 0x3b, 0x8f, 0x07, 0x0e, 0x56, 0xd3, 0x56, 0x64, 0x3d, 0xe8, + 0x8f, 0x06, 0x4f, 0x9e, 0x91, 0x9a, 0x0e, 0x17, 0x56, 0x42, 0x8b, 0xf5, 0xf2, 0xef, 0xe7, 0xe9, + 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7b, 0xfc, 0x96, 0xa9, 0x0c, 0x07, 0x00, 0x00, +} diff --git a/ext/go-plugin/vagrant/plugin/proto/vagrant_caps/capabilities.proto b/ext/go-plugin/vagrant/plugin/proto/vagrant_caps/capabilities.proto new file mode 100644 index 000000000..e041c7e5e --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/proto/vagrant_caps/capabilities.proto @@ -0,0 +1,72 @@ +syntax = "proto3"; +package vagrant.caps; + +import "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_common/common.proto"; + +message Capability { + string name = 1; + string platform = 2; +} + +message ProviderCapability { + string name = 1; + string provider = 2; +} + +message ProviderCapabilitiesResponse { + repeated ProviderCapability capabilities = 1; + string error = 2; +} + +message ProviderCapabilityRequest { + ProviderCapability capability = 1; + string machine = 2; + string arguments = 3; +} + +message ProviderCapabilityResponse { + string result = 1; + string error = 2; +} + +message CapabilitiesResponse { + repeated Capability capabilities = 1; + string error = 2; +} + +message GuestCapabilityRequest { + Capability capability = 1; + string machine = 2; + string arguments = 3; +} + +message GuestCapabilityResponse { + string result = 1; + string error = 2; +} + +message HostCapabilityRequest { + Capability capability = 1; + string environment = 2; + string arguments = 3; +} + +message HostCapabilityResponse { + string result = 1; + string error = 2; +} + +service GuestCapabilities { + rpc GuestCapabilities(vagrant.common.NullRequest) returns (CapabilitiesResponse); + rpc GuestCapability(GuestCapabilityRequest) returns (GuestCapabilityResponse); +} + +service HostCapabilities { + rpc HostCapabilities(vagrant.common.NullRequest) returns (CapabilitiesResponse); + rpc HostCapability(HostCapabilityRequest) returns (HostCapabilityResponse); +} + +service ProviderCapabilities { + rpc ProviderCapabilities(vagrant.common.NullRequest) returns (ProviderCapabilitiesResponse); + rpc ProviderCapability(ProviderCapabilityRequest) returns (ProviderCapabilityResponse); +} \ No newline at end of file diff --git a/ext/go-plugin/vagrant/plugin/proto/vagrant_common/common.pb.go b/ext/go-plugin/vagrant/plugin/proto/vagrant_common/common.pb.go new file mode 100644 index 000000000..741b5990e --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/proto/vagrant_common/common.pb.go @@ -0,0 +1,235 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: vagrant_common/common.proto + +package vagrant_common + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + +type NullRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NullRequest) Reset() { *m = NullRequest{} } +func (m *NullRequest) String() string { return proto.CompactTextString(m) } +func (*NullRequest) ProtoMessage() {} +func (*NullRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_86eb89499a7c6603, []int{0} +} +func (m *NullRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NullRequest.Unmarshal(m, b) +} +func (m *NullRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NullRequest.Marshal(b, m, deterministic) +} +func (m *NullRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_NullRequest.Merge(m, src) +} +func (m *NullRequest) XXX_Size() int { + return xxx_messageInfo_NullRequest.Size(m) +} +func (m *NullRequest) XXX_DiscardUnknown() { + xxx_messageInfo_NullRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_NullRequest proto.InternalMessageInfo + +type EmptyRequest struct { + Machine string `protobuf:"bytes,1,opt,name=machine,proto3" json:"machine,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *EmptyRequest) Reset() { *m = EmptyRequest{} } +func (m *EmptyRequest) String() string { return proto.CompactTextString(m) } +func (*EmptyRequest) ProtoMessage() {} +func (*EmptyRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_86eb89499a7c6603, []int{1} +} +func (m *EmptyRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_EmptyRequest.Unmarshal(m, b) +} +func (m *EmptyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_EmptyRequest.Marshal(b, m, deterministic) +} +func (m *EmptyRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_EmptyRequest.Merge(m, src) +} +func (m *EmptyRequest) XXX_Size() int { + return xxx_messageInfo_EmptyRequest.Size(m) +} +func (m *EmptyRequest) XXX_DiscardUnknown() { + xxx_messageInfo_EmptyRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_EmptyRequest proto.InternalMessageInfo + +func (m *EmptyRequest) GetMachine() string { + if m != nil { + return m.Machine + } + return "" +} + +type EmptyResponse struct { + Error string `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *EmptyResponse) Reset() { *m = EmptyResponse{} } +func (m *EmptyResponse) String() string { return proto.CompactTextString(m) } +func (*EmptyResponse) ProtoMessage() {} +func (*EmptyResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_86eb89499a7c6603, []int{2} +} +func (m *EmptyResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_EmptyResponse.Unmarshal(m, b) +} +func (m *EmptyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_EmptyResponse.Marshal(b, m, deterministic) +} +func (m *EmptyResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_EmptyResponse.Merge(m, src) +} +func (m *EmptyResponse) XXX_Size() int { + return xxx_messageInfo_EmptyResponse.Size(m) +} +func (m *EmptyResponse) XXX_DiscardUnknown() { + xxx_messageInfo_EmptyResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_EmptyResponse proto.InternalMessageInfo + +func (m *EmptyResponse) GetError() string { + if m != nil { + return m.Error + } + return "" +} + +type IsResponse struct { + Result bool `protobuf:"varint,1,opt,name=result,proto3" json:"result,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *IsResponse) Reset() { *m = IsResponse{} } +func (m *IsResponse) String() string { return proto.CompactTextString(m) } +func (*IsResponse) ProtoMessage() {} +func (*IsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_86eb89499a7c6603, []int{3} +} +func (m *IsResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_IsResponse.Unmarshal(m, b) +} +func (m *IsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_IsResponse.Marshal(b, m, deterministic) +} +func (m *IsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_IsResponse.Merge(m, src) +} +func (m *IsResponse) XXX_Size() int { + return xxx_messageInfo_IsResponse.Size(m) +} +func (m *IsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_IsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_IsResponse proto.InternalMessageInfo + +func (m *IsResponse) GetResult() bool { + if m != nil { + return m.Result + } + return false +} + +func (m *IsResponse) GetError() string { + if m != nil { + return m.Error + } + return "" +} + +type NameResponse struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NameResponse) Reset() { *m = NameResponse{} } +func (m *NameResponse) String() string { return proto.CompactTextString(m) } +func (*NameResponse) ProtoMessage() {} +func (*NameResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_86eb89499a7c6603, []int{4} +} +func (m *NameResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NameResponse.Unmarshal(m, b) +} +func (m *NameResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NameResponse.Marshal(b, m, deterministic) +} +func (m *NameResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_NameResponse.Merge(m, src) +} +func (m *NameResponse) XXX_Size() int { + return xxx_messageInfo_NameResponse.Size(m) +} +func (m *NameResponse) XXX_DiscardUnknown() { + xxx_messageInfo_NameResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_NameResponse proto.InternalMessageInfo + +func (m *NameResponse) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func init() { + proto.RegisterType((*NullRequest)(nil), "vagrant.common.NullRequest") + proto.RegisterType((*EmptyRequest)(nil), "vagrant.common.EmptyRequest") + proto.RegisterType((*EmptyResponse)(nil), "vagrant.common.EmptyResponse") + proto.RegisterType((*IsResponse)(nil), "vagrant.common.IsResponse") + proto.RegisterType((*NameResponse)(nil), "vagrant.common.NameResponse") +} + +func init() { proto.RegisterFile("vagrant_common/common.proto", fileDescriptor_86eb89499a7c6603) } + +var fileDescriptor_86eb89499a7c6603 = []byte{ + // 178 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2e, 0x4b, 0x4c, 0x2f, + 0x4a, 0xcc, 0x2b, 0x89, 0x4f, 0xce, 0xcf, 0xcd, 0xcd, 0xcf, 0xd3, 0x87, 0x50, 0x7a, 0x05, 0x45, + 0xf9, 0x25, 0xf9, 0x42, 0x7c, 0x50, 0x49, 0x3d, 0x88, 0xa8, 0x12, 0x2f, 0x17, 0xb7, 0x5f, 0x69, + 0x4e, 0x4e, 0x50, 0x6a, 0x61, 0x69, 0x6a, 0x71, 0x89, 0x92, 0x06, 0x17, 0x8f, 0x6b, 0x6e, 0x41, + 0x49, 0x25, 0x94, 0x2f, 0x24, 0xc1, 0xc5, 0x9e, 0x9b, 0x98, 0x9c, 0x91, 0x99, 0x97, 0x2a, 0xc1, + 0xa8, 0xc0, 0xa8, 0xc1, 0x19, 0x04, 0xe3, 0x2a, 0xa9, 0x72, 0xf1, 0x42, 0x55, 0x16, 0x17, 0xe4, + 0xe7, 0x15, 0xa7, 0x0a, 0x89, 0x70, 0xb1, 0xa6, 0x16, 0x15, 0xe5, 0x17, 0x41, 0x15, 0x42, 0x38, + 0x4a, 0x56, 0x5c, 0x5c, 0x9e, 0xc5, 0x70, 0x35, 0x62, 0x5c, 0x6c, 0x45, 0xa9, 0xc5, 0xa5, 0x39, + 0x25, 0x60, 0x45, 0x1c, 0x41, 0x50, 0x1e, 0x42, 0x2f, 0x13, 0xb2, 0x5e, 0x25, 0x2e, 0x1e, 0xbf, + 0xc4, 0xdc, 0x54, 0xb8, 0x6e, 0x21, 0x2e, 0x96, 0xbc, 0xc4, 0x5c, 0x98, 0x4b, 0xc0, 0xec, 0x24, + 0x36, 0xb0, 0xb7, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x02, 0xed, 0x61, 0x90, 0xf5, 0x00, + 0x00, 0x00, +} diff --git a/ext/go-plugin/vagrant/plugin/proto/vagrant_common/common.proto b/ext/go-plugin/vagrant/plugin/proto/vagrant_common/common.proto new file mode 100644 index 000000000..9bf15b58e --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/proto/vagrant_common/common.proto @@ -0,0 +1,19 @@ +syntax = "proto3"; +package vagrant.common; + +message NullRequest {} + +message EmptyRequest { + string machine = 1; +} + +message EmptyResponse { + string error = 1; +} + +message IsResponse { + bool result = 1; + string error = 2; +} + +message NameResponse { string name = 1; } diff --git a/ext/go-plugin/vagrant/plugin/proto/vagrant_config/config.pb.go b/ext/go-plugin/vagrant/plugin/proto/vagrant_config/config.pb.go new file mode 100644 index 000000000..1d138e268 --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/proto/vagrant_config/config.pb.go @@ -0,0 +1,541 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: vagrant_config/config.proto + +package vagrant_config + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import vagrant_common "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_common" + +import ( + context "golang.org/x/net/context" + grpc "google.golang.org/grpc" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + +type AttributesResponse struct { + Attributes []string `protobuf:"bytes,1,rep,name=attributes,proto3" json:"attributes,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AttributesResponse) Reset() { *m = AttributesResponse{} } +func (m *AttributesResponse) String() string { return proto.CompactTextString(m) } +func (*AttributesResponse) ProtoMessage() {} +func (*AttributesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_952629f1a9a7438c, []int{0} +} +func (m *AttributesResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AttributesResponse.Unmarshal(m, b) +} +func (m *AttributesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AttributesResponse.Marshal(b, m, deterministic) +} +func (m *AttributesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_AttributesResponse.Merge(m, src) +} +func (m *AttributesResponse) XXX_Size() int { + return xxx_messageInfo_AttributesResponse.Size(m) +} +func (m *AttributesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_AttributesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_AttributesResponse proto.InternalMessageInfo + +func (m *AttributesResponse) GetAttributes() []string { + if m != nil { + return m.Attributes + } + return nil +} + +func (m *AttributesResponse) GetError() string { + if m != nil { + return m.Error + } + return "" +} + +type LoadRequest struct { + Data string `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *LoadRequest) Reset() { *m = LoadRequest{} } +func (m *LoadRequest) String() string { return proto.CompactTextString(m) } +func (*LoadRequest) ProtoMessage() {} +func (*LoadRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_952629f1a9a7438c, []int{1} +} +func (m *LoadRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_LoadRequest.Unmarshal(m, b) +} +func (m *LoadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_LoadRequest.Marshal(b, m, deterministic) +} +func (m *LoadRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_LoadRequest.Merge(m, src) +} +func (m *LoadRequest) XXX_Size() int { + return xxx_messageInfo_LoadRequest.Size(m) +} +func (m *LoadRequest) XXX_DiscardUnknown() { + xxx_messageInfo_LoadRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_LoadRequest proto.InternalMessageInfo + +func (m *LoadRequest) GetData() string { + if m != nil { + return m.Data + } + return "" +} + +type LoadResponse struct { + Data string `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *LoadResponse) Reset() { *m = LoadResponse{} } +func (m *LoadResponse) String() string { return proto.CompactTextString(m) } +func (*LoadResponse) ProtoMessage() {} +func (*LoadResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_952629f1a9a7438c, []int{2} +} +func (m *LoadResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_LoadResponse.Unmarshal(m, b) +} +func (m *LoadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_LoadResponse.Marshal(b, m, deterministic) +} +func (m *LoadResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_LoadResponse.Merge(m, src) +} +func (m *LoadResponse) XXX_Size() int { + return xxx_messageInfo_LoadResponse.Size(m) +} +func (m *LoadResponse) XXX_DiscardUnknown() { + xxx_messageInfo_LoadResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_LoadResponse proto.InternalMessageInfo + +func (m *LoadResponse) GetData() string { + if m != nil { + return m.Data + } + return "" +} + +func (m *LoadResponse) GetError() string { + if m != nil { + return m.Error + } + return "" +} + +type ValidateRequest struct { + Data string `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` + Machine string `protobuf:"bytes,2,opt,name=machine,proto3" json:"machine,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ValidateRequest) Reset() { *m = ValidateRequest{} } +func (m *ValidateRequest) String() string { return proto.CompactTextString(m) } +func (*ValidateRequest) ProtoMessage() {} +func (*ValidateRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_952629f1a9a7438c, []int{3} +} +func (m *ValidateRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ValidateRequest.Unmarshal(m, b) +} +func (m *ValidateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ValidateRequest.Marshal(b, m, deterministic) +} +func (m *ValidateRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidateRequest.Merge(m, src) +} +func (m *ValidateRequest) XXX_Size() int { + return xxx_messageInfo_ValidateRequest.Size(m) +} +func (m *ValidateRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ValidateRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ValidateRequest proto.InternalMessageInfo + +func (m *ValidateRequest) GetData() string { + if m != nil { + return m.Data + } + return "" +} + +func (m *ValidateRequest) GetMachine() string { + if m != nil { + return m.Machine + } + return "" +} + +type ValidateResponse struct { + Errors []string `protobuf:"bytes,1,rep,name=errors,proto3" json:"errors,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ValidateResponse) Reset() { *m = ValidateResponse{} } +func (m *ValidateResponse) String() string { return proto.CompactTextString(m) } +func (*ValidateResponse) ProtoMessage() {} +func (*ValidateResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_952629f1a9a7438c, []int{4} +} +func (m *ValidateResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ValidateResponse.Unmarshal(m, b) +} +func (m *ValidateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ValidateResponse.Marshal(b, m, deterministic) +} +func (m *ValidateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidateResponse.Merge(m, src) +} +func (m *ValidateResponse) XXX_Size() int { + return xxx_messageInfo_ValidateResponse.Size(m) +} +func (m *ValidateResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ValidateResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ValidateResponse proto.InternalMessageInfo + +func (m *ValidateResponse) GetErrors() []string { + if m != nil { + return m.Errors + } + return nil +} + +func (m *ValidateResponse) GetError() string { + if m != nil { + return m.Error + } + return "" +} + +type FinalizeRequest struct { + Data string `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FinalizeRequest) Reset() { *m = FinalizeRequest{} } +func (m *FinalizeRequest) String() string { return proto.CompactTextString(m) } +func (*FinalizeRequest) ProtoMessage() {} +func (*FinalizeRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_952629f1a9a7438c, []int{5} +} +func (m *FinalizeRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_FinalizeRequest.Unmarshal(m, b) +} +func (m *FinalizeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_FinalizeRequest.Marshal(b, m, deterministic) +} +func (m *FinalizeRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_FinalizeRequest.Merge(m, src) +} +func (m *FinalizeRequest) XXX_Size() int { + return xxx_messageInfo_FinalizeRequest.Size(m) +} +func (m *FinalizeRequest) XXX_DiscardUnknown() { + xxx_messageInfo_FinalizeRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_FinalizeRequest proto.InternalMessageInfo + +func (m *FinalizeRequest) GetData() string { + if m != nil { + return m.Data + } + return "" +} + +type FinalizeResponse struct { + Data string `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FinalizeResponse) Reset() { *m = FinalizeResponse{} } +func (m *FinalizeResponse) String() string { return proto.CompactTextString(m) } +func (*FinalizeResponse) ProtoMessage() {} +func (*FinalizeResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_952629f1a9a7438c, []int{6} +} +func (m *FinalizeResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_FinalizeResponse.Unmarshal(m, b) +} +func (m *FinalizeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_FinalizeResponse.Marshal(b, m, deterministic) +} +func (m *FinalizeResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_FinalizeResponse.Merge(m, src) +} +func (m *FinalizeResponse) XXX_Size() int { + return xxx_messageInfo_FinalizeResponse.Size(m) +} +func (m *FinalizeResponse) XXX_DiscardUnknown() { + xxx_messageInfo_FinalizeResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_FinalizeResponse proto.InternalMessageInfo + +func (m *FinalizeResponse) GetData() string { + if m != nil { + return m.Data + } + return "" +} + +func (m *FinalizeResponse) GetError() string { + if m != nil { + return m.Error + } + return "" +} + +func init() { + proto.RegisterType((*AttributesResponse)(nil), "vagrant.config.AttributesResponse") + proto.RegisterType((*LoadRequest)(nil), "vagrant.config.LoadRequest") + proto.RegisterType((*LoadResponse)(nil), "vagrant.config.LoadResponse") + proto.RegisterType((*ValidateRequest)(nil), "vagrant.config.ValidateRequest") + proto.RegisterType((*ValidateResponse)(nil), "vagrant.config.ValidateResponse") + proto.RegisterType((*FinalizeRequest)(nil), "vagrant.config.FinalizeRequest") + proto.RegisterType((*FinalizeResponse)(nil), "vagrant.config.FinalizeResponse") +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// ConfigClient is the client API for Config service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type ConfigClient interface { + ConfigAttributes(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*AttributesResponse, error) + ConfigLoad(ctx context.Context, in *LoadRequest, opts ...grpc.CallOption) (*LoadResponse, error) + ConfigValidate(ctx context.Context, in *ValidateRequest, opts ...grpc.CallOption) (*ValidateResponse, error) + ConfigFinalize(ctx context.Context, in *FinalizeRequest, opts ...grpc.CallOption) (*FinalizeResponse, error) +} + +type configClient struct { + cc *grpc.ClientConn +} + +func NewConfigClient(cc *grpc.ClientConn) ConfigClient { + return &configClient{cc} +} + +func (c *configClient) ConfigAttributes(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*AttributesResponse, error) { + out := new(AttributesResponse) + err := c.cc.Invoke(ctx, "/vagrant.config.Config/ConfigAttributes", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *configClient) ConfigLoad(ctx context.Context, in *LoadRequest, opts ...grpc.CallOption) (*LoadResponse, error) { + out := new(LoadResponse) + err := c.cc.Invoke(ctx, "/vagrant.config.Config/ConfigLoad", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *configClient) ConfigValidate(ctx context.Context, in *ValidateRequest, opts ...grpc.CallOption) (*ValidateResponse, error) { + out := new(ValidateResponse) + err := c.cc.Invoke(ctx, "/vagrant.config.Config/ConfigValidate", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *configClient) ConfigFinalize(ctx context.Context, in *FinalizeRequest, opts ...grpc.CallOption) (*FinalizeResponse, error) { + out := new(FinalizeResponse) + err := c.cc.Invoke(ctx, "/vagrant.config.Config/ConfigFinalize", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// ConfigServer is the server API for Config service. +type ConfigServer interface { + ConfigAttributes(context.Context, *vagrant_common.NullRequest) (*AttributesResponse, error) + ConfigLoad(context.Context, *LoadRequest) (*LoadResponse, error) + ConfigValidate(context.Context, *ValidateRequest) (*ValidateResponse, error) + ConfigFinalize(context.Context, *FinalizeRequest) (*FinalizeResponse, error) +} + +func RegisterConfigServer(s *grpc.Server, srv ConfigServer) { + s.RegisterService(&_Config_serviceDesc, srv) +} + +func _Config_ConfigAttributes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.NullRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ConfigServer).ConfigAttributes(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.config.Config/ConfigAttributes", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ConfigServer).ConfigAttributes(ctx, req.(*vagrant_common.NullRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Config_ConfigLoad_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(LoadRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ConfigServer).ConfigLoad(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.config.Config/ConfigLoad", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ConfigServer).ConfigLoad(ctx, req.(*LoadRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Config_ConfigValidate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ValidateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ConfigServer).ConfigValidate(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.config.Config/ConfigValidate", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ConfigServer).ConfigValidate(ctx, req.(*ValidateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Config_ConfigFinalize_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(FinalizeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ConfigServer).ConfigFinalize(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.config.Config/ConfigFinalize", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ConfigServer).ConfigFinalize(ctx, req.(*FinalizeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Config_serviceDesc = grpc.ServiceDesc{ + ServiceName: "vagrant.config.Config", + HandlerType: (*ConfigServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "ConfigAttributes", + Handler: _Config_ConfigAttributes_Handler, + }, + { + MethodName: "ConfigLoad", + Handler: _Config_ConfigLoad_Handler, + }, + { + MethodName: "ConfigValidate", + Handler: _Config_ConfigValidate_Handler, + }, + { + MethodName: "ConfigFinalize", + Handler: _Config_ConfigFinalize_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "vagrant_config/config.proto", +} + +func init() { proto.RegisterFile("vagrant_config/config.proto", fileDescriptor_952629f1a9a7438c) } + +var fileDescriptor_952629f1a9a7438c = []byte{ + // 363 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xc1, 0x4b, 0xfb, 0x30, + 0x14, 0xc7, 0xd9, 0x7e, 0x3f, 0x27, 0x7b, 0xca, 0x36, 0x82, 0x48, 0xe9, 0x44, 0x67, 0x41, 0xd8, + 0xc5, 0x06, 0xf4, 0xe2, 0x41, 0x50, 0x11, 0x14, 0x44, 0x3c, 0x74, 0xe0, 0xc5, 0x83, 0x64, 0x5d, + 0x6c, 0x03, 0x6d, 0x52, 0xd3, 0x54, 0xc4, 0xbf, 0xd2, 0x3f, 0x49, 0x4c, 0xd2, 0x75, 0xeb, 0xd6, + 0x81, 0xa7, 0xe4, 0xbd, 0x7c, 0xf3, 0x79, 0xc9, 0xfb, 0x3e, 0x18, 0x7e, 0x90, 0x48, 0x12, 0xae, + 0x5e, 0x43, 0xc1, 0xdf, 0x58, 0x84, 0xcd, 0xe2, 0x67, 0x52, 0x28, 0x81, 0x7a, 0xf6, 0xd0, 0x37, + 0x59, 0xf7, 0x25, 0x62, 0x2a, 0x2e, 0xa6, 0x7e, 0x28, 0x52, 0x1c, 0x93, 0x3c, 0x66, 0xa1, 0x90, + 0x19, 0xb6, 0x22, 0x4c, 0x3f, 0x15, 0x8e, 0xc4, 0x69, 0x96, 0x14, 0x11, 0xe3, 0xf3, 0xac, 0x0d, + 0x35, 0x10, 0x57, 0xc5, 0xd2, 0x54, 0x70, 0x6c, 0x16, 0x53, 0xcc, 0x7b, 0x00, 0x74, 0xa3, 0x94, + 0x64, 0xd3, 0x42, 0xd1, 0x3c, 0xa0, 0x79, 0x26, 0x78, 0x4e, 0xd1, 0x21, 0x00, 0x99, 0x67, 0x9d, + 0xd6, 0xe8, 0xdf, 0xb8, 0x1b, 0x2c, 0x64, 0xd0, 0x1e, 0x6c, 0x51, 0x29, 0x85, 0x74, 0xda, 0xa3, + 0xd6, 0xb8, 0x1b, 0x98, 0xc0, 0x3b, 0x86, 0x9d, 0x47, 0x41, 0x66, 0x01, 0x7d, 0x2f, 0x68, 0xae, + 0x10, 0x82, 0xff, 0x33, 0xa2, 0x88, 0xd3, 0xd2, 0x1a, 0xbd, 0xf7, 0x2e, 0x60, 0xd7, 0x48, 0x6c, + 0xa1, 0x35, 0x9a, 0x06, 0xf8, 0x15, 0xf4, 0x9f, 0x49, 0xc2, 0x66, 0x44, 0xd1, 0x0d, 0x05, 0x90, + 0x03, 0xdb, 0x29, 0x09, 0x63, 0xc6, 0xa9, 0xbd, 0x5e, 0x86, 0xde, 0x35, 0x0c, 0x2a, 0x80, 0x2d, + 0xbf, 0x0f, 0x1d, 0x4d, 0x2f, 0xff, 0x68, 0xa3, 0x86, 0x27, 0x9c, 0x40, 0xff, 0x8e, 0x71, 0x92, + 0xb0, 0xaf, 0x4d, 0x4f, 0xf0, 0x2e, 0x61, 0x50, 0xc9, 0xfe, 0xfa, 0xcf, 0xb3, 0xef, 0x36, 0x74, + 0x6e, 0xb5, 0xf1, 0x68, 0x02, 0x03, 0xb3, 0xab, 0x1c, 0x42, 0x43, 0xbf, 0x9a, 0x0e, 0x6d, 0xe3, + 0x53, 0x91, 0x24, 0xf6, 0x35, 0xae, 0xe7, 0x2f, 0x8f, 0x8e, 0xbf, 0xc6, 0xda, 0x7b, 0x00, 0x03, + 0xfd, 0xf5, 0x61, 0x09, 0xa7, 0x6f, 0x2c, 0x18, 0xe8, 0x1e, 0xac, 0x3f, 0xb4, 0xa0, 0x09, 0xf4, + 0x0c, 0xa8, 0xec, 0x2a, 0x3a, 0xaa, 0xeb, 0x6b, 0x86, 0xb9, 0xa3, 0x66, 0x41, 0x1d, 0x5a, 0x76, + 0x70, 0x15, 0x5a, 0xb3, 0x60, 0x15, 0x5a, 0x6f, 0xfe, 0xb4, 0xa3, 0x47, 0xfd, 0xfc, 0x27, 0x00, + 0x00, 0xff, 0xff, 0xe0, 0x00, 0xbf, 0x51, 0x76, 0x03, 0x00, 0x00, +} diff --git a/ext/go-plugin/vagrant/plugin/proto/vagrant_config/config.proto b/ext/go-plugin/vagrant/plugin/proto/vagrant_config/config.proto new file mode 100644 index 000000000..ad939b9ce --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/proto/vagrant_config/config.proto @@ -0,0 +1,44 @@ +syntax = "proto3"; +package vagrant.config; + +import "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_common/common.proto"; + +message AttributesResponse { + repeated string attributes = 1; + string error = 2; +} + +message LoadRequest { + string data = 1; +} + +message LoadResponse { + string data = 1; + string error = 2; +} + +message ValidateRequest { + string data = 1; + string machine = 2; +} + +message ValidateResponse { + repeated string errors = 1; + string error = 2; +} + +message FinalizeRequest { + string data = 1; +} + +message FinalizeResponse { + string data = 1; + string error = 2; +} + +service Config { + rpc ConfigAttributes(vagrant.common.NullRequest) returns (AttributesResponse); + rpc ConfigLoad(LoadRequest) returns (LoadResponse); + rpc ConfigValidate(ValidateRequest) returns (ValidateResponse); + rpc ConfigFinalize(FinalizeRequest) returns (FinalizeResponse); +} \ No newline at end of file diff --git a/ext/go-plugin/vagrant/plugin/proto/vagrant_folder/synced_folder.pb.go b/ext/go-plugin/vagrant/plugin/proto/vagrant_folder/synced_folder.pb.go new file mode 100644 index 000000000..6222c9585 --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/proto/vagrant_folder/synced_folder.pb.go @@ -0,0 +1,688 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: vagrant_folder/synced_folder.proto + +package vagrant_folder + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import vagrant_caps "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_caps" +import vagrant_common "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_common" +import vagrant_io "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_io" + +import ( + context "golang.org/x/net/context" + grpc "google.golang.org/grpc" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + +type Request struct { + Machine string `protobuf:"bytes,1,opt,name=machine,proto3" json:"machine,omitempty"` + Folders string `protobuf:"bytes,2,opt,name=folders,proto3" json:"folders,omitempty"` + Options string `protobuf:"bytes,3,opt,name=options,proto3" json:"options,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Request) Reset() { *m = Request{} } +func (m *Request) String() string { return proto.CompactTextString(m) } +func (*Request) ProtoMessage() {} +func (*Request) Descriptor() ([]byte, []int) { + return fileDescriptor_8a01e482b349ecb1, []int{0} +} +func (m *Request) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Request.Unmarshal(m, b) +} +func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Request.Marshal(b, m, deterministic) +} +func (m *Request) XXX_Merge(src proto.Message) { + xxx_messageInfo_Request.Merge(m, src) +} +func (m *Request) XXX_Size() int { + return xxx_messageInfo_Request.Size(m) +} +func (m *Request) XXX_DiscardUnknown() { + xxx_messageInfo_Request.DiscardUnknown(m) +} + +var xxx_messageInfo_Request proto.InternalMessageInfo + +func (m *Request) GetMachine() string { + if m != nil { + return m.Machine + } + return "" +} + +func (m *Request) GetFolders() string { + if m != nil { + return m.Folders + } + return "" +} + +func (m *Request) GetOptions() string { + if m != nil { + return m.Options + } + return "" +} + +type CleanupRequest struct { + Machine string `protobuf:"bytes,1,opt,name=machine,proto3" json:"machine,omitempty"` + Options string `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CleanupRequest) Reset() { *m = CleanupRequest{} } +func (m *CleanupRequest) String() string { return proto.CompactTextString(m) } +func (*CleanupRequest) ProtoMessage() {} +func (*CleanupRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_8a01e482b349ecb1, []int{1} +} +func (m *CleanupRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CleanupRequest.Unmarshal(m, b) +} +func (m *CleanupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CleanupRequest.Marshal(b, m, deterministic) +} +func (m *CleanupRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_CleanupRequest.Merge(m, src) +} +func (m *CleanupRequest) XXX_Size() int { + return xxx_messageInfo_CleanupRequest.Size(m) +} +func (m *CleanupRequest) XXX_DiscardUnknown() { + xxx_messageInfo_CleanupRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_CleanupRequest proto.InternalMessageInfo + +func (m *CleanupRequest) GetMachine() string { + if m != nil { + return m.Machine + } + return "" +} + +func (m *CleanupRequest) GetOptions() string { + if m != nil { + return m.Options + } + return "" +} + +type InfoResponse struct { + Description string `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"` + Priority int64 `protobuf:"varint,2,opt,name=priority,proto3" json:"priority,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *InfoResponse) Reset() { *m = InfoResponse{} } +func (m *InfoResponse) String() string { return proto.CompactTextString(m) } +func (*InfoResponse) ProtoMessage() {} +func (*InfoResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_8a01e482b349ecb1, []int{2} +} +func (m *InfoResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_InfoResponse.Unmarshal(m, b) +} +func (m *InfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_InfoResponse.Marshal(b, m, deterministic) +} +func (m *InfoResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_InfoResponse.Merge(m, src) +} +func (m *InfoResponse) XXX_Size() int { + return xxx_messageInfo_InfoResponse.Size(m) +} +func (m *InfoResponse) XXX_DiscardUnknown() { + xxx_messageInfo_InfoResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_InfoResponse proto.InternalMessageInfo + +func (m *InfoResponse) GetDescription() string { + if m != nil { + return m.Description + } + return "" +} + +func (m *InfoResponse) GetPriority() int64 { + if m != nil { + return m.Priority + } + return 0 +} + +func init() { + proto.RegisterType((*Request)(nil), "vagrant.folder.Request") + proto.RegisterType((*CleanupRequest)(nil), "vagrant.folder.CleanupRequest") + proto.RegisterType((*InfoResponse)(nil), "vagrant.folder.InfoResponse") +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// SyncedFolderClient is the client API for SyncedFolder service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type SyncedFolderClient interface { + Cleanup(ctx context.Context, in *CleanupRequest, opts ...grpc.CallOption) (*vagrant_common.EmptyResponse, error) + Disable(ctx context.Context, in *Request, opts ...grpc.CallOption) (*vagrant_common.EmptyResponse, error) + Enable(ctx context.Context, in *Request, opts ...grpc.CallOption) (*vagrant_common.EmptyResponse, error) + Info(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*InfoResponse, error) + IsUsable(ctx context.Context, in *vagrant_common.EmptyRequest, opts ...grpc.CallOption) (*vagrant_common.IsResponse, error) + Name(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*vagrant_common.NameResponse, error) + Prepare(ctx context.Context, in *Request, opts ...grpc.CallOption) (*vagrant_common.EmptyResponse, error) + // These are IO helpers for streaming + Read(ctx context.Context, in *vagrant_io.ReadRequest, opts ...grpc.CallOption) (*vagrant_io.ReadResponse, error) + Write(ctx context.Context, in *vagrant_io.WriteRequest, opts ...grpc.CallOption) (*vagrant_io.WriteResponse, error) + // Capabilities + GuestCapabilities(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*vagrant_caps.CapabilitiesResponse, error) + GuestCapability(ctx context.Context, in *vagrant_caps.GuestCapabilityRequest, opts ...grpc.CallOption) (*vagrant_caps.GuestCapabilityResponse, error) + HostCapabilities(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*vagrant_caps.CapabilitiesResponse, error) + HostCapability(ctx context.Context, in *vagrant_caps.HostCapabilityRequest, opts ...grpc.CallOption) (*vagrant_caps.HostCapabilityResponse, error) +} + +type syncedFolderClient struct { + cc *grpc.ClientConn +} + +func NewSyncedFolderClient(cc *grpc.ClientConn) SyncedFolderClient { + return &syncedFolderClient{cc} +} + +func (c *syncedFolderClient) Cleanup(ctx context.Context, in *CleanupRequest, opts ...grpc.CallOption) (*vagrant_common.EmptyResponse, error) { + out := new(vagrant_common.EmptyResponse) + err := c.cc.Invoke(ctx, "/vagrant.folder.SyncedFolder/Cleanup", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *syncedFolderClient) Disable(ctx context.Context, in *Request, opts ...grpc.CallOption) (*vagrant_common.EmptyResponse, error) { + out := new(vagrant_common.EmptyResponse) + err := c.cc.Invoke(ctx, "/vagrant.folder.SyncedFolder/Disable", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *syncedFolderClient) Enable(ctx context.Context, in *Request, opts ...grpc.CallOption) (*vagrant_common.EmptyResponse, error) { + out := new(vagrant_common.EmptyResponse) + err := c.cc.Invoke(ctx, "/vagrant.folder.SyncedFolder/Enable", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *syncedFolderClient) Info(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*InfoResponse, error) { + out := new(InfoResponse) + err := c.cc.Invoke(ctx, "/vagrant.folder.SyncedFolder/Info", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *syncedFolderClient) IsUsable(ctx context.Context, in *vagrant_common.EmptyRequest, opts ...grpc.CallOption) (*vagrant_common.IsResponse, error) { + out := new(vagrant_common.IsResponse) + err := c.cc.Invoke(ctx, "/vagrant.folder.SyncedFolder/IsUsable", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *syncedFolderClient) Name(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*vagrant_common.NameResponse, error) { + out := new(vagrant_common.NameResponse) + err := c.cc.Invoke(ctx, "/vagrant.folder.SyncedFolder/Name", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *syncedFolderClient) Prepare(ctx context.Context, in *Request, opts ...grpc.CallOption) (*vagrant_common.EmptyResponse, error) { + out := new(vagrant_common.EmptyResponse) + err := c.cc.Invoke(ctx, "/vagrant.folder.SyncedFolder/Prepare", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *syncedFolderClient) Read(ctx context.Context, in *vagrant_io.ReadRequest, opts ...grpc.CallOption) (*vagrant_io.ReadResponse, error) { + out := new(vagrant_io.ReadResponse) + err := c.cc.Invoke(ctx, "/vagrant.folder.SyncedFolder/Read", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *syncedFolderClient) Write(ctx context.Context, in *vagrant_io.WriteRequest, opts ...grpc.CallOption) (*vagrant_io.WriteResponse, error) { + out := new(vagrant_io.WriteResponse) + err := c.cc.Invoke(ctx, "/vagrant.folder.SyncedFolder/Write", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *syncedFolderClient) GuestCapabilities(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*vagrant_caps.CapabilitiesResponse, error) { + out := new(vagrant_caps.CapabilitiesResponse) + err := c.cc.Invoke(ctx, "/vagrant.folder.SyncedFolder/GuestCapabilities", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *syncedFolderClient) GuestCapability(ctx context.Context, in *vagrant_caps.GuestCapabilityRequest, opts ...grpc.CallOption) (*vagrant_caps.GuestCapabilityResponse, error) { + out := new(vagrant_caps.GuestCapabilityResponse) + err := c.cc.Invoke(ctx, "/vagrant.folder.SyncedFolder/GuestCapability", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *syncedFolderClient) HostCapabilities(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*vagrant_caps.CapabilitiesResponse, error) { + out := new(vagrant_caps.CapabilitiesResponse) + err := c.cc.Invoke(ctx, "/vagrant.folder.SyncedFolder/HostCapabilities", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *syncedFolderClient) HostCapability(ctx context.Context, in *vagrant_caps.HostCapabilityRequest, opts ...grpc.CallOption) (*vagrant_caps.HostCapabilityResponse, error) { + out := new(vagrant_caps.HostCapabilityResponse) + err := c.cc.Invoke(ctx, "/vagrant.folder.SyncedFolder/HostCapability", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// SyncedFolderServer is the server API for SyncedFolder service. +type SyncedFolderServer interface { + Cleanup(context.Context, *CleanupRequest) (*vagrant_common.EmptyResponse, error) + Disable(context.Context, *Request) (*vagrant_common.EmptyResponse, error) + Enable(context.Context, *Request) (*vagrant_common.EmptyResponse, error) + Info(context.Context, *vagrant_common.NullRequest) (*InfoResponse, error) + IsUsable(context.Context, *vagrant_common.EmptyRequest) (*vagrant_common.IsResponse, error) + Name(context.Context, *vagrant_common.NullRequest) (*vagrant_common.NameResponse, error) + Prepare(context.Context, *Request) (*vagrant_common.EmptyResponse, error) + // These are IO helpers for streaming + Read(context.Context, *vagrant_io.ReadRequest) (*vagrant_io.ReadResponse, error) + Write(context.Context, *vagrant_io.WriteRequest) (*vagrant_io.WriteResponse, error) + // Capabilities + GuestCapabilities(context.Context, *vagrant_common.NullRequest) (*vagrant_caps.CapabilitiesResponse, error) + GuestCapability(context.Context, *vagrant_caps.GuestCapabilityRequest) (*vagrant_caps.GuestCapabilityResponse, error) + HostCapabilities(context.Context, *vagrant_common.NullRequest) (*vagrant_caps.CapabilitiesResponse, error) + HostCapability(context.Context, *vagrant_caps.HostCapabilityRequest) (*vagrant_caps.HostCapabilityResponse, error) +} + +func RegisterSyncedFolderServer(s *grpc.Server, srv SyncedFolderServer) { + s.RegisterService(&_SyncedFolder_serviceDesc, srv) +} + +func _SyncedFolder_Cleanup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CleanupRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SyncedFolderServer).Cleanup(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.folder.SyncedFolder/Cleanup", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SyncedFolderServer).Cleanup(ctx, req.(*CleanupRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SyncedFolder_Disable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(Request) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SyncedFolderServer).Disable(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.folder.SyncedFolder/Disable", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SyncedFolderServer).Disable(ctx, req.(*Request)) + } + return interceptor(ctx, in, info, handler) +} + +func _SyncedFolder_Enable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(Request) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SyncedFolderServer).Enable(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.folder.SyncedFolder/Enable", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SyncedFolderServer).Enable(ctx, req.(*Request)) + } + return interceptor(ctx, in, info, handler) +} + +func _SyncedFolder_Info_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.NullRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SyncedFolderServer).Info(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.folder.SyncedFolder/Info", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SyncedFolderServer).Info(ctx, req.(*vagrant_common.NullRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SyncedFolder_IsUsable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.EmptyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SyncedFolderServer).IsUsable(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.folder.SyncedFolder/IsUsable", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SyncedFolderServer).IsUsable(ctx, req.(*vagrant_common.EmptyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SyncedFolder_Name_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.NullRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SyncedFolderServer).Name(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.folder.SyncedFolder/Name", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SyncedFolderServer).Name(ctx, req.(*vagrant_common.NullRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SyncedFolder_Prepare_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(Request) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SyncedFolderServer).Prepare(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.folder.SyncedFolder/Prepare", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SyncedFolderServer).Prepare(ctx, req.(*Request)) + } + return interceptor(ctx, in, info, handler) +} + +func _SyncedFolder_Read_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_io.ReadRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SyncedFolderServer).Read(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.folder.SyncedFolder/Read", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SyncedFolderServer).Read(ctx, req.(*vagrant_io.ReadRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SyncedFolder_Write_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_io.WriteRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SyncedFolderServer).Write(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.folder.SyncedFolder/Write", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SyncedFolderServer).Write(ctx, req.(*vagrant_io.WriteRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SyncedFolder_GuestCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.NullRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SyncedFolderServer).GuestCapabilities(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.folder.SyncedFolder/GuestCapabilities", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SyncedFolderServer).GuestCapabilities(ctx, req.(*vagrant_common.NullRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SyncedFolder_GuestCapability_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_caps.GuestCapabilityRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SyncedFolderServer).GuestCapability(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.folder.SyncedFolder/GuestCapability", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SyncedFolderServer).GuestCapability(ctx, req.(*vagrant_caps.GuestCapabilityRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SyncedFolder_HostCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.NullRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SyncedFolderServer).HostCapabilities(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.folder.SyncedFolder/HostCapabilities", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SyncedFolderServer).HostCapabilities(ctx, req.(*vagrant_common.NullRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SyncedFolder_HostCapability_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_caps.HostCapabilityRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SyncedFolderServer).HostCapability(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.folder.SyncedFolder/HostCapability", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SyncedFolderServer).HostCapability(ctx, req.(*vagrant_caps.HostCapabilityRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _SyncedFolder_serviceDesc = grpc.ServiceDesc{ + ServiceName: "vagrant.folder.SyncedFolder", + HandlerType: (*SyncedFolderServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Cleanup", + Handler: _SyncedFolder_Cleanup_Handler, + }, + { + MethodName: "Disable", + Handler: _SyncedFolder_Disable_Handler, + }, + { + MethodName: "Enable", + Handler: _SyncedFolder_Enable_Handler, + }, + { + MethodName: "Info", + Handler: _SyncedFolder_Info_Handler, + }, + { + MethodName: "IsUsable", + Handler: _SyncedFolder_IsUsable_Handler, + }, + { + MethodName: "Name", + Handler: _SyncedFolder_Name_Handler, + }, + { + MethodName: "Prepare", + Handler: _SyncedFolder_Prepare_Handler, + }, + { + MethodName: "Read", + Handler: _SyncedFolder_Read_Handler, + }, + { + MethodName: "Write", + Handler: _SyncedFolder_Write_Handler, + }, + { + MethodName: "GuestCapabilities", + Handler: _SyncedFolder_GuestCapabilities_Handler, + }, + { + MethodName: "GuestCapability", + Handler: _SyncedFolder_GuestCapability_Handler, + }, + { + MethodName: "HostCapabilities", + Handler: _SyncedFolder_HostCapabilities_Handler, + }, + { + MethodName: "HostCapability", + Handler: _SyncedFolder_HostCapability_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "vagrant_folder/synced_folder.proto", +} + +func init() { proto.RegisterFile("vagrant_folder/synced_folder.proto", fileDescriptor_8a01e482b349ecb1) } + +var fileDescriptor_8a01e482b349ecb1 = []byte{ + // 488 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0x5f, 0x6f, 0xd3, 0x30, + 0x14, 0xc5, 0xb5, 0x3f, 0x2c, 0xe3, 0x32, 0x15, 0xf0, 0x0b, 0x21, 0x0c, 0x34, 0x95, 0x21, 0xf1, + 0x42, 0x22, 0xc1, 0x13, 0x12, 0x0f, 0x4c, 0xeb, 0x60, 0x95, 0xd0, 0x84, 0x52, 0xd0, 0x1e, 0x26, + 0x51, 0xb9, 0xa9, 0xd7, 0x5a, 0x4a, 0x6c, 0x63, 0x3b, 0x88, 0x7c, 0x48, 0xbe, 0x13, 0x4a, 0x6c, + 0x87, 0x38, 0x40, 0xa9, 0x58, 0x9f, 0xaa, 0x7b, 0xcf, 0x3d, 0x3f, 0x9f, 0xde, 0x38, 0x81, 0xe1, + 0x37, 0xbc, 0x90, 0x98, 0xe9, 0xe9, 0x35, 0xcf, 0xe7, 0x44, 0x26, 0xaa, 0x62, 0x19, 0x99, 0xdb, + 0x2a, 0x16, 0x92, 0x6b, 0x8e, 0x06, 0x76, 0x26, 0x36, 0xdd, 0xe8, 0x6a, 0x41, 0xf5, 0xb2, 0x9c, + 0xc5, 0x19, 0x2f, 0x92, 0x25, 0x56, 0x4b, 0x9a, 0x71, 0x29, 0x12, 0x3b, 0x94, 0x90, 0xef, 0x3a, + 0x59, 0xf0, 0x17, 0x22, 0x2f, 0x17, 0x94, 0xb5, 0x5d, 0x5b, 0x36, 0x40, 0xd7, 0x9c, 0x66, 0xbc, + 0x28, 0x38, 0x4b, 0xcc, 0x8f, 0x39, 0x2c, 0x9a, 0x6c, 0x0a, 0x4e, 0x79, 0x42, 0xb9, 0x85, 0x4e, + 0x37, 0x96, 0x18, 0x0b, 0x95, 0x64, 0x58, 0xe0, 0x19, 0xcd, 0xa9, 0xa6, 0x44, 0x99, 0x03, 0x86, + 0x97, 0x10, 0xa4, 0xe4, 0x6b, 0x49, 0x94, 0x46, 0x21, 0x04, 0x05, 0xce, 0x96, 0x94, 0x91, 0x70, + 0xeb, 0x68, 0xeb, 0xf9, 0xed, 0xd4, 0x95, 0xb5, 0x62, 0x36, 0xa8, 0xc2, 0x6d, 0xa3, 0xd8, 0xb2, + 0x56, 0xb8, 0xd0, 0x94, 0x33, 0x15, 0xee, 0x18, 0xc5, 0x96, 0xc3, 0x11, 0x0c, 0x4e, 0x73, 0x82, + 0x59, 0x29, 0xd6, 0xe2, 0x3b, 0xca, 0xb6, 0x4f, 0xf9, 0x00, 0x07, 0x63, 0x76, 0xcd, 0x53, 0xa2, + 0x04, 0x67, 0x8a, 0xa0, 0x23, 0xb8, 0x33, 0x27, 0x2a, 0x93, 0xb4, 0xd1, 0x2d, 0xa7, 0xdb, 0x42, + 0x11, 0xec, 0x0b, 0x49, 0xb9, 0xa4, 0xba, 0x6a, 0x60, 0x3b, 0x69, 0x5b, 0xbf, 0xfc, 0x11, 0xc0, + 0xc1, 0xa4, 0xb9, 0x27, 0xef, 0x9a, 0xfc, 0xe8, 0x1c, 0x02, 0x1b, 0x12, 0x3d, 0x89, 0xfd, 0xcb, + 0x12, 0xfb, 0xe9, 0xa3, 0xc7, 0xad, 0x6e, 0x9f, 0xfa, 0x59, 0x21, 0x74, 0xd5, 0x06, 0x3b, 0x81, + 0x60, 0x44, 0x15, 0x9e, 0xe5, 0x04, 0x3d, 0xe8, 0x93, 0xd6, 0x44, 0xbc, 0x85, 0xbd, 0x33, 0x76, + 0x23, 0xc2, 0x09, 0xec, 0xd6, 0xdb, 0x42, 0x8f, 0xfa, 0x63, 0x17, 0x65, 0x9e, 0x3b, 0xc6, 0x61, + 0x1f, 0xee, 0x2d, 0x78, 0x04, 0xfb, 0x63, 0xf5, 0xd9, 0xfc, 0x91, 0xc3, 0xbf, 0x9c, 0x66, 0x38, + 0x51, 0x5f, 0x1d, 0xab, 0x6e, 0x90, 0x0b, 0x5c, 0x90, 0x75, 0x83, 0x38, 0x11, 0x17, 0xa4, 0xbb, + 0xd0, 0x8f, 0x92, 0x08, 0x2c, 0xff, 0x7f, 0x1d, 0xaf, 0x61, 0x37, 0x25, 0x78, 0xde, 0xf1, 0x53, + 0x1e, 0xd7, 0x1d, 0xe7, 0x0f, 0x7f, 0x17, 0xac, 0xf5, 0x0d, 0xdc, 0xba, 0x94, 0x54, 0x13, 0xe4, + 0x8d, 0x34, 0x2d, 0x67, 0x7e, 0xf8, 0x07, 0xc5, 0xba, 0x3f, 0xc1, 0xfd, 0xf7, 0xf5, 0xcc, 0x69, + 0xe7, 0x7d, 0x5b, 0xbd, 0x8b, 0xe1, 0x2f, 0x11, 0x0b, 0x15, 0x77, 0x8d, 0x2d, 0xf5, 0x0b, 0xdc, + 0xf5, 0xa9, 0x15, 0x3a, 0xf6, 0x6d, 0x3d, 0xd9, 0xc1, 0x9f, 0xfd, 0x63, 0xca, 0xf2, 0x27, 0x70, + 0xef, 0x9c, 0x6f, 0x3a, 0xf4, 0x15, 0x0c, 0x3c, 0x68, 0x85, 0x9e, 0xfa, 0x2e, 0x5f, 0x75, 0xe8, + 0xe3, 0xd5, 0x43, 0x06, 0x3e, 0xdb, 0x6b, 0xbe, 0x61, 0xaf, 0x7e, 0x06, 0x00, 0x00, 0xff, 0xff, + 0x89, 0x36, 0xb1, 0x5c, 0x0c, 0x06, 0x00, 0x00, +} diff --git a/ext/go-plugin/vagrant/plugin/proto/vagrant_folder/synced_folder.proto b/ext/go-plugin/vagrant/plugin/proto/vagrant_folder/synced_folder.proto new file mode 100644 index 000000000..e192cab0a --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/proto/vagrant_folder/synced_folder.proto @@ -0,0 +1,40 @@ +syntax = "proto3"; +package vagrant.folder; + +import "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_common/common.proto"; +import "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_io/io.proto"; +import "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_caps/capabilities.proto"; + +message Request { + string machine = 1; + string folders = 2; + string options = 3; +} + +message CleanupRequest { + string machine = 1; + string options = 2; +} + +message InfoResponse { + string description = 1; + int64 priority = 2; +} + +service SyncedFolder { + rpc Cleanup(CleanupRequest) returns (vagrant.common.EmptyResponse); + rpc Disable(Request) returns (vagrant.common.EmptyResponse); + rpc Enable(Request) returns (vagrant.common.EmptyResponse); + rpc Info(vagrant.common.NullRequest) returns (InfoResponse); + rpc IsUsable(vagrant.common.EmptyRequest) returns (vagrant.common.IsResponse); + rpc Name(vagrant.common.NullRequest) returns (vagrant.common.NameResponse); + rpc Prepare(Request) returns (vagrant.common.EmptyResponse); + // These are IO helpers for streaming + rpc Read(vagrant.io.ReadRequest) returns (vagrant.io.ReadResponse); + rpc Write(vagrant.io.WriteRequest) returns (vagrant.io.WriteResponse); + // Capabilities + rpc GuestCapabilities(vagrant.common.NullRequest) returns (vagrant.caps.CapabilitiesResponse); + rpc GuestCapability(vagrant.caps.GuestCapabilityRequest) returns (vagrant.caps.GuestCapabilityResponse); + rpc HostCapabilities(vagrant.common.NullRequest) returns (vagrant.caps.CapabilitiesResponse); + rpc HostCapability(vagrant.caps.HostCapabilityRequest) returns (vagrant.caps.HostCapabilityResponse); +} \ No newline at end of file diff --git a/ext/go-plugin/vagrant/plugin/proto/vagrant_io/io.pb.go b/ext/go-plugin/vagrant/plugin/proto/vagrant_io/io.pb.go new file mode 100644 index 000000000..2793c66fa --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/proto/vagrant_io/io.pb.go @@ -0,0 +1,332 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: vagrant_io/io.proto + +package vagrant_io + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +import ( + context "golang.org/x/net/context" + grpc "google.golang.org/grpc" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + +type ReadRequest struct { + Target string `protobuf:"bytes,1,opt,name=target,proto3" json:"target,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ReadRequest) Reset() { *m = ReadRequest{} } +func (m *ReadRequest) String() string { return proto.CompactTextString(m) } +func (*ReadRequest) ProtoMessage() {} +func (*ReadRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_d46affeac7affd9e, []int{0} +} +func (m *ReadRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ReadRequest.Unmarshal(m, b) +} +func (m *ReadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ReadRequest.Marshal(b, m, deterministic) +} +func (m *ReadRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReadRequest.Merge(m, src) +} +func (m *ReadRequest) XXX_Size() int { + return xxx_messageInfo_ReadRequest.Size(m) +} +func (m *ReadRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ReadRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ReadRequest proto.InternalMessageInfo + +func (m *ReadRequest) GetTarget() string { + if m != nil { + return m.Target + } + return "" +} + +type ReadResponse struct { + Content string `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ReadResponse) Reset() { *m = ReadResponse{} } +func (m *ReadResponse) String() string { return proto.CompactTextString(m) } +func (*ReadResponse) ProtoMessage() {} +func (*ReadResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_d46affeac7affd9e, []int{1} +} +func (m *ReadResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ReadResponse.Unmarshal(m, b) +} +func (m *ReadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ReadResponse.Marshal(b, m, deterministic) +} +func (m *ReadResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReadResponse.Merge(m, src) +} +func (m *ReadResponse) XXX_Size() int { + return xxx_messageInfo_ReadResponse.Size(m) +} +func (m *ReadResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ReadResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ReadResponse proto.InternalMessageInfo + +func (m *ReadResponse) GetContent() string { + if m != nil { + return m.Content + } + return "" +} + +func (m *ReadResponse) GetError() string { + if m != nil { + return m.Error + } + return "" +} + +type WriteRequest struct { + Content string `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"` + Target string `protobuf:"bytes,2,opt,name=target,proto3" json:"target,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *WriteRequest) Reset() { *m = WriteRequest{} } +func (m *WriteRequest) String() string { return proto.CompactTextString(m) } +func (*WriteRequest) ProtoMessage() {} +func (*WriteRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_d46affeac7affd9e, []int{2} +} +func (m *WriteRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_WriteRequest.Unmarshal(m, b) +} +func (m *WriteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_WriteRequest.Marshal(b, m, deterministic) +} +func (m *WriteRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_WriteRequest.Merge(m, src) +} +func (m *WriteRequest) XXX_Size() int { + return xxx_messageInfo_WriteRequest.Size(m) +} +func (m *WriteRequest) XXX_DiscardUnknown() { + xxx_messageInfo_WriteRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_WriteRequest proto.InternalMessageInfo + +func (m *WriteRequest) GetContent() string { + if m != nil { + return m.Content + } + return "" +} + +func (m *WriteRequest) GetTarget() string { + if m != nil { + return m.Target + } + return "" +} + +type WriteResponse struct { + Length int32 `protobuf:"varint,1,opt,name=length,proto3" json:"length,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *WriteResponse) Reset() { *m = WriteResponse{} } +func (m *WriteResponse) String() string { return proto.CompactTextString(m) } +func (*WriteResponse) ProtoMessage() {} +func (*WriteResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_d46affeac7affd9e, []int{3} +} +func (m *WriteResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_WriteResponse.Unmarshal(m, b) +} +func (m *WriteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_WriteResponse.Marshal(b, m, deterministic) +} +func (m *WriteResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_WriteResponse.Merge(m, src) +} +func (m *WriteResponse) XXX_Size() int { + return xxx_messageInfo_WriteResponse.Size(m) +} +func (m *WriteResponse) XXX_DiscardUnknown() { + xxx_messageInfo_WriteResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_WriteResponse proto.InternalMessageInfo + +func (m *WriteResponse) GetLength() int32 { + if m != nil { + return m.Length + } + return 0 +} + +func (m *WriteResponse) GetError() string { + if m != nil { + return m.Error + } + return "" +} + +func init() { + proto.RegisterType((*ReadRequest)(nil), "vagrant.io.ReadRequest") + proto.RegisterType((*ReadResponse)(nil), "vagrant.io.ReadResponse") + proto.RegisterType((*WriteRequest)(nil), "vagrant.io.WriteRequest") + proto.RegisterType((*WriteResponse)(nil), "vagrant.io.WriteResponse") +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// IOClient is the client API for IO service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type IOClient interface { + Read(ctx context.Context, in *ReadRequest, opts ...grpc.CallOption) (*ReadResponse, error) + Write(ctx context.Context, in *WriteRequest, opts ...grpc.CallOption) (*WriteResponse, error) +} + +type iOClient struct { + cc *grpc.ClientConn +} + +func NewIOClient(cc *grpc.ClientConn) IOClient { + return &iOClient{cc} +} + +func (c *iOClient) Read(ctx context.Context, in *ReadRequest, opts ...grpc.CallOption) (*ReadResponse, error) { + out := new(ReadResponse) + err := c.cc.Invoke(ctx, "/vagrant.io.IO/Read", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *iOClient) Write(ctx context.Context, in *WriteRequest, opts ...grpc.CallOption) (*WriteResponse, error) { + out := new(WriteResponse) + err := c.cc.Invoke(ctx, "/vagrant.io.IO/Write", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// IOServer is the server API for IO service. +type IOServer interface { + Read(context.Context, *ReadRequest) (*ReadResponse, error) + Write(context.Context, *WriteRequest) (*WriteResponse, error) +} + +func RegisterIOServer(s *grpc.Server, srv IOServer) { + s.RegisterService(&_IO_serviceDesc, srv) +} + +func _IO_Read_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ReadRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(IOServer).Read(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.io.IO/Read", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(IOServer).Read(ctx, req.(*ReadRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _IO_Write_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(WriteRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(IOServer).Write(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.io.IO/Write", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(IOServer).Write(ctx, req.(*WriteRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _IO_serviceDesc = grpc.ServiceDesc{ + ServiceName: "vagrant.io.IO", + HandlerType: (*IOServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Read", + Handler: _IO_Read_Handler, + }, + { + MethodName: "Write", + Handler: _IO_Write_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "vagrant_io/io.proto", +} + +func init() { proto.RegisterFile("vagrant_io/io.proto", fileDescriptor_d46affeac7affd9e) } + +var fileDescriptor_d46affeac7affd9e = []byte{ + // 219 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x2e, 0x4b, 0x4c, 0x2f, + 0x4a, 0xcc, 0x2b, 0x89, 0xcf, 0xcc, 0xd7, 0xcf, 0xcc, 0xd7, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, + 0xe2, 0x82, 0x0a, 0xea, 0x65, 0xe6, 0x2b, 0xa9, 0x72, 0x71, 0x07, 0xa5, 0x26, 0xa6, 0x04, 0xa5, + 0x16, 0x96, 0xa6, 0x16, 0x97, 0x08, 0x89, 0x71, 0xb1, 0x95, 0x24, 0x16, 0xa5, 0xa7, 0x96, 0x48, + 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x06, 0x41, 0x79, 0x4a, 0x76, 0x5c, 0x3c, 0x10, 0x65, 0xc5, 0x05, + 0xf9, 0x79, 0xc5, 0xa9, 0x42, 0x12, 0x5c, 0xec, 0xc9, 0xf9, 0x79, 0x25, 0xa9, 0x79, 0x30, 0x85, + 0x30, 0xae, 0x90, 0x08, 0x17, 0x6b, 0x6a, 0x51, 0x51, 0x7e, 0x91, 0x04, 0x13, 0x58, 0x1c, 0xc2, + 0x51, 0x72, 0xe0, 0xe2, 0x09, 0x2f, 0xca, 0x2c, 0x49, 0x85, 0xd9, 0x83, 0x5b, 0x3f, 0xc2, 0x05, + 0x4c, 0x28, 0x2e, 0xb0, 0xe5, 0xe2, 0x85, 0x9a, 0x00, 0x75, 0x82, 0x18, 0x17, 0x5b, 0x4e, 0x6a, + 0x5e, 0x7a, 0x49, 0x06, 0xd8, 0x04, 0xd6, 0x20, 0x28, 0x0f, 0xbb, 0x03, 0x8c, 0x6a, 0xb9, 0x98, + 0x3c, 0xfd, 0x85, 0x2c, 0xb9, 0x58, 0x40, 0xde, 0x10, 0x12, 0xd7, 0x43, 0x04, 0x81, 0x1e, 0x92, + 0xff, 0xa5, 0x24, 0x30, 0x25, 0xa0, 0xd6, 0xd9, 0x70, 0xb1, 0x82, 0xed, 0x17, 0x42, 0x51, 0x82, + 0xec, 0x29, 0x29, 0x49, 0x2c, 0x32, 0x10, 0xdd, 0x49, 0x6c, 0xe0, 0x90, 0x37, 0x06, 0x04, 0x00, + 0x00, 0xff, 0xff, 0x47, 0x7e, 0x0b, 0xe4, 0x90, 0x01, 0x00, 0x00, +} diff --git a/ext/go-plugin/vagrant/plugin/proto/vagrant_io/io.proto b/ext/go-plugin/vagrant/plugin/proto/vagrant_io/io.proto new file mode 100644 index 000000000..b61b503bf --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/proto/vagrant_io/io.proto @@ -0,0 +1,26 @@ +syntax = "proto3"; +package vagrant.io; + +message ReadRequest { + string target = 1; +} + +message ReadResponse { + string content = 1; + string error = 2; +} + +message WriteRequest { + string content = 1; + string target = 2; +} + +message WriteResponse { + int32 length = 1; + string error = 2; +} + +service IO { + rpc Read(ReadRequest) returns (ReadResponse); + rpc Write(WriteRequest) returns (WriteResponse); +} \ No newline at end of file diff --git a/ext/go-plugin/vagrant/plugin/proto/vagrant_provider/provider.pb.go b/ext/go-plugin/vagrant/plugin/proto/vagrant_provider/provider.pb.go new file mode 100644 index 000000000..50cd4e580 --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/proto/vagrant_provider/provider.pb.go @@ -0,0 +1,1212 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: vagrant_provider/provider.proto + +package vagrant_provider + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import vagrant_caps "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_caps" +import vagrant_common "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_common" +import vagrant_config "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_config" +import vagrant_io "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_io" + +import ( + context "golang.org/x/net/context" + grpc "google.golang.org/grpc" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + +type ActionRequest struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Machine string `protobuf:"bytes,2,opt,name=machine,proto3" json:"machine,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ActionRequest) Reset() { *m = ActionRequest{} } +func (m *ActionRequest) String() string { return proto.CompactTextString(m) } +func (*ActionRequest) ProtoMessage() {} +func (*ActionRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_28396c8d66e1a9b4, []int{0} +} +func (m *ActionRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ActionRequest.Unmarshal(m, b) +} +func (m *ActionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ActionRequest.Marshal(b, m, deterministic) +} +func (m *ActionRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ActionRequest.Merge(m, src) +} +func (m *ActionRequest) XXX_Size() int { + return xxx_messageInfo_ActionRequest.Size(m) +} +func (m *ActionRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ActionRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ActionRequest proto.InternalMessageInfo + +func (m *ActionRequest) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *ActionRequest) GetMachine() string { + if m != nil { + return m.Machine + } + return "" +} + +type ActionResponse struct { + Result []string `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ActionResponse) Reset() { *m = ActionResponse{} } +func (m *ActionResponse) String() string { return proto.CompactTextString(m) } +func (*ActionResponse) ProtoMessage() {} +func (*ActionResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_28396c8d66e1a9b4, []int{1} +} +func (m *ActionResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ActionResponse.Unmarshal(m, b) +} +func (m *ActionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ActionResponse.Marshal(b, m, deterministic) +} +func (m *ActionResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ActionResponse.Merge(m, src) +} +func (m *ActionResponse) XXX_Size() int { + return xxx_messageInfo_ActionResponse.Size(m) +} +func (m *ActionResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ActionResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ActionResponse proto.InternalMessageInfo + +func (m *ActionResponse) GetResult() []string { + if m != nil { + return m.Result + } + return nil +} + +func (m *ActionResponse) GetError() string { + if m != nil { + return m.Error + } + return "" +} + +type InfoResponse struct { + Capabilities []string `protobuf:"bytes,1,rep,name=capabilities,proto3" json:"capabilities,omitempty"` + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` + Priority int64 `protobuf:"varint,3,opt,name=priority,proto3" json:"priority,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *InfoResponse) Reset() { *m = InfoResponse{} } +func (m *InfoResponse) String() string { return proto.CompactTextString(m) } +func (*InfoResponse) ProtoMessage() {} +func (*InfoResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_28396c8d66e1a9b4, []int{2} +} +func (m *InfoResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_InfoResponse.Unmarshal(m, b) +} +func (m *InfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_InfoResponse.Marshal(b, m, deterministic) +} +func (m *InfoResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_InfoResponse.Merge(m, src) +} +func (m *InfoResponse) XXX_Size() int { + return xxx_messageInfo_InfoResponse.Size(m) +} +func (m *InfoResponse) XXX_DiscardUnknown() { + xxx_messageInfo_InfoResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_InfoResponse proto.InternalMessageInfo + +func (m *InfoResponse) GetCapabilities() []string { + if m != nil { + return m.Capabilities + } + return nil +} + +func (m *InfoResponse) GetDescription() string { + if m != nil { + return m.Description + } + return "" +} + +func (m *InfoResponse) GetPriority() int64 { + if m != nil { + return m.Priority + } + return 0 +} + +type RunActionRequest struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Data string `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` + Machine string `protobuf:"bytes,3,opt,name=machine,proto3" json:"machine,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RunActionRequest) Reset() { *m = RunActionRequest{} } +func (m *RunActionRequest) String() string { return proto.CompactTextString(m) } +func (*RunActionRequest) ProtoMessage() {} +func (*RunActionRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_28396c8d66e1a9b4, []int{3} +} +func (m *RunActionRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RunActionRequest.Unmarshal(m, b) +} +func (m *RunActionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RunActionRequest.Marshal(b, m, deterministic) +} +func (m *RunActionRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RunActionRequest.Merge(m, src) +} +func (m *RunActionRequest) XXX_Size() int { + return xxx_messageInfo_RunActionRequest.Size(m) +} +func (m *RunActionRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RunActionRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_RunActionRequest proto.InternalMessageInfo + +func (m *RunActionRequest) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *RunActionRequest) GetData() string { + if m != nil { + return m.Data + } + return "" +} + +func (m *RunActionRequest) GetMachine() string { + if m != nil { + return m.Machine + } + return "" +} + +type RunActionResponse struct { + Data string `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RunActionResponse) Reset() { *m = RunActionResponse{} } +func (m *RunActionResponse) String() string { return proto.CompactTextString(m) } +func (*RunActionResponse) ProtoMessage() {} +func (*RunActionResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_28396c8d66e1a9b4, []int{4} +} +func (m *RunActionResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RunActionResponse.Unmarshal(m, b) +} +func (m *RunActionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RunActionResponse.Marshal(b, m, deterministic) +} +func (m *RunActionResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RunActionResponse.Merge(m, src) +} +func (m *RunActionResponse) XXX_Size() int { + return xxx_messageInfo_RunActionResponse.Size(m) +} +func (m *RunActionResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RunActionResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_RunActionResponse proto.InternalMessageInfo + +func (m *RunActionResponse) GetData() string { + if m != nil { + return m.Data + } + return "" +} + +func (m *RunActionResponse) GetError() string { + if m != nil { + return m.Error + } + return "" +} + +type SshInfoResponse struct { + Host string `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"` + Port int64 `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"` + PrivateKeyPath string `protobuf:"bytes,3,opt,name=private_key_path,json=privateKeyPath,proto3" json:"private_key_path,omitempty"` + Username string `protobuf:"bytes,4,opt,name=username,proto3" json:"username,omitempty"` + Error string `protobuf:"bytes,5,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SshInfoResponse) Reset() { *m = SshInfoResponse{} } +func (m *SshInfoResponse) String() string { return proto.CompactTextString(m) } +func (*SshInfoResponse) ProtoMessage() {} +func (*SshInfoResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_28396c8d66e1a9b4, []int{5} +} +func (m *SshInfoResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SshInfoResponse.Unmarshal(m, b) +} +func (m *SshInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SshInfoResponse.Marshal(b, m, deterministic) +} +func (m *SshInfoResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SshInfoResponse.Merge(m, src) +} +func (m *SshInfoResponse) XXX_Size() int { + return xxx_messageInfo_SshInfoResponse.Size(m) +} +func (m *SshInfoResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SshInfoResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_SshInfoResponse proto.InternalMessageInfo + +func (m *SshInfoResponse) GetHost() string { + if m != nil { + return m.Host + } + return "" +} + +func (m *SshInfoResponse) GetPort() int64 { + if m != nil { + return m.Port + } + return 0 +} + +func (m *SshInfoResponse) GetPrivateKeyPath() string { + if m != nil { + return m.PrivateKeyPath + } + return "" +} + +func (m *SshInfoResponse) GetUsername() string { + if m != nil { + return m.Username + } + return "" +} + +func (m *SshInfoResponse) GetError() string { + if m != nil { + return m.Error + } + return "" +} + +type StateResponse struct { + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + ShortDescription string `protobuf:"bytes,2,opt,name=short_description,json=shortDescription,proto3" json:"short_description,omitempty"` + LongDescription string `protobuf:"bytes,3,opt,name=long_description,json=longDescription,proto3" json:"long_description,omitempty"` + Error string `protobuf:"bytes,4,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StateResponse) Reset() { *m = StateResponse{} } +func (m *StateResponse) String() string { return proto.CompactTextString(m) } +func (*StateResponse) ProtoMessage() {} +func (*StateResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_28396c8d66e1a9b4, []int{6} +} +func (m *StateResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_StateResponse.Unmarshal(m, b) +} +func (m *StateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_StateResponse.Marshal(b, m, deterministic) +} +func (m *StateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_StateResponse.Merge(m, src) +} +func (m *StateResponse) XXX_Size() int { + return xxx_messageInfo_StateResponse.Size(m) +} +func (m *StateResponse) XXX_DiscardUnknown() { + xxx_messageInfo_StateResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_StateResponse proto.InternalMessageInfo + +func (m *StateResponse) GetId() string { + if m != nil { + return m.Id + } + return "" +} + +func (m *StateResponse) GetShortDescription() string { + if m != nil { + return m.ShortDescription + } + return "" +} + +func (m *StateResponse) GetLongDescription() string { + if m != nil { + return m.LongDescription + } + return "" +} + +func (m *StateResponse) GetError() string { + if m != nil { + return m.Error + } + return "" +} + +func init() { + proto.RegisterType((*ActionRequest)(nil), "vagrant.provider.ActionRequest") + proto.RegisterType((*ActionResponse)(nil), "vagrant.provider.ActionResponse") + proto.RegisterType((*InfoResponse)(nil), "vagrant.provider.InfoResponse") + proto.RegisterType((*RunActionRequest)(nil), "vagrant.provider.RunActionRequest") + proto.RegisterType((*RunActionResponse)(nil), "vagrant.provider.RunActionResponse") + proto.RegisterType((*SshInfoResponse)(nil), "vagrant.provider.SshInfoResponse") + proto.RegisterType((*StateResponse)(nil), "vagrant.provider.StateResponse") +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// ProviderClient is the client API for Provider service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type ProviderClient interface { + Action(ctx context.Context, in *ActionRequest, opts ...grpc.CallOption) (*ActionResponse, error) + Info(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*InfoResponse, error) + IsInstalled(ctx context.Context, in *vagrant_common.EmptyRequest, opts ...grpc.CallOption) (*vagrant_common.IsResponse, error) + IsUsable(ctx context.Context, in *vagrant_common.EmptyRequest, opts ...grpc.CallOption) (*vagrant_common.IsResponse, error) + MachineIdChanged(ctx context.Context, in *vagrant_common.EmptyRequest, opts ...grpc.CallOption) (*vagrant_common.EmptyResponse, error) + Name(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*vagrant_common.NameResponse, error) + RunAction(ctx context.Context, in *RunActionRequest, opts ...grpc.CallOption) (*RunActionResponse, error) + SshInfo(ctx context.Context, in *vagrant_common.EmptyRequest, opts ...grpc.CallOption) (*SshInfoResponse, error) + State(ctx context.Context, in *vagrant_common.EmptyRequest, opts ...grpc.CallOption) (*StateResponse, error) + // These are IO helpers for streaming + Read(ctx context.Context, in *vagrant_io.ReadRequest, opts ...grpc.CallOption) (*vagrant_io.ReadResponse, error) + Write(ctx context.Context, in *vagrant_io.WriteRequest, opts ...grpc.CallOption) (*vagrant_io.WriteResponse, error) + // These are Config helpers + ConfigAttributes(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*vagrant_config.AttributesResponse, error) + ConfigLoad(ctx context.Context, in *vagrant_config.LoadRequest, opts ...grpc.CallOption) (*vagrant_config.LoadResponse, error) + ConfigValidate(ctx context.Context, in *vagrant_config.ValidateRequest, opts ...grpc.CallOption) (*vagrant_config.ValidateResponse, error) + ConfigFinalize(ctx context.Context, in *vagrant_config.FinalizeRequest, opts ...grpc.CallOption) (*vagrant_config.FinalizeResponse, error) + // Capabilities + GuestCapabilities(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*vagrant_caps.CapabilitiesResponse, error) + GuestCapability(ctx context.Context, in *vagrant_caps.GuestCapabilityRequest, opts ...grpc.CallOption) (*vagrant_caps.GuestCapabilityResponse, error) + HostCapabilities(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*vagrant_caps.CapabilitiesResponse, error) + HostCapability(ctx context.Context, in *vagrant_caps.HostCapabilityRequest, opts ...grpc.CallOption) (*vagrant_caps.HostCapabilityResponse, error) + ProviderCapabilities(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*vagrant_caps.ProviderCapabilitiesResponse, error) + ProviderCapability(ctx context.Context, in *vagrant_caps.ProviderCapabilityRequest, opts ...grpc.CallOption) (*vagrant_caps.ProviderCapabilityResponse, error) +} + +type providerClient struct { + cc *grpc.ClientConn +} + +func NewProviderClient(cc *grpc.ClientConn) ProviderClient { + return &providerClient{cc} +} + +func (c *providerClient) Action(ctx context.Context, in *ActionRequest, opts ...grpc.CallOption) (*ActionResponse, error) { + out := new(ActionResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/Action", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) Info(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*InfoResponse, error) { + out := new(InfoResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/Info", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) IsInstalled(ctx context.Context, in *vagrant_common.EmptyRequest, opts ...grpc.CallOption) (*vagrant_common.IsResponse, error) { + out := new(vagrant_common.IsResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/IsInstalled", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) IsUsable(ctx context.Context, in *vagrant_common.EmptyRequest, opts ...grpc.CallOption) (*vagrant_common.IsResponse, error) { + out := new(vagrant_common.IsResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/IsUsable", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) MachineIdChanged(ctx context.Context, in *vagrant_common.EmptyRequest, opts ...grpc.CallOption) (*vagrant_common.EmptyResponse, error) { + out := new(vagrant_common.EmptyResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/MachineIdChanged", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) Name(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*vagrant_common.NameResponse, error) { + out := new(vagrant_common.NameResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/Name", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) RunAction(ctx context.Context, in *RunActionRequest, opts ...grpc.CallOption) (*RunActionResponse, error) { + out := new(RunActionResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/RunAction", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) SshInfo(ctx context.Context, in *vagrant_common.EmptyRequest, opts ...grpc.CallOption) (*SshInfoResponse, error) { + out := new(SshInfoResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/SshInfo", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) State(ctx context.Context, in *vagrant_common.EmptyRequest, opts ...grpc.CallOption) (*StateResponse, error) { + out := new(StateResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/State", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) Read(ctx context.Context, in *vagrant_io.ReadRequest, opts ...grpc.CallOption) (*vagrant_io.ReadResponse, error) { + out := new(vagrant_io.ReadResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/Read", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) Write(ctx context.Context, in *vagrant_io.WriteRequest, opts ...grpc.CallOption) (*vagrant_io.WriteResponse, error) { + out := new(vagrant_io.WriteResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/Write", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) ConfigAttributes(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*vagrant_config.AttributesResponse, error) { + out := new(vagrant_config.AttributesResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/ConfigAttributes", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) ConfigLoad(ctx context.Context, in *vagrant_config.LoadRequest, opts ...grpc.CallOption) (*vagrant_config.LoadResponse, error) { + out := new(vagrant_config.LoadResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/ConfigLoad", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) ConfigValidate(ctx context.Context, in *vagrant_config.ValidateRequest, opts ...grpc.CallOption) (*vagrant_config.ValidateResponse, error) { + out := new(vagrant_config.ValidateResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/ConfigValidate", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) ConfigFinalize(ctx context.Context, in *vagrant_config.FinalizeRequest, opts ...grpc.CallOption) (*vagrant_config.FinalizeResponse, error) { + out := new(vagrant_config.FinalizeResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/ConfigFinalize", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) GuestCapabilities(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*vagrant_caps.CapabilitiesResponse, error) { + out := new(vagrant_caps.CapabilitiesResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/GuestCapabilities", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) GuestCapability(ctx context.Context, in *vagrant_caps.GuestCapabilityRequest, opts ...grpc.CallOption) (*vagrant_caps.GuestCapabilityResponse, error) { + out := new(vagrant_caps.GuestCapabilityResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/GuestCapability", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) HostCapabilities(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*vagrant_caps.CapabilitiesResponse, error) { + out := new(vagrant_caps.CapabilitiesResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/HostCapabilities", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) HostCapability(ctx context.Context, in *vagrant_caps.HostCapabilityRequest, opts ...grpc.CallOption) (*vagrant_caps.HostCapabilityResponse, error) { + out := new(vagrant_caps.HostCapabilityResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/HostCapability", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) ProviderCapabilities(ctx context.Context, in *vagrant_common.NullRequest, opts ...grpc.CallOption) (*vagrant_caps.ProviderCapabilitiesResponse, error) { + out := new(vagrant_caps.ProviderCapabilitiesResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/ProviderCapabilities", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *providerClient) ProviderCapability(ctx context.Context, in *vagrant_caps.ProviderCapabilityRequest, opts ...grpc.CallOption) (*vagrant_caps.ProviderCapabilityResponse, error) { + out := new(vagrant_caps.ProviderCapabilityResponse) + err := c.cc.Invoke(ctx, "/vagrant.provider.Provider/ProviderCapability", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// ProviderServer is the server API for Provider service. +type ProviderServer interface { + Action(context.Context, *ActionRequest) (*ActionResponse, error) + Info(context.Context, *vagrant_common.NullRequest) (*InfoResponse, error) + IsInstalled(context.Context, *vagrant_common.EmptyRequest) (*vagrant_common.IsResponse, error) + IsUsable(context.Context, *vagrant_common.EmptyRequest) (*vagrant_common.IsResponse, error) + MachineIdChanged(context.Context, *vagrant_common.EmptyRequest) (*vagrant_common.EmptyResponse, error) + Name(context.Context, *vagrant_common.NullRequest) (*vagrant_common.NameResponse, error) + RunAction(context.Context, *RunActionRequest) (*RunActionResponse, error) + SshInfo(context.Context, *vagrant_common.EmptyRequest) (*SshInfoResponse, error) + State(context.Context, *vagrant_common.EmptyRequest) (*StateResponse, error) + // These are IO helpers for streaming + Read(context.Context, *vagrant_io.ReadRequest) (*vagrant_io.ReadResponse, error) + Write(context.Context, *vagrant_io.WriteRequest) (*vagrant_io.WriteResponse, error) + // These are Config helpers + ConfigAttributes(context.Context, *vagrant_common.NullRequest) (*vagrant_config.AttributesResponse, error) + ConfigLoad(context.Context, *vagrant_config.LoadRequest) (*vagrant_config.LoadResponse, error) + ConfigValidate(context.Context, *vagrant_config.ValidateRequest) (*vagrant_config.ValidateResponse, error) + ConfigFinalize(context.Context, *vagrant_config.FinalizeRequest) (*vagrant_config.FinalizeResponse, error) + // Capabilities + GuestCapabilities(context.Context, *vagrant_common.NullRequest) (*vagrant_caps.CapabilitiesResponse, error) + GuestCapability(context.Context, *vagrant_caps.GuestCapabilityRequest) (*vagrant_caps.GuestCapabilityResponse, error) + HostCapabilities(context.Context, *vagrant_common.NullRequest) (*vagrant_caps.CapabilitiesResponse, error) + HostCapability(context.Context, *vagrant_caps.HostCapabilityRequest) (*vagrant_caps.HostCapabilityResponse, error) + ProviderCapabilities(context.Context, *vagrant_common.NullRequest) (*vagrant_caps.ProviderCapabilitiesResponse, error) + ProviderCapability(context.Context, *vagrant_caps.ProviderCapabilityRequest) (*vagrant_caps.ProviderCapabilityResponse, error) +} + +func RegisterProviderServer(s *grpc.Server, srv ProviderServer) { + s.RegisterService(&_Provider_serviceDesc, srv) +} + +func _Provider_Action_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ActionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).Action(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/Action", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).Action(ctx, req.(*ActionRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_Info_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.NullRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).Info(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/Info", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).Info(ctx, req.(*vagrant_common.NullRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_IsInstalled_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.EmptyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).IsInstalled(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/IsInstalled", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).IsInstalled(ctx, req.(*vagrant_common.EmptyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_IsUsable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.EmptyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).IsUsable(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/IsUsable", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).IsUsable(ctx, req.(*vagrant_common.EmptyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_MachineIdChanged_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.EmptyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).MachineIdChanged(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/MachineIdChanged", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).MachineIdChanged(ctx, req.(*vagrant_common.EmptyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_Name_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.NullRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).Name(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/Name", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).Name(ctx, req.(*vagrant_common.NullRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_RunAction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RunActionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).RunAction(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/RunAction", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).RunAction(ctx, req.(*RunActionRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_SshInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.EmptyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).SshInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/SshInfo", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).SshInfo(ctx, req.(*vagrant_common.EmptyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_State_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.EmptyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).State(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/State", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).State(ctx, req.(*vagrant_common.EmptyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_Read_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_io.ReadRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).Read(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/Read", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).Read(ctx, req.(*vagrant_io.ReadRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_Write_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_io.WriteRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).Write(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/Write", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).Write(ctx, req.(*vagrant_io.WriteRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_ConfigAttributes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.NullRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).ConfigAttributes(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/ConfigAttributes", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).ConfigAttributes(ctx, req.(*vagrant_common.NullRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_ConfigLoad_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_config.LoadRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).ConfigLoad(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/ConfigLoad", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).ConfigLoad(ctx, req.(*vagrant_config.LoadRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_ConfigValidate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_config.ValidateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).ConfigValidate(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/ConfigValidate", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).ConfigValidate(ctx, req.(*vagrant_config.ValidateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_ConfigFinalize_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_config.FinalizeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).ConfigFinalize(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/ConfigFinalize", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).ConfigFinalize(ctx, req.(*vagrant_config.FinalizeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_GuestCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.NullRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).GuestCapabilities(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/GuestCapabilities", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).GuestCapabilities(ctx, req.(*vagrant_common.NullRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_GuestCapability_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_caps.GuestCapabilityRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).GuestCapability(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/GuestCapability", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).GuestCapability(ctx, req.(*vagrant_caps.GuestCapabilityRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_HostCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.NullRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).HostCapabilities(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/HostCapabilities", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).HostCapabilities(ctx, req.(*vagrant_common.NullRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_HostCapability_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_caps.HostCapabilityRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).HostCapability(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/HostCapability", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).HostCapability(ctx, req.(*vagrant_caps.HostCapabilityRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_ProviderCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_common.NullRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).ProviderCapabilities(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/ProviderCapabilities", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).ProviderCapabilities(ctx, req.(*vagrant_common.NullRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Provider_ProviderCapability_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vagrant_caps.ProviderCapabilityRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProviderServer).ProviderCapability(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vagrant.provider.Provider/ProviderCapability", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProviderServer).ProviderCapability(ctx, req.(*vagrant_caps.ProviderCapabilityRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Provider_serviceDesc = grpc.ServiceDesc{ + ServiceName: "vagrant.provider.Provider", + HandlerType: (*ProviderServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Action", + Handler: _Provider_Action_Handler, + }, + { + MethodName: "Info", + Handler: _Provider_Info_Handler, + }, + { + MethodName: "IsInstalled", + Handler: _Provider_IsInstalled_Handler, + }, + { + MethodName: "IsUsable", + Handler: _Provider_IsUsable_Handler, + }, + { + MethodName: "MachineIdChanged", + Handler: _Provider_MachineIdChanged_Handler, + }, + { + MethodName: "Name", + Handler: _Provider_Name_Handler, + }, + { + MethodName: "RunAction", + Handler: _Provider_RunAction_Handler, + }, + { + MethodName: "SshInfo", + Handler: _Provider_SshInfo_Handler, + }, + { + MethodName: "State", + Handler: _Provider_State_Handler, + }, + { + MethodName: "Read", + Handler: _Provider_Read_Handler, + }, + { + MethodName: "Write", + Handler: _Provider_Write_Handler, + }, + { + MethodName: "ConfigAttributes", + Handler: _Provider_ConfigAttributes_Handler, + }, + { + MethodName: "ConfigLoad", + Handler: _Provider_ConfigLoad_Handler, + }, + { + MethodName: "ConfigValidate", + Handler: _Provider_ConfigValidate_Handler, + }, + { + MethodName: "ConfigFinalize", + Handler: _Provider_ConfigFinalize_Handler, + }, + { + MethodName: "GuestCapabilities", + Handler: _Provider_GuestCapabilities_Handler, + }, + { + MethodName: "GuestCapability", + Handler: _Provider_GuestCapability_Handler, + }, + { + MethodName: "HostCapabilities", + Handler: _Provider_HostCapabilities_Handler, + }, + { + MethodName: "HostCapability", + Handler: _Provider_HostCapability_Handler, + }, + { + MethodName: "ProviderCapabilities", + Handler: _Provider_ProviderCapabilities_Handler, + }, + { + MethodName: "ProviderCapability", + Handler: _Provider_ProviderCapability_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "vagrant_provider/provider.proto", +} + +func init() { proto.RegisterFile("vagrant_provider/provider.proto", fileDescriptor_28396c8d66e1a9b4) } + +var fileDescriptor_28396c8d66e1a9b4 = []byte{ + // 830 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0x5d, 0x6f, 0xf3, 0x34, + 0x14, 0xc7, 0xd5, 0x35, 0xdd, 0xcb, 0xd9, 0xd6, 0x75, 0xd6, 0x04, 0xa5, 0xbc, 0xac, 0x74, 0x43, + 0x14, 0x10, 0x8d, 0x04, 0x57, 0x48, 0x0c, 0x69, 0xea, 0xd8, 0x28, 0x83, 0x31, 0xb5, 0x03, 0x2e, + 0x26, 0x51, 0xb9, 0x8d, 0x97, 0x58, 0xa4, 0x71, 0xb0, 0x9d, 0x89, 0xf2, 0x1d, 0xb8, 0xe4, 0x8e, + 0x0f, 0xfb, 0x28, 0x89, 0xed, 0xe6, 0xa5, 0x6b, 0x27, 0x3d, 0xbd, 0xaa, 0x7d, 0xce, 0xff, 0xfc, + 0x7c, 0x7c, 0xec, 0x13, 0x17, 0x4e, 0x9f, 0xb1, 0xcb, 0x71, 0x20, 0xc7, 0x21, 0x67, 0xcf, 0xd4, + 0x21, 0xdc, 0xd6, 0x83, 0x5e, 0xc8, 0x99, 0x64, 0xa8, 0xa1, 0x04, 0x3d, 0x6d, 0x6f, 0x8d, 0x5d, + 0x2a, 0xbd, 0x68, 0xd2, 0x9b, 0xb2, 0x99, 0xed, 0x61, 0xe1, 0xd1, 0x29, 0xe3, 0xa1, 0xad, 0x64, + 0x36, 0xf9, 0x5b, 0xda, 0x2e, 0xfb, 0x32, 0xf4, 0x23, 0x97, 0x06, 0xc6, 0xaa, 0xa6, 0x09, 0x52, + 0x1b, 0xc7, 0x53, 0x1c, 0x0a, 0x7b, 0x8a, 0x43, 0x3c, 0xa1, 0x3e, 0x95, 0x94, 0x88, 0x74, 0xc9, + 0xd6, 0xe3, 0xc6, 0x16, 0x60, 0xb3, 0x19, 0x0b, 0xec, 0xf4, 0x67, 0xf3, 0xf0, 0xe0, 0x89, 0xba, + 0x76, 0xfa, 0xa3, 0xe0, 0xa3, 0x4d, 0xc1, 0x29, 0xb3, 0x29, 0x4b, 0xa1, 0x9d, 0x0b, 0x38, 0xbc, + 0x9c, 0x4a, 0xca, 0x82, 0x21, 0xf9, 0x2b, 0x22, 0x42, 0x22, 0x04, 0x56, 0x80, 0x67, 0xa4, 0x59, + 0x69, 0x57, 0xba, 0x7b, 0xc3, 0x64, 0x8c, 0x9a, 0xb0, 0x33, 0xc3, 0x53, 0x8f, 0x06, 0xa4, 0xb9, + 0x95, 0x98, 0xf5, 0xb4, 0xf3, 0x1d, 0xd4, 0x75, 0xb8, 0x08, 0x59, 0x20, 0x08, 0x7a, 0x07, 0xb6, + 0x39, 0x11, 0x91, 0x2f, 0x9b, 0x95, 0x76, 0xb5, 0xbb, 0x37, 0x54, 0x33, 0x74, 0x02, 0x35, 0xc2, + 0x39, 0xe3, 0x8a, 0x90, 0x4e, 0x3a, 0x21, 0x1c, 0x0c, 0x82, 0x27, 0x66, 0xa2, 0x3b, 0x70, 0x90, + 0x3d, 0x33, 0xc5, 0xc8, 0xd9, 0x50, 0x1b, 0xf6, 0x1d, 0x22, 0xa6, 0x9c, 0x86, 0xf1, 0xc2, 0x8a, + 0x97, 0x35, 0xa1, 0x16, 0xec, 0x86, 0x9c, 0x32, 0x4e, 0xe5, 0xbc, 0x59, 0x6d, 0x57, 0xba, 0xd5, + 0xa1, 0x99, 0x77, 0x1e, 0xa0, 0x31, 0x8c, 0x82, 0xf5, 0x7b, 0x46, 0x60, 0x39, 0x58, 0x62, 0x85, + 0x4f, 0xc6, 0xd9, 0x3a, 0x54, 0xf3, 0x75, 0xb8, 0x80, 0xe3, 0x0c, 0x55, 0x6d, 0x46, 0x23, 0x2a, + 0x19, 0xc4, 0xf2, 0x32, 0xfc, 0x57, 0x81, 0xa3, 0x91, 0xf0, 0x72, 0xa5, 0x40, 0x60, 0x79, 0x4c, + 0x48, 0x1d, 0x1d, 0x8f, 0x63, 0x5b, 0xc8, 0xb8, 0x4c, 0x82, 0xab, 0xc3, 0x64, 0x8c, 0xba, 0xd0, + 0x08, 0x39, 0x7d, 0xc6, 0x92, 0x8c, 0xff, 0x24, 0xf3, 0x71, 0x88, 0xa5, 0xa7, 0xb2, 0xab, 0x2b, + 0xfb, 0x2d, 0x99, 0xdf, 0x63, 0xe9, 0xc5, 0x65, 0x89, 0x04, 0xe1, 0xc9, 0x56, 0xad, 0x44, 0x61, + 0xe6, 0x8b, 0xbc, 0x6a, 0xd9, 0xbc, 0xfe, 0xad, 0xc0, 0xe1, 0x48, 0x62, 0x49, 0x4c, 0x56, 0x75, + 0xd8, 0xa2, 0x8e, 0xca, 0x69, 0x8b, 0x3a, 0xe8, 0x0b, 0x38, 0x16, 0x1e, 0xe3, 0x72, 0x5c, 0x3e, + 0x92, 0x46, 0xe2, 0xb8, 0xca, 0x9c, 0xcb, 0x67, 0xd0, 0xf0, 0x59, 0xe0, 0xe6, 0xb4, 0x69, 0xaa, + 0x47, 0xb1, 0x3d, 0x2b, 0x35, 0xf9, 0x58, 0x99, 0x7c, 0xbe, 0xfa, 0xff, 0x10, 0x76, 0xef, 0xd5, + 0xa7, 0x02, 0xdd, 0xc2, 0x76, 0x5a, 0x70, 0x74, 0xda, 0x2b, 0x7e, 0x47, 0x7a, 0xb9, 0x03, 0x6e, + 0xb5, 0x5f, 0x16, 0xa8, 0x7d, 0xf5, 0xc1, 0x8a, 0xab, 0x8f, 0xde, 0x37, 0x4a, 0xd5, 0xd8, 0x77, + 0x91, 0xef, 0x6b, 0xcc, 0x47, 0x65, 0x4c, 0xee, 0xc8, 0x6e, 0x60, 0x7f, 0x20, 0x06, 0x81, 0x90, + 0xd8, 0xf7, 0x89, 0x83, 0x3e, 0x28, 0xb2, 0xbe, 0x9f, 0x85, 0x72, 0xae, 0x61, 0xad, 0xa2, 0x77, + 0x20, 0x0c, 0xe8, 0x0a, 0x76, 0x07, 0xe2, 0x57, 0x81, 0x27, 0x3e, 0x79, 0x0b, 0xca, 0x2f, 0xd0, + 0xf8, 0x39, 0xbd, 0x9f, 0x03, 0xa7, 0xef, 0xe1, 0xc0, 0x5d, 0x9b, 0xd3, 0x87, 0x2f, 0x78, 0x15, + 0xf0, 0x12, 0xac, 0xbb, 0xf8, 0xb2, 0xac, 0x2c, 0x52, 0x69, 0x85, 0x38, 0xc4, 0x20, 0x1e, 0x60, + 0xcf, 0x34, 0x0a, 0xea, 0x94, 0xeb, 0x59, 0xec, 0xcd, 0xd6, 0xd9, 0x4a, 0x8d, 0xa2, 0xfe, 0x08, + 0x3b, 0xaa, 0x7d, 0xd6, 0x6c, 0xf0, 0xe3, 0x32, 0xad, 0xd8, 0x77, 0xd7, 0x50, 0x4b, 0xae, 0xfc, + 0x1a, 0xd2, 0x92, 0x3b, 0x97, 0xef, 0x94, 0x6f, 0xc0, 0x1a, 0x12, 0xec, 0xa0, 0x77, 0x8d, 0x90, + 0xb2, 0x5e, 0x6c, 0xd1, 0x84, 0x66, 0xd9, 0xa1, 0x42, 0xbf, 0x85, 0xda, 0xef, 0x9c, 0x4a, 0x82, + 0x72, 0x92, 0xc4, 0xa4, 0x83, 0xdf, 0x5b, 0xe2, 0x51, 0xd1, 0x23, 0x68, 0xf4, 0x93, 0x77, 0xe3, + 0x52, 0x4a, 0x4e, 0x27, 0x91, 0x24, 0x62, 0xf5, 0x89, 0x75, 0x32, 0xce, 0xe4, 0xbd, 0x59, 0x04, + 0x66, 0xae, 0x36, 0xa4, 0xd0, 0x9f, 0x18, 0x76, 0x72, 0xb8, 0x24, 0x22, 0xb6, 0x2e, 0xbb, 0x00, + 0x19, 0xa7, 0xc9, 0xae, 0x9e, 0x82, 0x7e, 0xc3, 0x3e, 0x75, 0xe2, 0x3a, 0x9f, 0x16, 0xf5, 0xda, + 0x53, 0xee, 0xde, 0x92, 0xa0, 0x08, 0xbd, 0xa6, 0x01, 0xf6, 0xe9, 0x3f, 0x4b, 0xa0, 0xda, 0xf3, + 0x22, 0x74, 0x21, 0x30, 0x57, 0xf5, 0xf8, 0x26, 0x96, 0xf6, 0xb3, 0x8f, 0xcf, 0x6b, 0x0b, 0x89, + 0x43, 0xd1, 0xcb, 0x06, 0x1a, 0xea, 0x1f, 0x70, 0x94, 0xa7, 0xce, 0xd1, 0x79, 0x3e, 0xac, 0xe0, + 0xd6, 0xf0, 0x4f, 0xd6, 0xa8, 0x16, 0xa7, 0xff, 0x03, 0xdb, 0x74, 0xd2, 0x8f, 0x50, 0xcf, 0x41, + 0xe7, 0xe8, 0x2c, 0x1f, 0x95, 0xf7, 0x6a, 0xf4, 0xf9, 0x6a, 0x91, 0x82, 0x8f, 0xe1, 0x44, 0x7f, + 0xd3, 0x5f, 0x9f, 0xf5, 0xe7, 0x79, 0xf4, 0x32, 0x80, 0x59, 0xc0, 0x05, 0x54, 0xf2, 0xcf, 0xd1, + 0xa7, 0x6b, 0x08, 0x66, 0x17, 0xdd, 0xf5, 0xc2, 0x74, 0xa1, 0xc9, 0x76, 0xf2, 0x9f, 0xea, 0xeb, + 0x37, 0x01, 0x00, 0x00, 0xff, 0xff, 0x68, 0xce, 0xef, 0x16, 0xf8, 0x0a, 0x00, 0x00, +} diff --git a/ext/go-plugin/vagrant/plugin/proto/vagrant_provider/provider.proto b/ext/go-plugin/vagrant/plugin/proto/vagrant_provider/provider.proto new file mode 100644 index 000000000..6580fae84 --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/proto/vagrant_provider/provider.proto @@ -0,0 +1,74 @@ +syntax = "proto3"; +package vagrant.provider; + +import "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_caps/capabilities.proto"; +import "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_common/common.proto"; +import "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_config/config.proto"; +import "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_io/io.proto"; + +message ActionRequest { + string name = 1; + string machine = 2; +} +message ActionResponse { + repeated string result = 1; + string error = 2; +} + +message InfoResponse { + repeated string capabilities = 1; + string description = 2; + int64 priority = 3; +} + +message RunActionRequest { + string name = 1; + string data = 2; + string machine = 3; +} + +message RunActionResponse { + string data = 1; + string error = 2; +} + +message SshInfoResponse { + string host = 1; + int64 port = 2; + string private_key_path = 3; + string username = 4; + string error = 5; +} +message StateResponse { + string id = 1; + string short_description = 2; + string long_description = 3; + string error = 4; +} + +service Provider { + rpc Action(ActionRequest) returns (ActionResponse); + rpc Info(vagrant.common.NullRequest) returns (InfoResponse); + rpc IsInstalled(vagrant.common.EmptyRequest) returns (vagrant.common.IsResponse); + rpc IsUsable(vagrant.common.EmptyRequest) returns (vagrant.common.IsResponse); + rpc MachineIdChanged(vagrant.common.EmptyRequest) returns (vagrant.common.EmptyResponse); + rpc Name(vagrant.common.NullRequest) returns (vagrant.common.NameResponse); + rpc RunAction(RunActionRequest) returns (RunActionResponse); + rpc SshInfo(vagrant.common.EmptyRequest) returns (SshInfoResponse); + rpc State(vagrant.common.EmptyRequest) returns (StateResponse); + // These are IO helpers for streaming + rpc Read(vagrant.io.ReadRequest) returns (vagrant.io.ReadResponse); + rpc Write(vagrant.io.WriteRequest) returns (vagrant.io.WriteResponse); + // These are Config helpers + rpc ConfigAttributes(vagrant.common.NullRequest) returns (vagrant.config.AttributesResponse); + rpc ConfigLoad(vagrant.config.LoadRequest) returns (vagrant.config.LoadResponse); + rpc ConfigValidate(vagrant.config.ValidateRequest) returns (vagrant.config.ValidateResponse); + rpc ConfigFinalize(vagrant.config.FinalizeRequest) returns (vagrant.config.FinalizeResponse); + // Capabilities + rpc GuestCapabilities(vagrant.common.NullRequest) returns (vagrant.caps.CapabilitiesResponse); + rpc GuestCapability(vagrant.caps.GuestCapabilityRequest) returns (vagrant.caps.GuestCapabilityResponse); + rpc HostCapabilities(vagrant.common.NullRequest) returns (vagrant.caps.CapabilitiesResponse); + rpc HostCapability(vagrant.caps.HostCapabilityRequest) returns (vagrant.caps.HostCapabilityResponse); + rpc ProviderCapabilities(vagrant.common.NullRequest) returns (vagrant.caps.ProviderCapabilitiesResponse); + rpc ProviderCapability(vagrant.caps.ProviderCapabilityRequest) returns (vagrant.caps.ProviderCapabilityResponse); +} \ No newline at end of file diff --git a/ext/go-plugin/vagrant/plugin/provider.go b/ext/go-plugin/vagrant/plugin/provider.go new file mode 100644 index 000000000..b6734fc13 --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/provider.go @@ -0,0 +1,363 @@ +package plugin + +import ( + "context" + "errors" + + "google.golang.org/grpc" + + go_plugin "github.com/hashicorp/go-plugin" + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant" + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_common" + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_provider" +) + +type Provider interface { + vagrant.Provider + Meta +} + +type ProviderPlugin struct { + go_plugin.NetRPCUnsupportedPlugin + Impl Provider +} + +type GRPCProviderClient struct { + GRPCCoreClient + GRPCConfigClient + GRPCGuestCapabilitiesClient + GRPCHostCapabilitiesClient + GRPCProviderCapabilitiesClient + GRPCIOClient + client vagrant_provider.ProviderClient +} + +func (c *GRPCProviderClient) Action(actionName string, m *vagrant.Machine) (r []string, err error) { + machData, err := vagrant.DumpMachine(m) + if err != nil { + return + } + resp, err := c.client.Action(context.Background(), &vagrant_provider.ActionRequest{ + Name: actionName, + Machine: machData}) + if err != nil { + return + } + r = resp.Result + if resp.Error != "" { + err = errors.New(resp.Error) + } + return +} + +func (c *GRPCProviderClient) Info() *vagrant.ProviderInfo { + resp, err := c.client.Info(context.Background(), &vagrant_common.NullRequest{}) + if err != nil { + return &vagrant.ProviderInfo{} + } + return &vagrant.ProviderInfo{ + Description: resp.Description, + Priority: resp.Priority} +} + +func (c *GRPCProviderClient) IsInstalled(m *vagrant.Machine) (r bool, err error) { + machData, err := vagrant.DumpMachine(m) + if err != nil { + return + } + resp, err := c.client.IsInstalled(context.Background(), &vagrant_common.EmptyRequest{ + Machine: machData}) + if err != nil { + return + } + r = resp.Result + if resp.Error != "" { + err = errors.New(resp.Error) + } + return +} + +func (c *GRPCProviderClient) IsUsable(m *vagrant.Machine) (r bool, err error) { + machData, err := vagrant.DumpMachine(m) + if err != nil { + return + } + resp, err := c.client.IsUsable(context.Background(), &vagrant_common.EmptyRequest{ + Machine: machData}) + if err != nil { + return + } + r = resp.Result + if resp.Error != "" { + err = errors.New(resp.Error) + } + return +} + +func (c *GRPCProviderClient) MachineIdChanged(m *vagrant.Machine) (err error) { + machData, err := vagrant.DumpMachine(m) + if err != nil { + return + } + resp, err := c.client.MachineIdChanged(context.Background(), &vagrant_common.EmptyRequest{ + Machine: machData}) + if err != nil { + return + } + if resp.Error != "" { + err = errors.New(resp.Error) + } + return +} + +func (c *GRPCProviderClient) RunAction(actName string, runData string, m *vagrant.Machine) (r string, err error) { + machData, err := vagrant.DumpMachine(m) + if err != nil { + return + } + resp, err := c.client.RunAction(context.Background(), &vagrant_provider.RunActionRequest{ + Name: actName, + Data: runData, + Machine: machData}) + if err != nil { + return + } + r = resp.Data + if resp.Error != "" { + err = errors.New(resp.Error) + } + return +} + +func (c *GRPCProviderClient) SshInfo(m *vagrant.Machine) (r *vagrant.SshInfo, err error) { + machData, err := vagrant.DumpMachine(m) + if err != nil { + return + } + resp, err := c.client.SshInfo(context.Background(), &vagrant_common.EmptyRequest{ + Machine: machData}) + if err != nil { + return + } + if resp.Error != "" { + err = errors.New(resp.Error) + } + r = &vagrant.SshInfo{ + Host: resp.Host, + Port: resp.Port, + PrivateKeyPath: resp.PrivateKeyPath, + Username: resp.Username} + return +} + +func (c *GRPCProviderClient) State(m *vagrant.Machine) (r *vagrant.MachineState, err error) { + machData, err := vagrant.DumpMachine(m) + if err != nil { + return + } + resp, err := c.client.State(context.Background(), &vagrant_common.EmptyRequest{ + Machine: machData}) + if err != nil { + return + } + if resp.Error != "" { + err = errors.New(resp.Error) + } + r = &vagrant.MachineState{ + Id: resp.Id, + ShortDesc: resp.ShortDescription, + LongDesc: resp.LongDescription} + return +} + +func (c *GRPCProviderClient) Name() string { + resp, err := c.client.Name(context.Background(), &vagrant_common.NullRequest{}) + if err != nil { + return "" + } + return resp.Name +} + +func (p *ProviderPlugin) GRPCServer(broker *go_plugin.GRPCBroker, s *grpc.Server) error { + return nil +} + +func (p *ProviderPlugin) GRPCClient(ctx context.Context, broker *go_plugin.GRPCBroker, c *grpc.ClientConn) (interface{}, error) { + client := vagrant_provider.NewProviderClient(c) + return &GRPCProviderClient{ + GRPCConfigClient: GRPCConfigClient{ + client: client}, + GRPCGuestCapabilitiesClient: GRPCGuestCapabilitiesClient{ + client: client}, + GRPCHostCapabilitiesClient: GRPCHostCapabilitiesClient{ + client: client}, + GRPCProviderCapabilitiesClient: GRPCProviderCapabilitiesClient{ + client: client}, + GRPCIOClient: GRPCIOClient{ + client: client}, + client: client, + }, nil +} + +type GRPCProviderPlugin struct { + ProviderPlugin + Impl Provider +} + +func (p *GRPCProviderPlugin) GRPCServer(broker *go_plugin.GRPCBroker, s *grpc.Server) error { + p.Impl.Init() + vagrant_provider.RegisterProviderServer(s, &GRPCProviderServer{ + Impl: p.Impl, + GRPCConfigServer: GRPCConfigServer{ + Impl: p.Impl}, + GRPCGuestCapabilitiesServer: GRPCGuestCapabilitiesServer{ + Impl: p.Impl}, + GRPCHostCapabilitiesServer: GRPCHostCapabilitiesServer{ + Impl: p.Impl}, + GRPCProviderCapabilitiesServer: GRPCProviderCapabilitiesServer{ + Impl: p.Impl}, + GRPCIOServer: GRPCIOServer{ + Impl: p.Impl}}) + return nil +} + +func (p *GRPCProviderPlugin) GRPCClient(context.Context, *go_plugin.GRPCBroker, *grpc.ClientConn) (interface{}, error) { + return nil, nil +} + +type GRPCProviderServer struct { + GRPCIOServer + GRPCConfigServer + GRPCGuestCapabilitiesServer + GRPCHostCapabilitiesServer + GRPCProviderCapabilitiesServer + Impl Provider +} + +func (s *GRPCProviderServer) Action(ctx context.Context, req *vagrant_provider.ActionRequest) (resp *vagrant_provider.ActionResponse, err error) { + resp = &vagrant_provider.ActionResponse{} + m, e := vagrant.LoadMachine(req.Machine, s.Impl) + if e != nil { + resp.Error = e.Error() + return + } + r, e := s.Impl.Action(req.Name, m) + if e != nil { + resp.Error = e.Error() + return + } + resp.Result = r + return +} + +func (s *GRPCProviderServer) RunAction(ctx context.Context, req *vagrant_provider.RunActionRequest) (resp *vagrant_provider.RunActionResponse, err error) { + resp = &vagrant_provider.RunActionResponse{} + m, e := vagrant.LoadMachine(req.Machine, s.Impl) + if e != nil { + resp.Error = e.Error() + return + } + r, e := s.Impl.RunAction(req.Name, req.Data, m) + if e != nil { + resp.Error = e.Error() + return + } + resp.Data = r + return +} + +func (s *GRPCProviderServer) Info(ctx context.Context, req *vagrant_common.NullRequest) (*vagrant_provider.InfoResponse, error) { + r := s.Impl.Info() + return &vagrant_provider.InfoResponse{ + Description: r.Description, + Priority: r.Priority}, nil +} + +func (s *GRPCProviderServer) IsInstalled(ctx context.Context, req *vagrant_common.EmptyRequest) (resp *vagrant_common.IsResponse, err error) { + resp = &vagrant_common.IsResponse{} + m, e := vagrant.LoadMachine(req.Machine, s.Impl) + if e != nil { + resp.Error = e.Error() + return + } + r, e := s.Impl.IsInstalled(m) + if e != nil { + resp.Error = e.Error() + return + } + resp.Result = r + return +} + +func (s *GRPCProviderServer) IsUsable(ctx context.Context, req *vagrant_common.EmptyRequest) (resp *vagrant_common.IsResponse, err error) { + resp = &vagrant_common.IsResponse{} + m, e := vagrant.LoadMachine(req.Machine, s.Impl) + if e != nil { + resp.Error = e.Error() + return + } + r, e := s.Impl.IsUsable(m) + if e != nil { + resp.Error = e.Error() + return + } + resp.Result = r + return +} + +func (s *GRPCProviderServer) SshInfo(ctx context.Context, req *vagrant_common.EmptyRequest) (resp *vagrant_provider.SshInfoResponse, err error) { + resp = &vagrant_provider.SshInfoResponse{} + m, e := vagrant.LoadMachine(req.Machine, s.Impl) + if e != nil { + resp.Error = e.Error() + return + } + r, e := s.Impl.SshInfo(m) + if e != nil { + resp.Error = e.Error() + return + } + resp = &vagrant_provider.SshInfoResponse{ + Host: r.Host, + Port: r.Port, + Username: r.Username, + PrivateKeyPath: r.PrivateKeyPath} + return +} + +func (s *GRPCProviderServer) State(ctx context.Context, req *vagrant_common.EmptyRequest) (resp *vagrant_provider.StateResponse, err error) { + resp = &vagrant_provider.StateResponse{} + m, e := vagrant.LoadMachine(req.Machine, s.Impl) + if e != nil { + resp.Error = e.Error() + return + } + r, e := s.Impl.State(m) + if e != nil { + resp.Error = e.Error() + return + } + resp = &vagrant_provider.StateResponse{ + Id: r.Id, + ShortDescription: r.ShortDesc, + LongDescription: r.LongDesc} + return +} + +func (s *GRPCProviderServer) MachineIdChanged(ctx context.Context, req *vagrant_common.EmptyRequest) (resp *vagrant_common.EmptyResponse, err error) { + resp = &vagrant_common.EmptyResponse{} + m, e := vagrant.LoadMachine(req.Machine, s.Impl) + if e != nil { + resp.Error = e.Error() + return + } + e = s.Impl.MachineIdChanged(m) + if e != nil { + resp.Error = e.Error() + } + return +} + +func (s *GRPCProviderServer) Name(ctx context.Context, req *vagrant_common.NullRequest) (*vagrant_common.NameResponse, error) { + return &vagrant_common.NameResponse{Name: s.Impl.Name()}, nil +} diff --git a/ext/go-plugin/vagrant/plugin/synced_folder.go b/ext/go-plugin/vagrant/plugin/synced_folder.go new file mode 100644 index 000000000..443013471 --- /dev/null +++ b/ext/go-plugin/vagrant/plugin/synced_folder.go @@ -0,0 +1,291 @@ +package plugin + +import ( + "context" + "encoding/json" + "errors" + + "google.golang.org/grpc" + + go_plugin "github.com/hashicorp/go-plugin" + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant" + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_common" + "github.com/hashicorp/vagrant/ext/go-plugin/vagrant/plugin/proto/vagrant_folder" +) + +type SyncedFolder interface { + vagrant.SyncedFolder + Meta +} + +type SyncedFolderPlugin struct { + go_plugin.NetRPCUnsupportedPlugin + Impl SyncedFolder +} + +type GRPCSyncedFolderClient struct { + GRPCCoreClient + GRPCGuestCapabilitiesClient + GRPCHostCapabilitiesClient + GRPCIOClient + client vagrant_folder.SyncedFolderClient +} + +func (c *GRPCSyncedFolderClient) Cleanup(m *vagrant.Machine, o *vagrant.FolderOptions) (err error) { + machine, err := vagrant.DumpMachine(m) + if err != nil { + return + } + opts, err := json.Marshal(o) + if err != nil { + return + } + resp, err := c.client.Cleanup(context.Background(), &vagrant_folder.CleanupRequest{ + Machine: machine, + Options: string(opts)}) + if err != nil { + return + } + if resp.Error != "" { + err = errors.New(resp.Error) + } + return +} + +func (c *GRPCSyncedFolderClient) Disable(m *vagrant.Machine, f *vagrant.FolderList, o *vagrant.FolderOptions) (err error) { + machine, err := vagrant.DumpMachine(m) + if err != nil { + return + } + folders, err := json.Marshal(f) + if err != nil { + return + } + opts, err := json.Marshal(o) + if err != nil { + return + } + resp, err := c.client.Disable(context.Background(), &vagrant_folder.Request{ + Machine: machine, + Folders: string(folders), + Options: string(opts)}) + if err != nil { + return + } + if resp.Error != "" { + err = errors.New(resp.Error) + } + return +} + +func (c *GRPCSyncedFolderClient) Enable(m *vagrant.Machine, f *vagrant.FolderList, o *vagrant.FolderOptions) (err error) { + machine, err := vagrant.DumpMachine(m) + if err != nil { + return + } + folders, err := json.Marshal(f) + if err != nil { + return + } + opts, err := json.Marshal(o) + if err != nil { + return + } + resp, err := c.client.Enable(context.Background(), &vagrant_folder.Request{ + Machine: machine, + Folders: string(folders), + Options: string(opts)}) + if err != nil { + return + } + if resp.Error != "" { + err = errors.New(resp.Error) + } + return +} + +func (c *GRPCSyncedFolderClient) Info() *vagrant.SyncedFolderInfo { + resp, err := c.client.Info(context.Background(), &vagrant_common.NullRequest{}) + if err != nil { + return &vagrant.SyncedFolderInfo{} + } + return &vagrant.SyncedFolderInfo{ + Description: resp.Description, + Priority: resp.Priority} +} + +func (c *GRPCSyncedFolderClient) IsUsable(m *vagrant.Machine) (u bool, err error) { + machine, err := vagrant.DumpMachine(m) + if err != nil { + return + } + resp, err := c.client.IsUsable(context.Background(), &vagrant_common.EmptyRequest{ + Machine: machine}) + u = resp.Result + if resp.Error != "" { + err = errors.New(resp.Error) + } + return +} + +func (c *GRPCSyncedFolderClient) Name() string { + resp, err := c.client.Name(context.Background(), &vagrant_common.NullRequest{}) + if err != nil { + return "" + } + return resp.Name +} + +func (c *GRPCSyncedFolderClient) Prepare(m *vagrant.Machine, f *vagrant.FolderList, o *vagrant.FolderOptions) (err error) { + machine, err := vagrant.DumpMachine(m) + if err != nil { + return + } + folders, err := json.Marshal(f) + if err != nil { + return + } + opts, err := json.Marshal(o) + if err != nil { + return + } + resp, err := c.client.Prepare(context.Background(), &vagrant_folder.Request{ + Machine: machine, + Folders: string(folders), + Options: string(opts)}) + if err != nil { + return + } + if resp.Error != "" { + err = errors.New(resp.Error) + } + return +} + +type GRPCSyncedFolderServer struct { + GRPCGuestCapabilitiesServer + GRPCHostCapabilitiesServer + GRPCIOServer + Impl SyncedFolder +} + +func (s *GRPCSyncedFolderServer) Cleanup(ctx context.Context, req *vagrant_folder.CleanupRequest) (resp *vagrant_common.EmptyResponse, err error) { + resp = &vagrant_common.EmptyResponse{} + machine, err := vagrant.LoadMachine(req.Machine, nil) + if err != nil { + return + } + var options vagrant.FolderOptions + err = json.Unmarshal([]byte(req.Options), &options) + if err != nil { + return + } + e := s.Impl.Cleanup(machine, &options) + if e != nil { + resp.Error = e.Error() + } + return +} + +func (s *GRPCSyncedFolderServer) Disable(ctx context.Context, req *vagrant_folder.Request) (resp *vagrant_common.EmptyResponse, err error) { + resp = &vagrant_common.EmptyResponse{} + machine, err := vagrant.LoadMachine(req.Machine, nil) + if err != nil { + return + } + var folders vagrant.FolderList + err = json.Unmarshal([]byte(req.Folders), &folders) + if err != nil { + return + } + var options vagrant.FolderOptions + err = json.Unmarshal([]byte(req.Options), &options) + if err != nil { + return + } + e := s.Impl.Disable(machine, &folders, &options) + if e != nil { + resp.Error = e.Error() + } + return +} + +func (s *GRPCSyncedFolderServer) Enable(ctx context.Context, req *vagrant_folder.Request) (resp *vagrant_common.EmptyResponse, err error) { + resp = &vagrant_common.EmptyResponse{} + machine, err := vagrant.LoadMachine(req.Machine, nil) + if err != nil { + return + } + var folders vagrant.FolderList + err = json.Unmarshal([]byte(req.Folders), &folders) + if err != nil { + return + } + var options vagrant.FolderOptions + err = json.Unmarshal([]byte(req.Options), &options) + if err != nil { + return + } + e := s.Impl.Enable(machine, &folders, &options) + if e != nil { + resp.Error = e.Error() + } + return +} + +func (s *GRPCSyncedFolderServer) Info(ctx context.Context, req *vagrant_common.NullRequest) (*vagrant_folder.InfoResponse, error) { + r := s.Impl.Info() + return &vagrant_folder.InfoResponse{ + Description: r.Description, + Priority: r.Priority}, nil +} + +func (s *GRPCSyncedFolderServer) IsUsable(ctx context.Context, req *vagrant_common.EmptyRequest) (resp *vagrant_common.IsResponse, err error) { + resp = &vagrant_common.IsResponse{} + machine, err := vagrant.LoadMachine(req.Machine, nil) + if err != nil { + return + } + r, e := s.Impl.IsUsable(machine) + if e != nil { + resp.Error = e.Error() + } + resp.Result = r + return +} + +func (s *GRPCSyncedFolderServer) Name(ctx context.Context, req *vagrant_common.NullRequest) (*vagrant_common.NameResponse, error) { + return &vagrant_common.NameResponse{Name: s.Impl.Name()}, nil +} + +func (s *GRPCSyncedFolderServer) Prepare(ctx context.Context, req *vagrant_folder.Request) (resp *vagrant_common.EmptyResponse, err error) { + resp = &vagrant_common.EmptyResponse{} + machine, err := vagrant.LoadMachine(req.Machine, nil) + if err != nil { + return + } + var folders vagrant.FolderList + err = json.Unmarshal([]byte(req.Folders), &folders) + if err != nil { + return + } + var options vagrant.FolderOptions + err = json.Unmarshal([]byte(req.Options), &options) + if err != nil { + return + } + e := s.Impl.Prepare(machine, &folders, &options) + if e != nil { + resp.Error = e.Error() + } + return +} + +func (f *SyncedFolderPlugin) GRPCServer(broker *go_plugin.GRPCBroker, s *grpc.Server) error { + vagrant_folder.RegisterSyncedFolderServer(s, &GRPCSyncedFolderServer{Impl: f.Impl}) + return nil +} + +func (f *SyncedFolderPlugin) GRPCClient(ctx context.Context, broker *go_plugin.GRPCBroker, c *grpc.ClientConn) (interface{}, error) { + return &GRPCSyncedFolderClient{client: vagrant_folder.NewSyncedFolderClient(c)}, nil +} diff --git a/ext/go-plugin/vagrant/provider.go b/ext/go-plugin/vagrant/provider.go new file mode 100644 index 000000000..4111632c6 --- /dev/null +++ b/ext/go-plugin/vagrant/provider.go @@ -0,0 +1,23 @@ +package vagrant + +type Provider interface { + Info() *ProviderInfo + Action(actionName string, machData *Machine) ([]string, error) + IsInstalled(machData *Machine) (bool, error) + IsUsable(machData *Machine) (bool, error) + MachineIdChanged(machData *Machine) error + Name() string + RunAction(actionName string, data string, machData *Machine) (string, error) + SshInfo(machData *Machine) (*SshInfo, error) + State(machData *Machine) (*MachineState, error) + + Config + GuestCapabilities + HostCapabilities + ProviderCapabilities +} + +type ProviderInfo struct { + Description string `json:"description"` + Priority int64 `json:"priority"` +} diff --git a/ext/go-plugin/vagrant/response.go b/ext/go-plugin/vagrant/response.go new file mode 100644 index 000000000..a5518fa1c --- /dev/null +++ b/ext/go-plugin/vagrant/response.go @@ -0,0 +1,20 @@ +package vagrant + +import ( + "encoding/json" + "fmt" +) + +type Response struct { + Error error `json:"error"` + Result interface{} `json:"result"` +} + +// Serialize the response into a JSON string +func (r Response) Dump() string { + result, err := json.Marshal(r) + if err != nil { + return fmt.Sprintf(`{"error": "failed to encode response - %s"}`, err) + } + return string(result[:]) +} diff --git a/ext/go-plugin/vagrant/ssh_info.go b/ext/go-plugin/vagrant/ssh_info.go new file mode 100644 index 000000000..625aa845c --- /dev/null +++ b/ext/go-plugin/vagrant/ssh_info.go @@ -0,0 +1,8 @@ +package vagrant + +type SshInfo struct { + Host string `json:"host"` + Port int64 `json:"port"` + Username string `json:"username"` + PrivateKeyPath string `json:"private_key_path"` +} diff --git a/ext/go-plugin/vagrant/synced_folder.go b/ext/go-plugin/vagrant/synced_folder.go new file mode 100644 index 000000000..27928ba1b --- /dev/null +++ b/ext/go-plugin/vagrant/synced_folder.go @@ -0,0 +1,22 @@ +package vagrant + +type FolderList map[string]interface{} +type FolderOptions map[string]interface{} + +type SyncedFolderInfo struct { + Description string `json:"description"` + Priority int64 `json:"priority"` +} + +type SyncedFolder interface { + Cleanup(m *Machine, opts *FolderOptions) error + Disable(m *Machine, f *FolderList, opts *FolderOptions) error + Enable(m *Machine, f *FolderList, opts *FolderOptions) error + Info() *SyncedFolderInfo + IsUsable(m *Machine) (bool, error) + Name() string + Prepare(m *Machine, f *FolderList, opts *FolderOptions) error + + GuestCapabilities + HostCapabilities +} diff --git a/ext/go-plugin/vagrant/ui.go b/ext/go-plugin/vagrant/ui.go new file mode 100644 index 000000000..7a61daf14 --- /dev/null +++ b/ext/go-plugin/vagrant/ui.go @@ -0,0 +1,472 @@ +package vagrant + +import ( + "bufio" + "bytes" + "errors" + "fmt" + "io" + "os" + "os/signal" + "runtime" + "strings" + "sync" + "syscall" + "time" + "unicode" +) + +type UiColor uint + +const ( + UiColorRed UiColor = 31 + UiColorGreen = 32 + UiColorYellow = 33 + UiColorBlue = 34 + UiColorMagenta = 35 + UiColorCyan = 36 +) + +type UiChannel uint + +const ( + UiOutput UiChannel = 1 + UiError = 2 +) + +var logger = DefaultLogger().Named("ui") + +type Options struct { + Channel UiChannel + NewLine bool +} + +var defaultOptions = &Options{ + Channel: UiOutput, + NewLine: true, +} + +// The Ui interface handles all communication for Vagrant with the outside +// world. This sort of control allows us to strictly control how output +// is formatted and various levels of output. +type Ui interface { + Ask(string) (string, error) + Detail(string) + Info(string) + Error(string) + Machine(string, ...string) + Message(string, *Options) + Output(string) + Say(string) + Success(string) + Warn(string) +} + +// The BasicUI is a UI that reads and writes from a standard Go reader +// and writer. It is safe to be called from multiple goroutines. Machine +// readable output is simply logged for this UI. +type BasicUi struct { + Reader io.Reader + Writer io.Writer + ErrorWriter io.Writer + l sync.Mutex + interrupted bool + scanner *bufio.Scanner +} + +var _ Ui = new(BasicUi) + +func (rw *BasicUi) Ask(query string) (string, error) { + rw.l.Lock() + defer rw.l.Unlock() + + if rw.interrupted { + return "", errors.New("interrupted") + } + + if rw.scanner == nil { + rw.scanner = bufio.NewScanner(rw.Reader) + } + sigCh := make(chan os.Signal, 1) + signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM) + defer signal.Stop(sigCh) + + logger.Info("ask", query) + if query != "" { + if _, err := fmt.Fprint(rw.Writer, query+" "); err != nil { + return "", err + } + } + + result := make(chan string, 1) + go func() { + var line string + if rw.scanner.Scan() { + line = rw.scanner.Text() + } + if err := rw.scanner.Err(); err != nil { + logger.Error("scan failure", "error", err) + return + } + result <- line + }() + + select { + case line := <-result: + return line, nil + case <-sigCh: + // Print a newline so that any further output starts properly + // on a new line. + fmt.Fprintln(rw.Writer) + + // Mark that we were interrupted so future Ask calls fail. + rw.interrupted = true + + return "", errors.New("interrupted") + } +} + +func (rw *BasicUi) Detail(message string) { rw.Say(message) } +func (rw *BasicUi) Info(message string) { rw.Say(message) } +func (rw *BasicUi) Output(message string) { rw.Say(message) } +func (rw *BasicUi) Success(message string) { rw.Say(message) } +func (rw *BasicUi) Warn(message string) { rw.Say(message) } + +func (rw *BasicUi) Say(message string) { + rw.Message(message, nil) +} + +func (rw *BasicUi) Message(message string, opts *Options) { + rw.l.Lock() + defer rw.l.Unlock() + + if opts == nil { + opts = &Options{Channel: UiOutput, NewLine: true} + } + + logger.Debug("write message", "content", message, "options", opts) + target := rw.Writer + if opts.Channel == UiError { + if rw.ErrorWriter == nil { + logger.Error("error writer unset using writer") + } else { + target = rw.ErrorWriter + } + } + suffix := "" + if opts.NewLine { + suffix = "\n" + } + + _, err := fmt.Fprint(target, message+suffix) + if err != nil { + logger.Error("write failure", "error", err) + } +} + +func (rw *BasicUi) Error(message string) { + rw.Message(message, &Options{Channel: UiError, NewLine: true}) +} + +func (rw *BasicUi) Machine(t string, args ...string) { + logger.Info("machine readable", "category", t, "args", args) +} + +// MachineReadableUi is a UI that only outputs machine-readable output +// to the given Writer. +type MachineReadableUi struct { + Writer io.Writer +} + +var _ Ui = new(MachineReadableUi) + +func (u *MachineReadableUi) Ask(query string) (string, error) { + return "", errors.New("machine-readable UI can't ask") +} + +func (u *MachineReadableUi) Detail(message string) { + u.Machine("ui", "detail", message) +} + +func (u *MachineReadableUi) Info(message string) { + u.Machine("ui", "info", message) +} + +func (u *MachineReadableUi) Output(message string) { + u.Machine("ui", "output", message) +} + +func (u *MachineReadableUi) Success(message string) { + u.Machine("ui", "success", message) +} + +func (u *MachineReadableUi) Warn(message string) { + u.Machine("ui", "warn", message) +} + +func (u *MachineReadableUi) Say(message string) { + u.Machine("ui", "say", message) +} + +func (u *MachineReadableUi) Message(message string, opts *Options) { + u.Machine("ui", "message", message) +} + +func (u *MachineReadableUi) Error(message string) { + u.Machine("ui", "error", message) +} + +// TODO: Do we want to update this to match Vagrant machine style? +func (u *MachineReadableUi) Machine(category string, args ...string) { + now := time.Now().UTC() + + // Determine if we have a target, and set it + target := "" + commaIdx := strings.Index(category, ",") + if commaIdx > -1 { + target = category[0:commaIdx] + category = category[commaIdx+1:] + } + + // Prepare the args + for i, v := range args { + args[i] = strings.Replace(v, ",", "%!(VAGRANT_COMMA)", -1) + args[i] = strings.Replace(args[i], "\r", "\\r", -1) + args[i] = strings.Replace(args[i], "\n", "\\n", -1) + } + argsString := strings.Join(args, ",") + + _, err := fmt.Fprintf(u.Writer, "%d,%s,%s,%s\n", now.Unix(), target, category, argsString) + if err != nil { + if err == syscall.EPIPE || strings.Contains(err.Error(), "broken pipe") { + // Ignore epipe errors because that just means that the file + // is probably closed or going to /dev/null or something. + } else { + panic(err) + } + } +} + +type NoopUi struct{} + +var _ Ui = new(NoopUi) + +func (*NoopUi) Ask(string) (string, error) { return "", errors.New("this is a noop ui") } +func (*NoopUi) Detail(string) { return } +func (*NoopUi) Info(string) { return } +func (*NoopUi) Error(string) { return } +func (*NoopUi) Machine(string, ...string) { return } +func (*NoopUi) Message(string, *Options) { return } +func (*NoopUi) Output(string) { return } +func (*NoopUi) Say(string) { return } +func (*NoopUi) Success(string) { return } +func (*NoopUi) Warn(string) { return } + +// ColoredUi is a UI that is colored using terminal colors. +type ColoredUi struct { + Color UiColor + ErrorColor UiColor + SuccessColor UiColor + WarnColor UiColor + Ui Ui +} + +var _ Ui = new(ColoredUi) + +func (u *ColoredUi) Ask(query string) (string, error) { + return u.Ui.Ask(u.colorize(query, u.Color, true)) +} + +func (u *ColoredUi) Detail(message string) { + u.Say(message) +} + +func (u *ColoredUi) Info(message string) { + u.Say(message) +} + +func (u *ColoredUi) Error(message string) { + color := u.ErrorColor + if color == 0 { + color = UiColorRed + } + + u.Ui.Error(u.colorize(message, color, true)) +} + +func (u *ColoredUi) Machine(t string, args ...string) { + // Don't colorize machine-readable output + u.Ui.Machine(t, args...) +} + +func (u *ColoredUi) Message(message string, opts *Options) { + u.Ui.Message(u.colorize(message, u.Color, false), opts) +} + +func (u *ColoredUi) Output(message string) { + u.Say(message) +} + +func (u *ColoredUi) Say(message string) { + u.Ui.Say(u.colorize(message, u.Color, true)) +} + +func (u *ColoredUi) Success(message string) { + u.Ui.Say(u.colorize(message, u.SuccessColor, true)) +} + +func (u *ColoredUi) Warn(message string) { + u.Ui.Say(u.colorize(message, u.WarnColor, true)) +} + +func (u *ColoredUi) colorize(message string, color UiColor, bold bool) string { + if !u.supportsColors() { + return message + } + + attr := 0 + if bold { + attr = 1 + } + + return fmt.Sprintf("\033[%d;%dm%s\033[0m", attr, color, message) +} + +func (u *ColoredUi) supportsColors() bool { + // Never use colors if we have this environmental variable + if os.Getenv("VAGRANT_NO_COLOR") != "" { + return false + } + + // For now, on non-Windows machine, just assume it does + if runtime.GOOS != "windows" { + return true + } + + // On Windows, if we appear to be in Cygwin, then it does + cygwin := os.Getenv("CYGWIN") != "" || + os.Getenv("OSTYPE") == "cygwin" || + os.Getenv("TERM") == "cygwin" + + return cygwin +} + +// TargetedUi is a UI that wraps another UI implementation and modifies +// the output to indicate a specific target. Specifically, all Say output +// is prefixed with the target name. Message output is not prefixed but +// is offset by the length of the target so that output is lined up properly +// with Say output. Machine-readable output has the proper target set. +type TargetedUi struct { + Target string + Ui Ui +} + +var _ Ui = new(TargetedUi) + +func (u *TargetedUi) Ask(query string) (string, error) { + return u.Ui.Ask(u.prefixLines(true, query)) +} + +func (u *TargetedUi) Detail(message string) { + u.Ui.Detail(u.prefixLines(true, message)) +} + +func (u *TargetedUi) Info(message string) { + u.Ui.Info(u.prefixLines(true, message)) +} + +func (u *TargetedUi) Output(message string) { + u.Ui.Output(u.prefixLines(true, message)) +} + +func (u *TargetedUi) Success(message string) { + u.Ui.Success(u.prefixLines(true, message)) +} + +func (u *TargetedUi) Warn(message string) { + u.Ui.Warn(u.prefixLines(true, message)) +} + +func (u *TargetedUi) Say(message string) { + u.Ui.Say(u.prefixLines(true, message)) +} + +func (u *TargetedUi) Message(message string, opts *Options) { + u.Ui.Message(u.prefixLines(false, message), opts) +} + +func (u *TargetedUi) Error(message string) { + u.Ui.Error(u.prefixLines(true, message)) +} + +func (u *TargetedUi) Machine(t string, args ...string) { + // Prefix in the target, then pass through + u.Ui.Machine(fmt.Sprintf("%s,%s", u.Target, t), args...) +} + +func (u *TargetedUi) prefixLines(arrow bool, message string) string { + arrowText := "==>" + if !arrow { + arrowText = strings.Repeat(" ", len(arrowText)) + } + + var result bytes.Buffer + + for _, line := range strings.Split(message, "\n") { + result.WriteString(fmt.Sprintf("%s %s: %s\n", arrowText, u.Target, line)) + } + + return strings.TrimRightFunc(result.String(), unicode.IsSpace) +} + +// TimestampedUi is a UI that wraps another UI implementation and prefixes +// prefixes each message with an RFC3339 timestamp +type TimestampedUi struct { + Ui Ui +} + +var _ Ui = new(TimestampedUi) + +func (u *TimestampedUi) Ask(query string) (string, error) { + return u.Ui.Ask(query) +} + +func (u *TimestampedUi) Detail(message string) { + u.Ui.Detail(u.timestampLine(message)) +} + +func (u *TimestampedUi) Info(message string) { + u.Ui.Info(u.timestampLine(message)) +} + +func (u *TimestampedUi) Output(message string) { + u.Ui.Output(u.timestampLine(message)) +} + +func (u *TimestampedUi) Success(message string) { + u.Ui.Success(u.timestampLine(message)) +} + +func (u *TimestampedUi) Warn(message string) { + u.Ui.Warn(u.timestampLine(message)) +} + +func (u *TimestampedUi) Say(message string) { + u.Ui.Say(u.timestampLine(message)) +} + +func (u *TimestampedUi) Message(message string, opts *Options) { + u.Ui.Message(u.timestampLine(message), opts) +} + +func (u *TimestampedUi) Error(message string) { + u.Ui.Error(u.timestampLine(message)) +} + +func (u *TimestampedUi) Machine(message string, args ...string) { + u.Ui.Machine(message, args...) +} + +func (u *TimestampedUi) timestampLine(string string) string { + return fmt.Sprintf("%v: %v", time.Now().Format(time.RFC3339), string) +} diff --git a/ext/go-plugin/vagrant/ui_test.go b/ext/go-plugin/vagrant/ui_test.go new file mode 100644 index 000000000..225401b40 --- /dev/null +++ b/ext/go-plugin/vagrant/ui_test.go @@ -0,0 +1,290 @@ +package vagrant + +import ( + "bytes" + "os" + "strings" + "testing" +) + +// This reads the output from the bytes.Buffer in our test object +// and then resets the buffer. +func readWriter(ui *BasicUi) (result string) { + buffer := ui.Writer.(*bytes.Buffer) + result = buffer.String() + buffer.Reset() + return +} + +// Reset the input Reader then add some input to it. +func writeReader(ui *BasicUi, input string) { + buffer := ui.Reader.(*bytes.Buffer) + buffer.WriteString(input) +} + +func readErrorWriter(ui *BasicUi) (result string) { + buffer := ui.ErrorWriter.(*bytes.Buffer) + result = buffer.String() + buffer.Reset() + return +} + +func testUi() *BasicUi { + return &BasicUi{ + Reader: new(bytes.Buffer), + Writer: new(bytes.Buffer), + ErrorWriter: new(bytes.Buffer), + } +} + +func TestColoredUi(t *testing.T) { + bufferUi := testUi() + ui := &ColoredUi{UiColorBlue, UiColorRed, UiColorGreen, + UiColorYellow, bufferUi} + + if !ui.supportsColors() { + t.Skip("skipping for ui without color support") + } + + ui.Say("foo") + result := readWriter(bufferUi) + if result != "\033[1;34mfoo\033[0m\n" { + t.Fatalf("invalid output: %s", result) + } + + ui.Message("foo", nil) + result = readWriter(bufferUi) + if result != "\033[0;34mfoo\033[0m\n" { + t.Fatalf("invalid output: %s", result) + } + + ui.Error("foo") + result = readWriter(bufferUi) + if result != "" { + t.Fatalf("invalid output: %s", result) + } + + result = readErrorWriter(bufferUi) + if result != "\033[1;31mfoo\033[0m\n" { + t.Fatalf("invalid output: %s", result) + } +} + +func TestColoredUi_noColorEnv(t *testing.T) { + bufferUi := testUi() + ui := &ColoredUi{UiColorBlue, UiColorRed, UiColorGreen, + UiColorYellow, bufferUi} + + // Set the env var to get rid of the color + oldenv := os.Getenv("VAGRANT_NO_COLOR") + os.Setenv("VAGRANT_NO_COLOR", "1") + defer os.Setenv("VAGRANT_NO_COLOR", oldenv) + + ui.Say("foo") + result := readWriter(bufferUi) + if result != "foo\n" { + t.Fatalf("invalid output: %s", result) + } + + ui.Message("foo", nil) + result = readWriter(bufferUi) + if result != "foo\n" { + t.Fatalf("invalid output: %s", result) + } + + ui.Error("foo") + result = readErrorWriter(bufferUi) + if result != "foo\n" { + t.Fatalf("invalid output: %s", result) + } +} + +func TestTargetedUi(t *testing.T) { + bufferUi := testUi() + targetedUi := &TargetedUi{ + Target: "foo", + Ui: bufferUi, + } + + var actual, expected string + targetedUi.Say("foo") + actual = readWriter(bufferUi) + expected = "==> foo: foo\n" + if actual != expected { + t.Fatalf("bad: %#v", actual) + } + + targetedUi.Message("foo", nil) + actual = readWriter(bufferUi) + expected = " foo: foo\n" + if actual != expected { + t.Fatalf("bad: %#v", actual) + } + + targetedUi.Error("bar") + actual = readErrorWriter(bufferUi) + expected = "==> foo: bar\n" + if actual != expected { + t.Fatalf("bad: %#v", actual) + } + + targetedUi.Say("foo\nbar") + actual = readWriter(bufferUi) + expected = "==> foo: foo\n==> foo: bar\n" + if actual != expected { + t.Fatalf("bad: %#v", actual) + } +} + +func TestColoredUi_ImplUi(t *testing.T) { + var raw interface{} + raw = &ColoredUi{} + if _, ok := raw.(Ui); !ok { + t.Fatalf("ColoredUi must implement Ui") + } +} + +func TestTargetedUi_ImplUi(t *testing.T) { + var raw interface{} + raw = &TargetedUi{} + if _, ok := raw.(Ui); !ok { + t.Fatalf("TargetedUi must implement Ui") + } +} + +func TestBasicUi_ImplUi(t *testing.T) { + var raw interface{} + raw = &BasicUi{} + if _, ok := raw.(Ui); !ok { + t.Fatalf("BasicUi must implement Ui") + } +} + +func TestBasicUi_Error(t *testing.T) { + bufferUi := testUi() + + var actual, expected string + bufferUi.Error("foo") + actual = readErrorWriter(bufferUi) + expected = "foo\n" + if actual != expected { + t.Fatalf("bad: %#v", actual) + } + + bufferUi.ErrorWriter = nil + bufferUi.Error("5") + actual = readWriter(bufferUi) + expected = "5\n" + if actual != expected { + t.Fatalf("bad: %#v", actual) + } +} + +func TestBasicUi_Say(t *testing.T) { + bufferUi := testUi() + + var actual, expected string + + bufferUi.Say("foo") + actual = readWriter(bufferUi) + expected = "foo\n" + if actual != expected { + t.Fatalf("bad: %#v", actual) + } + + bufferUi.Say("5") + actual = readWriter(bufferUi) + expected = "5\n" + if actual != expected { + t.Fatalf("bad: %#v", actual) + } +} + +func TestBasicUi_Ask(t *testing.T) { + + var actual, expected string + var err error + + var testCases = []struct { + Prompt, Input, Answer string + }{ + {"[c]ontinue or [a]bort", "c\n", "c"}, + {"[c]ontinue or [a]bort", "c", "c"}, + // Empty input shouldn't give an error + {"Name", "Joe Bloggs\n", "Joe Bloggs"}, + {"Name", "Joe Bloggs", "Joe Bloggs"}, + {"Name", "\n", ""}, + } + + for _, testCase := range testCases { + // Because of the internal bufio we can't easily reset the input, so create a new one each time + bufferUi := testUi() + writeReader(bufferUi, testCase.Input) + + actual, err = bufferUi.Ask(testCase.Prompt) + if err != nil { + t.Fatal(err) + } + + if actual != testCase.Answer { + t.Fatalf("bad answer: %#v", actual) + } + + actual = readWriter(bufferUi) + expected = testCase.Prompt + " " + if actual != expected { + t.Fatalf("bad prompt: %#v", actual) + } + } + +} + +func TestMachineReadableUi_ImplUi(t *testing.T) { + var raw interface{} + raw = &MachineReadableUi{} + if _, ok := raw.(Ui); !ok { + t.Fatalf("MachineReadableUi must implement Ui") + } +} + +func TestMachineReadableUi(t *testing.T) { + var data, expected string + + buf := new(bytes.Buffer) + ui := &MachineReadableUi{Writer: buf} + + // No target + ui.Machine("foo", "bar", "baz") + data = strings.SplitN(buf.String(), ",", 2)[1] + expected = ",foo,bar,baz\n" + if data != expected { + t.Fatalf("bad: %s", data) + } + + // Target + buf.Reset() + ui.Machine("mitchellh,foo", "bar", "baz") + data = strings.SplitN(buf.String(), ",", 2)[1] + expected = "mitchellh,foo,bar,baz\n" + if data != expected { + t.Fatalf("bad: %s", data) + } + + // Commas + buf.Reset() + ui.Machine("foo", "foo,bar") + data = strings.SplitN(buf.String(), ",", 2)[1] + expected = ",foo,foo%!(VAGRANT_COMMA)bar\n" + if data != expected { + t.Fatalf("bad: %s", data) + } + + // New lines + buf.Reset() + ui.Machine("foo", "foo\n") + data = strings.SplitN(buf.String(), ",", 2)[1] + expected = ",foo,foo\\n\n" + if data != expected { + t.Fatalf("bad: %#v", data) + } +} diff --git a/lib/vagrant.rb b/lib/vagrant.rb index 66840226f..dc515720d 100644 --- a/lib/vagrant.rb +++ b/lib/vagrant.rb @@ -1,4 +1,5 @@ require "log4r" +require "log4r/logger" require "vagrant/util/credential_scrubber" # Update the default formatter within the log4r library to ensure # sensitive values are being properly scrubbed from logger data @@ -53,6 +54,8 @@ if ENV["VAGRANT_LOG"] && ENV["VAGRANT_LOG"] != "" # rest-client to write using the `<<` operator. # See https://github.com/rest-client/rest-client/issues/34#issuecomment-290858 # for more information + Log4r::PatternFormatter::DirectiveTable["l"] = + '"[" + ' + Log4r::PatternFormatter::DirectiveTable["l"] + ' + "]"' class VagrantLogger < Log4r::Logger def << (msg) debug(msg.strip) @@ -61,13 +64,10 @@ if ENV["VAGRANT_LOG"] && ENV["VAGRANT_LOG"] != "" logger = VagrantLogger.new("vagrant") logger.outputters = Log4r::Outputter.stderr logger.level = level - base_formatter = Log4r::BasicFormatter.new - if ENV["VAGRANT_LOG_TIMESTAMP"] - base_formatter = Log4r::PatternFormatter.new( - pattern: "%d [%5l] %m", - date_pattern: "%F %T" - ) - end + base_formatter = Log4r::PatternFormatter.new( + pattern: "%d %-7l %C: %m", + date_pattern: ENV["VAGRANT_LOG_TIMESTAMP"] ? "%FT%T.%L%z" : " " + ) # Vagrant Cloud gem uses RestClient to make HTTP requests, so # log them if debug is enabled and use Vagrants logger require 'rest_client' @@ -118,6 +118,7 @@ module Vagrant autoload :Driver, 'vagrant/driver' autoload :Environment, 'vagrant/environment' autoload :Errors, 'vagrant/errors' + autoload :GoPlugin, 'vagrant/go_plugin' autoload :Guest, 'vagrant/guest' autoload :Host, 'vagrant/host' autoload :Machine, 'vagrant/machine' diff --git a/lib/vagrant/config/v2/dummy_config.rb b/lib/vagrant/config/v2/dummy_config.rb index 149b66b7a..044331580 100644 --- a/lib/vagrant/config/v2/dummy_config.rb +++ b/lib/vagrant/config/v2/dummy_config.rb @@ -7,6 +7,10 @@ module Vagrant def method_missing(name, *args, &block) DummyConfig.new end + + def to_json(*_) + "null" + end end end end diff --git a/lib/vagrant/config/v2/root.rb b/lib/vagrant/config/v2/root.rb index 1329c57c7..e1d718777 100644 --- a/lib/vagrant/config/v2/root.rb +++ b/lib/vagrant/config/v2/root.rb @@ -112,6 +112,14 @@ module Vagrant @keys = state["keys"] if state.key?("keys") @missing_key_calls = state["missing_key_calls"] if state.key?("missing_key_calls") end + + def to_json(*args) + Hash[ + @keys.find_all { |k,v| + !k.to_s.start_with?("_") + } + ].to_json(*args) + end end end end diff --git a/lib/vagrant/environment.rb b/lib/vagrant/environment.rb index 2eb35bec9..eaf740dd2 100644 --- a/lib/vagrant/environment.rb +++ b/lib/vagrant/environment.rb @@ -175,6 +175,15 @@ module Vagrant # Load any global plugins Vagrant::Plugin::Manager.instance.load_plugins(plugins) + # Load any available go-plugins + Util::Experimental.guard_with(:go_plugin) do + begin + Vagrant::GoPlugin::Manager.instance.globalize! + rescue LoadError => err + @logger.warn("go plugin support is not available: #{err}") + end + end + plugins = process_configured_plugins # Call the hooks that does not require configurations to be loaded diff --git a/lib/vagrant/go_plugin.rb b/lib/vagrant/go_plugin.rb new file mode 100644 index 000000000..2484b4f8f --- /dev/null +++ b/lib/vagrant/go_plugin.rb @@ -0,0 +1,23 @@ +module Vagrant + module GoPlugin + + # @return [String] + INSTALL_DIRECTORY = Vagrant.user_data_path.join("go-plugins").to_s.freeze + + autoload :CapabilityPlugin, "vagrant/go_plugin/capability_plugin" + autoload :ConfigPlugin, "vagrant/go_plugin/config_plugin" + autoload :Core, "vagrant/go_plugin/core" + autoload :Interface, "vagrant/go_plugin/interface" + autoload :Manager, "vagrant/go_plugin/manager" + autoload :ProviderPlugin, "vagrant/go_plugin/provider_plugin" + autoload :SyncedFolderPlugin, "vagrant/go_plugin/synced_folder_plugin" + + # @return [Interface] + def self.interface + unless @_interface + @_interface = Interface.new + end + @_interface + end + end +end diff --git a/lib/vagrant/go_plugin/capability_plugin.rb b/lib/vagrant/go_plugin/capability_plugin.rb new file mode 100644 index 000000000..d505b53f7 --- /dev/null +++ b/lib/vagrant/go_plugin/capability_plugin.rb @@ -0,0 +1,179 @@ +require "vagrant/go_plugin/core" + +module Vagrant + module GoPlugin + # Contains all capability functionality for go-plugin + module CapabilityPlugin + # Wrapper class for go-plugin defined capabilities + class Capability + extend TypedGoPlugin + end + + # @return [Interface] + def self.interface + unless @_interface + @_interface = Interface.new + end + @_interface + end + + # Capability interface to access go-plugin + class Interface + include GoPlugin::Core + + typedef :string, :capability_args + typedef :string, :capability_name + typedef :string, :capability_platform + typedef :string, :capability_provider + + attach_function :_guest_capabilities, :GuestCapabilities, + [:plugin_name, :plugin_type], :plugin_result + attach_function :_guest_capability, :GuestCapability, + [:plugin_name, :plugin_type, :capability_name, :capability_platform, + :capability_args, :vagrant_machine], :plugin_result + attach_function :_host_capabilities, :HostCapabilities, + [:plugin_name, :plugin_type], :plugin_result + attach_function :_host_capability, :HostCapability, + [:plugin_name, :plugin_type, :capability_name, :capability_platform, + :capability_args, :vagrant_environment], :plugin_result + attach_function :_provider_capabilities, :ProviderCapabilities, + [:plugin_name, :plugin_type], :plugin_result + attach_function :_provider_capability, :ProviderCapability, + [:plugin_name, :plugin_type, :capability_name, :capability_provider, + :capability_args, :vagrant_machine], :plugin_result + + # List of supported guest capabilities + # + # @param [String] plugin_name Name of plugin + # @param [String] plugin_type Type of plugin + # @return [Array] List of guest capabilities + def guest_capabilities(plugin_name, plugin_type) + load_result { _guest_capabilities(plugin_name.to_s, plugin_type.to_s) } + end + + # Execute guest capability + # + # @param [String] plugin_name Name of plugin + # @param [String] plugin_type Type of plugin + # @param [String] cap_name Name of capability + # @param [String] cap_plat Guest platform of capability + # @param [Array] cap_args Arguments for the capability + # @param [Vagrant::Machine] machine Guest machine + def guest_capability(plugin_name, plugin_type, cap_name, cap_plat, cap_args, machine) + load_result { + _guest_capability(plugin_name.to_s, plugin_type.to_s, cap_name.to_s, cap_plat.to_s, + JSON.dump(cap_args), dump_machine(machine)) + } + end + + # List of supported host capabilities + # + # @param [String] plugin_name Name of plugin + # @param [String] plugin_type Type of plugin + # @return [Array] List of host capabilities + def host_capabilities(plugin_name, plugin_type) + load_result { _host_capabilities(plugin_name.to_s, plugin_type.to_s) } + end + + # Execute host capability + # + # @param [String] plugin_name Name of plugin + # @param [String] plugin_type Type of plugin + # @param [String] cap_name Name of capability + # @param [String] cap_plat Host platform of capability + # @param [Array] cap_args Arguments for the capability + # @param [Vagrant::Environment] env Vagrant environment + def host_capability(plugin_name, plugin_type, cap_name, cap_plat, cap_args, env) + load_result { + _host_capability(plugin_name.to_s, plugin_type.to_s, cap_name.to_s, cap_plat.to_s, + JSON.dump(cap_args), dump_environment(env)) + } + end + + # List of supported provider capabilities + # + # @param [String] plugin_name Name of plugin + # @param [String] plugin_type Type of plugin + # @return [Array] List of provider capabilities + def provider_capabilities(plugin_name, plugin_type) + load_result { _provider_capabilities(plugin_name.to_s, plugin_type.to_s) } + end + + # Execute provider capability + # + # @param [String] plugin_name Name of plugin + # @param [String] plugin_type Type of plugin + # @param [String] cap_name Name of capability + # @param [String] cap_prov Provider of capability + # @param [Array] cap_args Arguments for the capability + # @param [Vagrant::Machine] machine Guest machine + def provider_capability(plugin_name, plugin_type, cap_name, cap_prov, cap_args, machine) + load_result { + _provider_capability(plugin_name.to_s, plugin_type.to_s, cap_name.to_s, cap_prov.to_s, + JSON.dump(cap_args), dump_machine(machine)) + } + end + + # Fetch any defined guest capabilites for given plugin and register + # capabilities within given plugin class + # + # @param [String] plugin_name Name of plugin + # @param [String] plugin_type Type of plugin + # @param [Class] plugin_klass Plugin class to register capabilities + def generate_guest_capabilities(plugin_name, plugin_type, plugin_klass) + logger.debug("checking for guest capabilities in #{plugin_type} plugin #{plugin_name}") + caps = guest_capabilities(plugin_name.to_s, plugin_type.to_s) + return if !caps || caps.empty? + logger.debug("guest capabilities support detected in #{plugin_type} plugin #{plugin_name}") + caps.each do |cap| + cap_klass = Class.new(Capability).tap do |k| + k.class_eval("def self.#{k[:name]}(machine, *args){ CapabilityPlugin.interface.guest_capability(" \ + "plugin_name, plugin_type, '#{k[:name]}', '#{k[:platform]}', args, machine) }") + end + plugin_klass.guest_capability(k[:platform], k[:name]) + end + end + + # Fetch any defined host capabilites for given plugin and register + # capabilities within given plugin class + # + # @param [String] plugin_name Name of plugin + # @param [String] plugin_type Type of plugin + # @param [Class] plugin_klass Plugin class to register capabilities + def generate_host_capabilities(plugin_name, plugin_type, plugin_klass) + logger.debug("checking for host capabilities in #{plugin_type} plugin #{plugin_name}") + caps = host_capabilities(plugin_name.to_s, plugin_type.to_s) + return if !caps || caps.empty? + logger.debug("host capabilities support detected in #{plugin_type} plugin #{plugin_name}") + caps.each do |cap| + cap_klass = Class.new(Capability).tap do |k| + k.class_eval("def self.#{k[:name]}(env, *args){ CapabilityPlugin.interface.host_capability(" \ + "plugin_name, plugin_type, '#{k[:name]}', '#{k[:platform]}', args, env) }") + end + plugin_klass.host_capability(k[:platform], k[:name]) + end + end + + # Fetch any defined provider capabilites for given plugin and register + # capabilities within given plugin class + # + # @param [String] plugin_name Name of plugin + # @param [String] plugin_type Type of plugin + # @param [Class] plugin_klass Plugin class to register capabilities + def generate_provider_capabilities(plugin_name, plugin_type, plugin_klass) + logger.debug("checking for provider capabilities in #{plugin_type} plugin #{plugin_name}") + caps = provider_capabilities(plugin_name.to_s, plugin_type.to_s) + return if !caps || caps.empty? + logger.debug("provider capabilities support detected in #{plugin_type} plugin #{plugin_name}") + caps.each do |cap| + cap_klass = Class.new(Capability).tap do |k| + k.class_eval("def self.#{k[:name]}(machine, *args){ CapabilityPlugin.interface.provider_capability(" \ + "plugin_name, plugin_type, '#{k[:name]}', '#{k[:provider]}', args, machine) }") + end + plugin_klass.provider_capability(k[:provider], k[:name]) + end + end + end + end + end +end diff --git a/lib/vagrant/go_plugin/config_plugin.rb b/lib/vagrant/go_plugin/config_plugin.rb new file mode 100644 index 000000000..67e78d838 --- /dev/null +++ b/lib/vagrant/go_plugin/config_plugin.rb @@ -0,0 +1,133 @@ +require "vagrant/go_plugin/core" + +module Vagrant + module GoPlugin + # Contains all configuration functionality for go-plugin + module ConfigPlugin + # Config plugin class used with go-plugin + class Config < Vagrant.plugin("2", :config) + include TypedGoPlugin + + def finalize! + data = local_data + result = ConfigPlugin.interface.finalize(plugin_name, plugin_type, data) + result.each do |key, value| + next if data[key] == value + instance_variable_set("@#{key}", value) + end + self + end + + def validate(machine) + ConfigPlugin.interface.validate(plugin_name, plugin_type, local_data, machine) + end + + # @return [Hash] currently defined instance variables + def local_data + data = Vagrant::Util::HashWithIndifferentAccess. + new(instance_variables_hash) + data.delete_if { |k,v| + k.start_with?("_") + } + data + end + end + + # @return [Interface] + def self.interface + unless @_interface + @_interface = Interface.new + end + @_interface + end + + # Config interface to access go-plugin + class Interface + include GoPlugin::Core + + typedef :string, :config_name + typedef :string, :config_data + typedef :string, :plugin_type + + attach_function :_config_attributes, :ConfigAttributes, + [:plugin_name, :plugin_type], :plugin_result + attach_function :_config_load, :ConfigLoad, + [:plugin_name, :plugin_type, :config_data], :plugin_result + attach_function :_config_validate, :ConfigValidate, + [:plugin_name, :plugin_type, :config_data, :vagrant_machine], :plugin_result + attach_function :_config_finalize, :ConfigFinalize, + [:plugin_name, :plugin_type, :config_data], :plugin_result + + # List of all supported configuration attribute names + # + # @param [String] plugin_name Name of plugin + # @param [String] plugin_type Type of plugin + # @return [Array] List of attribute names + def attributes(plugin_name, plugin_type) + load_result { _config_attributes(plugin_name, plugin_type.to_s) } + end + + # Load configuration data + # + # @param [String] plugin_name Name of plugin + # @param [String] plugin_type Type of plugin + # @param [Hash] data Configuration data + # @return [Hash] Configuration data + def load(plugin_name, plugin_type, data) + load_result { _config_load(plugin_name, plugin_type, JSON.dump(data)) } + end + + # Validate configuration data + # + # @param [String] plugin_name Name of plugin + # @param [String] plugin_type Type of plugin + # @param [Hash] data Configuration data + # @param [Vagrant::Machine] machine Guest machine + # @return [Hash] Any validation errors + def validate(plugin_name, plugin_type, data, machine) + load_result { _config_validate(plugin_name, plugin_type, dump_config(data), dump_machine(machine)) } + end + + # Finalize the configuration data + # + # @param [String] plugin_name Name of plugin + # @param [String] plugin_type Type of plugin + # @param [Hash] data Configuration data + # @return [Hash] Configuration data + def finalize(plugin_name, plugin_type, data) + load_result { _config_finalize(plugin_name, plugin_type, dump_config(data)) } + end + + # Serialize configuration data + # + # @param [Hash] d Configuration data + # @return [String] + def dump_config(d) + JSON.dump(d) + end + + # Fetch any defined configuration support from the given plugin + # and register it within the given plugin class + # + # @param [String] plugin_name Name of plugin + # @param [String] plugin_type Type of plugin + # @param [Class] plugin_klass Plugin class to register configuration + def generate_config(plugin_name, plugin_type, plugin_klass) + logger.debug("checking for configuration support in #{plugin_type} plugin #{plugin_name}") + cattrs = attributes(plugin_name, plugin_type) + return nil if !cattrs || cattrs.empty? + logger.debug("configuration support detected in #{plugin_type} plugin #{plugin_name}") + config_klass = Class.new(Config) + cattrs.each { |att| + config_klass.instance_eval("attr_accessor :#{att}") + } + config_klass.go_plugin_name = plugin_name + config_klass.go_plugin_type = plugin_type + plugin_klass.config(plugin_name.to_sym, plugin_type.to_sym) do + config_klass + end + end + end + end + end +end diff --git a/lib/vagrant/go_plugin/core.rb b/lib/vagrant/go_plugin/core.rb new file mode 100644 index 000000000..9dd9d0a9d --- /dev/null +++ b/lib/vagrant/go_plugin/core.rb @@ -0,0 +1,198 @@ +require "ffi" + +module Vagrant + module GoPlugin + # Base module for generic setup of module/class + module Core + # Loads FFI and core helpers into given module/class + def self.included(const) + const.class_eval do + include Vagrant::Util::Logger + extend FFI::Library + + ffi_lib FFI::Platform::LIBC + # TODO: Update this to include OS/ARCH details + ffi_lib File.expand_path("./go-plugin.so", File.dirname(__FILE__)) + + typedef :string, :vagrant_environment + typedef :string, :vagrant_machine + typedef :string, :plugin_name + typedef :string, :plugin_type + typedef :strptr, :plugin_result + + # stdlib functions + if FFI::Platform.windows? + attach_function :free, :_free, [:pointer], :void + else + attach_function :free, [:pointer], :void + end + + # Generate a Hash representation of the given machine + # which can be serialized and sent to go-plugin + # + # @param [Vagrant::Machine] machine + # @return [String] JSON serialized Hash + def dump_machine(machine) + if !machine.is_a?(Vagrant::Machine) + raise TypeError, + "Expected `Vagrant::Machine` but received `#{machine.class}`" + end + m = { + box: {}, + config: machine.config, + data_dir: machine.data_dir, + environment: dump_environment(machine.env), + id: machine.id, + name: machine.name, + provider_config: machine.provider_config, + provider_name: machine.provider_name + } + if machine.box + m[:box] = { + name: machine.box.name, + provider: machine.box.provider, + version: machine.box.version, + directory: machine.box.directory.to_s, + metadata: machine.box.metadata, + metadata_url: machine.box.metadata_url + } + end + m.to_json + end + + # Generate a Hash representation of the given environment + # which can be serialized and sent to a go-plugin + # + # @param [Vagrant::Environmment] environment + # @return [Hash] Hash + def dump_environment(environment) + if !environment.is_a?(Vagrant::Environment) + raise TypeError, + "Expected `Vagrant::Environment` but received `#{environment.class}`" + end + e = { + cwd: environment.cwd, + data_dir: environment.data_dir, + vagrantfile_name: environment.vagrantfile_name, + home_path: environment.home_path, + local_data_path: environment.local_data_path, + tmp_path: environment.tmp_path, + aliases_path: environment.aliases_path, + boxes_path: environment.boxes_path, + gems_path: environment.gems_path, + default_private_key_path: environment.default_private_key_path, + root_path: environment.root_path, + primary_machine_name: environment.primary_machine_name, + machine_names: environment.machine_names, + active_machines: Hash[environment.active_machines] + } + end + + # Load given data into the provided machine. This is + # used to update the machine with data received from + # go-plugins + # + # @param [Hash] data Machine data from go-plugin + # @param [Vagrant::Machine] machine + # @return [Vagrant::Machine] + def load_machine(data, machine) + machine + end + + # Load the result received from the extension. This will load + # the JSON result, raise an error if detected, and properly + # free the memory associated with the result. + def load_result(*args) + val, ptr = block_given? ? yield : args + FFI::AutoPointer.new(ptr, self.method(:free)) + begin + result = JSON.load(val) + if !result.is_a?(Hash) + raise TypeError.new "Expected Hash but received `#{result.class}`" + end + if !result["error"].to_s.empty? + raise ArgumentError.new result["error"].to_s + end + result = result["result"] + if result.is_a?(Hash) + result = Vagrant::Util::HashWithIndifferentAccess.new(result) + end + result + rescue => e + # TODO: Customize to provide formatted output on error + raise + end + end + end + end + end + + module DirectGoPlugin + def self.included(klass) + klass.extend(ClassMethods) + klass.include(InstanceMethods) + end + + module ClassMethods + # @return [String] plugin name associated to this class + def go_plugin_name + @go_plugin_name + end + + def plugin_name + go_plugin_name + end + + # Set the plugin name for this class + # + # @param [String] n plugin name + # @return [String] + # @note can only be set once + def go_plugin_name=(n) + if @go_plugin_name + raise ArgumentError.new("Class plugin name has already been set") + end + @go_plugin_name = n + end + + # @return [String] + def name + go_plugin_name.to_s.capitalize.tr("_", "") + end + end + + module InstanceMethods + def plugin_name + self.class.go_plugin_name + end + end + end + + module TypedGoPlugin + def self.included(klass) + klass.extend(ClassMethods) + klass.include(InstanceMethods) + klass.include(DirectGoPlugin) + end + + module ClassMethods + def go_plugin_type + @go_plugin_type + end + + def go_plugin_type=(t) + if @go_plugin_type + raise ArgumentError.new("Class plugin type has already been set") + end + @go_plugin_type = t.to_s + end + end + + module InstanceMethods + def plugin_type + self.class.go_plugin_type + end + end + end + end +end diff --git a/lib/vagrant/go_plugin/interface.rb b/lib/vagrant/go_plugin/interface.rb new file mode 100644 index 000000000..230ede897 --- /dev/null +++ b/lib/vagrant/go_plugin/interface.rb @@ -0,0 +1,72 @@ +require "log4r" +require "vagrant/go_plugin/core" + +module Vagrant + module GoPlugin + # Interface for go-plugin integration + class Interface + include Core + + # go plugin functions + typedef :bool, :enable_logger + typedef :bool, :timestamps + typedef :string, :log_level + typedef :string, :plugin_directory + + attach_function :_setup, :Setup, [:enable_logger, :timestamps, :log_level], :bool + attach_function :_teardown, :Teardown, [], :void + attach_function :_load_plugins, :LoadPlugins, [:plugin_directory], :bool + + def initialize + setup + end + + # Load any plugins found at the given directory + # + # @param [String, Pathname] path Directory to load + def load_plugins(path) + logger.debug("loading plugins from path: #{path}") + if !File.directory?(path.to_s) + raise ArgumentError, "Directory expected for plugin loading" + end + _load_plugins(path.to_s) + end + + # Register all available plugins + def register_plugins + logger.debug("registering provider plugins") + ProviderPlugin.interface.load! + logger.debug("registering synced folder plugins") + SyncedFolderPlugin.interface.load! + end + + # Load the plugins found at the given directory + # + # @param [String] plugin_directory Directory containing go-plugins + def setup + if !@setup + @setup = true + Kernel.at_exit { Vagrant::GoPlugin.interface.teardown } + logger.debug("running go-plugin interface setup") + _setup(!Vagrant.log_level.to_s.empty?, + !!ENV["VAGRANT_LOG_TIMESTAMP"], + Vagrant.log_level.to_s) + else + logger.warn("go-plugin interface already setup") + end + end + + # Teardown any plugins that may be currently active + def teardown + logger.debug("starting teardown of go-plugin interface") + _teardown + logger.debug("teardown of go-plugin interface complete") + end + + # @return [Boolean] go plugins have been setup + def configured? + !!@setup + end + end + end +end diff --git a/lib/vagrant/go_plugin/manager.rb b/lib/vagrant/go_plugin/manager.rb new file mode 100644 index 000000000..597371585 --- /dev/null +++ b/lib/vagrant/go_plugin/manager.rb @@ -0,0 +1,88 @@ +require "zip" +require "vagrant/plugin/state_file" + +module Vagrant + module GoPlugin + class Manager + include Util::Logger + + # @return [Manager] + def self.instance(env=nil) + @instance ||= self.new + if env + @instance.envirnoment = env + end + @instance + end + + # @return [StateFile] user defined plugins + attr_reader :user_file + # @return [StateFile, nil] project local defined plugins + attr_reader :local_file + + def initialize + FileUtils.mkdir_p(INSTALL_DIRECTORY) + FileUtils.mkdir_p(Vagrant.user_data_path.join("tmp").to_s) + @user_file = Plugin::StateFile.new(Vagrant.user_data_path.join("plugins.json")) + end + + # Load global plugins + def globalize! + Dir.glob(File.join(INSTALL_DIRECTORY, "*")).each do |entry| + next if !File.directory?(entry) + logger.debug("loading go plugins from directory: #{entry}") + GoPlugin.interface.load_plugins(entry) + end + GoPlugin.interface.register_plugins + end + + # Load local plugins + def localize! + raise NotImplementedError + end + + # Install a go plugin + # + # @param [String] plugin_name Name of plugin + # @param [String] remote_source Location of plugin for download + # @param [Hash] options Currently unused + def install_plugin(plugin_name, remote_source, options={}) + install_dir = File.join(INSTALL_DIRECTORY, plugin_name) + FileUtils.mkdir_p(install_dir) + Dir.mktmpdir("go-plugin", Vagrant.user_data_path.join("tmp").to_s) do |dir| + dest_file = File.join(dir, "plugin.zip") + logger.debug("downloading go plugin #{plugin_name} from #{remote_source}") + Util::Downloader.new(remote_source, dest_file).download! + logger.debug("extracting go plugin #{plugin_name} from #{dest_file}") + Zip::File.open(dest_file) do |zfile| + zfile.each do |entry| + install_path = File.join(install_dir, entry.name) + if File.file?(install_path) + logger.warn("removing existing plugin path for unpacking - #{install_path}") + File.delete(install_path) + end + entry.extract(install_path) + FileUtils.chmod(0755, install_path) + end + end + end + user_file.add_go_plugin(plugin_name, source: remote_source) + end + + # Uninstall a go plugin + # + # @param [String] plugin_name Name of plugin + # @param [Hash] options Currently unused + def uninstall_plugin(plugin_name, options={}) + plugin_path = File.join(INSTALL_DIRECTORY, plugin_name) + if !File.directory?(plugin_path) + logger.warn("Plugin directory does not exist for #{plugin_name} - #{plugin_path}") + else + logger.debug("deleting go plugin from path #{plugin_path}") + FileUtils.rm_rf(plugin_path) + end + user_file.remove_go_plugin(plugin_name) + end + end + end +end diff --git a/lib/vagrant/go_plugin/provider_plugin.rb b/lib/vagrant/go_plugin/provider_plugin.rb new file mode 100644 index 000000000..5e896c42b --- /dev/null +++ b/lib/vagrant/go_plugin/provider_plugin.rb @@ -0,0 +1,341 @@ +require "vagrant/go_plugin/core" + +module Vagrant + module GoPlugin + module ProviderPlugin + # Helper class for wrapping actions in a go-plugin into + # something which can be used by Vagrant::Action::Builder + class Action + # @return [String] provider name associated to this class + def self.provider_name + @provider_name + end + + # Set the provider name for this class + # + # @param [String] n provider name + # @return [String] + # @note can only be set once + def self.provider_name=(n) + if @provider_name + raise ArgumentError.new("Class provider name has already been set") + end + @provider_name = n.to_s.dup.freeze + end + + # @return [String] action name associated to this class + def self.action_name + @action_name + end + + # Set the action name for this class + # + # @param [String] n action name + # @return [String] + # @note can only be set once + def self.action_name=(n) + if @action_name + raise ArgumentError.new("Class action name has already been set") + end + @action_name = n.to_s.dup.freeze + end + + def initialize(app, env) + @app = app + end + + def call(env) + env_data = env_dump(env) + result = VagrantGoPlugin._provider_run_action( + self.class.go_plugin_name, self.class.go_action_name, + env_data, env[:machine].environment.dump) + result.each_pair do |k, v| + env[k] = v + end + @app.call(env) + end + end + + # Helper class used to provide a wrapper around a go-plugin + # provider so that it can be interacted with normally within + # Vagrant + class Provider < Vagrant.plugin("2", :provider) + # @return [Vagrant::Machine] + attr_reader :machine + + # @return [String] plugin name associated to this class + def self.go_plugin_name + @go_plugin_name + end + + # Set the plugin name for this class + # + # @param [String] n plugin name + # @return [String] + # @note can only be set once + def self.go_plugin_name=(n) + if @go_plugin_name + raise ArgumentError.new("Class plugin name has already been set") + end + @go_plugin_name = n + end + + # @return [String] + def self.name + go_plugin_name.to_s.capitalize.tr("_", "") + end + + def initialize(machine) + @machine = machine + end + + # @return [String] name of the provider plugin for this class + def provider_name + self.class.go_plugin_name + end + + # Get callable action by name + # + # @param [Symbol] name name of the action + # @return [Class] callable action class + def action(name) + ProviderPlugin.interface.action(provider_name, name.to_s, machine) + end + + # Execute capability with given name + # + # @param [Symbol] name Name of the capability + # @return [Object] + def capability(name, *args) + args = args.map do |arg| + arg.response_to(:to_json) ? arg.to_json : arg.to_s + end + result = ProviderPlugin.interface.capability(provider_name, args.to_json, machine) + begin + JSON.load(result) + rescue + result + end + end + + # @return [Boolean] provider is installed + def is_installed? + ProviderPlugin.interface.is_installed(provider_name, machine) + end + + # @return [Boolean] provider is usable + def is_usable? + ProviderPlugin.interface.is_usable(provider_name, machine) + end + + # @return [nil] + def machine_id_changed + ProviderPlugin.interface.machine_id_changed(provider_name, machine) + nil + end + + # @return [Hash] SSH information + def ssh_info + ProviderPlugin.interface.ssh_info(provider_name, machine) + end + + # @return [Vagrant::MachineState] + def state + ProviderPlugin.interface.state(provider_name, machine) + end + end + + def self.interface + unless @_interface + @_interface = Interface.new + end + @_interface + end + + class Interface + include GoPlugin::Core + + typedef :string, :action_name + typedef :string, :action_data + typedef :string, :capability_name + typedef :string, :capability_data + typedef :string, :provider_name + + # provider plugin functions + attach_function :_provider_action, :ProviderAction, + [:provider_name, :action_name, :vagrant_machine], :plugin_result + + attach_function :_provider_capability, :ProviderCapability, + [:provider_name, :capability_name, :capability_data, :vagrant_machine], :plugin_result + + attach_function :_provider_is_installed, :ProviderIsInstalled, + [:provider_name, :vagrant_machine], :plugin_result + + attach_function :_provider_is_usable, :ProviderIsUsable, + [:provider_name, :vagrant_machine], :plugin_result + + attach_function :_provider_machine_id_changed, :ProviderMachineIdChanged, + [:provider_name, :vagrant_machine], :plugin_result + + attach_function :_provider_run_action, :ProviderRunAction, + [:provider_name, :action_name, :action_data, :vagrant_machine], :plugin_result + + attach_function :_provider_ssh_info, :ProviderSshInfo, + [:provider_name, :vagrant_machine], :plugin_result + + attach_function :_provider_state, :ProviderState, + [:provider_name, :vagrant_machine], :plugin_result + + attach_function :_list_providers, :ListProviders, [], :plugin_result + + # List of provider plugins currently available + # + # @return [Array] + def list_providers + result, ptr = _list_providers + load_result(result, ptr) || [] + end + + # Get callable action from a provider plugin + # + # @param [String] provider_name provider name for action + # @param [String] action_name name of requested action + # @param [Vagrant::Machine] machine instance of guest + # @return [Action] + def action(provider_name, action_name, machine) + result = load_result { _provider_action(provider_name, + action_name, dump_machine(machine)) } + klasses = result.map do |klass_name| + if klass_name.start_with?("self::") + action_name = klass_name.split("::", 2).last + klass = Class.new(Action) + klass.go_provider_name = provider_name + klass.go_action_name = action_name + klass.class_eval do + def self.name + "#{provider_name.capitalize}#{action_name.capitalize}".tr("_", "") + end + end + klass + else + klass_name.split("::").inject(Object) do |memo, const| + if memo.const_defined?(const) + memo.const_get(const) + else + raise NameError.new "Unknown action class `#{klass_name}`" + end + end + end + end + Vagrant::Action::Builder.new.tap do |builder| + klasses.each do |action_class| + builder.use action_class + end + end + end + + def capability + end + + # Check if provider has requested capability + # + # @param [String] provider_name provider name for request + # @param [String] capability_name name of the capability + # @param [Vagrant::Machine] machine instance of guest + # @return [Boolean] + def has_capability(provider_name, capability_name, machine) + result = load_result { _provider_has_capability(provider_name, + capability_name, dump_machine(machine)) } + result + end + + # Check if provider is installed + # + # @param [String] provider_name provider name for request + # @param [Vagrant::Machine] machine instance of guest + # @return [Boolean] + def is_installed(provider_name, machine) + result = load_result { _provider_is_installed(provider_name, + dump_machine(machine)) } + result + end + + # Check if provider is usable + # + # @param [String] provider_name provider name for request + # @param [Vagrant::Machine] machine instance of guest + # @return [Boolean] + def is_usable(provider_name, machine) + result = load_result { _provider_is_usable(provider_name, + dump_machine(machine)) } + result + end + + # Called when the ID of a machine has changed + # + # @param [String] provider_name provider name for request + # @param [Vagrant::Machine] machine instance of guest + def machine_id_changed(provider_name, machine) + load_result { _provider_machine_id_changed(provider_name, dump_machine(machine)) } + end + + # Get SSH info for guest + # + # @param [String] provider_name provider name for request + # @param [Vagrant::Machine] machine instance of guest + # @return [Hash] SSH information + def ssh_info(provider_name, machine) + load_result { _provider_ssh_info(provider_name, dump_machine(machine)) } + end + + # Get state of machine + # + # @param [String] provider_name provider name for request + # @param [Vagrant::Machine] machine instance of guest + # @return [Vagrant::MachineState] + def state(provider_name, machine) + result = load_result { _provider_state(provider_name, dump_machine(machine)) } + Vagrant::MachineState.new(result[:id], + result[:short_description], result[:long_description]) + end + + # Load any detected provider plugins + def load! + if !@loaded + @loaded = true + logger.debug("provider go-plugins have not been loaded... loading") + list_providers.each do |p_name, p_details| + logger.debug("loading go-plugin provider #{p_name}. details - #{p_details}") + # Create new provider class wrapper + provider_klass = Class.new(Provider) + provider_klass.go_plugin_name = p_name + # Create new plugin to register the provider + plugin_klass = Class.new(Vagrant.plugin("2")) + # Define the plugin + plugin_klass.class_eval do + name "#{p_name} Provider" + description p_details[:description] + end + # Register the provider + plugin_klass.provider(p_name.to_sym, priority: p_details.fetch(:priority, 0)) do + provider_klass + end + # Register any configuration support + ConfigPlugin.interface.generate_config(p_name, :provider, plugin_klass) + # Register any guest capabilities + CapabilityPlugin.interface.generate_guest_capabilities(p_name, :provider, plugin_klass) + # Register any host capabilities + CapabilityPlugin.interface.generate_host_capabilities(p_name, :provider, plugin_klass) + # Register any provider capabilities + CapabilityPlugin.interface.generate_provider_capabilities(p_name, :provider, plugin_klass) + logger.debug("completed loading provider go-plugin #{p_name}") + logger.info("loaded go-plugin provider - #{p_name}") + end + else + logger.warn("provider go-plugins have already been loaded. ignoring load request.") + end + end + end + end + end +end diff --git a/lib/vagrant/go_plugin/synced_folder_plugin.rb b/lib/vagrant/go_plugin/synced_folder_plugin.rb new file mode 100644 index 000000000..531834091 --- /dev/null +++ b/lib/vagrant/go_plugin/synced_folder_plugin.rb @@ -0,0 +1,170 @@ +require "vagrant/go_plugin/core" + +module Vagrant + module GoPlugin + # Contains all synced folder functionality for go-plugin + module SyncedFolderPlugin + + # Helper class used to provide a wrapper around a go-plugin + # synced folder so that it can be interacted with normally + # within Vagrant + class SyncedFolder < Vagrant.plugin("2", :synced_folder) + include DirectGoPlugin + + # Cleanup synced folders + # + # @param [Vagrant::Machine] machine Vagrant guest + # @param [Hash] opts Folder options + def cleanup(machine, opts) + SyncedFolderPlugin.interface.cleanup(plugin_name, machine, opts) + end + + # Disable synced folders + # + # @param [String] plugin_name Name of plugin + # @param [Vagrant::Machine] machine Vagrant guest + # @param [Hash] folders Folders to enable + # @param [Hash] opts Folder options + def disable(machine, folder, opts) + SyncedFolderPlugin.interface.disable(plugin_name, machine, folder, opts) + end + + # Enable synced folders + # + # @param [String] plugin_name Name of plugin + # @param [Vagrant::Machine] machine Vagrant guest + # @param [Hash] folders Folders to enable + # @param [Hash] opts Folder options + def enable(machine, folder, opts) + SyncedFolderPlugin.interface.enable(plugin_name, machine, folder, opts) + end + + # Check if plugin is usable + # + # @param [Vagrant::Machine] machine Vagrant guest + # @return [Boolean] + def usable?(machine, raise_error=false) + SyncedFolderPlugin.interface.usable?(plugin_name, machine) + end + end + + # @return [Interface] + def self.interface + unless @_interface + @_interface = Interface.new + end + @_interface + end + + # Synced folder interface to go-plugin + class Interface + include GoPlugin::Core + + typedef :string, :folders + typedef :string, :folder_options + + # synced folder plugin functions + attach_function :_cleanup, :SyncedFolderCleanup, + [:plugin_name, :vagrant_machine, :folder_options], :plugin_result + attach_function :_disable, :SyncedFolderDisable, + [:plugin_name, :vagrant_machine, :folders, :folder_options], :plugin_result + attach_function :_enable, :SyncedFolderEnable, + [:plugin_name, :vagrant_machine, :folders, :folder_options], :plugin_result + attach_function :_list_synced_folders, :ListSyncedFolders, + [], :plugin_result + attach_function :_usable, :SyncedFolderIsUsable, + [:plugin_name, :vagrant_machine], :plugin_result + + # Cleanup synced folders + # + # @param [String] plugin_name Name of plugin + # @param [Vagrant::Machine] machine Vagrant guest + # @param [Hash] opts Folder options + def cleanup(plugin_name, machine, opts) + load_result { + _cleanup(plugin_name, dump_machine(machine), JSON.dump(opts)) + } + end + + # Disable synced folders + # + # @param [String] plugin_name Name of plugin + # @param [Vagrant::Machine] machine Vagrant guest + # @param [Hash] folders Folders to enable + # @param [Hash] opts Folder options + def disable(plugin_name, machine, folders, opts) + load_result { + _disable(plugin_name, dump_machine(machine), + JSON.dump(folders), JSON.dump(opts)) + } + end + + # Enable synced folders + # + # @param [String] plugin_name Name of plugin + # @param [Vagrant::Machine] machine Vagrant guest + # @param [Hash] folders Folders to enable + # @param [Hash] opts Folder options + def enable(plugin_name, machine, folders, opts) + load_result { + _enable(plugin_name, dump_machine(machine), + JSON.dump(folders), JSON.dump(opts)) + } + end + + # List of available synced folder plugins + # + # @return [Array] + def list_synced_folders + load_result { _list_synced_folders } + end + + # Check if plugin is usable + # + # @param [String] plugin_name Name of plugin + # @param [Vagrant::Machine] machine Vagrant guest + # @return [Boolean] + def usable?(plugin_name, machine) + load_result { + _usable(plugin_name, dump_machine(machine)) + } + end + + # Load any detected synced folder plugins + def load! + if !@loaded + @loaded = true + logger.debug("synced folder go-plugins have not been loaded... loading") + list_synced_folders.each do |f_name, f_details| + logger.debug("loading go-plugin synced folder #{f_name}. details - #{f_details}") + # Create new synced folder class wrapper + folder_klass = Class.new(SyncedFolder) + folder_klass.go_plugin_name = f_name + # Create new plugin to register the synced folder + plugin_klass = Class.new(Vagrant.plugin("2")) + # Define the plugin + plugin_klass.class_eval do + name "#{f_name} Synced Folder" + description f_details[:description] + end + # Register the synced folder + plugin_klass.synced_folder(f_name.to_sym, f_details.fetch(:priority, 10)) do + folder_klass + end + # Register any guest capabilities + CapabilityPlugin.interface.generate_guest_capabilities(f_name, :synced_folder, plugin_klass) + # Register any host capabilities + CapabilityPlugin.interface.generate_host_capabilities(f_name, :synced_folder, plugin_klass) + # Register any provider capabilities + CapabilityPlugin.interface.generate_provider_capabilities(f_name, :synced_folder, plugin_klass) + logger.debug("completed loading synced folder go-plugin #{f_name}") + logger.info("loaded go-plugin synced folder - #{f_name}") + end + else + logger.warn("synced folder go-plugins have already been loaded. ignoring load request.") + end + end + end + end + end +end diff --git a/lib/vagrant/plugin/state_file.rb b/lib/vagrant/plugin/state_file.rb index c6872d4fd..5a0892263 100644 --- a/lib/vagrant/plugin/state_file.rb +++ b/lib/vagrant/plugin/state_file.rb @@ -24,17 +24,53 @@ module Vagrant end upgrade_v0! if !@data["version"] + upgrade_v1! if @data["version"].to_s == "1" end - @data["version"] ||= "1" - @data["installed"] ||= {} + @data["version"] ||= "2" + @data["ruby"] ||= {"installed" => {}} + @data["go_plugin"] ||= {} + end + + # Add a go plugin that is installed to the state file. + # + # @param [String] name The name of the plugin + def add_go_plugin(name, **opts) + @data["go_plugin"][name] = { + "source" => opts[:source] + } + + save! + end + + # Remove a plugin that is installed from the state file. + # + # @param [String] name The name of the plugin + def remove_go_plugin(name) + @data["go_plugin"].delete(name) + + save! + end + + # @return [Boolean] go plugin is present in this state file + def has_go_plugin?(name) + @data["go_plugin"].key?(name) + end + + # This returns a hash of installed go plugins according to the state + # file. Note that this may _not_ directly match over to actually + # installed plugins. + # + # @return [Hash] + def installed_go_plugins + @data["go_plugin"] end # Add a plugin that is installed to the state file. # # @param [String] name The name of the plugin def add_plugin(name, **opts) - @data["installed"][name] = { + @data["ruby"]["installed"][name] = { "ruby_version" => RUBY_VERSION, "vagrant_version" => Vagrant::VERSION, "gem_version" => opts[:version] || "", @@ -51,8 +87,8 @@ module Vagrant # # @param [String] url URL of the source. def add_source(url) - @data["sources"] ||= [] - @data["sources"] << url if !@data["sources"].include?(url) + @data["ruby"]["sources"] ||= [] + @data["ruby"]["sources"] |= [url] save! end @@ -62,21 +98,21 @@ module Vagrant # # @return [Hash] def installed_plugins - @data["installed"] + @data["ruby"]["installed"] end # Returns true/false if the plugin is present in this state file. # # @return [Boolean] def has_plugin?(name) - @data["installed"].key?(name) + @data["ruby"]["installed"].key?(name) end # Remove a plugin that is installed from the state file. # # @param [String] name The name of the plugin. def remove_plugin(name) - @data["installed"].delete(name) + @data["ruby"]["installed"].delete(name) save! end @@ -84,8 +120,8 @@ module Vagrant # # @param [String] url URL of the source def remove_source(url) - @data["sources"] ||= [] - @data["sources"].delete(url) + @data["ruby"]["sources"] ||= [] + @data["ruby"]["sources"].delete(url) save! end @@ -94,7 +130,7 @@ module Vagrant # # @return [Array] def sources - @data["sources"] || [] + @data["ruby"]["sources"] || [] end # This saves the state back into the state file. @@ -128,6 +164,18 @@ module Vagrant save! end + + # This upgrades the internal data representation from V1 to V2 + def upgrade_v1! + @data.delete("version") + new_data = { + "version" => "2", + "ruby" => @data, + "go_plugin" => {} + } + + save! + end end end end diff --git a/lib/vagrant/util.rb b/lib/vagrant/util.rb index 32babe50d..d019c33a7 100644 --- a/lib/vagrant/util.rb +++ b/lib/vagrant/util.rb @@ -9,6 +9,7 @@ module Vagrant autoload :Env, 'vagrant/util/env' autoload :HashWithIndifferentAccess, 'vagrant/util/hash_with_indifferent_access' autoload :GuestInspection, 'vagrant/util/guest_inspection' + autoload :Logger, 'vagrant/util/logger' autoload :LoggingFormatter, 'vagrant/util/logging_formatter' autoload :Platform, 'vagrant/util/platform' autoload :Retryable, 'vagrant/util/retryable' diff --git a/lib/vagrant/util/logger.rb b/lib/vagrant/util/logger.rb new file mode 100644 index 000000000..af5139cc9 --- /dev/null +++ b/lib/vagrant/util/logger.rb @@ -0,0 +1,18 @@ +require "log4r" + +module Vagrant + module Util + # Adds a logger method which provides automatically + # namespaced logger instance + module Logger + + # @return [Log4r::Logger] + def logger + if !@_logger + @_logger = Log4r::Logger.new(self.class.name.downcase) + end + @_logger + end + end + end +end diff --git a/plugins/commands/plugin/action.rb b/plugins/commands/plugin/action.rb index d0f9bf8e9..7979c2435 100644 --- a/plugins/commands/plugin/action.rb +++ b/plugins/commands/plugin/action.rb @@ -74,6 +74,23 @@ module VagrantPlugins autoload :RepairPluginsLocal, action_root.join("repair_plugins") autoload :UninstallPlugin, action_root.join("uninstall_plugin") autoload :UpdateGems, action_root.join("update_gems") + + Vagrant::Util::Experimental.guard_with(:go_plugin) do + autoload :UninstallGoPlugin, action_root.join("uninstall_go_plugin") + autoload :InstallGoPlugin, action_root.join("install_go_plugin") + + def self.action_go_install + Vagrant::Action::Builder.new.tap do |b| + b.use InstallGoPlugin + end + end + + def self.action_go_uninstall + Vagrant::Action::Builder.new.tap do |b| + b.use UninstallGoPlugin + end + end + end end end end diff --git a/plugins/commands/plugin/action/install_go_plugin.rb b/plugins/commands/plugin/action/install_go_plugin.rb new file mode 100644 index 000000000..b79e86158 --- /dev/null +++ b/plugins/commands/plugin/action/install_go_plugin.rb @@ -0,0 +1,35 @@ +require "log4r" +require "vagrant/go_plugin/manager" + +module VagrantPlugins + module CommandPlugin + module Action + class InstallGoPlugin + def initialize(app, env) + @app = app + @logger = Log4r::Logger.new("vagrant::plugins::plugincommand::installgoplugin") + end + + def call(env) + plugin_name = env[:plugin_name] + plugin_source = env[:plugin_source] + + manager = Vagrant::GoPlugin::Manager.instance + + env[:ui].info(I18n.t("vagrant.commands.plugin.installing", + name: plugin_name)) + + manager.install_plugin(plugin_name, plugin_source) + + # Tell the user + env[:ui].success(I18n.t("vagrant.commands.plugin.installed", + name: plugin_name, + version: plugin_source)) + + # Continue + @app.call(env) + end + end + end + end +end diff --git a/plugins/commands/plugin/action/uninstall_go_plugin.rb b/plugins/commands/plugin/action/uninstall_go_plugin.rb new file mode 100644 index 000000000..7c3d0a48f --- /dev/null +++ b/plugins/commands/plugin/action/uninstall_go_plugin.rb @@ -0,0 +1,22 @@ +module VagrantPlugins + module CommandPlugin + module Action + class UninstallGoPlugin + def initialize(app, env) + @app = app + end + + def call(env) + # Remove it! + env[:ui].info(I18n.t("vagrant.commands.plugin.uninstalling", + name: env[:plugin_name])) + + manager = Vagrant::GoPlugin::Manager.instance + manager.uninstall_plugin(env[:plugin_name]) + + @app.call(env) + end + end + end + end +end diff --git a/plugins/commands/plugin/command/go_install.rb b/plugins/commands/plugin/command/go_install.rb new file mode 100644 index 000000000..a09691b0c --- /dev/null +++ b/plugins/commands/plugin/command/go_install.rb @@ -0,0 +1,43 @@ +require 'optparse' + +require_relative "base" + +module VagrantPlugins + module CommandPlugin + module Command + class GoInstall < Base + + def execute + options = { verbose: false } + + opts = OptionParser.new do |o| + o.banner = "Usage: vagrant plugin goinstall " + o.separator "" + + o.on("--verbose", "Enable verbose output for plugin installation") do |v| + options[:verbose] = v + end + end + + # Parse the options + argv = parse_options(opts) + return if !argv + + if argv.length != 2 + raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp + end + + plugin_name, plugin_source = argv + + action(Action.action_go_install, + plugin_name: plugin_name, + plugin_source: plugin_source + ) + + # Success, exit status 0 + 0 + end + end + end + end +end diff --git a/plugins/commands/plugin/command/go_uninstall.rb b/plugins/commands/plugin/command/go_uninstall.rb new file mode 100644 index 000000000..8bae93023 --- /dev/null +++ b/plugins/commands/plugin/command/go_uninstall.rb @@ -0,0 +1,31 @@ +require 'optparse' + +require_relative "base" + +module VagrantPlugins + module CommandPlugin + module Command + class GoUninstall < Base + def execute + options = {} + opts = OptionParser.new do |o| + o.banner = "Usage: vagrant plugin gouninstall [ ...] [-h]" + end + + # Parse the options + argv = parse_options(opts) + return if !argv + raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp if argv.length < 1 + + # Uninstall the plugins + argv.each do |entry| + action(Action.action_go_uninstall, plugin_name: entry) + end + + # Success, exit status 0 + 0 + end + end + end + end +end diff --git a/plugins/commands/plugin/command/root.rb b/plugins/commands/plugin/command/root.rb index 6953eb495..6529f4c0d 100644 --- a/plugins/commands/plugin/command/root.rb +++ b/plugins/commands/plugin/command/root.rb @@ -48,6 +48,18 @@ module VagrantPlugins require_relative "uninstall" Uninstall end + + Vagrant::Util::Experimental.guard_with(:go_plugin) do + @subcommands.register(:goinstall) do + require_relative "go_install" + GoInstall + end + + @subcommands.register(:gouninstall) do + require_relative "go_uninstall" + GoUninstall + end + end end def execute diff --git a/vagrant.gemspec b/vagrant.gemspec index 885c0d359..21db808f4 100644 --- a/vagrant.gemspec +++ b/vagrant.gemspec @@ -13,6 +13,7 @@ Gem::Specification.new do |s| s.description = "Vagrant is a tool for building and distributing virtualized development environments." s.required_ruby_version = "~> 2.2", "< 2.7" + s.required_rubygems_version = ">= 1.3.6" s.rubyforge_project = "vagrant" @@ -49,6 +50,7 @@ Gem::Specification.new do |s| s.add_development_dependency "rspec-its", "~> 1.2.0" s.add_development_dependency "webmock", "~> 2.3.1" s.add_development_dependency "fake_ftp", "~> 0.1.1" + s.add_development_dependency "rake-compiler" # The following block of code determines the files that should be included # in the gem. It does this by reading all the files in the directory where diff --git a/website/source/docs/experimental/index.html.md b/website/source/docs/experimental/index.html.md index 5de2365d7..17da3ee6f 100644 --- a/website/source/docs/experimental/index.html.md +++ b/website/source/docs/experimental/index.html.md @@ -54,3 +54,7 @@ Enabling this feature allows all provisioners to specify `before` and `after` options. These options allow provisioners to be configured to run before or after any given "root" provisioner. more information about these options can be found on the [base provisioner documentation page](/docs/provisioning/basic_usage.html) + +### `go_plugin` + +Enabling this feature turns on support for [go-plugin](https://github.com/hashicorp/go-plugin) based plugin for Vagrant.