resources

type AccessInfo struct {
	Endpoint   string // ex) https://1.2.3.4:6443
	Kubeconfig string
}

type AddonsInfo struct {
	KeyValueList []KeyValue
}

type AnyCallHandler interface {
	AnyCall(callInfo AnyCallInfo) (AnyCallInfo, error)
}

type AnyCallInfo struct {
	FID string // Function ID

	IKeyValueList []KeyValue // Input Arguments List
	OKeyValueList []KeyValue // Output Results List
}

type CloudPrice struct {
	CloudName string  `json:"cloudName"`
	PriceList []Price `json:"priceList"`
}

type CloudPriceData struct {
	Meta           Meta         `json:"meta"`
	CloudPriceList []CloudPrice `json:"cloudPriceList"`
}

type ClusterHandler interface {

	//------ Cluster Management
	CreateCluster(clusterReqInfo ClusterInfo) (ClusterInfo, error)
	ListCluster() ([]*ClusterInfo, error)
	GetCluster(clusterIID IID) (ClusterInfo, error)
	DeleteCluster(clusterIID IID) (bool, error)

	//------ NodeGroup Management
	AddNodeGroup(clusterIID IID, nodeGroupReqInfo NodeGroupInfo) (NodeGroupInfo, error)
	SetNodeGroupAutoScaling(clusterIID IID, nodeGroupIID IID, on bool) (bool, error)
	ChangeNodeGroupScaling(clusterIID IID, nodeGroupIID IID,
		DesiredNodeSize int, MinNodeSize int, MaxNodeSize int) (NodeGroupInfo, error)
	RemoveNodeGroup(clusterIID IID, nodeGroupIID IID) (bool, error)

	//------ Upgrade K8S
	UpgradeCluster(clusterIID IID, newVersion string) (ClusterInfo, error)
}

type ClusterInfo struct {
	IId IID // {NameId, SystemId}

	Version string // Kubernetes Version, ex) 1.23.3
	Network NetworkInfo

	NodeGroupList []NodeGroupInfo
	AccessInfo    AccessInfo
	Addons        AddonsInfo

	Status ClusterStatus

	CreatedTime  time.Time
	TagList      []KeyValue
	KeyValueList []KeyValue
}

type ClusterStatus string

type DiskHandler interface {

	//------ Disk Management
	CreateDisk(DiskReqInfo DiskInfo) (DiskInfo, error)
	ListDisk() ([]*DiskInfo, error)
	GetDisk(diskIID IID) (DiskInfo, error)
	ChangeDiskSize(diskIID IID, size string) (bool, error)
	DeleteDisk(diskIID IID) (bool, error)

	//------ Disk Attachment
	AttachDisk(diskIID IID, ownerVM IID) (DiskInfo, error)
	DetachDisk(diskIID IID, ownerVM IID) (bool, error)
}

type DiskInfo struct {
	IId  IID    // {NameId, SystemId}
	Zone string // Target Zone Name

	DiskType string // "", "SSD(gp2)", "Premium SSD", ...
	DiskSize string // "", "default", "50", "1000"  # (GB)

	Status  DiskStatus // DiskCreating | DiskAvailable | DiskAttached | DiskDeleting | DiskError
	OwnerVM IID        // When the Status is DiskAttached

	CreatedTime  time.Time
	TagList      []KeyValue
	KeyValueList []KeyValue
}

type DiskStatus string

type GpuInfo struct {
	Count string
	Mfr   string
	Model string
	Mem   string // MB
}

type HealthCheckerInfo struct {
	Protocol  string // TCP|HTTP
	Port      string // Listener Port or 1-65535
	Interval  int    // secs, Interval time between health checks.
	Timeout   int    // secs, Waiting time to decide an unhealthy VM when no response.
	Threshold int    // num, The number of continuous health checks to change the VM status.

	CspID        string // Optional, May be Used by Driver.
	KeyValueList []KeyValue
}

type HealthInfo struct {
	AllVMs       *[]IID
	HealthyVMs   *[]IID
	UnHealthyVMs *[]IID
}

type IID struct {
	NameId   string // NameID by user
	SystemId string // SystemID by CloudOS
}

type ImageHandler interface {
	CreateImage(imageReqInfo ImageReqInfo) (ImageInfo, error)
	ListImage() ([]*ImageInfo, error)
	GetImage(imageIID IID) (ImageInfo, error)
	CheckWindowsImage(imageIID IID) (bool, error)
	DeleteImage(imageIID IID) (bool, error)
}

type ImageInfo struct {
	IId     IID    // {NameId, SystemId}
	GuestOS string // Windows7, Ubuntu etc.
	Status  string // available, unavailable

	TagList      []KeyValue
	KeyValueList []KeyValue
}

type ImageReqInfo struct {
	IId IID // {NameId, SystemId}

}

type ImageType string

type KeyPairHandler interface {
	CreateKey(keyPairReqInfo KeyPairReqInfo) (KeyPairInfo, error)
	ListKey() ([]*KeyPairInfo, error)
	GetKey(keyIID IID) (KeyPairInfo, error)
	DeleteKey(keyIID IID) (bool, error)
}

type KeyPairInfo struct {
	IId         IID // {NameId, SystemId}
	Fingerprint string
	PublicKey   string
	PrivateKey  string
	VMUserID    string

	TagList      []KeyValue
	KeyValueList []KeyValue
}

type KeyPairReqInfo struct {
	IId IID // {NameId, SystemId}

	TagList []KeyValue
}

type KeyValue struct {
	Key   string
	Value string
}

type ListenerInfo struct {
	Protocol string // TCP|UDP
	IP       string // Auto Generated and attached
	Port     string // 1-65535
	DNSName  string // Optional, Auto Generated and attached

	CspID        string // Optional, May be Used by Driver.
	KeyValueList []KeyValue
}

type Meta struct {
	Version     string `json:"version"`
	Description string `json:"description"`
}

type MyImageHandler interface {

	//------ Snapshot to create a MyImage
	SnapshotVM(snapshotReqInfo MyImageInfo) (MyImageInfo, error)

	//------ MyImage Management
	ListMyImage() ([]*MyImageInfo, error)
	GetMyImage(myImageIID IID) (MyImageInfo, error)
	CheckWindowsImage(myImageIID IID) (bool, error)
	DeleteMyImage(myImageIID IID) (bool, error)
}

type MyImageInfo struct {
	IId IID // {NameId, SystemId}

	SourceVM IID

	Status MyImageStatus // Available | Unavailable

	CreatedTime  time.Time
	TagList      []KeyValue
	KeyValueList []KeyValue
}

type MyImageStatus string

type NLBHandler interface {

	//------ NLB Management
	CreateNLB(nlbReqInfo NLBInfo) (NLBInfo, error)
	ListNLB() ([]*NLBInfo, error)
	GetNLB(nlbIID IID) (NLBInfo, error)
	DeleteNLB(nlbIID IID) (bool, error)

	GetVMGroupHealthInfo(nlbIID IID) (HealthInfo, error)
	AddVMs(nlbIID IID, vmIIDs *[]IID) (VMGroupInfo, error)
	RemoveVMs(nlbIID IID, vmIIDs *[]IID) (bool, error)

	//------ Frontend Control
	ChangeListener(nlbIID IID, listener ListenerInfo) (ListenerInfo, error)
	//------ Backend Control
	ChangeVMGroupInfo(nlbIID IID, vmGroup VMGroupInfo) (VMGroupInfo, error)
	ChangeHealthCheckerInfo(nlbIID IID, healthChecker HealthCheckerInfo) (HealthCheckerInfo, error)
}

type NLBInfo struct {
	IId    IID // {NameId, SystemId}
	VpcIID IID // {NameId, SystemId}

	Type  string // PUBLIC(V) | INTERNAL
	Scope string // REGION(V) | GLOBAL

	//------ Frontend
	Listener ListenerInfo

	//------ Backend
	VMGroup       VMGroupInfo
	HealthChecker HealthCheckerInfo

	CreatedTime  time.Time
	TagList      []KeyValue
	KeyValueList []KeyValue
}

type NetworkInfo struct {
	VpcIID            IID // {NameId, SystemId}
	SubnetIIDs        []IID
	SecurityGroupIIDs []IID

	KeyValueList []KeyValue
}

type NodeGroupInfo struct {
	IId IID // {NameId, SystemId}

	// VM config.
	ImageIID     IID
	VMSpecName   string
	RootDiskType string // "SSD(gp2)", "Premium SSD", ...
	RootDiskSize string // "", "default", "50", "1000" (GB)
	KeyPairIID   IID

	// Scaling config.
	OnAutoScaling   bool // default: true
	DesiredNodeSize int
	MinNodeSize     int
	MaxNodeSize     int

	Status NodeGroupStatus
	Nodes  []IID

	KeyValueList []KeyValue
}

type NodeGroupStatus string

type Platform string

type Price struct {
	ProductInfo ProductInfo `json:"productInfo"`
	PriceInfo   PriceInfo   `json:"priceInfo"`
}

type PriceInfo struct {
	PricingPolicies []PricingPolicies `json:"pricingPolicies"`
	CSPPriceInfo    interface{}       `json:"cspPriceInfo"`
}

type PriceInfoHandler interface {
	ListProductFamily(regionName string) ([]string, error)
	GetPriceInfo(productFamily string, regionName string, filterList []KeyValue) (string, error) // return string: json format
}

type PricingPolicies struct {
	PricingId         string             `json:"pricingId"`
	PricingPolicy     string             `json:"pricingPolicy"`
	Unit              string             `json:"unit"`
	Currency          string             `json:"currency"`
	Price             string             `json:"price"`
	Description       string             `json:"description"`
	PricingPolicyInfo *PricingPolicyInfo `json:"pricingPolicyInfo,omitempty"`
}

type PricingPolicyInfo struct {
	LeaseContractLength string `json:"LeaseContractLength"`
	OfferingClass       string `json:"OfferingClass"`
	PurchaseOption      string `json:"PurchaseOption"`
}

type ProductInfo struct {
	ProductId  string `json:"productId"`
	RegionName string `json:"regionName"`
	ZoneName   string `json:"zoneName"`

	//--------- Compute Instance
	InstanceType    string `json:"instanceType,omitempty"`
	Vcpu            string `json:"vcpu,omitempty"`
	Memory          string `json:"memory,omitempty"`
	Storage         string `json:"storage,omitempty"` // Root-Disk
	Gpu             string `json:"gpu,omitempty"`
	GpuMemory       string `json:"gpuMemory,omitempty"`
	OperatingSystem string `json:"operatingSystem,omitempty"`
	PreInstalledSw  string `json:"preInstalledSw,omitempty"`

	//--------- Storage  // Data-Disk(AWS:EBS)
	VolumeType          string `json:"volumeType,omitempty"`
	StorageMedia        string `json:"storageMedia,omitempty"`
	MaxVolumeSize       string `json:"maxVolumeSize,omitempty"`
	MaxIOPSVolume       string `json:"maxIopsvolume,omitempty"`
	MaxThroughputVolume string `json:"maxThroughputvolume,omitempty"`

	Description    string      `json:"description"`
	CSPProductInfo interface{} `json:"cspProductInfo"`
}

type RSType string

type RegionInfo struct {
	Region string
	Zone   string
}

type RegionZoneHandler interface {
	ListRegionZone() ([]*RegionZoneInfo, error)
	GetRegionZone(Name string) (RegionZoneInfo, error)

	ListOrgRegion() (string, error) // return string: json format
	ListOrgZone() (string, error)   // return string: json format
}

type RegionZoneInfo struct {
	Name        string
	DisplayName string
	ZoneList    []ZoneInfo

	KeyValueList []KeyValue
}

type SecurityHandler interface {
	CreateSecurity(securityReqInfo SecurityReqInfo) (SecurityInfo, error)
	ListSecurity() ([]*SecurityInfo, error)
	GetSecurity(securityIID IID) (SecurityInfo, error)
	DeleteSecurity(securityIID IID) (bool, error)

	AddRules(sgIID IID, securityRules *[]SecurityRuleInfo) (SecurityInfo, error)
	RemoveRules(sgIID IID, securityRules *[]SecurityRuleInfo) (bool, error)
}

type SecurityInfo struct {
	IId IID // {NameId, SystemId}

	VpcIID IID // {NameId, SystemId}
	//Direction     string // @todo userd??
	SecurityRules *[]SecurityRuleInfo

	TagList      []KeyValue
	KeyValueList []KeyValue
}

type SecurityReqInfo struct {
	IId IID // {NameId, SystemId}

	VpcIID IID // {NameId, SystemId}
	//Direction     string // To be deprecated
	SecurityRules *[]SecurityRuleInfo

	TagList []KeyValue
}

type SecurityRuleInfo struct {
	Direction  string
	IPProtocol string
	FromPort   string
	ToPort     string
	CIDR       string
}

type SubnetInfo struct {
	IId       IID    // {NameId, SystemId}
	Zone      string // Target Zone Name
	IPv4_CIDR string

	TagList      []KeyValue
	KeyValueList []KeyValue
}

type TagHandler interface {
	AddTag(resType RSType, resIID IID, tag KeyValue) (KeyValue, error)
	ListTag(resType RSType, resIID IID) ([]KeyValue, error)
	GetTag(resType RSType, resIID IID, key string) (KeyValue, error)
	RemoveTag(resType RSType, resIID IID, key string) (bool, error)

	// Find tags by tag key or value
	// resType: ALL | VPC, SUBNET, etc.,.
	// keyword: The keyword to search for in the tag key or value.
	// if you want to find all tags, set keyword to "" or "*".
	FindTag(resType RSType, keyword string) ([]*TagInfo, error)
}

type TagInfo struct {
	ResType RSType // VPC, SUBNET, VM, etc.,.)
	ResIId  IID    // {NameId, SystemId}

	TagList      []KeyValue
	KeyValueList []KeyValue // reserved for optinal usage
}

type VCpuInfo struct {
	Count string
	Clock string // GHz
}

type VMGroupInfo struct {
	Protocol string // TCP|UDP
	Port     string // 1-65535
	VMs      *[]IID

	CspID        string // Optional, May be Used by Driver.
	KeyValueList []KeyValue
}

type VMHandler interface {
	StartVM(vmReqInfo VMReqInfo) (VMInfo, error)

	SuspendVM(vmIID IID) (VMStatus, error)
	ResumeVM(vmIID IID) (VMStatus, error)
	RebootVM(vmIID IID) (VMStatus, error)
	TerminateVM(vmIID IID) (VMStatus, error)

	ListVMStatus() ([]*VMStatusInfo, error)
	GetVMStatus(vmIID IID) (VMStatus, error)

	ListVM() ([]*VMInfo, error)
	GetVM(vmIID IID) (VMInfo, error)
}

type VMInfo struct {
	IId       IID       // {NameId, SystemId}
	StartTime time.Time // Timezone: based on cloud-barista server location.

	Region            RegionInfo //  ex) {us-east1, us-east1-c} or {ap-northeast-2}
	ImageType         ImageType  // PublicImage | MyImage
	ImageIId          IID
	VMSpecName        string //  instance type or flavour, etc... ex) t2.micro or f1.micro
	VpcIID            IID
	SubnetIID         IID   // AWS, ex) subnet-8c4a53e4
	SecurityGroupIIds []IID // AWS, ex) sg-0b7452563e1121bb6

	KeyPairIId IID

	RootDiskType   string // "SSD(gp2)", "Premium SSD", ...
	RootDiskSize   string // "default", "50", "1000" (GB)
	RootDeviceName string // "/dev/sda1", ...

	DataDiskIIDs []IID

	VMBootDisk  string // Deprecated soon
	VMBlockDisk string // Deprecated soon

	VMUserId     string // ex) user1
	VMUserPasswd string

	NetworkInterface string // ex) eth0
	PublicIP         string
	PublicDNS        string
	PrivateIP        string
	PrivateDNS       string

	Platform Platform // LINUX | WINDOWS

	SSHAccessPoint string // ex) 10.2.3.2:22, 123.456.789.123:4321 ==> Deprecated
	AccessPoint    string // ex) 10.2.3.2:22, 123.456.789.123:4321

	TagList      []KeyValue
	KeyValueList []KeyValue
}

type VMReqInfo struct {
	IId IID // {NameId, SystemId}

	ImageType         ImageType // PublicImage | MyImage, default: PublicImage
	ImageIID          IID
	VpcIID            IID
	SubnetIID         IID
	SecurityGroupIIDs []IID

	VMSpecName string
	KeyPairIID IID

	RootDiskType string // "", "SSD(gp2)", "Premium SSD", ...
	RootDiskSize string // "", "default", "50", "1000" (GB)

	DataDiskIIDs []IID

	VMUserId     string
	VMUserPasswd string
	WindowsType  bool

	TagList []KeyValue
}

type VMSpecHandler interface {
	ListVMSpec() ([]*VMSpecInfo, error)
	GetVMSpec(Name string) (VMSpecInfo, error)

	ListOrgVMSpec() (string, error)           // return string: json format
	GetOrgVMSpec(Name string) (string, error) // return string: json format
}

type VMSpecInfo struct {
	Region string
	Name   string
	VCpu   VCpuInfo
	Mem    string // MB
	Gpu    []GpuInfo

	KeyValueList []KeyValue
}

type VMStatus string

type VMStatusInfo struct {
	IId      IID // {NameId, SystemId}
	VmStatus VMStatus
}

type VPCHandler interface {
	CreateVPC(vpcReqInfo VPCReqInfo) (VPCInfo, error)
	ListVPC() ([]*VPCInfo, error)
	GetVPC(vpcIID IID) (VPCInfo, error)
	DeleteVPC(vpcIID IID) (bool, error)

	AddSubnet(vpcIID IID, subnetInfo SubnetInfo) (VPCInfo, error)
	RemoveSubnet(vpcIID IID, subnetIID IID) (bool, error)
}

type VPCInfo struct {
	IId            IID // {NameId, SystemId}
	IPv4_CIDR      string
	SubnetInfoList []SubnetInfo

	TagList      []KeyValue
	KeyValueList []KeyValue
}

type VPCReqInfo struct {
	IId            IID // {NameId, SystemId}
	IPv4_CIDR      string
	SubnetInfoList []SubnetInfo

	TagList []KeyValue
}

type ZoneInfo struct {
	Name        string
	DisplayName string
	Status      ZoneStatus // Available | Unavailable | NotSupported

	KeyValueList []KeyValue
}

type ZoneStatus string