@gcnv/gcnv-mcp-server 1.0.3

package/build/tools/handlers/snapshot-handler.js

@@ -0,0 +1,320 @@
+import { NetAppClientFactory } from '../../utils/netapp-client-factory.js';
+import { logger } from '../../logger.js';
+const log = logger.child({ module: 'snapshot-handler' });
+// Helper to format snapshot data for responses
+function formatSnapshotData(snapshot) {
+    const result = {};
+    if (!snapshot)
+        return result;
+    if (snapshot.name) {
+        // Extract snapshotId from name (last part after last slash)
+        const nameParts = snapshot.name.split('/');
+        result.name = snapshot.name;
+        result.snapshotId = nameParts[nameParts.length - 1];
+        // Extract volumeId from name
+        const volumeMatch = snapshot.name.match(/\/volumes\/([^/]+)\/snapshots\//);
+        if (volumeMatch && volumeMatch[1]) {
+            result.volumeId = volumeMatch[1];
+        }
+    }
+    // Copy basic properties
+    if (snapshot.state)
+        result.state = snapshot.state;
+    // Format timestamps if they exist
+    if (snapshot.createTime) {
+        result.createTime = new Date(snapshot.createTime.seconds * 1000);
+    }
+    // Copy optional properties
+    if (snapshot.description)
+        result.description = snapshot.description;
+    if (snapshot.labels)
+        result.labels = snapshot.labels;
+    return result;
+}
+// Create Snapshot Handler
+export const createSnapshotHandler = async (args) => {
+    try {
+        const { projectId, location, volumeId, snapshotId, description, labels } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the parent path for the snapshot
+        const parent = `projects/${projectId}/locations/${location}/volumes/${volumeId}`;
+        // Create the snapshot request
+        const request = {
+            parent,
+            snapshotId,
+            snapshot: {
+                description,
+                labels,
+            },
+        };
+        log.info({ request }, 'Create Snapshot request');
+        // Call the API to create a snapshot
+        const [operation] = await netAppClient.createSnapshot(request);
+        log.info({ operation }, 'Create Snapshot operation');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        name: `projects/${projectId}/locations/${location}/volumes/${volumeId}/snapshots/${snapshotId}`,
+                        operation: operation,
+                    }, null, 2),
+                },
+            ],
+            structuredContent: {
+                name: `projects/${projectId}/locations/${location}/volumes/${volumeId}/snapshots/${snapshotId}`,
+                operationId: operation.name || '',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error creating snapshot');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error creating snapshot: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// Delete Snapshot Handler
+export const deleteSnapshotHandler = async (args) => {
+    try {
+        const { projectId, location, volumeId, snapshotId } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the name for the snapshot
+        const name = `projects/${projectId}/locations/${location}/volumes/${volumeId}/snapshots/${snapshotId}`;
+        // Call the API to delete the snapshot
+        const request = { name };
+        log.info({ request }, 'Delete Snapshot request');
+        const [operation] = await netAppClient.deleteSnapshot(request);
+        log.info({ operation }, 'Delete Snapshot operation');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Snapshot '${snapshotId}' deletion operation started.`,
+                },
+            ],
+            structuredContent: {
+                success: true,
+                operationId: operation.name || '',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error deleting snapshot');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error deleting snapshot: ${error.message || 'Unknown error'}`,
+                },
+            ],
+            structuredContent: {
+                success: false,
+            },
+        };
+    }
+};
+// Get Snapshot Handler
+export const getSnapshotHandler = async (args) => {
+    try {
+        const { projectId, location, volumeId, snapshotId } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the name for the snapshot
+        const name = `projects/${projectId}/locations/${location}/volumes/${volumeId}/snapshots/${snapshotId}`;
+        // Call the API to get the snapshot
+        log.info({ name }, 'Get Snapshot request');
+        const [snapshot] = await netAppClient.getSnapshot({ name });
+        log.info({ snapshot }, 'Get Snapshot response');
+        // Format the snapshot data
+        const formattedSnapshot = formatSnapshotData(snapshot);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(formattedSnapshot, null, 2),
+                },
+            ],
+            structuredContent: formattedSnapshot,
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error getting snapshot');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error getting snapshot: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// List Snapshots Handler
+export const listSnapshotsHandler = async (args) => {
+    try {
+        const { projectId, location, volumeId, filter, pageSize, pageToken } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the parent path
+        const parent = `projects/${projectId}/locations/${location}/volumes/${volumeId}`;
+        // Create the request object
+        const request = { parent };
+        if (filter)
+            request.filter = filter;
+        if (pageSize)
+            request.pageSize = pageSize;
+        if (pageToken)
+            request.pageToken = pageToken;
+        // Call the API to list snapshots
+        log.info({ request }, 'List Snapshots request');
+        const [snapshots, , nextPageToken] = await netAppClient.listSnapshots(request);
+        log.info({ snapshots, nextPageToken }, 'List Snapshots response');
+        const formattedSnapshots = snapshots.map(formatSnapshotData);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        snapshots: snapshots,
+                        nextPageToken: nextPageToken || '',
+                    }, null, 2),
+                },
+            ],
+            structuredContent: {
+                snapshots: formattedSnapshots,
+                nextPageToken: nextPageToken || '',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error listing snapshots');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error listing snapshots: ${error.message || 'Unknown error'}`,
+                },
+            ],
+            structuredContent: {
+                snapshots: [],
+                nextPageToken: '',
+            },
+        };
+    }
+};
+// Revert Volume to Snapshot Handler
+export const revertVolumeToSnapshotHandler = async (args) => {
+    try {
+        const { projectId, location, volumeId, snapshotId } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the name for the snapshot
+        const snapshot = `projects/${projectId}/locations/${location}/volumes/${volumeId}/snapshots/${snapshotId}`;
+        const volume = `projects/${projectId}/locations/${location}/volumes/${volumeId}`;
+        // Call the API to revert to snapshot
+        const request = {
+            name: volume,
+            snapshot,
+        };
+        log.info({ request }, 'Revert to Snapshot request');
+        const [operation] = await netAppClient.revertVolume(request);
+        log.info({ operation }, 'Revert to Snapshot operation');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Volume '${volumeId}' revert to snapshot '${snapshotId}' operation started.`,
+                },
+            ],
+            structuredContent: {
+                success: true,
+                operationId: operation.name || '',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error reverting to snapshot');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error reverting to snapshot: ${error.message || 'Unknown error'}`,
+                },
+            ],
+            structuredContent: {
+                success: false,
+            },
+        };
+    }
+};
+// Update Snapshot Handler
+export const updateSnapshotHandler = async (args) => {
+    try {
+        const { projectId, location, volumeId, snapshotId, description, labels } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the name for the snapshot
+        const name = `projects/${projectId}/locations/${location}/volumes/${volumeId}/snapshots/${snapshotId}`;
+        // Prepare the update mask based on provided fields
+        const updateMask = [];
+        const snapshot = { name };
+        if (description !== undefined) {
+            snapshot.description = description;
+            updateMask.push('description');
+        }
+        if (labels !== undefined) {
+            snapshot.labels = labels;
+            updateMask.push('labels');
+        }
+        // Call the API to update the snapshot
+        const request = {
+            snapshot,
+            updateMask: {
+                paths: updateMask,
+            },
+        };
+        log.info({ request }, 'Update Snapshot request');
+        const [operation] = await netAppClient.updateSnapshot(request);
+        log.info({ operation }, 'Update Snapshot operation');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        message: `Snapshot '${snapshotId}' update operation started`,
+                        operation: operation,
+                    }, null, 2),
+                },
+            ],
+            structuredContent: {
+                name: name,
+                operationId: operation.name || '',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error updating snapshot');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error updating snapshot: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};

package/build/tools/handlers/storage-pool-handler.js

@@ -0,0 +1,346 @@
+import { NetAppClientFactory } from '../../utils/netapp-client-factory.js';
+import { logger } from '../../logger.js';
+const log = logger.child({ module: 'storage-pool-handler' });
+// Create Storage Pool Handler
+export const createStoragePoolHandler = async (args) => {
+    try {
+        const { projectId, location, storagePoolId, capacityGib, serviceLevel, description, labels, network, activeDirectory, kmsConfig, encryptionType, ldapEnabled, psaRange, globalAccessAllowed, allowAutoTiering, } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the parent path for the storage pool
+        const parent = `projects/${projectId}/locations/${location}`;
+        // Build the storage pool payload with provided fields only
+        const storagePoolPayload = {
+            capacityGib,
+            serviceLevel,
+            description,
+            labels,
+            network,
+        };
+        if (activeDirectory)
+            storagePoolPayload.activeDirectory = activeDirectory;
+        if (kmsConfig)
+            storagePoolPayload.kmsConfig = kmsConfig;
+        if (encryptionType)
+            storagePoolPayload.encryptionType = encryptionType;
+        if (ldapEnabled !== undefined)
+            storagePoolPayload.ldapEnabled = ldapEnabled;
+        if (psaRange)
+            storagePoolPayload.psaRange = psaRange;
+        if (globalAccessAllowed !== undefined)
+            storagePoolPayload.globalAccessAllowed = globalAccessAllowed;
+        if (allowAutoTiering !== undefined)
+            storagePoolPayload.allowAutoTiering = allowAutoTiering;
+        // Create the storage pool request
+        const request = {
+            parent,
+            storagePoolId,
+            storagePool: storagePoolPayload,
+        };
+        log.info({ request }, 'Create Storage Pool request');
+        // Call the API to create a storage pool
+        const [operation] = await netAppClient.createStoragePool(request);
+        log.info({ operation }, 'Create Storage Pool operation');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        name: `projects/${projectId}/locations/${location}/storagePools/${storagePoolId}`,
+                        operation: operation,
+                    }, null, 2),
+                },
+            ],
+            structuredContent: {
+                name: `projects/${projectId}/locations/${location}/storagePools/${storagePoolId}`,
+                operationId: operation.name || '',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error creating storage pool');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error creating storage pool: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// Delete Storage Pool Handler
+export const deleteStoragePoolHandler = async (args) => {
+    try {
+        const { projectId, location, storagePoolId, force = false } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the name for the storage pool
+        const name = `projects/${projectId}/locations/${location}/storagePools/${storagePoolId}`;
+        // Call the API to delete the storage pool
+        const request = { name };
+        // Only add force if it's true to avoid API errors
+        if (force) {
+            request.force = force;
+        }
+        const operation = await netAppClient.deleteStoragePool(request);
+        const operationName = operation[0].name || '';
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ success: true, operation: operation }, null, 2),
+                },
+            ],
+            structuredContent: {
+                success: true,
+                operationId: operationName,
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error deleting storage pool');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error deleting storage pool: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// Get Storage Pool Handler
+export const getStoragePoolHandler = async (args) => {
+    try {
+        const { projectId, location, storagePoolId } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the name for the storage pool
+        const name = `projects/${projectId}/locations/${location}/storagePools/${storagePoolId}`;
+        // Call the API to get the storage pool
+        const [storagePool] = await netAppClient.getStoragePool({ name });
+        log.info({ storagePool }, 'Get Storage Pool response');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(storagePool, null, 2),
+                },
+            ],
+            structuredContent: {
+                name: storagePool.name || '',
+                storagePoolId: storagePoolId,
+                capacityGib: Number(storagePool.capacityGib) || 0,
+                volumeCapacityGib: Number(storagePool.volumeCapacityGib) || 0,
+                volumecount: storagePool.volumeCount || 0,
+                serviceLevel: storagePool.serviceLevel || '',
+                state: storagePool.state || 'UNKNOWN',
+                createTime: storagePool.createTime && storagePool.createTime.seconds
+                    ? new Date(Number(storagePool.createTime.seconds) * 1000)
+                    : new Date(),
+                description: storagePool.description || '',
+                labels: storagePool.labels || {},
+                network: storagePool.network,
+                activeDirectory: storagePool.activeDirectory,
+                kmsConfig: storagePool.kmsConfig,
+                encryptionType: storagePool.encryptionType,
+                ldapEnabled: storagePool.ldapEnabled ?? false,
+                psaRange: storagePool.psaRange,
+                globalAccessAllowed: storagePool.globalAccessAllowed ?? false,
+                allowAutoTiering: storagePool.allowAutoTiering ?? false,
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error getting storage pool');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error getting storage pool: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// List Storage Pools Handler
+export const listStoragePoolsHandler = async (args) => {
+    try {
+        const { projectId, location, filter, pageSize, pageToken } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the parent path for listing storage pools
+        const parent = `projects/${projectId}/locations/${location}`;
+        // Call the API to list storage pools
+        const [storagePools, , paginated_response] = await netAppClient.listStoragePools({
+            parent,
+            pageSize,
+            pageToken,
+            orderBy: undefined,
+            filter,
+        });
+        log.info({ storagePools, paginated_response }, 'List Storage Pools response');
+        // Get the storage pools and next page token
+        const nextPageToken = paginated_response ? paginated_response.nextPageToken : undefined;
+        // Map the storage pools to the desired format
+        const formattedPools = storagePools.map((pool) => {
+            // Extract the ID from the name
+            const name = pool.name || '';
+            const nameParts = name.split('/');
+            const extractedId = nameParts[nameParts.length - 1];
+            return {
+                name: name,
+                storagePoolId: extractedId,
+                serviceLevel: pool.serviceLevel || '',
+                capacityGib: Number(pool.capacityGib) || 0,
+                volumeCapacityGib: Number(pool.volumeCapacityGib) || 0,
+                volumecount: pool.volumeCount || 0,
+                state: pool.state || 'UNKNOWN',
+                createTime: pool.createTime && pool.createTime.seconds
+                    ? new Date(Number(pool.createTime.seconds) * 1000)
+                    : new Date(),
+                description: pool.description || '',
+                labels: pool.labels || {},
+                network: pool.network,
+                activeDirectory: pool.activeDirectory,
+                kmsConfig: pool.kmsConfig,
+                encryptionType: pool.encryptionType,
+                ldapEnabled: pool.ldapEnabled ?? false,
+                psaRange: pool.psaRange,
+                globalAccessAllowed: pool.globalAccessAllowed ?? false,
+                allowAutoTiering: pool.allowAutoTiering ?? false,
+            };
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(storagePools, null, 2),
+                },
+            ],
+            structuredContent: {
+                storagePools: formattedPools,
+                nextPageToken: nextPageToken,
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error listing storage pools');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error listing storage pools: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// Update Storage Pool Handler
+export const updateStoragePoolHandler = async (args) => {
+    try {
+        const { projectId, location, storagePoolId, capacityGib, description, labels } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the name for the storage pool
+        const name = `projects/${projectId}/locations/${location}/storagePools/${storagePoolId}`;
+        // Prepare the update mask based on provided fields
+        const updateMask = [];
+        const storagePool = {};
+        if (capacityGib !== undefined) {
+            storagePool.capacityGib = capacityGib;
+            updateMask.push('capacity_gib');
+        }
+        if (description !== undefined) {
+            storagePool.description = description;
+            updateMask.push('description');
+        }
+        if (labels !== undefined) {
+            storagePool.labels = labels;
+            updateMask.push('labels');
+        }
+        // Call the API to update the storage pool
+        const [operation] = await netAppClient.updateStoragePool({
+            storagePool: {
+                name,
+                ...storagePool,
+            },
+            updateMask: {
+                paths: updateMask,
+            },
+        });
+        log.info({ operation }, 'Update Storage Pool operation');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ name: `Update ${name}`, operation: operation }, null, 2),
+                },
+            ],
+            structuredContent: {
+                name: storagePool.name || '',
+                operationId: operation.name || '',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error updating storage pool');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error updating storage pool: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// Validate Directory Service Handler
+export const validateDirectoryServiceHandler = async (args) => {
+    try {
+        const { projectId, location, storagePoolId, directoryServiceType } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the name for the storage pool
+        const name = `projects/${projectId}/locations/${location}/storagePools/${storagePoolId}`;
+        // Call the API to validate directory service
+        const [operation] = await netAppClient.validateDirectoryService({
+            name,
+            directoryServiceType,
+        });
+        log.info({ operation }, 'Validate Directory Service operation');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        message: `Directory service validation initiated for storage pool ${storagePoolId}`,
+                        operation: operation,
+                    }, null, 2),
+                },
+            ],
+            structuredContent: {
+                success: true,
+                operationId: operation.name || '',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error validating directory service');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error validating directory service: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};