types

type Client struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// ClientIp
	ClientIp string `json:"client_ip"`
	// ClientPort
	ClientPort int `json:"client_port"`
	// Token
	ClientToken string `json:"client_token"`
}

type ClientStatus struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// CPUUsage is the CPU usage of the client
	CPUUsage float64 `json:"cpu_usage"`
	// MemoryUsage is the memory usage of the client
	MemoryUsage float64 `json:"memory_usage"`
	// DiskUsage is the disk usage of the client
	DiskUsage float64 `json:"disk_usage"`
	// NetworkUsage is the network usage of the client
	NetworkUsage float64 `json:"network_usage"`
	// ContainerNum is the number of containers of the client
	ContainerNum int `json:"container_num"`
	// ContainerUsage is the usage of containers of the client
	ContainerUsage float64 `json:"container_usage"`
}

type Container struct {
	Id       string            `json:"id"`
	Image    string            `json:"image"`
	Uuid     string            `json:"uuid"`
	Time     int               `json:"time"`
	Owner    int               `json:"owner"`
	HostPort string            `json:"host_port"`
	Labels   map[string]string `json:"labels"`
	Status   string            `json:"status"`
	CPUUsage float64           `json:"cpu_usage"`
	MemUsage float64           `json:"mem_usage"`
	Networks []Network         `json:"networks"`
}

type DBContainer struct {
	gorm.Model
	Id            int    `gorm:"primaryKey;autoIncrement;not null"`
	ContainerName string `gorm:"type:varchar(255);not null"`
	ContainerId   string `gorm:"type:varchar(255);not null;unique;index"`
	Labels        string `gorm:"type:varchar(2048);not null"`
	Image         string `gorm:"type:varchar(255);not null"`
	Uid           int    `gorm:"type:int;not null"`
}

type DBImage struct {
	gorm.Model
	Id        int       `gorm:"primaryKey;autoIncrement;not null"`
	ImageName string    `gorm:"type:varchar(255);not null"`
	ImageId   string    `gorm:"type:varchar(255);not null;index"`
	LastUsage time.Time `gorm:"type:datetime;not null"`
}

type DBService struct {
	gorm.Model
	Id          int    `gorm:"primaryKey;autoIncrement;not null"`
	ServiceName string `gorm:"type:varchar(255);not null"`
	ServiceId   string `gorm:"type:varchar(255);not null;unique;index"`
	Containers  string `gorm:"type:varchar(2048);not null"`
	Networks    string `gorm:"type:varchar(2048);not null"`
	Flags       string `gorm:"type:varchar(2048);not null"`
}

type DockerComposeFile struct {
	Services map[string]DockerComposeFileService `yaml:"services"`
	Networks map[string]DockerComposeFileNetwork `yaml:"networks"`
	Volumes  map[string]struct{}                 `yaml:"volumes"`
}

type DockerComposeFileNetwork struct {
	IPAM DockerComposeFileNetworkIPAM `yaml:"ipam"`
}

type DockerComposeFileNetworkIPAM struct {
	Driver     string                               `yaml:"driver"`
	Attachable bool                                 `yaml:"attachable"`
	Internal   bool                                 `yaml:"internal"`
	Config     []DockerComposeFileNetworkIPAMConfig `yaml:"config"`
}

type DockerComposeFileNetworkIPAMConfig struct {
	Subnet string `yaml:"subnet"`
}

type DockerComposeFileService struct {
	Image    string                                     `yaml:"image"`
	Build    string                                     `yaml:"build"`
	Networks map[string]DockerComposeFileServiceNetwork `yaml:"networks"`
	Ports    []string                                   `yaml:"ports"`
}

type DockerComposeFileServiceNetwork struct {
	Ipv4Address string `yaml:"ipv4_address"`
	Ipv6Address string `yaml:"ipv6_address"`
}

type Image struct {
	Id           int    `json:"id"`
	Uuid         string `json:"uuid"`
	Name         string `json:"name"`
	User         string `json:"user"`
	LastUpdate   int    `json:"last_update"`
	PortProtocol string `json:"port_protocol"`
	VirtualSize  int64  `json:"virtual_size"`
}

type KisaraNetworkMonitorContainer struct {
	ContainerId string `json:"container_id"`
}

type KisaraNetworkMonitorImage struct {
	ImageName string `json:"image_name"`
}

type KisaraNetworkTest struct {
	// The container to be tested
	ContainerId string `json:"container_id"`
	// The container to test
	TestContainerId string `json:"test_container_id"`
	// The test cmd like "python3 test.py $ip", the $ip will be replaced by the container's ip
	Script string `json:"script"`
}

type KisaraNetworkTestResult struct {
	// The container to be tested
	ContainerId string `json:"container_id"`
	// Result of the test, bytewise
	Result []byte `json:"result"`
}

type KisaraNetworkTestResultSet struct {
	Results []KisaraNetworkTestResult `json:"results"`
}

type KisaraNetworkTestSet struct {
	Containers []KisaraNetworkTest `json:"containers"`
}

type KisaraResponse struct {
	// Code is the code of the response
	Code int `json:"code"`
	// Message is the message of the response
	Message string `json:"message"`
	// Data is the data of the response
	Data interface{} `json:"data"`
}

type KisaraResponseWrap[T any] struct {
	// Code is the code of the response
	Code int `json:"code"`
	// Message is the message of the response
	Message string `json:"message"`
	// Data is the data of the response
	Data T `json:"data"`
}

type KisaraService struct {
	Id          string `json:"id"`
	Name        string `json:"name"`
	Description string `json:"description"`
	Owner       int    `json:"owner"`
	Config      string `json:"config"` // json string of service config
}

type KisaraVMImage struct {
	// Id of the VM image
	Id string `json:"id"`
	// Image name
	Image string `json:"image"`
	// Image tag
	Tag string `json:"tag"`
	// architecture
	Arch string `json:"arch"`
	// Type of VM
	Type string `json:"type"`
	// Base qemu image
	BaseImage string `json:"base_image"`
	// Image size
	Size int64 `json:"size"`
	// created time
	Created int64 `json:"created"`
	// Require resource
	Limit KisaraVmLimit `json:"limit"`
	// checksum
	Checksum string `json:"checksum"` // sha256
}

type KisaraVmLimit struct {
	// CPU limit
	Cpu float64 `json:"cpu"` // 0.5 means 50% of one core
	// Memory limit
	Mem int64 `json:"mem"` // bytes
	// Disk limit
	Disk int64 `json:"disk"` // bytes
	// Network limit
	Network int64 `json:"network"` // bytes
}

type KisaraVmNetwork struct {
	// Network name
	Name string `json:"name"`
	// Network type
	Type string `json:"type"`
	// Ip
	Ip string `json:"ip"`
	// Gateway
	Gateway string `json:"gateway"`
	// Subnet
	Subnet string `json:"subnet"`
	// Mac
	Mac string `json:"mac"`
}

type Network struct {
	Id       string `json:"id"`
	Subnet   string `json:"subnet"`
	Name     string `json:"name"`
	Internal bool   `json:"internal"`
	Driver   string `json:"driver"`
	Scope    string `json:"scope"`
}

type RequestCheckLaunchService struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// RequestID is the request ID of the container
	MessageResponseId string `json:"response_id" form:"response_id" binding:"required"`
	// FinishResponseID is the finish response ID of the container
	FinishResponseID string `json:"finish_response_id" form:"finish_response_id" binding:"required"`
}

type RequestCheckLaunchStatus struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// Response Id
	ResponseId string `json:"response_id" form:"response_id" binding:"required"`
}

type RequestCheckLaunchVm struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// RequestID is the request ID of the container
	MessageResponseId string `json:"response_id" form:"response_id" binding:"required"`
	// FinishResponseID is the finish response ID of the container
	FinishResponseID string `json:"finish_response_id" form:"finish_response_id" binding:"required"`
}

type RequestCheckPullImage struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// func HandleControllerRequestCheckPullImage(request_id string)
	// RequestID is the request ID of the container
	MessageResponseId string `json:"message_resposne_id" form:"message_resposne_id" binding:"required"`
	// FinishResponseID is the finish response ID of the container
	FinishResponseID string `json:"finish_response_id" form:"finish_response_id" binding:"required"`
}

type RequestCheckStopService struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// ResponseID
	ResponseID string `json:"response_id" form:"response_id" binding:"required"`
}

type RequestConnect struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// ClientIp
	ClientIp string `json:"client_ip" form:"client_ip" binding:"required"`
	// ClientPort
	ClientPort int `json:"client_port" form:"client_port" binding:"required"`
	// callback
	Callback func(ResponseConnect) `json:"-"`
}

type RequestCreateNetwork struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// func (c *Docker) CreateNetwork(subnet string, name string, host_join bool) error
	// Subnet is the subnet of the container
	Subnet string `json:"subnet" form:"subnet" binding:"required"`
	// Name is the name of the container
	Name string `json:"name" form:"name" binding:"required"`
	// Internal is the host join of the container
	Internal bool `json:"internal" form:"internal" binding:"required"`
	// Driver
	Driver string `json:"driver" form:"driver" binding:"required"`
}

type RequestDeleteImage struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// func (c *Docker) DeleteImage(image_id string) error
	// ImageID is the image ID of the container
	ImageID string `json:"image_id" form:"image_id" binding:"required"`
}

type RequestDisconnect struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
}

type RequestExecContainer struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// func (c *Docker) Exec(container_id string, cmd string) error
	// ContainerID is the container ID of the container
	ContainerID string `json:"container_id" form:"container_id" binding:"required"`
	// Cmd is the cmd of the container
	Cmd string `json:"cmd" form:"cmd" binding:"required"`
}

type RequestHeartBeat struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
}

type RequestInspectContainer struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// func (c *Docker) InspectContainer(container_id string, has_state ...bool) (*kisara_types.Container, error)
	// ContainerID is the container ID of the container
	ContainerIDs []string `json:"container_id" form:"container_id" binding:"required"`
	// HasState is the has state of the container
	HasState bool `json:"has_state" form:"has_state" binding:"required"`
}

type RequestLaunchContainer struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// func (c *Docker) CreateContainer(image *Image, uid int, port_protocol string, subnet_name string, module string, env_mount ...map[string]string) (*Container, error)
	// Image is the image of the container
	Image string `json:"image" form:"image" binding:"required"`
	// UID is the uid of the container
	UID int `json:"uid" form:"uid"`
	// PortProtocol is the port protocol of the container
	PortProtocol string `json:"port_protocol" form:"port_protocol"`
	// SubnetName is the subnet name of the container
	SubnetName string `json:"subnet_name" form:"subnet_name" binding:"required"`
	// Module is the module of the container
	Module string `json:"module" form:"module"`
	// EnvMount is the env mount of the container
	EnvMount []map[string]string `json:"env_mount" form:"env_mount"`
}

type RequestLaunchService struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// ServiceConfig
	ServiceConfig KisaraService `json:"service_config" form:"service_config" binding:"required"`
}

type RequestLaunchVm struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// Vm id
	ImageId string `json:"image_id" form:"image_id" binding:"required"`
	// Cpu limit
	CpuLimit int `json:"cpu_limit" form:"cpu_limit" binding:"required"`
	// Memory limit
	MemoryLimit int `json:"memory_limit" form:"memory_limit" binding:"required"`
	// Disk limit
	DiskLimit int `json:"disk_limit" form:"disk_limit" binding:"required"`
	// Network limit
	NetworkLimit int `json:"network_limit" form:"network_limit" binding:"required"`
	// NetworkNames is the network names of the container, vm will be connected to these networks if they exist, otherwise, error will be returned
	NetworkNames []string `json:"network_names" form:"network_names" binding:"required"`
}

type RequestListContainer struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
}

type RequestListImage struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
}

type RequestListNetwork struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
}

type RequestListService struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
}

type RequestListVm struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
}

type RequestNetworkMonitorCheck struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// Response Id
	ResponseId string `json:"response_id" form:"response_id" binding:"required"`
	// FinishResponseID is the finish response ID of the container
	FinishResponseID string `json:"finish_response_id" form:"finish_response_id" binding:"required"`
}

type RequestNetworkMonitorRun struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// context
	Context io.Reader `json:"context" form:"context"`
	// NetworkName
	NetworkName string `json:"network_name" form:"network_name" binding:"required"`
}

type RequestNetworkMonitorRunScript struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// Containers to be tested
	Containers KisaraNetworkTestSet `json:"containers" form:"containers" binding:"required"`
}

type RequestNetworkMonitorRunToByRecieved struct {
	// ClientID is the unique ID of the client
	ClientID string `form:"client_id" binding:"required"`
	// context
	Context *multipart.FileHeader `form:"file" binding:"required"`
	// NetworkName
	NetworkName string `form:"network_name" binding:"required"`
}

type RequestNetworkMonitorStop struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// NetworkMonitor Container Id
	NetworkMonitorContainerId string `json:"network_monitor_container_id" form:"network_monitor_container_id" binding:"required"`
}

type RequestPullImage struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// func HandleControllerRequestPullImage(request_id string, image_name string, port_protocol string, user string)
	// ImageName is the image name of the container
	ImageName string `json:"image_name" form:"image_name" binding:"required"`
	// PortProtocol is the port protocol of the container
	PortProtocol string `json:"port_protocol" form:"port_protocol" binding:"required"`
	// User is the user of the container
	User string `json:"user" form:"user" binding:"required"`
}

type RequestRemoveContainer struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// ContainerID is the container ID of the container
	ContainerID string `json:"container_id" form:"container_id" binding:"required"`
}

type RequestRemoveNetwork struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// func (c *Docker) RemoveNetwork(network_id string) error
	// NetworkID is the network ID of the container
	NetworkID string `json:"network_id" form:"network_id" binding:"required"`
}

type RequestStatus struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// CPUUsage is the CPU usage of the client
	CPUUsage float64 `json:"cpu_usage" form:"cpu_usage" binding:"required"`
	// MemoryUsage is the memory usage of the client
	MemoryUsage float64 `json:"memory_usage" form:"memory_usage" binding:"required"`
	// DiskUsage is the disk usage of the client
	DiskUsage float64 `json:"disk_usage" form:"disk_usage" binding:"required"`
	// NetworkUsage is the network usage of the client
	NetworkUsage float64 `json:"network_usage" form:"network_usage" binding:"required"`
	// ContainerNum is the number of containers of the client
	ContainerNum int `json:"container_num" form:"container_num" binding:"required"`
	// ContainerUsage is the usage of containers of the client
	ContainerUsage float64 `json:"container_usage" form:"container_usage" binding:"required"`
}

type RequestStopContainer struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// ContainerID is the container ID of the container
	ContainerID string `json:"container_id" form:"container_id" binding:"required"`
}

type RequestStopService struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// ServiceID
	ServiceID string `json:"service_id" form:"service_id" binding:"required"`
}

type ResponseCheckLaunchService struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the container
	Error string `json:"error"`
	// Finished is the finished of the container
	Finished bool `json:"finished"`
	// Message
	Message string `json:"message"`
	// Service
	Service Service `json:"service"`
}

type ResponseCheckLaunchStatus struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// ContainerID is the container ID of the container
	Container Container
	// Error is the error of the container
	Error string `json:"error"`
	// Finished
	Finished bool `json:"finished"`
}

type ResponseCheckLaunchVm struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the vm
	Error string `json:"error"`
	// Finished is the finished of the vm
	Finished bool `json:"finished"`
	// Message
	Message string `json:"message"`
}

type ResponseCheckPullImage struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the container
	Error string `json:"error"`
	// Finished is the finished of the container
	Finished bool `json:"finished"`
	// RequestID is the request ID of the container
	Message string `json:"message"`
}

type ResponseCheckStopService struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the container
	Error string `json:"error"`
	// Finished is the finished of the container
	Finished bool `json:"finished"`
}

type ResponseConnect struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Token is the token of the client
	ClientToken string `json:"client_token"`
}

type ResponseCreateNetwork struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the container
	Error string `json:"error"`
}

type ResponseDeleteImage struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the container
	Error string `json:"error"`
}

type ResponseDisconnect struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
}

type ResponseExecContainer struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the container
	Error string `json:"error"`
}

type ResponseFinalLaunchServiceStatus struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the container
	Error string `json:"error"`
	// Service
	Service Service `json:"service"`
}

type ResponseFinalLaunchStatus struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// ContainerID is the container ID of the container
	Container Container
	// Error is the error of the container
	Error string `json:"error"`
}

type ResponseFinalLaunchVmStatus struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the vm
	Error string `json:"error"`
	// Vm
	Vm VM `json:"vm"`
}

type ResponseFinalNetworkMonitorStatus struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the run
	Error string `json:"error"`
	// NetworkMonitor Container Id
	NetworkMonitorContainerId string `json:"network_monitor_container_id"`
}

type ResponseFinalPullImageStatus struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the container
	Error string `json:"error"`
}

type ResponseHeartBeat struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Timestamp is the timestamp of the client, used to check the connection, if the timestamp is not updated for a long time, the client should reconnect
	Timestamp int64 `json:"timestamp"`
}

type ResponseInspectContainer struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Container is the container of the container
	Containers []Container `json:"container"`
	// Error is the error of the container
	Error string `json:"error"`
}

type ResponseLaunchContainer struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id" form:"client_id" binding:"required"`
	// Response Id
	ResponseId string `json:"response_id" form:"response_id" binding:"required"`
}

type ResponseLaunchService struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the container
	Error string `json:"error"`
	// Service
	MessageResponseId string `json:"response_id"`
	// FinishResponseID is the finish response ID of the container
	FinishResponseID string `json:"finish_response_id"`
}

type ResponseLaunchVm struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the vm
	Error string `json:"error"`
	// Vm
	MessageResponseId string `json:"response_id"`
	// FinishResponseID is the finish response ID of the container
	FinishResponseID string `json:"finish_response_id"`
}

type ResponseListContainer struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Containers is the containers of the container
	Containers []Container `json:"containers"`
	// Error is the error of the container
	Error string `json:"error"`
}

type ResponseListImage struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Images is the images of the container
	Images []Image `json:"images"`
	// Error is the error of the container
	Error string `json:"error"`
}

type ResponseListNetwork struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Networks is the networks of the container
	Networks []Network `json:"networks"`
	// Error is the error of the container
	Error string `json:"error"`
}

type ResponseListService struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Services is the services of the container
	Services []Service `json:"services"`
	// Error is the error of the container
	Error string `json:"error"`
}

type ResponseListVm struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Vms is the vms of the container
	Vms []VM `json:"vms"`
	// Error is the error of the container
	Error string `json:"error"`
}

type ResponseNetworkMonitorCheck struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the run
	Error string `json:"error"`
	// Finished is the finished of the run
	Finished bool `json:"finished"`
	// Message
	Message string `json:"message"`
	// NetworkMonitor Container Id
	NetworkMonitorContainerId string `json:"network_monitor_container_id"`
}

type ResponseNetworkMonitorRun struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the vm
	Error string `json:"error"`
	// Response Id
	ResponseId string `json:"response_id"`
	// FinishResponseID is the finish response ID of the container
	FinishResponseID string `json:"finish_response_id"`
}

type ResponseNetworkMonitorRunScript struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the run
	Error string `json:"error"`
	// Containers to be tested
	Result KisaraNetworkTestResultSet `json:"result"`
}

type ResponseNetworkMonitorStop struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the run
	Error string `json:"error"`
}

type ResponsePullImage struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the container
	Error string `json:"error"`
	// RequestID is the request ID of the container
	MessageResponseId string `json:"message_resposne_id"`
	// FinishResponseID is the finish response ID of the container
	FinishResponseID string `json:"finish_response_id"`
}

type ResponseRemoveContainer struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the container
	Error string `json:"error"`
}

type ResponseRemoveNetwork struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the container
	Error string `json:"error"`
}

type ResponseStatus struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
}

type ResponseStopContainer struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the container
	Error string `json:"error"`
}

type ResponseStopService struct {
	// ClientID is the unique ID of the client
	ClientID string `json:"client_id"`
	// Error is the error of the container
	Error string `json:"error"`
	// ResponseID
	ResponseID string `json:"response_id"`
}

type Server struct {
	ServerIp   string `json:"server_ip"`
	ServerPort string `json:"server_port"`
}

type Service struct {
	Id         string        `json:"id"`
	Name       string        `json:"name"`
	Containers []Container   `json:"containers"`
	Networks   []Network     `json:"networks"`
	Flags      []ServiceFlag `json:"flags"`
	Status     string        `json:"status"`
}

type ServiceConfig struct {
	Containers     []ServiceConfigContainer `json:"containers" yaml:"containers"`
	TotalScore     int                      `json:"total_score" yaml:"total_score"`
	NetworkCount   int                      `json:"network_count" yaml:"network_count"`
	ContainerCount int                      `json:"container_count" yaml:"container_count"`
}

type ServiceConfigContainer struct {
	Image    string                              `json:"image" yaml:"image"`
	Ports    []ServiceConfigContainerPortMapping `json:"ports" yaml:"ports"`
	Networks []ServiceConfigContainerNetwork     `json:"networks" yaml:"networks"`
	Flags    []ServiceConfigContainerFlag        `json:"flags" yaml:"flags"`
	Env      map[string]string                   `json:"env" yaml:"env"`
}

type ServiceConfigContainerFlag struct {
	FlagCommand string `json:"flag_command" yaml:"flag_command"`
	FlagScore   int    `json:"flag_score" yaml:"flag_score"`
	FlagUuid    string `json:"flag_uuid" yaml:"flag_uuid"` // uuid of flag
}

type ServiceConfigContainerNetwork struct {
	Network    string `json:"network" yaml:"network"`        // network to be used, if random_network is true, this field should be a string of network name
	RandomCIDR bool   `json:"random_cidr" yaml:"RandomCIDR"` // whether to generate random container
}

type ServiceConfigContainerPortMapping struct {
	Port     int    `json:"port" yaml:"port"`         // port in container to be mapped
	Protocol string `json:"protocol" yaml:"protocol"` // protocol of port
}

type ServiceFlag struct {
	FlagUuid string `json:"flag_uuid"`
	Flag     string `json:"flag"`
}

type VM struct {
	// VM name
	Name string `json:"name"`
	// base image
	ImageId string `json:"image_id"`
	// VM type
	Type string `json:"type"`
	// VM arch
	Arch string `json:"arch"`
	// VM status
	Status string `json:"status"`
	// VM created time
	Created int64 `json:"created"`
	// Base  container id
	BaseContainerId string `json:"base_container_id"`
	// VM id
	Id string `json:"id"`
	// Limit of VM
	Limit KisaraVmLimit `json:"limit"`
	// Network
	Network []KisaraVmNetwork `json:"network"`
}