github.com/daniellockard/packer@v0.7.6-0.20141210173435-5a9390934716/packer/rpc/environment.go (about)

     1  package rpc
     2  
     3  import (
     4  	"github.com/mitchellh/packer/packer"
     5  	"log"
     6  	"net/rpc"
     7  )
     8  
     9  // A Environment is an implementation of the packer.Environment interface
    10  // where the actual environment is executed over an RPC connection.
    11  type Environment struct {
    12  	client *rpc.Client
    13  	mux    *muxBroker
    14  }
    15  
    16  // A EnvironmentServer wraps a packer.Environment and makes it exportable
    17  // as part of a Golang RPC server.
    18  type EnvironmentServer struct {
    19  	env packer.Environment
    20  	mux *muxBroker
    21  }
    22  
    23  func (e *Environment) Builder(name string) (b packer.Builder, err error) {
    24  	var streamId uint32
    25  	err = e.client.Call("Environment.Builder", name, &streamId)
    26  	if err != nil {
    27  		return
    28  	}
    29  
    30  	client, err := newClientWithMux(e.mux, streamId)
    31  	if err != nil {
    32  		return nil, err
    33  	}
    34  	b = client.Builder()
    35  	return
    36  }
    37  
    38  func (e *Environment) Cache() packer.Cache {
    39  	var streamId uint32
    40  	if err := e.client.Call("Environment.Cache", new(interface{}), &streamId); err != nil {
    41  		panic(err)
    42  	}
    43  
    44  	client, err := newClientWithMux(e.mux, streamId)
    45  	if err != nil {
    46  		log.Printf("[ERR] Error getting cache client: %s", err)
    47  		return nil
    48  	}
    49  	return client.Cache()
    50  }
    51  
    52  func (e *Environment) Hook(name string) (h packer.Hook, err error) {
    53  	var streamId uint32
    54  	err = e.client.Call("Environment.Hook", name, &streamId)
    55  	if err != nil {
    56  		return
    57  	}
    58  
    59  	client, err := newClientWithMux(e.mux, streamId)
    60  	if err != nil {
    61  		return nil, err
    62  	}
    63  	return client.Hook(), nil
    64  }
    65  
    66  func (e *Environment) PostProcessor(name string) (p packer.PostProcessor, err error) {
    67  	var streamId uint32
    68  	err = e.client.Call("Environment.PostProcessor", name, &streamId)
    69  	if err != nil {
    70  		return
    71  	}
    72  
    73  	client, err := newClientWithMux(e.mux, streamId)
    74  	if err != nil {
    75  		return nil, err
    76  	}
    77  	p = client.PostProcessor()
    78  	return
    79  }
    80  
    81  func (e *Environment) Provisioner(name string) (p packer.Provisioner, err error) {
    82  	var streamId uint32
    83  	err = e.client.Call("Environment.Provisioner", name, &streamId)
    84  	if err != nil {
    85  		return
    86  	}
    87  
    88  	client, err := newClientWithMux(e.mux, streamId)
    89  	if err != nil {
    90  		return nil, err
    91  	}
    92  	p = client.Provisioner()
    93  	return
    94  }
    95  
    96  func (e *Environment) Ui() packer.Ui {
    97  	var streamId uint32
    98  	e.client.Call("Environment.Ui", new(interface{}), &streamId)
    99  
   100  	client, err := newClientWithMux(e.mux, streamId)
   101  	if err != nil {
   102  		log.Printf("[ERR] Error connecting to Ui: %s", err)
   103  		return nil
   104  	}
   105  	return client.Ui()
   106  }
   107  
   108  func (e *EnvironmentServer) Builder(name string, reply *uint32) error {
   109  	builder, err := e.env.Builder(name)
   110  	if err != nil {
   111  		return NewBasicError(err)
   112  	}
   113  
   114  	*reply = e.mux.NextId()
   115  	server := newServerWithMux(e.mux, *reply)
   116  	server.RegisterBuilder(builder)
   117  	go server.Serve()
   118  	return nil
   119  }
   120  
   121  func (e *EnvironmentServer) Cache(args *interface{}, reply *uint32) error {
   122  	cache := e.env.Cache()
   123  
   124  	*reply = e.mux.NextId()
   125  	server := newServerWithMux(e.mux, *reply)
   126  	server.RegisterCache(cache)
   127  	go server.Serve()
   128  	return nil
   129  }
   130  
   131  func (e *EnvironmentServer) Hook(name string, reply *uint32) error {
   132  	hook, err := e.env.Hook(name)
   133  	if err != nil {
   134  		return NewBasicError(err)
   135  	}
   136  
   137  	*reply = e.mux.NextId()
   138  	server := newServerWithMux(e.mux, *reply)
   139  	server.RegisterHook(hook)
   140  	go server.Serve()
   141  	return nil
   142  }
   143  
   144  func (e *EnvironmentServer) PostProcessor(name string, reply *uint32) error {
   145  	pp, err := e.env.PostProcessor(name)
   146  	if err != nil {
   147  		return NewBasicError(err)
   148  	}
   149  
   150  	*reply = e.mux.NextId()
   151  	server := newServerWithMux(e.mux, *reply)
   152  	server.RegisterPostProcessor(pp)
   153  	go server.Serve()
   154  	return nil
   155  }
   156  
   157  func (e *EnvironmentServer) Provisioner(name string, reply *uint32) error {
   158  	prov, err := e.env.Provisioner(name)
   159  	if err != nil {
   160  		return NewBasicError(err)
   161  	}
   162  
   163  	*reply = e.mux.NextId()
   164  	server := newServerWithMux(e.mux, *reply)
   165  	server.RegisterProvisioner(prov)
   166  	go server.Serve()
   167  	return nil
   168  }
   169  
   170  func (e *EnvironmentServer) Ui(args *interface{}, reply *uint32) error {
   171  	ui := e.env.Ui()
   172  
   173  	*reply = e.mux.NextId()
   174  	server := newServerWithMux(e.mux, *reply)
   175  	server.RegisterUi(ui)
   176  	go server.Serve()
   177  	return nil
   178  }