rpc

package
v0.0.12 Latest Latest
Warning

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

 Go to latest Published: Feb 8, 2021 License: MPL-2.0 Imports: 20 Imported by: 0

Documentation

Overview

Package rpc contains the implementation of the remote procedure call code that the Packer core uses to communicate with packer plugins. As a plugin maintainer, you are unlikely to need to directly import or use this package, but it underpins the packer server that all plugins must implement.

Index

Constants

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

Variables

This section is empty.

Functions

func Communicator 

func Communicator(client *rpc.Client) *communicator

func NewFileInfo 

func NewFileInfo(fi os.FileInfo) *fileInfo

Types

type ArtifactServer 

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

ArtifactServer wraps a packersdk.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 packersdk.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

func (*BuildServer) SetOnError 

func (b *BuildServer) SetOnError(val *string, reply *interface{}) error

type BuilderPrepareArgs 

type BuilderPrepareArgs struct {
	Configs []interface{}
}

type BuilderPrepareResponse 

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

type BuilderServer 

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

BuilderServer wraps a packersdk.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) ConfigSpec 

func (s *BuilderServer) ConfigSpec(_ interface{}, reply *ConfigSpecResponse) error

func (*BuilderServer) Prepare 

func (b *BuilderServer) Prepare(args *BuilderPrepareArgs, reply *BuilderPrepareResponse) error

func (*BuilderServer) Run 

func (b *BuilderServer) Run(streamId uint32, reply *uint32) 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 communicate over any ReadWriteCloser. In Packer, each "plugin" (builder, provisioner, and post-processor) creates and launches a server. The the packer "core" creates and uses the client.

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) Close 

func (c *Client) Close() error

func (*Client) Communicator 

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

func (*Client) Datasource 

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

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 CommunicatorDownloadDirArgs 

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

type CommunicatorServer 

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

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

func (*CommunicatorServer) ConfigSpec 

func (s *CommunicatorServer) ConfigSpec(_ interface{}, reply *ConfigSpecResponse) error

func (*CommunicatorServer) Download 

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

func (*CommunicatorServer) DownloadDir 

func (c *CommunicatorServer) DownloadDir(args *CommunicatorUploadDirArgs, reply *error) 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
	FileInfo       *fileInfo
}

type CommunicatorUploadDirArgs 

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

type ConfigSpecResponse 

type ConfigSpecResponse struct {
	ConfigSpec []byte
}

type DatasourceConfigureArgs 

type DatasourceConfigureArgs struct {
	Configs []interface{}
}

type DatasourceConfigureResponse 

type DatasourceConfigureResponse struct {
	Error *BasicError
}

type DatasourceServer 

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

DatasourceServer wraps a packer.Datasource implementation and makes it exportable as part of a Golang RPC server.

func (*DatasourceServer) Cancel 

func (d *DatasourceServer) Cancel(args *interface{}, reply *interface{}) error

func (*DatasourceServer) ConfigSpec 

func (s *DatasourceServer) ConfigSpec(_ interface{}, reply *ConfigSpecResponse) error

func (*DatasourceServer) Configure 

func (d *DatasourceServer) Configure(args *DatasourceConfigureArgs, reply *DatasourceConfigureResponse) error

func (*DatasourceServer) Execute 

func (d *DatasourceServer) Execute(args *interface{}, reply *ExecuteResponse) error

func (*DatasourceServer) OutputSpec 

func (d *DatasourceServer) OutputSpec(args *DatasourceConfigureArgs, reply *OutputSpecResponse) error

type ExecuteResponse 

type ExecuteResponse struct {
	Value []byte
	Error *BasicError
}

type HookRunArgs 

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

type HookServer 

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

HookServer wraps a packersdk.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 OutputSpecResponse 

type OutputSpecResponse struct {
	OutputSpec []byte
}

type PluginServer 

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

PluginServer represents an RPC server for Packer. This must be paired on the other side with a PluginClient. In Packer, each "plugin" (builder, provisioner, and post-processor) creates and launches a server. The client created and used by the packer "core"

func NewServer 

func NewServer(conn io.ReadWriteCloser) (*PluginServer, error)

NewServer returns a new Packer RPC server.

func (*PluginServer) Close 

func (s *PluginServer) Close() error

func (*PluginServer) RegisterArtifact 

func (s *PluginServer) RegisterArtifact(a packer.Artifact) error

func (*PluginServer) RegisterBuild 

func (s *PluginServer) RegisterBuild(b packer.Build) error

func (*PluginServer) RegisterBuilder 

func (s *PluginServer) RegisterBuilder(b packer.Builder) error

func (*PluginServer) RegisterCommunicator 

func (s *PluginServer) RegisterCommunicator(c packer.Communicator) error

func (*PluginServer) RegisterDatasource 

func (s *PluginServer) RegisterDatasource(d packer.Datasource) error

func (*PluginServer) RegisterHook 

func (s *PluginServer) RegisterHook(h packer.Hook) error

func (*PluginServer) RegisterPostProcessor 

func (s *PluginServer) RegisterPostProcessor(p packer.PostProcessor) error

func (*PluginServer) RegisterProvisioner 

func (s *PluginServer) RegisterProvisioner(p packer.Provisioner) error

func (*PluginServer) RegisterUi 

func (s *PluginServer) RegisterUi(ui packer.Ui) error

func (*PluginServer) Serve 

func (s *PluginServer) Serve()

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

type PostProcessorConfigureArgs 

type PostProcessorConfigureArgs struct {
	Configs []interface{}
}

type PostProcessorProcessResponse 

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

type PostProcessorServer 

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

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

func (*PostProcessorServer) Cancel 

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

func (*PostProcessorServer) ConfigSpec 

func (s *PostProcessorServer) ConfigSpec(_ interface{}, reply *ConfigSpecResponse) error

func (*PostProcessorServer) Configure 

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

func (*PostProcessorServer) PostProcess 

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

type ProgressTrackingClient 

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

func (*ProgressTrackingClient) Close 

func (u *ProgressTrackingClient) Close() error

func (*ProgressTrackingClient) Read 

func (u *ProgressTrackingClient) Read(b []byte) (read int, err error)

Read will send len(b) over the wire instead of it's content

type ProgressTrackingServer 

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

func (*ProgressTrackingServer) Add 

func (t *ProgressTrackingServer) Add(size int, _ *interface{}) error

func (*ProgressTrackingServer) Close 

func (t *ProgressTrackingServer) Close(_, _ *interface{}) error

type ProvisionerPrepareArgs 

type ProvisionerPrepareArgs struct {
	Configs []interface{}
}

type ProvisionerProvisionArgs 

type ProvisionerProvisionArgs struct {
	GeneratedData map[string]interface{}
	StreamID      uint32
}

type ProvisionerServer 

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

ProvisionerServer wraps a packersdk.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) ConfigSpec 

func (s *ProvisionerServer) ConfigSpec(_ interface{}, reply *ConfigSpecResponse) error

func (*ProvisionerServer) Prepare 

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

func (*ProvisionerServer) Provision 

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

type TrackProgressParameters 

type TrackProgressParameters struct {
	Src         string
	TotalSize   int64
	CurrentSize int64
}

type Ui 

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

An implementation of packersdk.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) ConfigSpec 

func (p *Ui) ConfigSpec() hcldec.ObjectSpec

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)

func (*Ui) TrackProgress 

func (u *Ui) TrackProgress(src string, currentSize, totalSize int64, stream io.ReadCloser) io.ReadCloser

TrackProgress starts a pair of ProgressTrackingClient and ProgressProgressTrackingServer that will send the size of each read bytes of stream. In order to track an operation on the terminal side.

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 packersdk.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) NewTrackProgress 

func (ui *UiServer) NewTrackProgress(pl *TrackProgressParameters, reply *string) error

func (*UiServer) Say 

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.