hypervisor

type AttachCommand struct {
	Streams   *TtyIO
	Stderr    *TtyIO
	Size      *WindowSize
	Container string
}

type BlockDescriptor struct {
	Name       string
	Filename   string
	Format     string
	Fstype     string
	DeviceName string
	ScsiId     int
	Options    map[string]string
}

type BlockdevInsertedEvent struct {
	Name       string
	SourceType string //image or volume
	DeviceName string
	ScsiId     int
	ScsiAddr   string // pass scsi addr to hyperstart
}

type BootConfig struct {
	CPU          int
	Memory       int
	HotAddCpuMem bool
	Kernel       string
	Initrd       string
	Bios         string
	Cbfs         string
	Vbox         string
}

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

type CommandError CommandAck

type Container struct {
	Id       string
	Name     string
	PodId    string
	Image    string
	Cmds     []string
	Logs     LogStatus
	Status   uint32
	ExitCode int
}

type ContainerCreatedEvent struct {
	Index  int
	Id     string
	Rootfs string
	Image  string // if fstype is `dir`, this should be a path relative to share_dir
	// which described the mounted aufs or overlayfs dir.
	Fstype     string
	Workdir    string
	Entrypoint []string
	Cmd        []string
	Envs       map[string]string
}

type ContainerInfo struct {
	Id      string
	User    string
	MountId string
	Rootfs  string
	Image   string // if fstype is `dir`, this should be a path relative to share_dir
	// which described the mounted aufs or overlayfs dir.
	Fstype     string
	Workdir    string
	Entrypoint []string
	Cmd        []string
	Envs       map[string]string
	Initialize bool // need to initialize container environment in start
}

type ContainerUnmounted struct {
	Index   int
	Success bool
}

type DevSkipEvent struct{}

type DeviceFailed struct {
	Session VmEvent
}

type DriverContext interface {
	Launch(ctx *VmContext)
	Associate(ctx *VmContext)
	Dump() (map[string]interface{}, error)

	AddDisk(ctx *VmContext, sourceType string, blockInfo *BlockDescriptor)
	RemoveDisk(ctx *VmContext, blockInfo *BlockDescriptor, callback VmEvent)

	AddNic(ctx *VmContext, host *HostNicInfo, guest *GuestNicInfo, result chan<- VmEvent)
	RemoveNic(ctx *VmContext, n *InterfaceCreated, callback VmEvent)

	SetCpus(ctx *VmContext, cpus int, result chan<- error)
	AddMem(ctx *VmContext, slot, size int, result chan<- error)

	Save(ctx *VmContext, path string, result chan<- error)

	Shutdown(ctx *VmContext)
	Kill(ctx *VmContext)

	Pause(ctx *VmContext, pause bool, result chan<- error)

	ConfigureNetwork(vmId, requestedIP string, maps []pod.UserContainerPort, config pod.UserInterface) (*network.Settings, error)
	AllocateNetwork(vmId, requestedIP string, maps []pod.UserContainerPort) (*network.Settings, error)
	ReleaseNetwork(vmId, releasedIP string, maps []pod.UserContainerPort, file *os.File) error

	Stats(ctx *VmContext) (*types.PodStats, error)

	Close()
}

type EmptyContext struct{}

type EmptyDriver struct{}

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

type GenericOperation struct {
	OpName string
	State  []string
	OpFunc func(ctx *VmContext, result chan<- error)
	Result chan<- error
}

type GetPodStatsCommand struct {
	Id string
}

type GuestNicInfo struct {
	Device  string
	Ipaddr  string
	Index   int
	Busaddr int
}

type HandleEvent struct {
	Handle func(*types.VmResponse, interface{}, *PodStatus, *Vm) bool
	Data   interface{}
}

type HostNicInfo struct {
	Fd      uint64
	Device  string
	Mac     string
	Bridge  string
	Gateway string
}

type HypervisorDriver interface {
	InitContext(homeDir string) DriverContext

	LoadContext(persisted map[string]interface{}) (DriverContext, error)

	BuildinNetwork() bool

	InitNetwork(bIface, bIP string, disableIptables bool) error

	SupportLazyMode() bool
}

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

type InitFailedEvent struct {
	Reason string
}

type InterfaceCreated struct {
	Index      int
	PCIAddr    int
	Fd         *os.File
	Bridge     string
	HostDevice string
	DeviceName string
	MacAddr    string
	IpAddr     string
	NetMask    string
	RouteTable []*RouteRule
}

type InterfaceReleased struct {
	Index   int
	Success bool
}

type Interrupted struct {
	Reason string
}

type LazyDriverContext interface {
	DriverContext

	LazyLaunch(ctx *VmContext)
	InitVM(ctx *VmContext) error
	LazyAddDisk(ctx *VmContext, name, sourceType, filename, format string, id int)
	LazyAddNic(ctx *VmContext, host *HostNicInfo, guest *GuestNicInfo)
}

type LogStatus struct {
	Copier  *logger.Copier
	Driver  logger.Logger
	LogPath string
}

type NetDevInsertedEvent struct {
	Index      int
	DeviceName string
	Address    int
}

type NetDevRemovedEvent struct {
	Index int
}

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

type OnlineCpuMemCommand struct{}

type PersistInfo struct {
	Id          string
	DriverInfo  map[string]interface{}
	UserSpec    *pod.UserPod
	VmSpec      *hyperstartapi.Pod
	HwStat      *VmHwStatus
	VolumeList  []*PersistVolumeInfo
	NetworkList []*PersistNetworkInfo
}

type PersistNetworkInfo struct {
	Index      int
	PciAddr    int
	DeviceName string
	IpAddr     string
}

type PersistVolumeInfo struct {
	Name       string
	Filename   string
	Format     string
	Fstype     string
	DeviceName string
	ScsiId     int
	Containers []int
	MontPoints []string
}

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

type PodStatus struct {
	Id            string
	Name          string
	Vm            string
	Wg            *sync.WaitGroup
	Containers    []*Container
	Status        uint
	Type          string
	RestartPolicy string
	Autoremove    bool
	Handler       HandleEvent
	StartedAt     string
	FinishedAt    string
	ResourcePath  string
}

type PreparingItem interface {
	ItemType() string
}

type ReleaseVMCommand struct{}

type ReplacePodCommand RunPodCommand

type RouteRule struct {
	Destination string
	Gateway     string
	ViaThis     bool
}

type RunPodCommand struct {
	Spec       *pod.UserPod
	Containers []*ContainerInfo
	Volumes    map[string]*VolumeInfo
	Wg         *sync.WaitGroup
}

type RunningContainer struct {
	Id string `json:"id"`
}

type ShutdownCommand struct {
	Wait bool
}

type StopPodCommand struct{}

type TtyIO struct {
	Stdin     io.ReadCloser
	Stdout    io.WriteCloser
	ClientTag string
	Callback  chan *types.VmResponse
	ExitCode  uint8
}

type Vm struct {
	Id     string
	Pod    *PodStatus
	Status uint
	Cpu    int
	Mem    int
	Lazy   bool

	Hub chan VmEvent
	// contains filtered or unexported fields
}

type VmContext struct {
	Id string

	Paused bool
	Boot   *BootConfig

	// Communication Context
	Hub chan VmEvent

	DCtx DriverContext

	HomeDir         string
	HyperSockName   string
	TtySockName     string
	ConsoleSockName string
	ShareDir        string

	InterfaceCount int
	// contains filtered or unexported fields
}

type VmEvent interface {
	Event() int
}

type VmExit struct{}

type VmHwStatus struct {
	PciAddr  int    //next available pci addr for pci hotplug
	ScsiId   int    //next available scsi id for scsi hotplug
	AttachId uint64 //next available attachId for attached tty
}

type VmKilledEvent struct {
	Success bool
}

type VmStartFailEvent struct {
	Message string
}

type VmTimeout struct{}

type VolumeInfo struct {
	Name         string //volumen name in spec
	Filepath     string //block dev absolute path, or dir path relative to share dir
	Fstype       string //"xfs", "ext4" etc. for block dev, or "dir" for dir path
	Format       string //"raw" (or "qcow2") for volume, no meaning for dir path
	DockerVolume bool
}

type VolumeReadyEvent struct {
	Name     string //volumen name in spec
	Filepath string //block dev absolute path, or dir path relative to share dir
	Fstype   string //"xfs", "ext4" etc. for block dev, or "dir" for dir path
	Format   string //"raw" (or "qcow2") for volume, no meaning for dir path
}

type VolumeUnmounted struct {
	Name    string
	Success bool
}

type WindowSize struct {
	Row    uint16 `json:"row"`
	Column uint16 `json:"column"`
}

type WindowSizeCommand struct {
	ClientTag string
	Size      *WindowSize
}