github.com/jbronn/packer@v0.1.6-0.20140120165540-8a1364dbd817/packer/rpc/client.go (about)

     1  package rpc
     2  
     3  import (
     4  	"github.com/mitchellh/packer/packer"
     5  	"io"
     6  	"log"
     7  	"net/rpc"
     8  )
     9  
    10  // Client is the client end that communicates with a Packer RPC server.
    11  // Establishing a connection is up to the user, the Client can just
    12  // communicate over any ReadWriteCloser.
    13  type Client struct {
    14  	mux      *MuxConn
    15  	client   *rpc.Client
    16  	closeMux bool
    17  }
    18  
    19  func NewClient(rwc io.ReadWriteCloser) (*Client, error) {
    20  	result, err := newClientWithMux(NewMuxConn(rwc), 0)
    21  	if err != nil {
    22  		return nil, err
    23  	}
    24  
    25  	result.closeMux = true
    26  	return result, err
    27  }
    28  
    29  func newClientWithMux(mux *MuxConn, streamId uint32) (*Client, error) {
    30  	clientConn, err := mux.Dial(streamId)
    31  	if err != nil {
    32  		return nil, err
    33  	}
    34  
    35  	return &Client{
    36  		mux:      mux,
    37  		client:   rpc.NewClient(clientConn),
    38  		closeMux: false,
    39  	}, nil
    40  }
    41  
    42  func (c *Client) Close() error {
    43  	if err := c.client.Close(); err != nil {
    44  		return err
    45  	}
    46  
    47  	if c.closeMux {
    48  		log.Printf("[WARN] Client is closing mux")
    49  		return c.mux.Close()
    50  	}
    51  
    52  	return nil
    53  }
    54  
    55  func (c *Client) Artifact() packer.Artifact {
    56  	return &artifact{
    57  		client:   c.client,
    58  		endpoint: DefaultArtifactEndpoint,
    59  	}
    60  }
    61  
    62  func (c *Client) Build() packer.Build {
    63  	return &build{
    64  		client: c.client,
    65  		mux:    c.mux,
    66  	}
    67  }
    68  
    69  func (c *Client) Builder() packer.Builder {
    70  	return &builder{
    71  		client: c.client,
    72  		mux:    c.mux,
    73  	}
    74  }
    75  
    76  func (c *Client) Cache() packer.Cache {
    77  	return &cache{
    78  		client: c.client,
    79  	}
    80  }
    81  
    82  func (c *Client) Command() packer.Command {
    83  	return &command{
    84  		client: c.client,
    85  		mux:    c.mux,
    86  	}
    87  }
    88  
    89  func (c *Client) Communicator() packer.Communicator {
    90  	return &communicator{
    91  		client: c.client,
    92  		mux:    c.mux,
    93  	}
    94  }
    95  
    96  func (c *Client) Environment() packer.Environment {
    97  	return &Environment{
    98  		client: c.client,
    99  		mux:    c.mux,
   100  	}
   101  }
   102  
   103  func (c *Client) Hook() packer.Hook {
   104  	return &hook{
   105  		client: c.client,
   106  		mux:    c.mux,
   107  	}
   108  }
   109  
   110  func (c *Client) PostProcessor() packer.PostProcessor {
   111  	return &postProcessor{
   112  		client: c.client,
   113  		mux:    c.mux,
   114  	}
   115  }
   116  
   117  func (c *Client) Provisioner() packer.Provisioner {
   118  	return &provisioner{
   119  		client: c.client,
   120  		mux:    c.mux,
   121  	}
   122  }
   123  
   124  func (c *Client) Ui() packer.Ui {
   125  	return &Ui{
   126  		client:   c.client,
   127  		endpoint: DefaultUiEndpoint,
   128  	}
   129  }