rpc

package
v0.0.0-...-82a7f6e Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 15, 2015 License: MPL-2.0 Imports: 14 Imported by: 0

Documentation

Index

Constants

View Source
const (
	DefaultArtifactEndpoint      string = "Artifact"
	DefaultBuildEndpoint                = "Build"
	DefaultBuilderEndpoint              = "Builder"
	DefaultCacheEndpoint                = "Cache"
	DefaultCommandEndpoint              = "Command"
	DefaultCommunicatorEndpoint         = "Communicator"
	DefaultHookEndpoint                 = "Hook"
	DefaultPostProcessorEndpoint        = "PostProcessor"
	DefaultProvisionerEndpoint          = "Provisioner"
	DefaultUiEndpoint                   = "Ui"
)

Variables

This section is empty.

Functions

func Communicator

func Communicator(client *rpc.Client) *communicator

Types

type ArtifactServer

type ArtifactServer struct {
	// contains filtered or unexported fields
}

ArtifactServer wraps a packer.Artifact implementation and makes it exportable as part of a Golang RPC server.

func (*ArtifactServer) BuilderId

func (s *ArtifactServer) BuilderId(args *interface{}, reply *string) error

func (*ArtifactServer) Destroy

func (s *ArtifactServer) Destroy(args *interface{}, reply *error) error

func (*ArtifactServer) Files

func (s *ArtifactServer) Files(args *interface{}, reply *[]string) error

func (*ArtifactServer) Id

func (s *ArtifactServer) Id(args *interface{}, reply *string) error

func (*ArtifactServer) State

func (s *ArtifactServer) State(name string, reply *interface{}) error

func (*ArtifactServer) String

func (s *ArtifactServer) String(args *interface{}, reply *string) error

type BasicError

type BasicError struct {
	Message string
}

This is a type that wraps error types so that they can be messaged across RPC channels. Since "error" is an interface, we can't always gob-encode the underlying structure. This is a valid error interface implementer that we will push across.

func NewBasicError

func NewBasicError(err error) *BasicError

func (*BasicError) Error

func (e *BasicError) Error() string

type BuildPrepareResponse

type BuildPrepareResponse struct {
	Warnings []string
	Error    *BasicError
}

type BuildServer

type BuildServer struct {
	// contains filtered or unexported fields
}

BuildServer wraps a packer.Build implementation and makes it exportable as part of a Golang RPC server.

func (*BuildServer) Cancel

func (b *BuildServer) Cancel(args *interface{}, reply *interface{}) error

func (*BuildServer) Name

func (b *BuildServer) Name(args *interface{}, reply *string) error

func (*BuildServer) Prepare

func (b *BuildServer) Prepare(args *interface{}, resp *BuildPrepareResponse) error

func (*BuildServer) Run

func (b *BuildServer) Run(streamId uint32, reply *[]uint32) error

func (*BuildServer) SetDebug

func (b *BuildServer) SetDebug(val *bool, reply *interface{}) error

func (*BuildServer) SetForce

func (b *BuildServer) SetForce(val *bool, reply *interface{}) error

type BuilderPrepareArgs

type BuilderPrepareArgs struct {
	Configs []interface{}
}

type BuilderPrepareResponse

type BuilderPrepareResponse struct {
	Warnings []string
	Error    *BasicError
}

type BuilderServer

type BuilderServer struct {
	// contains filtered or unexported fields
}

BuilderServer wraps a packer.Builder implementation and makes it exportable as part of a Golang RPC server.

func (*BuilderServer) Cancel

func (b *BuilderServer) Cancel(args *interface{}, reply *interface{}) error

func (*BuilderServer) Prepare

func (*BuilderServer) Run

func (b *BuilderServer) Run(streamId uint32, reply *uint32) error

type CacheRLockResponse

type CacheRLockResponse struct {
	Path   string
	Exists bool
}

type CacheServer

type CacheServer struct {
	// contains filtered or unexported fields
}

CacheServer wraps a packer.Cache implementation and makes it exportable as part of a Golang RPC server.

func (*CacheServer) Lock

func (c *CacheServer) Lock(key string, result *string) error

func (*CacheServer) RLock

func (c *CacheServer) RLock(key string, result *CacheRLockResponse) error

func (*CacheServer) RUnlock

func (c *CacheServer) RUnlock(key string, result *interface{}) error

func (*CacheServer) Unlock

func (c *CacheServer) Unlock(key string, result *interface{}) error

type Client

type Client struct {
	// contains filtered or unexported fields
}

Client is the client end that communicates with a Packer RPC server. Establishing a connection is up to the user, the Client can just communicate over any ReadWriteCloser.

func NewClient

func NewClient(rwc io.ReadWriteCloser) (*Client, error)

func (*Client) Artifact

func (c *Client) Artifact() packer.Artifact

func (*Client) Build

func (c *Client) Build() packer.Build

func (*Client) Builder

func (c *Client) Builder() packer.Builder

func (*Client) Cache

func (c *Client) Cache() packer.Cache

func (*Client) Close

func (c *Client) Close() error

func (*Client) Communicator

func (c *Client) Communicator() packer.Communicator

func (*Client) Hook

func (c *Client) Hook() packer.Hook

func (*Client) PostProcessor

func (c *Client) PostProcessor() packer.PostProcessor

func (*Client) Provisioner

func (c *Client) Provisioner() packer.Provisioner

func (*Client) Ui

func (c *Client) Ui() packer.Ui

type CommandFinished

type CommandFinished struct {
	ExitStatus int
}

type CommunicatorDownloadArgs

type CommunicatorDownloadArgs struct {
	Path           string
	WriterStreamId uint32
}

type CommunicatorServer

type CommunicatorServer struct {
	// contains filtered or unexported fields
}

CommunicatorServer wraps a packer.Communicator implementation and makes it exportable as part of a Golang RPC server.

func (*CommunicatorServer) Download

func (c *CommunicatorServer) Download(args *CommunicatorDownloadArgs, reply *interface{}) (err error)

func (*CommunicatorServer) Start

func (c *CommunicatorServer) Start(args *CommunicatorStartArgs, reply *interface{}) error

func (*CommunicatorServer) Upload

func (c *CommunicatorServer) Upload(args *CommunicatorUploadArgs, reply *interface{}) (err error)

func (*CommunicatorServer) UploadDir

func (c *CommunicatorServer) UploadDir(args *CommunicatorUploadDirArgs, reply *error) error

type CommunicatorStartArgs

type CommunicatorStartArgs struct {
	Command          string
	StdinStreamId    uint32
	StdoutStreamId   uint32
	StderrStreamId   uint32
	ResponseStreamId uint32
}

type CommunicatorUploadArgs

type CommunicatorUploadArgs struct {
	Path           string
	ReaderStreamId uint32
}

type CommunicatorUploadDirArgs

type CommunicatorUploadDirArgs struct {
	Dst     string
	Src     string
	Exclude []string
}

type HookRunArgs

type HookRunArgs struct {
	Name     string
	Data     interface{}
	StreamId uint32
}

type HookServer

type HookServer struct {
	// contains filtered or unexported fields
}

HookServer wraps a packer.Hook implementation and makes it exportable as part of a Golang RPC server.

func (*HookServer) Cancel

func (h *HookServer) Cancel(args *interface{}, reply *interface{}) error

func (*HookServer) Run

func (h *HookServer) Run(args *HookRunArgs, reply *interface{}) error

type PostProcessorConfigureArgs

type PostProcessorConfigureArgs struct {
	Configs []interface{}
}

type PostProcessorProcessResponse

type PostProcessorProcessResponse struct {
	Err      *BasicError
	Keep     bool
	StreamId uint32
}

type PostProcessorServer

type PostProcessorServer struct {
	// contains filtered or unexported fields
}

PostProcessorServer wraps a packer.PostProcessor implementation and makes it exportable as part of a Golang RPC server.

func (*PostProcessorServer) Configure

func (p *PostProcessorServer) Configure(args *PostProcessorConfigureArgs, reply *interface{}) error

func (*PostProcessorServer) PostProcess

func (p *PostProcessorServer) PostProcess(streamId uint32, reply *PostProcessorProcessResponse) error

type ProvisionerPrepareArgs

type ProvisionerPrepareArgs struct {
	Configs []interface{}
}

type ProvisionerServer

type ProvisionerServer struct {
	// contains filtered or unexported fields
}

ProvisionerServer wraps a packer.Provisioner implementation and makes it exportable as part of a Golang RPC server.

func (*ProvisionerServer) Cancel

func (p *ProvisionerServer) Cancel(args *interface{}, reply *interface{}) error

func (*ProvisionerServer) Prepare

func (p *ProvisionerServer) Prepare(args *ProvisionerPrepareArgs, reply *interface{}) error

func (*ProvisionerServer) Provision

func (p *ProvisionerServer) Provision(streamId uint32, reply *interface{}) error

type Server

type Server struct {
	// contains filtered or unexported fields
}

Server represents an RPC server for Packer. This must be paired on the other side with a Client.

func NewServer

func NewServer(conn io.ReadWriteCloser) *Server

NewServer returns a new Packer RPC server.

func (*Server) Close

func (s *Server) Close() error

func (*Server) RegisterArtifact

func (s *Server) RegisterArtifact(a packer.Artifact)

func (*Server) RegisterBuild

func (s *Server) RegisterBuild(b packer.Build)

func (*Server) RegisterBuilder

func (s *Server) RegisterBuilder(b packer.Builder)

func (*Server) RegisterCache

func (s *Server) RegisterCache(c packer.Cache)

func (*Server) RegisterCommunicator

func (s *Server) RegisterCommunicator(c packer.Communicator)

func (*Server) RegisterHook

func (s *Server) RegisterHook(h packer.Hook)

func (*Server) RegisterPostProcessor

func (s *Server) RegisterPostProcessor(p packer.PostProcessor)

func (*Server) RegisterProvisioner

func (s *Server) RegisterProvisioner(p packer.Provisioner)

func (*Server) RegisterUi

func (s *Server) RegisterUi(ui packer.Ui)

func (*Server) Serve

func (s *Server) Serve()

ServeConn serves a single connection over the RPC server. It is up to the caller to obtain a proper io.ReadWriteCloser.

type Ui

type Ui struct {
	// contains filtered or unexported fields
}

An implementation of packer.Ui where the Ui is actually executed over an RPC connection.

func (*Ui) Ask

func (u *Ui) Ask(query string) (result string, err error)

func (*Ui) Error

func (u *Ui) Error(message string)

func (*Ui) Machine

func (u *Ui) Machine(t string, args ...string)

func (*Ui) Message

func (u *Ui) Message(message string)

func (*Ui) Say

func (u *Ui) Say(message string)

type UiMachineArgs

type UiMachineArgs struct {
	Category string
	Args     []string
}

The arguments sent to Ui.Machine

type UiServer

type UiServer struct {
	// contains filtered or unexported fields
}

UiServer wraps a packer.Ui implementation and makes it exportable as part of a Golang RPC server.

func (*UiServer) Ask

func (u *UiServer) Ask(query string, reply *string) (err error)

func (*UiServer) Error

func (u *UiServer) Error(message *string, reply *interface{}) error

func (*UiServer) Machine

func (u *UiServer) Machine(args *UiMachineArgs, reply *interface{}) error

func (*UiServer) Message

func (u *UiServer) Message(message *string, reply *interface{}) error

func (*UiServer) Say

func (u *UiServer) Say(message *string, reply *interface{}) error

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL