343 lines
15 KiB
Go
343 lines
15 KiB
Go
package infrastructure
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"oc-scheduler/infrastructure/scheduling"
|
|
"strings"
|
|
"time"
|
|
|
|
oclib "cloud.o-forge.io/core/oc-lib"
|
|
"cloud.o-forge.io/core/oc-lib/models/bill"
|
|
"cloud.o-forge.io/core/oc-lib/models/booking"
|
|
"cloud.o-forge.io/core/oc-lib/models/common/enum"
|
|
"cloud.o-forge.io/core/oc-lib/models/common/pricing"
|
|
"cloud.o-forge.io/core/oc-lib/models/order"
|
|
"cloud.o-forge.io/core/oc-lib/models/peer"
|
|
"cloud.o-forge.io/core/oc-lib/models/resources/purchase_resource"
|
|
"cloud.o-forge.io/core/oc-lib/models/utils"
|
|
"cloud.o-forge.io/core/oc-lib/models/workflow"
|
|
"cloud.o-forge.io/core/oc-lib/models/workflow_execution"
|
|
"cloud.o-forge.io/core/oc-lib/tools"
|
|
"github.com/google/uuid"
|
|
"github.com/robfig/cron"
|
|
)
|
|
|
|
/*
|
|
* WorkflowSchedule is a struct that contains the scheduling information of a workflow
|
|
* It contains the mode of the schedule (Task or Service), the name of the schedule, the start and end time of the schedule and the cron expression
|
|
*/
|
|
// it's a flying object only use in a session time. It's not stored in the database
|
|
type WorkflowSchedule struct {
|
|
UUID string `json:"id" validate:"required"` // ExecutionsID is the list of the executions id of the workflow
|
|
Workflow *workflow.Workflow `json:"workflow,omitempty"` // Workflow is the workflow dependancy of the schedule
|
|
WorkflowExecution []*workflow_execution.WorkflowExecution `json:"workflow_executions,omitempty"` // WorkflowExecution is the list of executions of the workflow
|
|
Message string `json:"message,omitempty"` // Message is the message of the schedule
|
|
Warning string `json:"warning,omitempty"` // Warning is the warning message of the schedule
|
|
Start time.Time `json:"start" validate:"required,ltfield=End"` // Start is the start time of the schedule, is required and must be less than the End time
|
|
End *time.Time `json:"end,omitempty"` // End is the end time of the schedule, is required and must be greater than the Start time
|
|
DurationS float64 `json:"duration_s" default:"-1"` // End is the end time of the schedule
|
|
Cron string `json:"cron,omitempty"` // here the cron format : ss mm hh dd MM dw task
|
|
|
|
BookingMode booking.BookingMode `json:"booking_mode,omitempty"` // BookingMode qualify the preemption order of the scheduling. if no payment allowed with preemption set up When_Possible
|
|
SelectedInstances workflow.ConfigItem `json:"selected_instances"`
|
|
SelectedPartnerships workflow.ConfigItem `json:"selected_partnerships"`
|
|
SelectedBuyings workflow.ConfigItem `json:"selected_buyings"`
|
|
SelectedStrategies workflow.ConfigItem `json:"selected_strategies"`
|
|
|
|
SelectedBillingStrategy pricing.BillingStrategy `json:"selected_billing_strategy"`
|
|
|
|
// Confirm, when true, triggers Schedule() to confirm the drafts held by this session.
|
|
Confirm bool `json:"confirm,omitempty"`
|
|
}
|
|
|
|
// TODO PREEMPTION !
|
|
/*
|
|
To schedule a preempted, omg.
|
|
pour faire ça on doit alors lancé une exécution prioritaire qui passera devant toutes les autres, celon un niveau de priorité.
|
|
Preemptible = 7, pour le moment il n'existera que 0 et 7.
|
|
Dans le cas d'une préemption l'exécution est immédiable et bloquera tout le monde tant qu'il n'a pas été exécuté.
|
|
Une ressource doit pouvoir être preemptible pour être exécutée de la sorte.
|
|
Se qui implique si on est sur une ressource par ressource que si un élement n'est pas préemptible,
|
|
alors il devra être effectué dés que possible
|
|
|
|
Dans le cas dés que possible, la start date est immédiate MAIS !
|
|
ne pourra se lancé que SI il n'existe pas d'exécution se lançant durant la période indicative. ( Ultra complexe )
|
|
*/
|
|
|
|
func NewScheduler(mode int, start string, end string, durationInS float64, cron string) *WorkflowSchedule {
|
|
ws := &WorkflowSchedule{
|
|
UUID: uuid.New().String(),
|
|
Start: time.Now().Add(asapBuffer),
|
|
BookingMode: booking.BookingMode(mode),
|
|
DurationS: durationInS,
|
|
Cron: cron,
|
|
}
|
|
s, err := time.Parse("2006-01-02T15:04:05", start)
|
|
if err == nil && ws.BookingMode == booking.PLANNED {
|
|
ws.Start = s // can apply a defined start other than now, if planned
|
|
}
|
|
|
|
e, err := time.Parse("2006-01-02T15:04:05", end)
|
|
if err == nil {
|
|
ws.End = &e
|
|
}
|
|
return ws
|
|
}
|
|
|
|
func (ws *WorkflowSchedule) GetBuyAndBook(wfID string, request *tools.APIRequest) (bool, *workflow.Workflow, []*workflow_execution.WorkflowExecution, []scheduling.SchedulerObject, []scheduling.SchedulerObject, error) {
|
|
access := workflow.NewAccessor(request)
|
|
res, code, err := access.LoadOne(wfID)
|
|
if code != 200 {
|
|
return false, nil, []*workflow_execution.WorkflowExecution{}, []scheduling.SchedulerObject{}, []scheduling.SchedulerObject{}, errors.New("could not load the workflow with id: " + err.Error())
|
|
}
|
|
wf := res.(*workflow.Workflow)
|
|
isPreemptible, longest, priceds, wf, err := wf.Planify(ws.Start, ws.End,
|
|
ws.SelectedInstances, ws.SelectedPartnerships, ws.SelectedBuyings, ws.SelectedStrategies,
|
|
int(ws.BookingMode), request)
|
|
if err != nil {
|
|
return false, wf, []*workflow_execution.WorkflowExecution{}, []scheduling.SchedulerObject{}, []scheduling.SchedulerObject{}, err
|
|
}
|
|
ws.DurationS = longest
|
|
ws.Message = "We estimate that the workflow will start at " + ws.Start.String() + " and last " + fmt.Sprintf("%v", ws.DurationS) + " seconds."
|
|
if ws.End != nil && ws.Start.Add(time.Duration(longest)*time.Second).After(*ws.End) {
|
|
ws.Warning = "The workflow may be too long to be executed in the given time frame, we will try to book it anyway\n"
|
|
}
|
|
execs, err := ws.GetExecutions(wf, isPreemptible)
|
|
if err != nil {
|
|
return false, wf, []*workflow_execution.WorkflowExecution{}, []scheduling.SchedulerObject{}, []scheduling.SchedulerObject{}, err
|
|
}
|
|
purchased := []scheduling.SchedulerObject{}
|
|
bookings := []scheduling.SchedulerObject{}
|
|
for _, exec := range execs {
|
|
for _, obj := range exec.Buy(ws.SelectedBillingStrategy, ws.UUID, wfID, priceds) {
|
|
purchased = append(purchased, scheduling.ToSchedulerObject(tools.PURCHASE_RESOURCE, obj))
|
|
}
|
|
for _, obj := range exec.Book(ws.UUID, wfID, priceds) {
|
|
bookings = append(bookings, scheduling.ToSchedulerObject(tools.BOOKING, obj))
|
|
}
|
|
}
|
|
return true, wf, execs, purchased, bookings, nil
|
|
}
|
|
|
|
// GenerateOrder creates a draft order (+ draft bill) for the given purchases and bookings.
|
|
// Returns the created order ID and any error.
|
|
func (ws *WorkflowSchedule) GenerateOrder(purchases []scheduling.SchedulerObject, bookings []scheduling.SchedulerObject, executionsID string, request *tools.APIRequest) (string, error) {
|
|
newOrder := &order.Order{
|
|
AbstractObject: utils.AbstractObject{
|
|
Name: "order_" + request.PeerID + "_" + time.Now().UTC().Format("2006-01-02T15:04:05"),
|
|
IsDraft: true,
|
|
},
|
|
ExecutionsID: executionsID,
|
|
Purchases: []*purchase_resource.PurchaseResource{},
|
|
Bookings: []*booking.Booking{},
|
|
Status: enum.PENDING,
|
|
}
|
|
for _, purch := range purchases {
|
|
newOrder.Purchases = append(
|
|
newOrder.Purchases, scheduling.FromSchedulerObject(tools.PURCHASE_RESOURCE, purch).(*purchase_resource.PurchaseResource))
|
|
}
|
|
for _, b := range bookings {
|
|
newOrder.Bookings = append(
|
|
newOrder.Bookings, scheduling.FromSchedulerObject(tools.BOOKING, b).(*booking.Booking))
|
|
}
|
|
res, _, err := order.NewAccessor(request).StoreOne(newOrder)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if _, err := bill.DraftFirstBill(res.(*order.Order), request); err != nil {
|
|
return res.GetID(), err
|
|
}
|
|
return res.GetID(), nil
|
|
}
|
|
|
|
func (ws *WorkflowSchedule) Schedules(wfID string, request *tools.APIRequest) (*WorkflowSchedule, *workflow.Workflow, []*workflow_execution.WorkflowExecution, error) {
|
|
if request == nil {
|
|
return ws, nil, []*workflow_execution.WorkflowExecution{}, errors.New("no request found")
|
|
}
|
|
selfID, _ := oclib.GetMySelf()
|
|
|
|
// If the client provides a scheduling_id from a Check session, confirm the
|
|
// pre-created drafts (bookings/purchases). Executions already exist as drafts
|
|
// and will be confirmed later by the considers mechanism.
|
|
if ws.UUID != "" {
|
|
adminReq := &tools.APIRequest{Admin: true}
|
|
|
|
// Obsolescence check: abort if any session execution's start date has passed.
|
|
executions := loadSessionExecs(ws.UUID)
|
|
for _, exec := range executions {
|
|
if !exec.ExecDate.IsZero() && exec.ExecDate.Before(time.Now()) {
|
|
return ws, nil, nil, fmt.Errorf("execution %s is obsolete (start date in the past)", exec.GetID())
|
|
}
|
|
}
|
|
|
|
if err := ConfirmSession(ws.UUID, selfID, request); err != nil {
|
|
return ws, nil, []*workflow_execution.WorkflowExecution{}, fmt.Errorf("confirm session failed: %w", err)
|
|
}
|
|
|
|
for _, exec := range executions {
|
|
go WatchExecDeadline(exec.GetID(), exec.ExecDate, selfID, request)
|
|
}
|
|
|
|
obj, _, _ := workflow.NewAccessor(request).LoadOne(wfID)
|
|
if obj == nil {
|
|
return ws, nil, executions, nil
|
|
}
|
|
wf := obj.(*workflow.Workflow)
|
|
ws.Workflow = wf
|
|
ws.WorkflowExecution = executions
|
|
wf.GetAccessor(adminReq).UpdateOne(wf.Serialize(wf), wf.GetID())
|
|
return ws, wf, executions, nil
|
|
}
|
|
|
|
// Schedule must be called from a Check session (ws.UUID set above).
|
|
// Direct scheduling without a prior Check session is not supported.
|
|
return ws, nil, []*workflow_execution.WorkflowExecution{}, errors.New("no scheduling session: use the Check stream first")
|
|
}
|
|
|
|
// propagateResource routes a purchase or booking to its destination:
|
|
// - If destPeerID matches our own peer (selfMongoID), the object is stored
|
|
// directly in the local DB as draft and the local planner is refreshed.
|
|
// - Otherwise a NATS CREATE_RESOURCE message is emitted so the destination
|
|
// peer can process it asynchronously.
|
|
//
|
|
// The caller is responsible for setting obj.IsDraft before calling.
|
|
func propagateResource(obj utils.DBObject, destPeerID string, dt tools.DataType, selfMongoID *peer.Peer, request *tools.APIRequest, errCh chan error) {
|
|
if destPeerID == selfMongoID.GetID() {
|
|
stored := oclib.NewRequestAdmin(oclib.LibDataEnum(dt), nil).StoreOne(obj.Serialize(obj))
|
|
if stored.Err != "" || stored.Data == nil {
|
|
errCh <- fmt.Errorf("could not store %s locally: %s", dt.String(), stored.Err)
|
|
return
|
|
}
|
|
// The planner tracks booking time-slots only; purchases do not affect it.
|
|
if dt == tools.BOOKING {
|
|
go refreshSelfPlanner(selfMongoID.PeerID, request)
|
|
}
|
|
errCh <- nil
|
|
return
|
|
}
|
|
m := obj.Serialize(obj)
|
|
if m["dest_peer_id"] != nil {
|
|
if data := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil).LoadOne(fmt.Sprintf("%v", m["dest_peer_id"])); data.Data != nil {
|
|
m["peer_id"] = data.Data.(*peer.Peer).PeerID
|
|
}
|
|
} else {
|
|
fmt.Println("NO DEST ID")
|
|
return
|
|
}
|
|
payload, err := json.Marshal(m)
|
|
if err != nil {
|
|
errCh <- fmt.Errorf("could not serialize %s: %w", dt.String(), err)
|
|
return
|
|
}
|
|
if b, err := json.Marshal(&tools.PropalgationMessage{
|
|
DataType: dt.EnumIndex(),
|
|
Action: tools.PB_CREATE,
|
|
Payload: payload,
|
|
}); err == nil {
|
|
tools.NewNATSCaller().SetNATSPub(tools.PROPALGATION_EVENT, tools.NATSResponse{
|
|
FromApp: "oc-scheduler",
|
|
Datatype: dt,
|
|
Method: int(tools.PROPALGATION_EVENT),
|
|
Payload: b,
|
|
})
|
|
}
|
|
errCh <- nil
|
|
}
|
|
|
|
/*
|
|
BOOKING IMPLIED TIME, not of subscription but of execution
|
|
so is processing time execution time applied on computes
|
|
data can improve the processing time
|
|
time should implied a security time border (10sec) if not from the same executions
|
|
VERIFY THAT WE HANDLE DIFFERENCE BETWEEN LOCATION TIME && BOOKING
|
|
*/
|
|
|
|
/*
|
|
* getExecutions is a function that returns the executions of a workflow
|
|
* it returns an array of workflow_execution.WorkflowExecution
|
|
*/
|
|
func (ws *WorkflowSchedule) GetExecutions(workflow *workflow.Workflow, isPreemptible bool) ([]*workflow_execution.WorkflowExecution, error) {
|
|
workflows_executions := []*workflow_execution.WorkflowExecution{}
|
|
dates, err := ws.GetDates()
|
|
if err != nil {
|
|
return workflows_executions, err
|
|
}
|
|
for _, date := range dates {
|
|
obj := &workflow_execution.WorkflowExecution{
|
|
AbstractObject: utils.AbstractObject{
|
|
UUID: uuid.New().String(), // set the uuid of the execution
|
|
Name: workflow.Name + "_execution_" + date.Start.String(), // set the name of the execution
|
|
},
|
|
Priority: 1,
|
|
ExecutionsID: ws.UUID,
|
|
ExecDate: date.Start, // set the execution date
|
|
EndDate: date.End, // set the end date
|
|
State: enum.DRAFT, // set the state to 1 (scheduled)
|
|
WorkflowID: workflow.GetID(), // set the workflow id dependancy of the execution
|
|
}
|
|
if ws.BookingMode != booking.PLANNED {
|
|
obj.Priority = 0
|
|
}
|
|
if ws.BookingMode == booking.PREEMPTED && isPreemptible {
|
|
obj.Priority = 7
|
|
}
|
|
|
|
ws.SelectedStrategies = obj.SelectedStrategies
|
|
ws.SelectedPartnerships = obj.SelectedPartnerships
|
|
ws.SelectedBuyings = obj.SelectedBuyings
|
|
ws.SelectedInstances = obj.SelectedInstances
|
|
|
|
workflows_executions = append(workflows_executions, obj)
|
|
}
|
|
return workflows_executions, nil
|
|
}
|
|
|
|
func (ws *WorkflowSchedule) GetDates() ([]Schedule, error) {
|
|
schedule := []Schedule{}
|
|
if len(ws.Cron) > 0 { // if cron is set then end date should be set
|
|
if ws.End == nil {
|
|
return schedule, errors.New("a cron task should have an end date")
|
|
}
|
|
if ws.DurationS <= 0 {
|
|
ws.DurationS = ws.End.Sub(ws.Start).Seconds()
|
|
}
|
|
cronStr := strings.Split(ws.Cron, " ") // split the cron string to treat it
|
|
if len(cronStr) < 6 { // if the cron string is less than 6 fields, return an error because format is : ss mm hh dd MM dw (6 fields)
|
|
return schedule, errors.New("Bad cron message: (" + ws.Cron + "). Should be at least ss mm hh dd MM dw")
|
|
}
|
|
subCron := strings.Join(cronStr[:6], " ")
|
|
// cron should be parsed as ss mm hh dd MM dw t (min 6 fields)
|
|
specParser := cron.NewParser(cron.Second | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow) // create a new cron parser
|
|
sched, err := specParser.Parse(subCron) // parse the cron string
|
|
if err != nil {
|
|
return schedule, errors.New("Bad cron message: " + err.Error())
|
|
}
|
|
// loop through the cron schedule to set the executions
|
|
for s := sched.Next(ws.Start); !s.IsZero() && s.Before(*ws.End); s = sched.Next(s) {
|
|
e := s.Add(time.Duration(ws.DurationS) * time.Second)
|
|
schedule = append(schedule, Schedule{
|
|
Start: s,
|
|
End: &e,
|
|
})
|
|
}
|
|
} else { // if no cron, set the execution to the start date
|
|
schedule = append(schedule, Schedule{
|
|
Start: ws.Start,
|
|
End: ws.End,
|
|
})
|
|
}
|
|
return schedule, nil
|
|
}
|
|
|
|
type Schedule struct {
|
|
Start time.Time
|
|
End *time.Time
|
|
}
|
|
|
|
/*
|
|
* TODO : LARGEST GRAIN PLANIFYING THE WORKFLOW WHEN OPTION IS SET
|
|
* SET PROTECTION BORDER TIME
|
|
*/
|