feature: pull in work from Aaron's pr related factory globus and metadata (#1603)

JoshuaSBrown · AronPerez · JoshuaSBrown · commit 2b9e7b7fb789 · 2025-10-09T10:47:50.000-04:00
Co-authored-by: Aaron Perez &lt;perezam@ornl.gov&gt;
diff --git a/core/database/foxx/api/repository/factory.js b/core/database/foxx/api/repository/factory.js
@@ -0,0 +1,167 @@
+"use strict";
+
+const {
+    RepositoryType,
+    Result,
+    createRepository,
+    createRepositoryData,
+    createGlobusConfig,
+} = require("./types");
+const { validateGlobusConfig, validateMetadataConfig } = require("./validation");
+const globusRepo = require("./globus");
+const metadataRepo = require("./metadata");
+const g_lib = require("../support");
+
+/**
+ * Repository factory using Rust-compatible patterns
+ * Uses switch/case for type-based polymorphism instead of inheritance
+ */
+
+/**
+ * Create repository based on type (similar to Rust match expression)
+ * Rust's match expression provides exhaustive pattern matching
+ * JavaScript's switch is used here to emulate this pattern
+ * @param {object} config - Repository configuration object
+ * @param {string} config.id - Repository ID
+ * @param {string} config.type - Repository type (from RepositoryType enum)
+ * @param {string} config.title - Repository title
+ * @param {string} [config.desc] - Repository description
+ * @param {number} config.capacity - Storage capacity in bytes
+ * @param {string[]} config.admins - Array of admin user IDs
+ * @param {string} [config.endpoint] - Globus endpoint (required for GLOBUS type)
+ * @param {string} [config.path] - File path (required for GLOBUS type)
+ * @param {string} [config.pub_key] - Public key for ZeroMQ CURVE authentication (required for GLOBUS type)
+ * @param {string} [config.address] - Network address (required for GLOBUS type)
+ * @param {string} [config.exp_path] - Export path (optional for GLOBUS type)
+ * @returns {{ok: boolean, error: *}|{ok: boolean, value: *}} Result object containing repository or error
+ * @see https://doc.rust-lang.org/book/ch06-02-match.html
+ */
+const createRepositoryByType = (config) => {
+    const missingFields = [];
+    if (!config.id) missingFields.push("id");
+    if (!config.type) missingFields.push("type");
+    if (!config.title) missingFields.push("title");
+    if (!config.capacity) missingFields.push("capacity");
+    if (!config.admins) missingFields.push("admins");
+
+    if (missingFields.length > 0) {
+        return Result.err({
+            code: g_lib.ERR_INVALID_PARAM,
+            message: `Missing required repository fields: ${missingFields.join(", ")}`,
+        });
+    }
+    /**
+     * Type-based creation using switch (Rust match pattern)
+     * Each case is like a match arm in Rust, handling a specific variant
+     * @see https://doc.rust-lang.org/book/ch18-03-pattern-syntax.html
+     */
+    switch (config.type) {
+        case RepositoryType.GLOBUS: {
+            const validationResult = validateGlobusConfig(config);
+            if (!validationResult.ok) {
+                return validationResult;
+            }
+
+            const globusConfig = createGlobusConfig({
+                endpoint: config.endpoint,
+                path: config.path,
+                pub_key: config.pub_key,
+                address: config.address,
+                exp_path: config.exp_path,
+            });
+
+            const repoData = createRepositoryData({
+                id: config.id,
+                type: config.type,
+                title: config.title,
+                desc: config.desc,
+                capacity: config.capacity,
+                admins: config.admins,
+                typeSpecific: globusConfig,
+            });
+
+            return Result.ok(createRepository(RepositoryType.GLOBUS, repoData));
+        }
+
+        case RepositoryType.METADATA_ONLY: {
+            const validationResult = validateMetadataConfig(config);
+            if (!validationResult.ok) {
+                return validationResult;
+            }
+
+            const repoData = createRepositoryData({
+                id: config.id,
+                type: config.type,
+                title: config.title,
+                desc: config.desc,
+                capacity: config.capacity,
+                admins: config.admins,
+            });
+
+            return Result.ok(createRepository(RepositoryType.METADATA_ONLY, repoData));
+        }
+
+        default:
+            /**
+             * In Rust, match must be exhaustive - all cases must be handled
+             * The default case ensures we handle unknown variants
+             * @see https://doc.rust-lang.org/book/ch06-02-match.html#matching-with-option-t
+             */
+            return Result.err({
+                code: g_lib.ERR_INVALID_PARAM,
+                message: `Unknown repository type: ${config.type}`,
+            });
+    }
+};
+
+/**
+ * Get repository implementation based on type
+ * This emulates Rust's trait object dynamic dispatch
+ * @param {string} repositoryType - Repository type from RepositoryType enum
+ * @returns {object|null} Repository implementation object or null if not found
+ * @see https://doc.rust-lang.org/book/ch17-02-trait-objects.html
+ */
+const getRepositoryImplementation = (repositoryType) => {
+    switch (repositoryType) {
+        case RepositoryType.GLOBUS:
+            return globusRepo;
+        case RepositoryType.METADATA_ONLY:
+            return metadataRepo;
+        default:
+            return null;
+    }
+};
+
+/**
+ * Execute operation on repository using dynamic dispatch
+ * This pattern emulates Rust's trait method dispatch
+ * @param {object} repository - Repository object with type and data fields
+ * @param {string} operation - Operation name to execute
+ * @param {...*} args - Additional arguments to pass to the operation
+ * @returns {{ok: boolean, error: *}|*} Result of the operation
+ * @see https://doc.rust-lang.org/book/ch17-02-trait-objects.html#trait-objects-perform-dynamic-dispatch
+ */
+const executeRepositoryOperation = (repository, operation, ...args) => {
+    const impl = getRepositoryImplementation(repository.type);
+    if (!impl) {
+        return Result.err({
+            code: g_lib.ERR_INVALID_PARAM,
+            message: `No implementation for repository type: ${repository.type}`,
+        });
+    }
+
+    if (typeof impl[operation] !== "function") {
+        return Result.err({
+            code: g_lib.ERR_NOT_IMPLEMENTED,
+            message: `Operation '${operation}' not implemented for type: ${repository.type}`,
+        });
+    }
+
+    return impl[operation](repository.data, ...args);
+};
+
+module.exports = {
+    createRepositoryByType,
+    getRepositoryImplementation,
+    executeRepositoryOperation,
+};
diff --git a/core/database/foxx/api/repository/globus.js b/core/database/foxx/api/repository/globus.js
@@ -0,0 +1,145 @@
+"use strict";
+
+const { Result, ExecutionMethod, createAllocationResult } = require("./types");
+const { validateAllocationParams } = require("./validation");
+const g_tasks = require("../tasks");
+const g_lib = require("../support");
+
+/**
+ * @module globus
+ * Globus repository implementation
+ * Implements repository operations specific to Globus-backed repositories
+ */
+
+/**
+ * This module acts like a trait implementation for the Globus repository type
+ * Each function implements a trait method for this specific type
+ * @see https://doc.rust-lang.org/book/ch10-02-traits.html#implementing-a-trait-on-a-type
+ */
+
+// Validate Globus repository (already validated in factory)
+const validate = (repoData) => {
+    return Result.ok(true);
+};
+
+// Create allocation in Globus repository (async via task)
+const createAllocation = (repoData, params) => {
+    // Validate allocation parameters
+    const validationResult = validateAllocationParams(params);
+    if (!validationResult.ok) {
+        return validationResult;
+    }
+
+    try {
+        // Create task for async Globus allocation
+        // Note: taskInitAllocCreate expects (client, repo_id, subject_id, data_limit, rec_limit)
+        // For now, using a system client since this is called from the new repository pattern
+        const systemClient = { _id: "system", is_admin: true };
+
+        const taskResult = g_tasks.taskInitAllocCreate(
+            systemClient,
+            repoData._id,
+            params.subject,
+            params.size || params.data_limit, // Handle both parameter names
+            params.rec_limit || 1000000, // Default to 1M records if not specified
+        );
+
+        // The taskResult contains { task: taskObject }
+        // We need to return the task properties that the web service expects
+        const task = taskResult.task;
+
+        // Return a structure that matches what the original API expects
+        // The web service needs properties like state, task_id, status, etc.
+        return Result.ok({
+            id: `alloc/${Date.now()}`, // Temporary allocation ID format
+            repo_id: repoData._id,
+            subject: params.subject,
+            task_id: task._id,
+            status: task.status,
+            state: task.state, // Important: include the state property
+            queue_time: task.ct || Date.now(),
+        });
+    } catch (e) {
+        // Handle both Error objects and array-style errors
+        const errorMessage = e.message || (Array.isArray(e) && e[1]) || String(e);
+        return Result.err({
+            code: g_lib.ERR_INTERNAL_FAULT,
+            message: `Failed to create allocation task: ${errorMessage}`,
+        });
+    }
+};
+
+// Delete allocation from Globus repository (async via task)
+const deleteAllocation = (repoData, subjectId) => {
+    if (!subjectId || typeof subjectId !== "string") {
+        return Result.err({
+            code: g_lib.ERR_INVALID_PARAM,
+            message: "Subject ID is required for allocation deletion",
+        });
+    }
+
+    try {
+        // Create task for async Globus allocation deletion
+        const task = g_tasks.repoAllocationDeleteTask({
+            repo_id: repoData._id,
+            subject: subjectId,
+        });
+
+        return Result.ok(
+            createAllocationResult(ExecutionMethod.TASK, {
+                task_id: task.task_id,
+                status: task.status,
+                queue_time: task.queue_time,
+            }),
+        );
+    } catch (e) {
+        return Result.err({
+            code: g_lib.ERR_INTERNAL_FAULT,
+            message: `Failed to create deletion task: ${e.message}`,
+        });
+    }
+};
+
+// Globus repositories support data operations
+const supportsDataOperations = (repoData) => {
+    return Result.ok(true);
+};
+
+// Get capacity information for Globus repository
+const getCapacityInfo = (repoData) => {
+    try {
+        // For Globus repos, we'd typically query the actual filesystem
+        // For now, return the configured capacity
+        return Result.ok({
+            total_capacity: repoData.capacity,
+            used_capacity: 0, // Would be populated from actual usage
+            available_capacity: repoData.capacity,
+            supports_quotas: true,
+        });
+    } catch (e) {
+        return Result.err({
+            code: g_lib.ERR_INTERNAL_FAULT,
+            message: `Failed to get capacity info: ${e.message}`,
+        });
+    }
+};
+
+/**
+ * Export all operations (trait implementation)
+ * These exports define the trait implementation for Globus repository type
+ * allowing polymorphic behavior through dynamic dispatch
+ * @type {object}
+ * @property {function(object): {ok: boolean, value: boolean}} validate - Validate Globus repository
+ * @property {function(object, object): {ok: boolean, error?: *, value?: *}} createAllocation - Create allocation in Globus repository
+ * @property {function(object, string): {ok: boolean, error?: *, value?: *}} deleteAllocation - Delete allocation from Globus repository
+ * @property {function(object): {ok: boolean, value: boolean}} supportsDataOperations - Check if supports data operations
+ * @property {function(object): {ok: boolean, error?: *, value?: *}} getCapacityInfo - Get capacity information
+ * @see https://doc.rust-lang.org/book/ch17-02-trait-objects.html
+ */
+module.exports = {
+    validate,
+    createAllocation,
+    deleteAllocation,
+    supportsDataOperations,
+    getCapacityInfo,
+};
diff --git a/core/database/foxx/api/repository/metadata.js b/core/database/foxx/api/repository/metadata.js
