container

type BuildRegistry ¶

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

func (br *BuildRegistry) BuildStatus(ccid string) (*BuildStatus, bool)

type BuildStatus ¶

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

func NewBuildStatus() *BuildStatus

func (bs *BuildStatus) Done() <-chan struct{}

func (bs *BuildStatus) Err() error

func (bs *BuildStatus) Notify(err error)

type CreateImageReq ¶

type CreateImageReq struct {
	ccintf.CCID
	Reader io.Reader
	Args   []string
	Env    []string
}

CreateImageReq - properties for creating an container image

type DestroyImageReq ¶

type DestroyImageReq struct {
	ccintf.CCID
	Timeout uint
	Force   bool
	NoPrune bool
}

DestroyImageReq - properties for stopping a container.

type DockerBuilder ¶

type DockerBuilder interface {
	Build(ccid string, metadata *persistence.ChaincodePackageMetadata, codePackageStream io.Reader) (Instance, error)
}

DockerBuilder is what is exposed by the dockercontroller

type ExternalBuilder ¶

type ExternalBuilder interface {
	Build(ccid string, metadata []byte, codePackageStream io.Reader) (Instance, error)
}

ExternalBuilder is what is exposed by the dockercontroller

type Instance ¶

type Instance interface {
	Start(peerConnection *ccintf.PeerConnection) error
	ChaincodeServerInfo() (*ccintf.ChaincodeServerInfo, error)
	Stop() error
	Wait() (int, error)
}

Instance represents a built chaincode instance, because of the docker legacy, calling this a built 'container' would be very misleading, and going forward with the external launcher 'image' also seemed inappropriate. So, the vague 'Instance' is used here.

type PackageProvider ¶

type PackageProvider interface {
	GetChaincodePackage(packageID string) (md *persistence.ChaincodePackageMetadata, mdBytes []byte, codeStream io.ReadCloser, err error)
}

PackageProvider gets chaincode packages from the filesystem.

type Router ¶

type Router struct {
	ExternalBuilder ExternalBuilder
	DockerBuilder   DockerBuilder

	PackageProvider PackageProvider
	// contains filtered or unexported fields
}

func (r *Router) Build(ccid string) error

func (r *Router) ChaincodeServerInfo(ccid string) (*ccintf.ChaincodeServerInfo, error)

func (r *Router) Start(ccid string, peerConnection *ccintf.PeerConnection) error

func (r *Router) Stop(ccid string) error

func (r *Router) Wait(ccid string) (int, error)

type StartImageReq ¶

type StartImageReq struct {
	ccintf.CCID
	Builder       api.BuildSpecFactory
	Args          []string
	Env           []string
	PrelaunchFunc api.PrelaunchFunc
}

StartImageReq - properties for starting a container.

type StopImageReq ¶

type StopImageReq struct {
	ccintf.CCID
	Timeout uint
	//by default we will kill the container after stopping
	Dontkill bool
	//by default we will remove the container after killing
	Dontremove bool
}

StopImageReq - properties for stopping a container.

type UninitializedInstance ¶

type UninitializedInstance struct{}

func (UninitializedInstance) ChaincodeServerInfo() (*ccintf.ChaincodeServerInfo, error)

func (UninitializedInstance) Start(peerConnection *ccintf.PeerConnection) error

func (UninitializedInstance) Stop() error

func (UninitializedInstance) Wait() (int, error)

type VMCReqIntf ¶

type VMCReqIntf interface {
	// contains filtered or unexported methods
}

VMCReqIntf - all requests should implement this interface. The context should be passed and tested at each layer till we stop note that we'd stop on the first method on the stack that does not take context

type VMCResp ¶

type VMCResp struct {
	Err  error
	Resp interface{}
}

VMCResp - response from requests. resp field is a anon interface. It can hold any response. err should be tested first

type VMController ¶

type VMController struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

VMController - manages VMs

. abstract construction of different types of VMs (we only care about Docker for now)
. manage lifecycle of VM (start with build, start, stop ...
  eventually probably need fine grained management)