engine

type DeltaProjectInfoBasic struct {
	CompileFinishTimes int64
	CompileFailedTimes int64
}

type Engine interface {

	// Name() is to get this engine name, this name must match the project.EngineName
	Name() TypeName

	// SelectFirstTaskBasic receive a task queue group(which contains many queues) and the target queue name
	// let the engine decide which task basic should be get in priority
	// basically, queueGroup.GetQueue(queueName).First() is just fine
	SelectFirstTaskBasic(queueGroup *TaskQueueGroup, queueName string) (*TaskBasic, error)

	// CreateTaskExtension provide the task basic data and the extra data,
	// extra data should be defined by different engines and decode inside engines
	// engine should generate the concerned data and save it during this function
	CreateTaskExtension(tb *TaskBasic, extra []byte) error

	// Get TaskExtension from engine
	// Task provide many public functions so that manager don't have to ask engine everything between progresses
	GetTaskExtension(taskID string) (TaskExtension, error)

	// LaunchTask tell engine to launch the distribute service
	// it should be asynchronous and return immediately after exec the launch job
	// if there is no enough resources for task launching, just return engine.ErrorNoEnoughResources
	LaunchTask(tb *TaskBasic, queueName string) error

	// LaunchDone is used to check if the launch job is done
	LaunchDone(taskID string) (bool, error)

	// CheckTask let engine check this task status
	CheckTask(tb *TaskBasic) error

	// DegradeTask will be called when manager decide to degrade this task, such as staging timeout
	// engine can just return an error if no support degrade mode.
	DegradeTask(taskID string) error

	// SendProjectMessage provide the message to engine,
	// it should be decode inside the engines
	// then get data back
	SendProjectMessage(projectID string, message []byte) ([]byte, error)

	// SendTaskMessage provide the message to engine,
	// it should be decode inside the engines
	// then get data back
	SendTaskMessage(taskID string, message []byte) ([]byte, error)

	// CollectTaskData tell engine that this distribute service will not be used any more,
	// fell free to collect data or some after-work jobs
	CollectTaskData(tb *TaskBasic) error

	// ReleaseTask tell engine to shutdown the service and release the resource
	ReleaseTask(taskID string) error

	// GetPreferences return the engine preferences settings
	GetPreferences() Preferences

	// GetTaskBasicTable return the DB instance where TableTaskBasic is
	GetTaskBasicTable() *gorm.DB

	// GetProjectBasicTable return the DB instance where TableProjectBasic is
	GetProjectBasicTable() *gorm.DB

	// GetProjectInfoBasicTable return the DB instance where TableProjectInfoBasic is
	GetProjectInfoBasicTable() *gorm.DB

	// GetWhitelistBasicTable return the DB instance where TableWhitelistBasic is
	GetWhitelistBasicTable() *gorm.DB
}

type MySQLConf struct {
	MySQLStorage     string
	MySQLDatabase    string
	MySQLUser        string
	MySQLPwd         string
	Charset          string
	MySQLDebug       bool
	MysqlTableOption string
}

type Preferences struct {
	// heartbeat timeout = heartbeat tick gap * tick times
	HeartbeatTimeoutTickTimes int
}

type ProjectBasic struct {

	// PRIMARY key, which should be unique in global(among all engines).
	ProjectID string

	// detail name for this project
	ProjectName string

	// detail descriptions for this project
	Message string

	// Priority defines the priority of tasks launched by this project
	// which matters the task position in waiting queue
	Priority TaskPriority

	// QueueName defines which queue will manage the tasks launched by this project.
	QueueName string

	// EngineName decide which engine will be used to launch the tasks from this project
	EngineName TypeName

	// StageTimeout defines the timeout(seconds) when tasks in staging status.
	// After timeout, the task will be regarded as in the situation "no enough resources",
	// then the task will be do the regraded progress
	StageTimeout int

	// Concurrency defines the max concurrency unterminated task under this projects
	// a new task which reach the limits will be rejected.
	Concurrency int
}

type QueueBriefInfo struct {
	QueueName  string
	EngineName TypeName
}

type QueueShareType int

type StagingTaskQueue interface {
	// get length of this queue
	Len() int64

	// list all TaskBasic from this queue, order by Priority and CreateTime(in same Priority)
	All() []*TaskBasic

	// get first instance from this queue
	First() (*TaskBasic, error)

	// check if task exist
	Exist(taskID string) bool

	// get the specific TaskBasic rank in this queue
	Rank(taskID string) (int, error)

	// add new TaskBasic into this queue
	// the ordering will be adjusted automatically
	Add(task *TaskBasic)

	// delete the specific TaskBasic from this queue
	Delete(taskID string) error

	// clear all elements from this queue
	Clear()
}

type TableBasic struct {
	UpdatedAt time.Time `gorm:"column:update_at" json:"-"`
	Disabled  bool      `gorm:"column:disabled;default:false;index" json:"-"`
}

type TableProjectBasic struct {
	TableBasic

	ProjectID    string `gorm:"column:project_id;primary_key" json:"project_id"`
	ProjectName  string `gorm:"column:project_name" json:"project_name"`
	Priority     int    `gorm:"column:priority" json:"priority"`
	EngineName   string `gorm:"column:engine_name" json:"engine_name"`
	QueueName    string `gorm:"column:queue_name" json:"queue_name"`
	StageTimeout int    `gorm:"column:stage_timeout;default:60" json:"stage_timeout"`
	Message      string `gorm:"column:message" sql:"type:text" json:"message"`
	Concurrency  int    `gorm:"column:concurrency;default:0" json:"concurrency"`
}

type TableProjectInfoBasic struct {
	TableBasic

	ProjectID          string `gorm:"column:project_id;primary_key" json:"project_id"`
	CompileFinishTimes int64  `gorm:"column:compile_finish_times" json:"compile_finish_times"`
	CompileFailedTimes int64  `gorm:"column:compile_failed_times" json:"compile_failed_times"`
}

type TableTaskBasic struct {
	TableBasic
	TaskID string `gorm:"column:task_id;primary_key" json:"task_id"`

	// basic client
	EngineName    string `gorm:"column:engine_name" json:"engine_name"`
	QueueName     string `gorm:"column:queue_name" json:"queue_name"`
	ProjectID     string `gorm:"column:project_id;index" json:"project_id"`
	BuildID       string `gorm:"column:build_id" json:"build_id"`
	ClientIP      string `gorm:"column:client_ip" sql:"type:text" json:"client_ip"`
	ClientCPU     int    `gorm:"column:client_cpu" json:"client_cpu"`
	ClientVersion string `gorm:"column:client_version" json:"client_version"`
	ClientMessage string `gorm:"column:client_message" sql:"type:text" json:"client_message"`
	StageTimeout  int    `gorm:"column:stage_timeout;default:60" json:"stage_timeout"`
	Priority      int    `gorm:"column:priority" json:"priority"`

	// basic status
	Status            string `gorm:"column:status;index" json:"status"`
	StatusCode        int    `gorm:"column:status_code" json:"status_code"`
	StatusMessage     string `gorm:"column:status_message" sql:"type:text" json:"status_message"`
	Released          bool   `gorm:"column:released;index" json:"released"`
	LastHeartBeatTime int64  `gorm:"column:last_heartbeat_time" json:"last_heartbeat_time"`
	StatusChangeTime  int64  `gorm:"column:status_change_time" json:"status_change_time"`
	InitTime          int64  `gorm:"column:init_time" json:"init_time"`
	CreateTime        int64  `gorm:"column:create_time;index" json:"create_time"`
	UpdateTime        int64  `gorm:"column:update_time" json:"update_time"`
	LaunchTime        int64  `gorm:"column:launch_time" json:"launch_time"`
	ReadyTime         int64  `gorm:"column:ready_time" json:"ready_time"`
	ShutDownTime      int64  `gorm:"column:shutdown_time" json:"shutdown_time"`
	StartTime         int64  `gorm:"column:start_time" json:"start_time"`
	EndTime           int64  `gorm:"column:end_time" json:"end_time"`
}

type TableWhitelistBasic struct {
	TableBasic

	IP        string `gorm:"column:ip;primary_key" json:"ip"`
	ProjectID string `gorm:"column:project_id;primary_key" json:"project_id"`
	Message   string `gorm:"column:message" sql:"type:text" json:"message"`
}

type TaskBasic struct {
	// the primary key of tasks
	ID string

	// settings when created
	Client TaskBasicClient

	// status after created
	Status TaskBasicStatus
}

type TaskBasicClient struct {
	EngineName    TypeName
	QueueName     string
	ProjectID     string
	BuildID       string
	Priority      TaskPriority
	ClientIP      string
	ClientCPU     int
	ClientVersion string
	StageTimeout  int
	Message       string
}

type TaskBasicStatus struct {
	Status     TaskStatusType
	StatusCode TaskStatusCode
	Message    string

	Released bool

	// Task time
	LastHeartBeatTime time.Time
	StatusChangeTime  time.Time
	InitTime          time.Time
	CreateTime        time.Time
	UpdateTime        time.Time
	LaunchTime        time.Time
	ReadyTime         time.Time
	ShutDownTime      time.Time
	StartTime         time.Time
	EndTime           time.Time
}

type TaskExtension interface {
	// if task get enough available resource
	EnoughAvailableResource() bool

	// get worker list from task
	WorkerList() []string

	GetRequestInstance() int

	GetWorkerCount() int

	// dump the task data
	Dump() []byte

	// return the engine custom data from task
	CustomData(interface{}) interface{}
}

type TaskListOptions struct {
	Status   []TaskStatusType
	Released *bool
}

type TaskPriority uint

type TaskQueueGroup struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type TaskStatusCode uint

type TaskStatusType string

type TypeName string

type WhiteListKey struct {
	IP        string `json:"ip"`
	ProjectID string `json:"project_id"`
}

type WhitelistBasic struct {
	ProjectID string
	IP        string
	Message   string
}