forked from longtao.wu/droboticflow
767 lines
21 KiB
Go
767 lines
21 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"droboticflow/internal/domain"
|
|
)
|
|
|
|
type MemoryStore struct {
|
|
mu sync.Mutex
|
|
projects map[string]domain.ProjectRecord
|
|
operators map[string]domain.OperatorRecord
|
|
workflows map[string]domain.WorkflowRecord
|
|
templates map[string]domain.TemplateRecord
|
|
runs map[string]domain.RunRecord
|
|
auditTasks map[string]domain.AuditTaskRecord
|
|
users map[string]domain.UserRecord
|
|
settings *domain.SettingsRecord
|
|
}
|
|
|
|
func NewMemoryStore() *MemoryStore {
|
|
return &MemoryStore{
|
|
projects: map[string]domain.ProjectRecord{},
|
|
operators: map[string]domain.OperatorRecord{},
|
|
workflows: map[string]domain.WorkflowRecord{},
|
|
templates: map[string]domain.TemplateRecord{},
|
|
runs: map[string]domain.RunRecord{},
|
|
auditTasks: map[string]domain.AuditTaskRecord{},
|
|
users: map[string]domain.UserRecord{},
|
|
}
|
|
}
|
|
|
|
func sortProjects(items []domain.ProjectRecord) {
|
|
sort.Slice(items, func(left int, right int) bool { return items[left].CreatedAt > items[right].CreatedAt })
|
|
}
|
|
|
|
func sortOperators(items []domain.OperatorRecord) {
|
|
sort.Slice(items, func(left int, right int) bool { return items[left].CreatedAt > items[right].CreatedAt })
|
|
}
|
|
|
|
func sortWorkflows(items []domain.WorkflowRecord) {
|
|
sort.Slice(items, func(left int, right int) bool { return items[left].CreatedAt > items[right].CreatedAt })
|
|
}
|
|
|
|
func sortTemplates(items []domain.TemplateRecord) {
|
|
sort.Slice(items, func(left int, right int) bool { return items[left].CreatedAt > items[right].CreatedAt })
|
|
}
|
|
|
|
func sortRuns(items []domain.RunRecord) {
|
|
sort.Slice(items, func(left int, right int) bool { return items[left].CreatedAt > items[right].CreatedAt })
|
|
}
|
|
|
|
func sortAuditTasks(items []domain.AuditTaskRecord) {
|
|
sort.Slice(items, func(left int, right int) bool { return items[left].CreatedAt > items[right].CreatedAt })
|
|
}
|
|
|
|
func sortUsers(items []domain.UserRecord) {
|
|
sort.Slice(items, func(left int, right int) bool { return items[left].CreatedAt < items[right].CreatedAt })
|
|
}
|
|
|
|
func (store *MemoryStore) ListProjects(context.Context) ([]domain.ProjectRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
items := make([]domain.ProjectRecord, 0, len(store.projects))
|
|
for _, project := range store.projects {
|
|
items = append(items, clone(project))
|
|
}
|
|
sortProjects(items)
|
|
return items, nil
|
|
}
|
|
|
|
func (store *MemoryStore) GetProject(_ context.Context, id string) (*domain.ProjectRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
project, ok := store.projects[id]
|
|
if !ok {
|
|
return nil, nil
|
|
}
|
|
cloned := clone(project)
|
|
return &cloned, nil
|
|
}
|
|
|
|
func (store *MemoryStore) CreateProject(_ context.Context, input domain.CreateProjectInput) (*domain.ProjectRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
now := nowISO()
|
|
project := domain.ProjectRecord{
|
|
ID: domain.NewID("project"),
|
|
Name: input.Name,
|
|
Description: input.Description,
|
|
Status: "active",
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
store.projects[project.ID] = clone(project)
|
|
cloned := clone(project)
|
|
return &cloned, nil
|
|
}
|
|
|
|
func (store *MemoryStore) DeleteProject(_ context.Context, id string) (bool, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
if _, ok := store.projects[id]; !ok {
|
|
return false, nil
|
|
}
|
|
delete(store.projects, id)
|
|
|
|
workflowIDs := make([]string, 0)
|
|
for workflowID, workflow := range store.workflows {
|
|
if workflow.ProjectID == id {
|
|
workflowIDs = append(workflowIDs, workflowID)
|
|
delete(store.workflows, workflowID)
|
|
}
|
|
}
|
|
for runID, run := range store.runs {
|
|
if run.ProjectID == id {
|
|
delete(store.runs, runID)
|
|
continue
|
|
}
|
|
for _, workflowID := range workflowIDs {
|
|
if run.WorkflowID == workflowID {
|
|
delete(store.runs, runID)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
for taskID, task := range store.auditTasks {
|
|
if task.ProjectID == id {
|
|
delete(store.auditTasks, taskID)
|
|
continue
|
|
}
|
|
for _, workflowID := range workflowIDs {
|
|
if task.WorkflowID == workflowID {
|
|
delete(store.auditTasks, taskID)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
func (store *MemoryStore) UpsertProject(_ context.Context, project domain.ProjectRecord) error {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
store.projects[project.ID] = clone(project)
|
|
return nil
|
|
}
|
|
|
|
func (store *MemoryStore) ListOperators(context.Context) ([]domain.OperatorRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
items := make([]domain.OperatorRecord, 0, len(store.operators))
|
|
for _, item := range store.operators {
|
|
items = append(items, clone(item))
|
|
}
|
|
sortOperators(items)
|
|
return items, nil
|
|
}
|
|
|
|
func (store *MemoryStore) GetOperator(_ context.Context, id string) (*domain.OperatorRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
item, ok := store.operators[id]
|
|
if !ok {
|
|
return nil, nil
|
|
}
|
|
cloned := clone(item)
|
|
return &cloned, nil
|
|
}
|
|
|
|
func (store *MemoryStore) CreateOperator(_ context.Context, input domain.CreateOperatorInput) (*domain.OperatorRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
now := nowISO()
|
|
item := domain.OperatorRecord{
|
|
ID: domain.NewID("operator"),
|
|
Name: input.Name,
|
|
Type: input.Type,
|
|
Category: input.Category,
|
|
Description: input.Description,
|
|
Inputs: clone(input.Inputs),
|
|
Outputs: clone(input.Outputs),
|
|
ConfigSchema: clone(input.ConfigSchema),
|
|
Image: input.Image,
|
|
SkillDefinition: input.SkillDefinition,
|
|
Hyperparams: clone(input.Hyperparams),
|
|
Resources: clone(input.Resources),
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
store.operators[item.ID] = clone(item)
|
|
cloned := clone(item)
|
|
return &cloned, nil
|
|
}
|
|
|
|
func (store *MemoryStore) DeleteOperator(_ context.Context, id string) (bool, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
if _, ok := store.operators[id]; !ok {
|
|
return false, nil
|
|
}
|
|
delete(store.operators, id)
|
|
return true, nil
|
|
}
|
|
|
|
func (store *MemoryStore) UpsertOperator(_ context.Context, item domain.OperatorRecord) error {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
store.operators[item.ID] = clone(item)
|
|
return nil
|
|
}
|
|
|
|
func (store *MemoryStore) ListWorkflowsByProject(_ context.Context, projectID string) ([]domain.WorkflowRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
items := make([]domain.WorkflowRecord, 0)
|
|
for _, workflow := range store.workflows {
|
|
if workflow.ProjectID == projectID {
|
|
items = append(items, clone(workflow))
|
|
}
|
|
}
|
|
sortWorkflows(items)
|
|
return items, nil
|
|
}
|
|
|
|
func (store *MemoryStore) ListAllWorkflows(context.Context) ([]domain.WorkflowRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
items := make([]domain.WorkflowRecord, 0, len(store.workflows))
|
|
for _, workflow := range store.workflows {
|
|
items = append(items, clone(workflow))
|
|
}
|
|
sortWorkflows(items)
|
|
return items, nil
|
|
}
|
|
|
|
func (store *MemoryStore) GetWorkflow(_ context.Context, id string) (*domain.WorkflowRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
workflow, ok := store.workflows[id]
|
|
if !ok {
|
|
return nil, nil
|
|
}
|
|
cloned := clone(workflow)
|
|
return &cloned, nil
|
|
}
|
|
|
|
func (store *MemoryStore) CreateWorkflow(_ context.Context, input domain.CreateWorkflowInput) (*domain.WorkflowRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
now := nowISO()
|
|
item := domain.WorkflowRecord{
|
|
ID: domain.NewID("workflow"),
|
|
ProjectID: input.ProjectID,
|
|
Name: input.Name,
|
|
Description: input.Description,
|
|
Type: input.Type,
|
|
MaxConcurrentRuns: input.MaxConcurrentRuns,
|
|
NodeTimeoutSeconds: input.NodeTimeoutSeconds,
|
|
RunTimeoutSeconds: input.RunTimeoutSeconds,
|
|
MaxRetryAttempts: input.MaxRetryAttempts,
|
|
RetryBackoffSeconds: input.RetryBackoffSeconds,
|
|
Schedule: clone(input.Schedule),
|
|
Nodes: clone(input.Nodes),
|
|
Edges: clone(input.Edges),
|
|
Status: domain.WorkflowStatusDraft,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
store.workflows[item.ID] = clone(item)
|
|
cloned := clone(item)
|
|
return &cloned, nil
|
|
}
|
|
|
|
func (store *MemoryStore) DeleteWorkflow(_ context.Context, id string) (bool, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
if _, ok := store.workflows[id]; !ok {
|
|
return false, nil
|
|
}
|
|
delete(store.workflows, id)
|
|
for runID, run := range store.runs {
|
|
if run.WorkflowID == id {
|
|
delete(store.runs, runID)
|
|
}
|
|
}
|
|
for taskID, task := range store.auditTasks {
|
|
if task.WorkflowID == id {
|
|
delete(store.auditTasks, taskID)
|
|
}
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
func (store *MemoryStore) UpsertWorkflow(_ context.Context, workflow domain.WorkflowRecord) error {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
store.workflows[workflow.ID] = clone(workflow)
|
|
return nil
|
|
}
|
|
|
|
func (store *MemoryStore) ListTemplates(context.Context) ([]domain.TemplateRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
items := make([]domain.TemplateRecord, 0, len(store.templates))
|
|
for _, item := range store.templates {
|
|
items = append(items, clone(item))
|
|
}
|
|
sortTemplates(items)
|
|
return items, nil
|
|
}
|
|
|
|
func (store *MemoryStore) GetTemplate(_ context.Context, id string) (*domain.TemplateRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
item, ok := store.templates[id]
|
|
if !ok {
|
|
return nil, nil
|
|
}
|
|
cloned := clone(item)
|
|
return &cloned, nil
|
|
}
|
|
|
|
func (store *MemoryStore) CreateTemplate(_ context.Context, input domain.CreateTemplateInput) (*domain.TemplateRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
now := nowISO()
|
|
templateType := input.Type
|
|
if templateType == "" {
|
|
templateType = domain.WorkflowTypeBatch
|
|
}
|
|
item := domain.TemplateRecord{
|
|
ID: domain.NewID("template"),
|
|
Name: input.Name,
|
|
Description: input.Description,
|
|
Type: templateType,
|
|
MaxConcurrentRuns: input.MaxConcurrentRuns,
|
|
NodeTimeoutSeconds: input.NodeTimeoutSeconds,
|
|
RunTimeoutSeconds: input.RunTimeoutSeconds,
|
|
MaxRetryAttempts: input.MaxRetryAttempts,
|
|
RetryBackoffSeconds: input.RetryBackoffSeconds,
|
|
Schedule: clone(input.Schedule),
|
|
Nodes: clone(input.Nodes),
|
|
Edges: clone(input.Edges),
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
store.templates[item.ID] = clone(item)
|
|
cloned := clone(item)
|
|
return &cloned, nil
|
|
}
|
|
|
|
func (store *MemoryStore) DeleteTemplate(_ context.Context, id string) (bool, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
if _, ok := store.templates[id]; !ok {
|
|
return false, nil
|
|
}
|
|
delete(store.templates, id)
|
|
return true, nil
|
|
}
|
|
|
|
func (store *MemoryStore) UpsertTemplate(_ context.Context, item domain.TemplateRecord) error {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
store.templates[item.ID] = clone(item)
|
|
return nil
|
|
}
|
|
|
|
func (store *MemoryStore) ListRuns(_ context.Context, status string) ([]domain.RunRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
items := make([]domain.RunRecord, 0)
|
|
for _, run := range store.runs {
|
|
if status == "" || string(run.Status) == status {
|
|
items = append(items, clone(run))
|
|
}
|
|
}
|
|
sortRuns(items)
|
|
return items, nil
|
|
}
|
|
|
|
func (store *MemoryStore) GetRun(_ context.Context, id string) (*domain.RunRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
run, ok := store.runs[id]
|
|
if !ok {
|
|
return nil, nil
|
|
}
|
|
cloned := clone(run)
|
|
return &cloned, nil
|
|
}
|
|
|
|
func (store *MemoryStore) CreateRun(_ context.Context, workflowID string, trigger domain.RunTrigger) (*domain.RunRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
workflow, ok := store.workflows[workflowID]
|
|
if !ok {
|
|
return nil, fmt.Errorf("workflow %s not found", workflowID)
|
|
}
|
|
if workflow.Status == domain.WorkflowStatusCompleted && trigger != domain.RunTriggerScheduled {
|
|
return nil, ErrWorkflowAlreadyCompleted
|
|
}
|
|
project, ok := store.projects[workflow.ProjectID]
|
|
if !ok {
|
|
return nil, fmt.Errorf("project %s not found", workflow.ProjectID)
|
|
}
|
|
|
|
now := nowISO()
|
|
run := domain.RunRecord{
|
|
ID: domain.NewID("run"),
|
|
WorkflowID: workflow.ID,
|
|
WorkflowName: workflow.Name,
|
|
ProjectID: project.ID,
|
|
ProjectName: project.Name,
|
|
Trigger: trigger,
|
|
Attempt: 1,
|
|
AvailableAt: now,
|
|
Status: domain.RunStatusQueued,
|
|
NodeExecutions: []domain.NodeExecutionRecord{},
|
|
Logs: []domain.LogEntryRecord{},
|
|
ResourceSeries: []domain.ResourceSample{},
|
|
Artifacts: []domain.ExecutionArtifact{},
|
|
K8sRefs: []domain.K8sRef{},
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
store.runs[run.ID] = clone(run)
|
|
|
|
workflow.LastRunID = run.ID
|
|
workflow.LastRunAt = now
|
|
workflow.Status = domain.WorkflowStatusRunning
|
|
workflow.UpdatedAt = now
|
|
store.workflows[workflow.ID] = workflow
|
|
|
|
cloned := clone(run)
|
|
return &cloned, nil
|
|
}
|
|
|
|
func (store *MemoryStore) ClaimNextQueuedRun(_ context.Context) (*domain.RunRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
var selected *domain.RunRecord
|
|
now := time.Now().UTC()
|
|
for _, run := range store.runs {
|
|
if run.Status != domain.RunStatusQueued {
|
|
continue
|
|
}
|
|
candidate := clone(run)
|
|
if !runIsAvailable(&candidate, now) {
|
|
continue
|
|
}
|
|
if selected == nil || candidate.CreatedAt < selected.CreatedAt {
|
|
selected = &candidate
|
|
}
|
|
}
|
|
if selected == nil {
|
|
return nil, nil
|
|
}
|
|
selected.Status = domain.RunStatusRunning
|
|
selected.StartedAt = nowISO()
|
|
selected.UpdatedAt = nowISO()
|
|
computeRunDuration(selected)
|
|
store.runs[selected.ID] = clone(*selected)
|
|
cloned := clone(*selected)
|
|
return &cloned, nil
|
|
}
|
|
|
|
func (store *MemoryStore) ClaimQueuedRun(_ context.Context, runID string) (*domain.RunRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
run, ok := store.runs[runID]
|
|
if !ok || run.Status != domain.RunStatusQueued {
|
|
return nil, nil
|
|
}
|
|
if !runIsAvailable(&run, time.Now().UTC()) {
|
|
return nil, nil
|
|
}
|
|
run.Status = domain.RunStatusRunning
|
|
run.StartedAt = nowISO()
|
|
run.UpdatedAt = nowISO()
|
|
computeRunDuration(&run)
|
|
store.runs[run.ID] = clone(run)
|
|
cloned := clone(run)
|
|
return &cloned, nil
|
|
}
|
|
|
|
func (store *MemoryStore) UpsertRun(_ context.Context, run domain.RunRecord) error {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
computeRunDuration(&run)
|
|
store.runs[run.ID] = clone(run)
|
|
return nil
|
|
}
|
|
|
|
func (store *MemoryStore) ListAuditTasks(_ context.Context, status string) ([]domain.AuditTaskRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
items := make([]domain.AuditTaskRecord, 0)
|
|
for _, task := range store.auditTasks {
|
|
if status == "" || status == "all" || string(task.Status) == status {
|
|
items = append(items, clone(task))
|
|
}
|
|
}
|
|
sortAuditTasks(items)
|
|
return items, nil
|
|
}
|
|
|
|
func (store *MemoryStore) GetAuditTask(_ context.Context, id string) (*domain.AuditTaskRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
task, ok := store.auditTasks[id]
|
|
if !ok {
|
|
return nil, nil
|
|
}
|
|
cloned := clone(task)
|
|
return &cloned, nil
|
|
}
|
|
|
|
func (store *MemoryStore) CreateAuditTask(_ context.Context, task domain.AuditTaskRecord) (*domain.AuditTaskRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
store.auditTasks[task.ID] = clone(task)
|
|
cloned := clone(task)
|
|
return &cloned, nil
|
|
}
|
|
|
|
func (store *MemoryStore) UpsertAuditTask(_ context.Context, task domain.AuditTaskRecord) error {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
store.auditTasks[task.ID] = clone(task)
|
|
return nil
|
|
}
|
|
|
|
func (store *MemoryStore) ListUsers(context.Context) ([]domain.UserRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
items := make([]domain.UserRecord, 0, len(store.users))
|
|
for _, item := range store.users {
|
|
items = append(items, clone(item))
|
|
}
|
|
sortUsers(items)
|
|
return items, nil
|
|
}
|
|
|
|
func (store *MemoryStore) GetUser(_ context.Context, id string) (*domain.UserRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
item, ok := store.users[id]
|
|
if !ok {
|
|
return nil, nil
|
|
}
|
|
cloned := clone(item)
|
|
return &cloned, nil
|
|
}
|
|
|
|
func (store *MemoryStore) CreateUser(_ context.Context, input domain.CreateUserInput) (*domain.UserRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
now := nowISO()
|
|
user := domain.UserRecord{
|
|
ID: domain.NewID("user"),
|
|
Name: input.Name,
|
|
Email: input.Email,
|
|
Role: input.Role,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
store.users[user.ID] = clone(user)
|
|
cloned := clone(user)
|
|
return &cloned, nil
|
|
}
|
|
|
|
func (store *MemoryStore) DeleteUser(_ context.Context, id string) (bool, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
if _, ok := store.users[id]; !ok {
|
|
return false, nil
|
|
}
|
|
delete(store.users, id)
|
|
return true, nil
|
|
}
|
|
|
|
func (store *MemoryStore) UpsertUser(_ context.Context, item domain.UserRecord) error {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
store.users[item.ID] = clone(item)
|
|
return nil
|
|
}
|
|
|
|
func (store *MemoryStore) GetSettings(_ context.Context) (*domain.SettingsRecord, error) {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
if store.settings == nil {
|
|
defaultValue := defaultSettings()
|
|
store.settings = &defaultValue
|
|
}
|
|
cloned := ensureSettingsDefaults(clone(*store.settings))
|
|
return &cloned, nil
|
|
}
|
|
|
|
func (store *MemoryStore) UpsertSettings(_ context.Context, item domain.SettingsRecord) error {
|
|
store.mu.Lock()
|
|
defer store.mu.Unlock()
|
|
cloned := ensureSettingsDefaults(clone(item))
|
|
store.settings = &cloned
|
|
return nil
|
|
}
|
|
|
|
func (store *MemoryStore) GetDashboardSummary(ctx context.Context) (domain.DashboardSummary, error) {
|
|
projects, err := store.ListProjects(ctx)
|
|
if err != nil {
|
|
return domain.DashboardSummary{}, err
|
|
}
|
|
operators, err := store.ListOperators(ctx)
|
|
if err != nil {
|
|
return domain.DashboardSummary{}, err
|
|
}
|
|
runs, err := store.ListRuns(ctx, "")
|
|
if err != nil {
|
|
return domain.DashboardSummary{}, err
|
|
}
|
|
auditTasks, err := store.ListAuditTasks(ctx, "all")
|
|
if err != nil {
|
|
return domain.DashboardSummary{}, err
|
|
}
|
|
|
|
return buildDashboardSummary(projects, operators, runs, auditTasks), nil
|
|
}
|
|
|
|
func buildDashboardSummary(
|
|
projects []domain.ProjectRecord,
|
|
operators []domain.OperatorRecord,
|
|
runs []domain.RunRecord,
|
|
auditTasks []domain.AuditTaskRecord,
|
|
) domain.DashboardSummary {
|
|
completedRuns := make([]domain.RunRecord, 0)
|
|
failedRuns := make([]domain.RunRecord, 0)
|
|
runningRuns := make([]domain.RunRecord, 0)
|
|
for _, run := range runs {
|
|
switch run.Status {
|
|
case domain.RunStatusCompleted:
|
|
completedRuns = append(completedRuns, run)
|
|
case domain.RunStatusFailed:
|
|
failedRuns = append(failedRuns, run)
|
|
case domain.RunStatusRunning:
|
|
runningRuns = append(runningRuns, run)
|
|
}
|
|
}
|
|
|
|
var durations []int64
|
|
for _, run := range completedRuns {
|
|
if run.DurationMS > 0 {
|
|
durations = append(durations, run.DurationMS)
|
|
}
|
|
}
|
|
var average int64
|
|
if len(durations) > 0 {
|
|
var total int64
|
|
for _, duration := range durations {
|
|
total += duration
|
|
}
|
|
average = total / int64(len(durations))
|
|
}
|
|
|
|
var summary domain.DashboardSummary
|
|
for _, project := range projects {
|
|
if project.Status == "active" {
|
|
summary.Projects.Active++
|
|
}
|
|
if project.Status == "archived" {
|
|
summary.Projects.Archived++
|
|
}
|
|
}
|
|
summary.Operators.Total = len(operators)
|
|
for _, item := range operators {
|
|
if item.Type == "custom" {
|
|
summary.Operators.Custom++
|
|
}
|
|
}
|
|
totalFinished := len(completedRuns) + len(failedRuns)
|
|
summary.Jobs.Today = len(runs)
|
|
if totalFinished == 0 {
|
|
summary.Jobs.SuccessRate = 100
|
|
} else {
|
|
summary.Jobs.SuccessRate = float64(len(completedRuns)) * 100 / float64(totalFinished)
|
|
}
|
|
summary.Jobs.Running = len(runningRuns)
|
|
summary.Jobs.Failed = len(failedRuns)
|
|
summary.Jobs.AverageDurationMS = average
|
|
for _, task := range auditTasks {
|
|
if task.Status == domain.AuditStatusPending {
|
|
summary.Audits.Pending++
|
|
}
|
|
}
|
|
return summary
|
|
}
|
|
|
|
func (store *MemoryStore) ListStorageBuckets(ctx context.Context, sourcePath string) ([]string, error) {
|
|
return listBucketsFromSourcePath(sourcePath)
|
|
}
|
|
|
|
func (store *MemoryStore) ListStorageObjects(ctx context.Context, sourcePath string, bucket string, prefix string) ([]string, error) {
|
|
return listObjectsFromSourcePath(sourcePath, bucket, prefix)
|
|
}
|
|
|
|
func MergeSettings(current domain.SettingsRecord, patch domain.SettingsRecord) domain.SettingsRecord {
|
|
merged := current
|
|
if patch.K8s.Namespace != "" {
|
|
merged.K8s.Namespace = patch.K8s.Namespace
|
|
}
|
|
if patch.K8s.Endpoint != "" {
|
|
merged.K8s.Endpoint = patch.K8s.Endpoint
|
|
}
|
|
if patch.K8s.Kubeconfig != "" {
|
|
merged.K8s.Kubeconfig = patch.K8s.Kubeconfig
|
|
}
|
|
if patch.K8s.Enabled != current.K8s.Enabled {
|
|
merged.K8s.Enabled = patch.K8s.Enabled
|
|
}
|
|
if patch.Worker.PollIntervalMS > 0 {
|
|
merged.Worker.PollIntervalMS = patch.Worker.PollIntervalMS
|
|
}
|
|
if patch.Worker.MaxConcurrentRuns > 0 {
|
|
merged.Worker.MaxConcurrentRuns = patch.Worker.MaxConcurrentRuns
|
|
}
|
|
if patch.Storage.Endpoint != "" {
|
|
merged.Storage.Endpoint = patch.Storage.Endpoint
|
|
}
|
|
if len(patch.Storage.Buckets) > 0 {
|
|
merged.Storage.Buckets = clone(patch.Storage.Buckets)
|
|
}
|
|
if patch.Defaults.CPURequest != "" {
|
|
merged.Defaults.CPURequest = patch.Defaults.CPURequest
|
|
}
|
|
if patch.Defaults.CPULimit != "" {
|
|
merged.Defaults.CPULimit = patch.Defaults.CPULimit
|
|
}
|
|
if patch.Defaults.MemoryRequest != "" {
|
|
merged.Defaults.MemoryRequest = patch.Defaults.MemoryRequest
|
|
}
|
|
if patch.Defaults.MemoryLimit != "" {
|
|
merged.Defaults.MemoryLimit = patch.Defaults.MemoryLimit
|
|
}
|
|
if patch.Timezone != "" {
|
|
merged.Timezone = patch.Timezone
|
|
}
|
|
merged.UpdatedAt = nowISO()
|
|
return merged
|
|
}
|
|
|
|
func CopyRunWithUpdate(run domain.RunRecord) domain.RunRecord {
|
|
copy := clone(run)
|
|
computeRunDuration(©)
|
|
copy.UpdatedAt = nowISO()
|
|
return copy
|
|
}
|
|
|
|
func NormalizeStatusFilter(status string) string {
|
|
return strings.TrimSpace(status)
|
|
}
|