model

package
v0.0.0-...-a3a5c94 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 21, 2021 License: MIT Imports: 11 Imported by: 0

README

Package cron implements a cron spec parser and job runner. Usage Callers may register Funcs to be invoked on a given schedule. Cron will run them in their own goroutines. c := cron.New() c.AddFunc("0 30 * * * *", func() { fmt.Println("Every hour on the half hour") }) c.AddFunc("@hourly", func() { fmt.Println("Every hour") }) c.AddFunc("@every 1h30m", func() { fmt.Println("Every hour thirty") }) c.Start() .. // Funcs are invoked in their own goroutine, asynchronously. ... // Funcs may also be added to a running Cron c.AddFunc("@daily", func() { fmt.Println("Every day") }) .. // Inspect the cron job entries' next and previous run times. inspect(c.Entries()) .. c.Stop() // Stop the scheduler (does not stop any jobs already running). CRON Expression Format A cron expression represents a set of times, using 6 space-separated fields.

Field name Mandatory? Allowed values Allowed special characters
Seconds Yes 0-59 * / , -
Minutes Yes 0-59 * / , -
Hours Yes 0-23 * / , -
Day of month Yes 1-31 * / , - ?
Month Yes 1-12 or JAN-DEC * / , -
Day of week Yes 0-6 or SUN-SAT * / , - ?
Note: Month and Day-of-week field values are case insensitive. "SUN", "Sun",
and "sun" are equally accepted.
Special Characters
Asterisk ( * )
The asterisk indicates that the cron expression will match for all values of the
field; e.g., using an asterisk in the 5th field (month) would indicate every
month.
Slash ( / )
Slashes are used to describe increments of ranges. For example 3-59/15 in the
1st field (minutes) would indicate the 3rd minute of the hour and every 15
minutes thereafter. The form "*/..." is equivalent to the form "first-last/...",
that is, an increment over the largest possible range of the field. The form
"N/..." is accepted as meaning "N-MAX/...", that is, starting at N, use the
increment until the end of that specific range. It does not wrap around.
Comma ( , )
Commas are used to separate items of a list. For example, using "MON,WED,FRI" in
the 5th field (day of week) would mean Mondays, Wednesdays and Fridays.
Hyphen ( - )
Hyphens are used to define ranges. For example, 9-17 would indicate every
hour between 9am and 5pm inclusive.
Question mark ( ? )
Question mark may be used instead of '*' for leaving either day-of-month or
day-of-week blank.
Predefined schedules
You may use one of several pre-defined schedules in place of a cron expression.
Entry Description Equivalent To
----- ----------- -------------
@yearly (or @annually) Run once a year, midnight, Jan. 1st 0 0 0 1 1 *
@monthly Run once a month, midnight, first of month 0 0 0 1 * *
@weekly Run once a week, midnight on Sunday 0 0 0 * * 0
@daily (or @midnight) Run once a day, midnight 0 0 0 * * *
@hourly Run once an hour, beginning of hour 0 0 * * * *
Intervals
You may also schedule a job to execute at fixed intervals, starting at the time it's added
or cron is run. This is supported by formatting the cron spec like this:
@every
where "duration" is a string accepted by time.ParseDuration
(http://golang.org/pkg/time/#ParseDuration).
For example, "@every 1h30m10s" would indicate a schedule that activates immediately,
and then every 1 hour, 30 minutes, 10 seconds.
Note: The interval does not take the job runtime into account. For example,
if a job takes 3 minutes to run, and it is scheduled to run every 5 minutes,
it will have only 2 minutes of idle time between each run.
Time zones
All interpretation and scheduling is done in the machine's local time zone (as
provided by the Go time package (http://www.golang.org/pkg/time).
Be aware that jobs scheduled during daylight-savings leap-ahead transitions will
not be run!
Thread safety
Since the Cron service runs concurrently with the calling code, some amount of
care must be taken to ensure proper synchronization.
All cron methods are designed to be correctly synchronized as long as the caller
ensures that invocations have a clear happens-before ordering between them.
Implementation
Cron entries are stored in an array, sorted by their next activation time. Cron
sleeps until the next job is due to be run.
Upon waking:
  • it runs each entry that is active on that second
  • it calculates the next run times for the jobs that were run
  • it re-sorts the array of entries by next activation time.
  • it goes to sleep until the soonest job.

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var AtLeastOnceStrategy = "AtLeastOnce"

AtLeastOnceStrategy

View Source 
var SameNodeStrategy = "SameNode"

SameNodeStrategy

Functions

func DoRequest 

func DoRequest(baseAPI, query, queryType, method string, body []byte) ([]byte, int, error)

DoRequest -

Types

type AlertingNameConfig 

type AlertingNameConfig struct {
	Name  string         `yaml:"name" json:"name"`
	Rules []*RulesConfig `yaml:"rules" json:"rules"`
}

AlertingNameConfig -

type AlertingRulesConfig 

type AlertingRulesConfig struct {
	Groups []*AlertingNameConfig `yaml:"groups" json:"groups"`
}

AlertingRulesConfig -

type AllocatedResources 

type AllocatedResources struct {
	CPURequests     int64
	CPULimits       int64
	MemoryRequests  int64
	MemoryLimits    int64
	MemoryRequestsR string
	MemoryLimitsR   string
	CPURequestsR    string
	CPULimitsR      string
}

AllocatedResources -

type Body 

type Body struct {
	List interface{} `json:"list"`
	Bean interface{} `json:"bean,omitempty"`
}

Body -

type ClusterResource 

type ClusterResource struct {
	AllNode                          int           `json:"all_node"`
	NotReadyNode                     int           `json:"notready_node"`
	ComputeNode                      int           `json:"compute_node"`
	Tenant                           int           `json:"tenant"`
	CapCPU                           int           `json:"cap_cpu"`          //Total CPU allocation
	CapMem                           int           `json:"cap_mem"`          //Total Distributable Mem
	HealthCapCPU                     int           `json:"health_cap_cpu"`   //Health can allocate CPU
	HealthCapMem                     int           `json:"health_cap_mem"`   //Health Distributable Mem
	UnhealthCapCPU                   int           `json:"unhealth_cap_cpu"` //Unhealthy CPU can be allocated
	UnhealthCapMem                   int           `json:"unhealth_cap_mem"` //Unhealthy Mem can be allocated
	ReqCPU                           float32       `json:"req_cpu"`          //Total CPU used
	ReqMem                           int           `json:"req_mem"`          //Total Mem Used
	HealthReqCPU                     float32       `json:"health_req_cpu"`   //Health has used CPU
	HealthReqMem                     int           `json:"health_req_mem"`   //Health has used Mem
	UnhealthReqCPU                   float32       `json:"unhealth_req_cpu"` //Unhealthy used CPU
	UnhealthReqMem                   int           `json:"unhealth_req_mem"` //Unhealthy has used Mem
	CapDisk                          uint64        `json:"cap_disk"`
	ReqDisk                          uint64        `json:"req_disk"`
	MaxAllocatableMemoryNodeResource *NodeResource `json:"max_allocatable_memory_node_resource"`
}

ClusterResource

type Config 

type Config struct {
	Cn    string `json:"cn_name"`
	Name  string `json:"name"`
	Value string `json:"value"`
}

Config -

type ConfigUnit 

type ConfigUnit struct {
	//Configuration name: network
	Name   string `json:"name" validate:"name|required"`
	CNName string `json:"cn_name" validate:"cn_name"`
	//Type for example: midonet
	Value     interface{} `json:"value" validate:"value|required"`
	ValueType string      `json:"value_type"`
	//Optional type Type name and required configuration items
	OptionalValue []string                `json:"optional_value,omitempty"`
	DependConfig  map[string][]ConfigUnit `json:"depend_config,omitempty"`
	//Is user configurable
	IsConfigurable bool `json:"is_configurable"`
}

ConfigUnit

func (ConfigUnit) String 

func (c ConfigUnit) String() string

type DependStrategy 

type DependStrategy struct {
	DependTaskID      string `json:"depend_task_id"`
	DetermineStrategy string `json:"strategy"`
}

DependStrategy

type ExecedTask 

type ExecedTask struct {
	ID             string   `json:"id"`
	Seq            int      `json:"seq"`
	Desc           string   `json:"desc"`
	Status         string   `json:"status"`
	CompleteStatus string   `json:"complete_status"`
	ErrorMsg       string   `json:"err_msg"`
	Depends        []string `json:"dep"`
	Next           []string `json:"next"`
}

ExecedTask -

type Expr 

type Expr struct {
	Body struct {
		// expr
		// in: body
		// required: true
		Expr string `json:"expr" validate:"expr|required"`
	}
}

Expr swagger:parameters createToken

type FirstConfig 

type FirstConfig struct {
	StorageMode     string `json:"storage_mode"`
	StorageHost     string `json:"storage_host,omitempty"`
	StorageEndPoint string `json:"storage_endpoint,omitempty"`

	NetworkMode string `json:"network_mode"`
	ZKHosts     string `json:"zk_host,omitempty"`
	CassandraIP string `json:"cassandra_ip,omitempty"`
	K8SAPIAddr  string `json:"k8s_apiserver,omitempty"`
	MasterIP    string `json:"master_ip,omitempty"`
	DNS         string `json:"dns,omitempty"`
	ZMQSub      string `json:"zmq_sub,omitempty"`
	ZMQTo       string `json:"zmq_to,omitempty"`
	EtcdIP      string `json:"etcd_ip,omitempty"`
}

FirstConfig -

type GlobalConfig 

type GlobalConfig struct {
	Configs map[string]*ConfigUnit `json:"configs"`
}

GlobalConfig

func CreateDefaultGlobalConfig 

func CreateDefaultGlobalConfig() *GlobalConfig

CreateDefaultGlobalConfig

func CreateGlobalConfig 

func CreateGlobalConfig(kvs []*mvccpb.KeyValue) (*GlobalConfig, error)

CreateGlobalConfig

func (*GlobalConfig) Add 

func (g *GlobalConfig) Add(c ConfigUnit)

Add

func (GlobalConfig) Bytes 

func (g GlobalConfig) Bytes() []byte

Bytes

func (*GlobalConfig) Delete 

func (g *GlobalConfig) Delete(Name string)

Delete

func (*GlobalConfig) Get 

func (g *GlobalConfig) Get(name string) *ConfigUnit

Get

func (*GlobalConfig) String 

func (g *GlobalConfig) String() string

String

type InitStatus 

type InitStatus struct {
	Status   int    `json:"status"`
	StatusCN string `json:"cn"`
	HostID   string `json:"uuid"`
}

InitStatus -

type InstallStatus 

type InstallStatus struct {
	Status   int           `json:"status"`
	StatusCN string        `json:"cn"`
	Tasks    []*ExecedTask `json:"tasks"`
}

InstallStatus -

type LabelsResp 

type LabelsResp struct {
	SysLabels    map[string]string `json:"sys_labels"`
	CustomLabels map[string]string `json:"custom_labels"`
}

LabelsResp -

type Login 

type Login struct {
	HostPort  string `json:"hostport"`
	LoginType bool   `json:"type"`
	HostType  string `json:"hosttype"`
	RootPwd   string `json:"pwd,omitempty"`
}

Login -

type LoginResult 

type LoginResult struct {
	HostPort  string `json:"hostport"`
	LoginType bool   `json:"type"`
	Result    string `json:"result"`
}

LoginResult -

type NodeDetails 

type NodeDetails struct {
	Name               string              `json:"name"`
	Role               []string            `json:"role"`
	Status             string              `json:"status"`
	Labels             map[string]string   `json:"labels"`
	Annotations        map[string]string   `json:"annotations"`
	CreationTimestamp  string              `json:"creationtimestamp"`
	Conditions         []v1.NodeCondition  `json:"conditions"`
	Addresses          map[string]string   `json:"addresses"`
	Capacity           map[string]string   `json:"capacity"`
	Allocatable        map[string]string   `json:"allocatable"`
	SystemInfo         v1.NodeSystemInfo   `json:"systeminfo"`
	NonterminatedPods  []*Pods             `json:"nonterminatedpods"`
	AllocatedResources map[string]string   `json:"allocatedresources"`
	Events             map[string][]string `json:"events"`
}

NodeDetails

type NodePodResource 

type NodePodResource struct {
	AllocatedResources `json:"allocatedresources"`
	Resource           `json:"allocatable"`
}

NodePodResource -

type NodeResource 

type NodeResource struct {
	MilliCPU         int64 `json:"milli_cpu"`
	Memory           int64 `json:"memory"`
	NvidiaGPU        int64 `json:"nvidia_gpu"`
	EphemeralStorage int64 `json:"ephemeral_storage"`
	// We store allowedPodNumber (which is Node.Status.Allocatable.Pods().Value())
	// explicitly as int, to avoid conversions and improve performance.
	AllowedPodNumber int `json:"allowed_pod_number"`
}

NodeResource is a collection of compute resource.

func NewResource 

func NewResource(rl v1.ResourceList) *NodeResource

NewResource creates a Resource from ResourceList

func (*NodeResource) Add 

func (r *NodeResource) Add(rl v1.ResourceList)

Add adds ResourceList into Resource.

func (*NodeResource) ResourceList 

func (r *NodeResource) ResourceList() v1.ResourceList

ResourceList returns a resource list of this resource.

type NodeResourceResponse 

type NodeResourceResponse struct {
	CapCPU int     `json:"cap_cpu"`
	CapMem int     `json:"cap_mem"`
	ReqCPU float32 `json:"req_cpu"`
	ReqMem int     `json:"req_mem"`
}

NodeResourceResponse

type NotificationEvent 

type NotificationEvent struct {
	//Kind could be service, tenant, cluster, node
	Kind string `json:"Kind"`
	//KindID could be service_id,tenant_id,cluster_id,node_id
	KindID string `json:"KindID"`
	Hash   string `json:"Hash"`
	//Type could be Normal / UnNormal Notification
	Type          string `json:"Type"`
	Message       string `json:"Message"`
	Reason        string `json:"Reason"`
	Count         int    `json:"Count"`
	LastTime      string `json:"LastTime"`
	FirstTime     string `json:"FirstTime"`
	IsHandle      bool   `json:"IsHandle"`
	HandleMessage string `json:"HandleMessage"`
	ServiceName   string `json:"ServiceName"`
	TenantName    string `json:"TenantName"`
}

NotificationEvent

type Pods 

type Pods struct {
	Namespace       string `json:"namespace"`
	Id              string `json:"id"`
	Name            string `json:"name"`
	TenantName      string `json:"tenant_name"`
	CPURequests     string `json:"cpurequest"`
	CPURequestsR    string `json:"cpurequestr"`
	CPULimits       string `json:"cpulimits"`
	CPULimitsR      string `json:"cpulimitsr"`
	MemoryRequests  string `json:"memoryrequests"`
	MemoryRequestsR string `json:"memoryrequestsr"`
	MemoryLimits    string `json:"memorylimits"`
	MemoryLimitsR   string `json:"memorylimitsr"`
	Status          string `json:"status"`
}

Pods -

type Prome 

type Prome struct {
	Status string    `json:"status"`
	Data   PromeData `json:"data"`
}

Prome -

type PromeData 

type PromeData struct {
	ResultType string             `json:"resultType"`
	Result     []*PromeResultCore `json:"result"`
}

PromeData -

type PromeResultCore 

type PromeResultCore struct {
	Metric map[string]string `json:"metric"`
	Value  []interface{}     `json:"value"`
	Values []interface{}     `json:"values"`
}

PromeResultCore -

type PrometheusAPI 

type PrometheusAPI struct {
	API string
}

PrometheusAPI -

func (*PrometheusAPI) Query 

func (s *PrometheusAPI) Query(query string) (*Prome, *utils.APIHandleError)

Query Get

func (*PrometheusAPI) QueryRange 

func (s *PrometheusAPI) QueryRange(query string, start, end, step string) (*Prome, *utils.APIHandleError)

QueryRange Get

type PrometheusInterface 

type PrometheusInterface interface {
	Query(query string) *Prome
	QueryRange(query string, start, end, step string) *Prome
}

PrometheusInterface -

type Resource 

type Resource struct {
	CPU  int `json:"cpu"`
	MemR int `json:"mem"`
}

Resource

type ResponseBody 

type ResponseBody struct {
	Code  int    `json:"code"`
	Msg   string `json:"msg"`
	MsgCN string `json:"msgcn"`
	Body  Body   `json:"body,omitempty"`
}

ResponseBody -

type RulesConfig 

type RulesConfig struct {
	Alert       string            `yaml:"alert" json:"alert"`
	Expr        string            `yaml:"expr" json:"expr"`
	For         string            `yaml:"for" json:"for"`
	Labels      map[string]string `yaml:"labels" json:"labels"`
	Annotations map[string]string `yaml:"annotations" json:"annotations"`
}

RulesConfig -

type Scheduler 

type Scheduler struct {
	Mode   string                     `json:"mode"` //Immediate scheduling (Intime), trigger scheduling (Passive)
	Status map[string]SchedulerStatus `json:"status"`
}

Scheduler

type SchedulerStatus 

type SchedulerStatus struct {
	Status          string    `json:"status"`
	Message         string    `json:"message"`
	SchedulerTime   time.Time `json:"scheduler_time"`   //Scheduling time
	SchedulerMaster string    `json:"scheduler_master"` //Scheduled management node
}

SchedulerStatus

type Shell 

type Shell struct {
	Cmd []string `json:"cmd"`
}

Shell

type Task 

type Task struct {
	Name    string    `json:"name" validate:"name|required"`
	ID      string    `json:"id" validate:"id|uuid"`
	TempID  string    `json:"temp_id,omitempty" validate:"temp_id|uuid"`
	Temp    *TaskTemp `json:"temp,omitempty"`
	GroupID string    `json:"group_id,omitempty"`
	//Node of execution
	Nodes []string `json:"nodes"`
	//Execution time definition
	//For example, execute every 30 minutes: @every 30m
	Timer   string `json:"timer"`
	TimeOut int64  `json:"time_out"`
	//The number of failed retry attempts
	//The default is 0, do not try again
	Retry int `json:"retry"`
	//Failed task execution retry interval
	//Unit second, if not greater than 0, try again immediately
	Interval int `json:"interval"`
	//ExecCount
	ExecCount int `json:"exec_count"`
	//Execution status of each execution node
	Status       map[string]TaskStatus `json:"status,omitempty"`
	Scheduler    Scheduler             `json:"scheduler"`
	CreateTime   time.Time             `json:"create_time"`
	StartTime    time.Time             `json:"start_time"`
	CompleteTime time.Time             `json:"complete_time"`
	ResultPath   string                `json:"result_path"`
	EventID      string                `json:"event_id"`
	RunMode      string                `json:"run_mode"`
	OutPut       []*TaskOutPut         `json:"out_put"`
}

Task

func (Task) CanBeDelete 

func (t Task) CanBeDelete() bool

CanBeDelete

func (*Task) Decode 

func (t *Task) Decode(data []byte) error

Decode

func (Task) String 

func (t Task) String() string

func (*Task) UpdataOutPut 

func (t *Task) UpdataOutPut(output TaskOutPut)

UpdataOutPut

type TaskGroup 

type TaskGroup struct {
	Name       string           `json:"name" validate:"name|required"`
	ID         string           `json:"id" validate:"id|uuid"`
	Tasks      []*Task          `json:"tasks"`
	CreateTime time.Time        `json:"create_time"`
	Status     *TaskGroupStatus `json:"status"`
}

TaskGroup

func (TaskGroup) CanBeDelete 

func (t TaskGroup) CanBeDelete() bool

CanBeDelete

func (TaskGroup) String 

func (t TaskGroup) String() string

type TaskGroupStatus 

type TaskGroupStatus struct {
	TaskStatus map[string]TaskStatus `json:"task_status"`
	InitTime   time.Time             `json:"init_time"`
	StartTime  time.Time             `json:"start_time"`
	EndTime    time.Time             `json:"end_time"`
	Status     string                `json:"status"` //create init exec complete timeout
}

TaskGroupStatus

type TaskOutPut 

type TaskOutPut struct {
	NodeID string            `json:"node_id"`
	JobID  string            `json:"job_id"`
	Global map[string]string `json:"global"`
	Inner  map[string]string `json:"inner"`
	//Return data type, test result type (check), execution installation type (install), common type (common)
	Type       string             `json:"type"`
	Status     []TaskOutPutStatus `json:"status"`
	ExecStatus string             `json:"exec_status"`
	Body       string             `json:"body"`
}

TaskOutPut

func ParseTaskOutPut 

func ParseTaskOutPut(body string) (t TaskOutPut, err error)

ParseTaskOutPut json parse

type TaskOutPutStatus 

type TaskOutPutStatus struct {
	Name string `json:"name"`
	//Node attributes
	ConditionType string `json:"condition_type"`
	//Node attribute value
	ConditionStatus string   `json:"condition_status"`
	NextTask        []string `json:"next_tasks,omitempty"`
	NextGroups      []string `json:"next_groups,omitempty"`
}

TaskOutPutStatus

type TaskStatus 

type TaskStatus struct {
	JobID        string    `json:"job_id"`
	Status       string    `json:"status"` //Execution status，create init exec complete timeout
	StartTime    time.Time `json:"start_time"`
	EndTime      time.Time `json:"end_time"`
	TakeTime     int       `json:"take_time"`
	CompleStatus string    `json:"comple_status"`
	//Script exit code
	ShellCode int    `json:"shell_code"`
	Message   string `json:"message,omitempty"`
}

TaskStatus

type TaskTemp 

type TaskTemp struct {
	Name       string            `json:"name" validate:"name|required"`
	ID         string            `json:"id" validate:"id|uuid"`
	Shell      Shell             `json:"shell"`
	Envs       map[string]string `json:"envs,omitempty"`
	Input      string            `json:"input,omitempty"`
	Args       []string          `json:"args,omitempty"`
	Depends    []DependStrategy  `json:"depends,omitempty"`
	Timeout    int               `json:"timeout" validate:"timeout|required|numeric"`
	CreateTime time.Time         `json:"create_time"`
	Labels     map[string]string `json:"labels,omitempty"`
}

TaskTemp

func (TaskTemp) String 

func (t TaskTemp) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.