140 lines
3.2 KiB
Go
140 lines
3.2 KiB
Go
package rpc
|
|
|
|
import (
|
|
"io"
|
|
"log"
|
|
"net/rpc"
|
|
|
|
"github.com/hashicorp/packer/packer"
|
|
"github.com/ugorji/go/codec"
|
|
)
|
|
|
|
const (
|
|
DefaultArtifactEndpoint string = "Artifact"
|
|
DefaultBuildEndpoint = "Build"
|
|
DefaultBuilderEndpoint = "Builder"
|
|
DefaultCacheEndpoint = "Cache"
|
|
DefaultCommandEndpoint = "Command"
|
|
DefaultCommunicatorEndpoint = "Communicator"
|
|
DefaultHookEndpoint = "Hook"
|
|
DefaultPostProcessorEndpoint = "PostProcessor"
|
|
DefaultProvisionerEndpoint = "Provisioner"
|
|
DefaultUiEndpoint = "Ui"
|
|
)
|
|
|
|
// Server represents an RPC server for Packer. This must be paired on
|
|
// the other side with a Client.
|
|
type Server struct {
|
|
mux *muxBroker
|
|
streamId uint32
|
|
server *rpc.Server
|
|
closeMux bool
|
|
}
|
|
|
|
// NewServer returns a new Packer RPC server.
|
|
func NewServer(conn io.ReadWriteCloser) *Server {
|
|
mux, _ := newMuxBrokerServer(conn)
|
|
result := newServerWithMux(mux, 0)
|
|
result.closeMux = true
|
|
go mux.Run()
|
|
return result
|
|
}
|
|
|
|
func newServerWithMux(mux *muxBroker, streamId uint32) *Server {
|
|
return &Server{
|
|
mux: mux,
|
|
streamId: streamId,
|
|
server: rpc.NewServer(),
|
|
closeMux: false,
|
|
}
|
|
}
|
|
|
|
func (s *Server) Close() error {
|
|
if s.closeMux {
|
|
log.Printf("[WARN] Shutting down mux conn in Server")
|
|
return s.mux.Close()
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Server) RegisterArtifact(a packer.Artifact) {
|
|
s.server.RegisterName(DefaultArtifactEndpoint, &ArtifactServer{
|
|
artifact: a,
|
|
})
|
|
}
|
|
|
|
func (s *Server) RegisterBuild(b packer.Build) {
|
|
s.server.RegisterName(DefaultBuildEndpoint, &BuildServer{
|
|
build: b,
|
|
mux: s.mux,
|
|
})
|
|
}
|
|
|
|
func (s *Server) RegisterBuilder(b packer.Builder) {
|
|
s.server.RegisterName(DefaultBuilderEndpoint, &BuilderServer{
|
|
builder: b,
|
|
mux: s.mux,
|
|
})
|
|
}
|
|
|
|
func (s *Server) RegisterCache(c packer.Cache) {
|
|
s.server.RegisterName(DefaultCacheEndpoint, &CacheServer{
|
|
cache: c,
|
|
})
|
|
}
|
|
|
|
func (s *Server) RegisterCommunicator(c packer.Communicator) {
|
|
s.server.RegisterName(DefaultCommunicatorEndpoint, &CommunicatorServer{
|
|
c: c,
|
|
mux: s.mux,
|
|
})
|
|
}
|
|
|
|
func (s *Server) RegisterHook(h packer.Hook) {
|
|
s.server.RegisterName(DefaultHookEndpoint, &HookServer{
|
|
hook: h,
|
|
mux: s.mux,
|
|
})
|
|
}
|
|
|
|
func (s *Server) RegisterPostProcessor(p packer.PostProcessor) {
|
|
s.server.RegisterName(DefaultPostProcessorEndpoint, &PostProcessorServer{
|
|
mux: s.mux,
|
|
p: p,
|
|
})
|
|
}
|
|
|
|
func (s *Server) RegisterProvisioner(p packer.Provisioner) {
|
|
s.server.RegisterName(DefaultProvisionerEndpoint, &ProvisionerServer{
|
|
mux: s.mux,
|
|
p: p,
|
|
})
|
|
}
|
|
|
|
func (s *Server) RegisterUi(ui packer.Ui) {
|
|
s.server.RegisterName(DefaultUiEndpoint, &UiServer{
|
|
ui: ui,
|
|
})
|
|
}
|
|
|
|
// ServeConn serves a single connection over the RPC server. It is up
|
|
// to the caller to obtain a proper io.ReadWriteCloser.
|
|
func (s *Server) Serve() {
|
|
// Accept a connection on stream ID 0, which is always used for
|
|
// normal client to server connections.
|
|
stream, err := s.mux.Accept(s.streamId)
|
|
if err != nil {
|
|
log.Printf("[ERR] Error retrieving stream for serving: %s", err)
|
|
return
|
|
}
|
|
defer stream.Close()
|
|
|
|
h := &codec.MsgpackHandle{
|
|
RawToString: true,
|
|
WriteExt: true,
|
|
}
|
|
rpcCodec := codec.GoRpc.ServerCodec(stream, h)
|
|
s.server.ServeCodec(rpcCodec)
|
|
}
|