prepare api for oc3-frontend

.gitignore

@@ -13,4 +13,5 @@
 !Makefile
 .idea
 core/version/version.go
-.trash
+.trash
+.claude

Dockerfile

@@ -21,7 +21,9 @@ RUN echo "Cache busted at $(date): oc3 version: $(./dist/oc3 version)"
 FROM alpine:3.22.4
 ARG BUILDTIME
 
-RUN apk add --no-cache bash
+# git keeps the history of the form definitions (forms revisions) and of
+# the sysreports.
+RUN apk add --no-cache bash git
 
 COPY --from=builder /opt/oc3/dist/oc3 /usr/bin/oc3
 

README.md

@@ -76,6 +76,7 @@ worker.fast:
     - "instance_action"
     - "node_disk"
     - "object_config"
+    - "san_switch"
     - "system"
 ```
 

cachekeys/main.go

@@ -20,6 +20,10 @@ const (
 	FeedNodeDiskQ        = "oc3:q:feed_node_disk"
 	FeedNodeDiskPendingH = "oc3:h:feed_node_disk_pending"
 
+	FeedSANSwitchH        = "oc3:h:feed_san_switch"
+	FeedSANSwitchQ        = "oc3:q:feed_san_switch"
+	FeedSANSwitchPendingH = "oc3:h:feed_san_switch_pending"
+
 	FeedObjectConfigForClusterIDH = "oc3:h:feed_object_config_for_cluster_id"
 
 	FeedObjectConfigH        = "oc3:h:feed_object_config"

cdb/db_action_queue.go

@@ -70,13 +70,19 @@ func (oDb *DB) UpdateActionStatus(ctx context.Context, id int64, status string,
 	return nil
 }
 
+// actionQueueJoins makes the "nodes." and "services." props selectable: a queued
+// action carries only the ids, and a node action names no service (empty svc_id),
+// hence the LEFT JOINs. Same approach as logJoins.
+const actionQueueJoins = " LEFT JOIN nodes ON nodes.node_id = action_queue.node_id" +
+	" LEFT JOIN services ON services.svc_id = action_queue.svc_id"
+
 func buildActionsQuery(p ListParams, idCond string, idArgs []any) (string, []any, error) {
 	if len(p.SelectExprs) == 0 {
 		return "", nil, fmt.Errorf("buildActionsQuery: no columns selected")
 	}
 
 	sb := &strings.Builder{}
-	fmt.Fprintf(sb, "SELECT %s\nFROM action_queue", strings.Join(p.SelectExprs, ", "))
+	fmt.Fprintf(sb, "SELECT %s\nFROM action_queue%s", strings.Join(p.SelectExprs, ", "), actionQueueJoins)
 
 	var conds []string
 	var args []any
@@ -92,7 +98,7 @@ func buildActionsQuery(p ListParams, idCond string, idArgs []any) (string, []any
 			conds = append(conds, "1=0")
 		} else {
 			conds = append(conds,
-				"node_id IN ("+
+				"action_queue.node_id IN ("+
 					"SELECT n.node_id FROM nodes n"+
 					" JOIN apps a ON n.app = a.app"+
 					" JOIN apps_responsibles ar ON ar.app_id = a.id"+
@@ -103,6 +109,12 @@ func buildActionsQuery(p ListParams, idCond string, idArgs []any) (string, []any
 		}
 	}
 
+	// Column filters of the request: the nodes and services joins are always in
+	// place here, so a filter on their names needs nothing more.
+	filterConds, filterArgs := p.FilterConditions()
+	conds = append(conds, filterConds...)
+	args = append(args, filterArgs...)
+
 	if len(conds) > 0 {
 		sb.WriteString("\nWHERE " + strings.Join(conds, " AND "))
 	}
@@ -147,3 +159,132 @@ func (oDb *DB) GetActionOne(ctx context.Context, id string, p ListParams) ([]map
 
 	return scanRowsToMaps(rows, p.Props, p.TypeHints)
 }
+
+// NodeActionTarget is what building an agent action command needs from a node.
+type NodeActionTarget struct {
+	NodeID     string
+	Nodename   string
+	OSName     string
+	ActionType string
+	Collector  string
+	ConnectTo  string
+}
+
+// NodeActionTargetByID returns the node fields the action queue entry is built from.
+func (oDb *DB) NodeActionTargetByID(ctx context.Context, nodeID string) (*NodeActionTarget, error) {
+	const query = "SELECT node_id, COALESCE(nodename, ''), COALESCE(os_name, ''), COALESCE(action_type, '')," +
+		" COALESCE(collector, ''), COALESCE(connect_to, '') FROM nodes WHERE node_id = ?"
+	var t NodeActionTarget
+	err := oDb.DB.QueryRowContext(ctx, query, nodeID).
+		Scan(&t.NodeID, &t.Nodename, &t.OSName, &t.ActionType, &t.Collector, &t.ConnectTo)
+	switch {
+	case errors.Is(err, sql.ErrNoRows):
+		return nil, nil
+	case err != nil:
+		return nil, fmt.Errorf("nodeActionTargetByID: %w", err)
+	}
+	return &t, nil
+}
+
+// NodeReachableAddress returns the address an action should connect to, mirroring
+// get_reachable_name() of the python collector: the explicit connect_to, else the
+// best routable address of the node, else its name.
+func (oDb *DB) NodeReachableAddress(ctx context.Context, t *NodeActionTarget) (string, error) {
+	if t.ConnectTo != "" {
+		return t.ConnectTo, nil
+	}
+	const query = "SELECT addr FROM v_nodenetworks WHERE node_id = ?" +
+		" AND mask IS NOT NULL AND mask != '' AND flag_deprecated = 0" +
+		" AND net_gateway IS NOT NULL AND net_gateway != '' AND net_gateway != '0.0.0.0'" +
+		" ORDER BY prio DESC, type LIMIT 1"
+	var addr string
+	err := oDb.DB.QueryRowContext(ctx, query, t.NodeID).Scan(&addr)
+	switch {
+	case errors.Is(err, sql.ErrNoRows):
+		return t.Nodename, nil
+	case err != nil:
+		return "", fmt.Errorf("nodeReachableAddress: %w", err)
+	}
+	return addr, nil
+}
+
+// EnqueueNodeAction posts a node action to the action queue and returns its id.
+func (oDb *DB) EnqueueNodeAction(ctx context.Context, nodeID, actionType, command, connectTo string, userID *int64) (int64, error) {
+	const query = "INSERT INTO action_queue (node_id, svc_id, action_type, command, user_id, connect_to)" +
+		" VALUES (?, '', ?, ?, ?, ?)"
+	res, err := oDb.ExecContext(ctx, query, nodeID, actionType, command, userID, connectTo)
+	if err != nil {
+		return 0, fmt.Errorf("enqueueNodeAction: %w", err)
+	}
+	id, err := res.LastInsertId()
+	if err != nil {
+		return 0, fmt.Errorf("enqueueNodeAction lastInsertId: %w", err)
+	}
+	oDb.SetChange("action_queue")
+	return id, nil
+}
+
+// ServiceLiveNode returns a node of the service seen alive in the last 15 minutes,
+// as get_svc_live_nodes() does, plus the agent version an action command needs.
+func (oDb *DB) ServiceLiveNode(ctx context.Context, svcID string) (*NodeActionTarget, string, error) {
+	const query = "SELECT nodes.node_id, COALESCE(nodes.nodename, ''), COALESCE(nodes.os_name, '')," +
+		" COALESCE(nodes.action_type, ''), COALESCE(nodes.collector, ''), COALESCE(nodes.connect_to, '')," +
+		" COALESCE(nodes.version, '')" +
+		" FROM svcmon JOIN nodes ON nodes.node_id = svcmon.node_id" +
+		" WHERE svcmon.svc_id = ? AND nodes.last_comm > NOW() - INTERVAL 15 MINUTE" +
+		" ORDER BY nodes.nodename LIMIT 1"
+	var t NodeActionTarget
+	var version string
+	err := oDb.DB.QueryRowContext(ctx, query, svcID).
+		Scan(&t.NodeID, &t.Nodename, &t.OSName, &t.ActionType, &t.Collector, &t.ConnectTo, &version)
+	switch {
+	case errors.Is(err, sql.ErrNoRows):
+		return nil, "", nil
+	case err != nil:
+		return nil, "", fmt.Errorf("serviceLiveNode: %w", err)
+	}
+	return &t, version, nil
+}
+
+// NodeAgentVersion returns the agent version reported by a node, empty when unknown.
+func (oDb *DB) NodeAgentVersion(ctx context.Context, nodeID string) (string, error) {
+	var version string
+	err := oDb.DB.QueryRowContext(ctx, "SELECT COALESCE(version, '') FROM nodes WHERE node_id = ?", nodeID).Scan(&version)
+	switch {
+	case errors.Is(err, sql.ErrNoRows):
+		return "", nil
+	case err != nil:
+		return "", fmt.Errorf("nodeAgentVersion: %w", err)
+	}
+	return version, nil
+}
+
+// HasServiceInstance reports whether the service runs on that node.
+func (oDb *DB) HasServiceInstance(ctx context.Context, svcID, nodeID string) (bool, error) {
+	var one int
+	err := oDb.DB.QueryRowContext(ctx,
+		"SELECT 1 FROM svcmon WHERE svc_id = ? AND node_id = ? LIMIT 1", svcID, nodeID).Scan(&one)
+	switch {
+	case errors.Is(err, sql.ErrNoRows):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("hasServiceInstance: %w", err)
+	}
+	return true, nil
+}
+
+// EnqueueServiceAction posts a service action to the action queue and returns its id.
+func (oDb *DB) EnqueueServiceAction(ctx context.Context, nodeID, svcID, actionType, command, connectTo string, userID *int64) (int64, error) {
+	const query = "INSERT INTO action_queue (node_id, svc_id, action_type, command, user_id, connect_to)" +
+		" VALUES (?, ?, ?, ?, ?, ?)"
+	res, err := oDb.ExecContext(ctx, query, nodeID, svcID, actionType, command, userID, connectTo)
+	if err != nil {
+		return 0, fmt.Errorf("enqueueServiceAction: %w", err)
+	}
+	id, err := res.LastInsertId()
+	if err != nil {
+		return 0, fmt.Errorf("enqueueServiceAction lastInsertId: %w", err)
+	}
+	oDb.SetChange("action_queue")
+	return id, nil
+}

cdb/db_apps.go

@@ -62,7 +62,7 @@ func scanApps(rows *sql.Rows) ([]App, error) {
 	return apps, nil
 }
 
-func buildAppsQuery(groups []string, isManager bool, selectExprs []string) (string, []any, error) {
+func buildAppsQuery(groups []string, isManager bool, selectExprs []string, filters []ColumnFilter) (string, []any, error) {
 	q := From(schema.TApps).
 		Distinct().
 		RawSelect(selectExprs...)
@@ -75,6 +75,9 @@ func buildAppsQuery(groups []string, isManager bool, selectExprs []string) (stri
 		q = q.Where(schema.AppsID, ">", 0)
 	}
 
+	// Column filters of the request, ANDed with the access control above.
+	q = q.WhereFilters(filters)
+
 	query, args, err := q.Build()
 	if err != nil {
 		return "", nil, fmt.Errorf("buildAppsQuery: %w", err)
@@ -87,11 +90,11 @@ func buildAppsQueryAll(groups []string, isManager bool) (string, []any, error) {
 		"apps.id", "apps.app",
 		"COALESCE(apps.updated, '')", "COALESCE(apps.app_domain, '')",
 		"COALESCE(apps.app_team_ops, '')", "COALESCE(apps.description, '')",
-	})
+	}, nil)
 }
 
 func (oDb *DB) GetApps(ctx context.Context, p ListParams) ([]map[string]any, error) {
-	query, args, err := buildAppsQuery(p.Groups, p.IsManager, p.SelectExprs)
+	query, args, err := buildAppsQuery(p.Groups, p.IsManager, p.SelectExprs, p.Filters)
 	if err != nil {
 		return nil, err
 	}
@@ -366,7 +369,7 @@ func (oDb *DB) GetAppNodes(ctx context.Context, appIDOrName string, p ListParams
 		}
 	}
 
-	query, args, err := buildNodesQuery(p.Groups, p.IsManager, p.SelectExprs)
+	query, args, err := buildNodesQuery(p.Groups, p.IsManager, p.SelectExprs, p.Filters)
 	if err != nil {
 		return nil, err
 	}
@@ -407,7 +410,7 @@ func (oDb *DB) GetAppServices(ctx context.Context, appIDOrName string, p ListPar
 		}
 	}
 
-	query, args, err := buildServicesQuery(p.Groups, p.IsManager, p.SelectExprs)
+	query, args, err := buildServicesQuery(p.Groups, p.IsManager, p.SelectExprs, p.Filters)
 	if err != nil {
 		return nil, err
 	}

cdb/db_auth_group.go

@@ -26,6 +26,11 @@ func (oDb *DB) GetGroups(ctx context.Context, p ListParams) ([]map[string]any, e
 			args = append(args, stringsToAny(cleanG)...)
 		}
 	}
+	filterConds, filterArgs := p.FilterConditions()
+	for _, cond := range filterConds {
+		query += " AND " + cond
+	}
+	args = append(args, filterArgs...)
 	if gb := p.GroupByClause(""); gb != "" {
 		query += " " + gb
 	}