@gcnv/gcnv-mcp-server 1.0.3

package/build/tools/handlers/backup-policy-handler.js

@@ -0,0 +1,275 @@
+import { NetAppClientFactory } from '../../utils/netapp-client-factory.js';
+import { createBackupPolicyTool, deleteBackupPolicyTool, getBackupPolicyTool, listBackupPoliciesTool, updateBackupPolicyTool, } from '../backup-policy-tools.js';
+/**
+ * Creates a new backup policy
+ */
+export const createBackupPolicyHandler = async (args) => {
+    try {
+        const { projectId, location, backupPolicyId, dailyBackupLimit, weeklyBackupLimit, monthlyBackupLimit, description, enabled, labels, } = args;
+        const client = NetAppClientFactory.createClient();
+        // Format resource name
+        const parent = `projects/${projectId}/locations/${location}`;
+        // Build backup policy
+        const backupPolicy = {
+            dailyBackupLimit,
+            weeklyBackupLimit,
+            monthlyBackupLimit,
+            description,
+            enabled,
+            labels,
+        };
+        // Filter out undefined properties
+        Object.keys(backupPolicy).forEach((key) => {
+            if (backupPolicy[key] === undefined) {
+                delete backupPolicy[key];
+            }
+        });
+        // Call the API to create a backup policy
+        const [operation] = await client.createBackupPolicy({
+            parent,
+            backupPolicy,
+            backupPolicyId,
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Created backup policy: ${backupPolicyId}. Operation ID: ${operation.name}`,
+                },
+            ],
+            structuredContent: {
+                name: `projects/${projectId}/locations/${location}/backupPolicy/${backupPolicyId}`,
+                operationId: operation.name || '',
+            },
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Failed to create backup policy: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+};
+/**
+ * Deletes a backup policy
+ */
+export const deleteBackupPolicyHandler = async (args) => {
+    try {
+        const { projectId, location, backupPolicyId } = args;
+        const client = NetAppClientFactory.createClient();
+        // Format resource name
+        const name = `projects/${projectId}/locations/${location}/backupPolicies/${backupPolicyId}`;
+        // Call the API to delete a backup policy
+        const [operation] = await client.deleteBackupPolicy({
+            name,
+        });
+        const result = {
+            success: true,
+            operationId: operation.name || '',
+        };
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Deleted backup policy ${backupPolicyId}. Operation ID: ${result.operationId}`,
+                },
+            ],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Failed to delete backup policy: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+};
+/**
+ * Gets a backup policy
+ */
+export const getBackupPolicyHandler = async (args) => {
+    try {
+        const { projectId, location, backupPolicyId } = args;
+        const client = NetAppClientFactory.createClient();
+        // Format resource name
+        const name = `projects/${projectId}/locations/${location}/backupPolicies/${backupPolicyId}`;
+        // Call the API to get a backup policy
+        const [backupPolicy] = await client.getBackupPolicy({ name });
+        const result = {
+            name: backupPolicy.name || '',
+            backupPolicyId: backupPolicy.name?.split('/').pop() || '',
+            dailyBackupLimit: backupPolicy.dailyBackupLimit,
+            weeklyBackupLimit: backupPolicy.weeklyBackupLimit,
+            monthlyBackupLimit: backupPolicy.monthlyBackupLimit,
+            description: backupPolicy.description,
+            enabled: backupPolicy.enabled || false,
+            assignedVolumeCount: backupPolicy.assignedVolumeCount,
+            state: backupPolicy.state || 'UNKNOWN',
+            createTime: backupPolicy.createTime
+                ? new Date(Number(backupPolicy.createTime.seconds || 0) * 1000)
+                : new Date(),
+            labels: backupPolicy.labels,
+        };
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Failed to get backup policy: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+};
+/**
+ * Lists backup policies
+ */
+export const listBackupPoliciesHandler = async (args) => {
+    try {
+        const { projectId, location, filter, pageSize, pageToken } = args;
+        const client = NetAppClientFactory.createClient();
+        // Format resource name
+        const parent = `projects/${projectId}/locations/${location}`;
+        // Call the API to list backup policies
+        const [response] = await client.listBackupPolicies({
+            parent,
+            filter,
+            pageSize,
+            pageToken,
+        });
+        // Handle API response
+        const backupPolicies = Array.isArray(response)
+            ? response
+            : response.backupPolicies || [];
+        const nextPageToken = typeof response === 'object' && response !== null
+            ? response.nextPageToken || ''
+            : '';
+        const result = {
+            backupPolicies: backupPolicies.map((policy) => ({
+                name: policy.name || '',
+                backupPolicyId: policy.name?.split('/').pop() || '',
+                dailyBackupLimit: policy.dailyBackupLimit,
+                weeklyBackupLimit: policy.weeklyBackupLimit,
+                monthlyBackupLimit: policy.monthlyBackupLimit,
+                description: policy.description,
+                enabled: policy.enabled || false,
+                assignedVolumeCount: policy.assignedVolumeCount,
+                state: policy.state || 'UNKNOWN',
+                createTime: policy.createTime
+                    ? new Date(Number(policy.createTime.seconds ?? 0) * 1000)
+                    : undefined,
+                labels: policy.labels,
+            })),
+            nextPageToken: nextPageToken,
+        };
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ backupPolicies: backupPolicies, nextPageToken: nextPageToken }, null, 2),
+                },
+            ],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Failed to list backup policies: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+};
+/**
+ * Updates a backup policy
+ */
+export const updateBackupPolicyHandler = async (args) => {
+    try {
+        const { projectId, location, backupPolicyId, dailyBackupLimit, weeklyBackupLimit, monthlyBackupLimit, description, enabled, labels, } = args;
+        const client = NetAppClientFactory.createClient();
+        // Format resource name
+        const name = `projects/${projectId}/locations/${location}/backupPolicies/${backupPolicyId}`;
+        // Build backup policy update
+        const backupPolicy = {
+            name,
+            dailyBackupLimit,
+            weeklyBackupLimit,
+            monthlyBackupLimit,
+            description,
+            enabled,
+            labels,
+        };
+        // Filter out undefined properties
+        Object.keys(backupPolicy).forEach((key) => {
+            if (backupPolicy[key] === undefined) {
+                delete backupPolicy[key];
+            }
+        });
+        // Create an update mask based on the provided fields
+        const updateMask = {
+            paths: Object.keys(backupPolicy).filter((key) => key !== 'name'),
+        };
+        // Call the API to update a backup policy
+        const [operation] = await client.updateBackupPolicy({
+            backupPolicy,
+            updateMask,
+        });
+        const result = {
+            name: operation.metadata ? operation.metadata.target || '' : '',
+            operationId: operation.name || '',
+        };
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Updated backup policy: ${result.name}. Operation ID: ${result.operationId}`,
+                },
+            ],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Failed to update backup policy: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+};
+// Export tool handler mappings
+export const backupPolicyHandlers = {
+    [createBackupPolicyTool.name]: createBackupPolicyHandler,
+    [deleteBackupPolicyTool.name]: deleteBackupPolicyHandler,
+    [getBackupPolicyTool.name]: getBackupPolicyHandler,
+    [listBackupPoliciesTool.name]: listBackupPoliciesHandler,
+    [updateBackupPolicyTool.name]: updateBackupPolicyHandler,
+};

package/build/tools/handlers/backup-vault-handler.js

@@ -0,0 +1,370 @@
+import { NetAppClientFactory } from '../../utils/netapp-client-factory.js';
+import { logger } from '../../logger.js';
+const log = logger.child({ module: 'backup-vault-handler' });
+// Helper to format backup vault data for responses
+function formatBackupVaultData(backupVault) {
+    const result = {};
+    if (!backupVault)
+        return result;
+    if (backupVault.name) {
+        // Extract backupVaultId from name (last part after last slash)
+        const nameParts = backupVault.name.split('/');
+        result.name = backupVault.name;
+        result.backupVaultId = nameParts[nameParts.length - 1];
+    }
+    // Copy basic properties
+    if (backupVault.state)
+        result.state = backupVault.state;
+    // Format timestamps if they exist
+    if (backupVault.createTime) {
+        result.createTime = new Date(backupVault.createTime.seconds * 1000);
+    }
+    if (backupVault.updateTime) {
+        result.updateTime = new Date(backupVault.updateTime.seconds * 1000);
+    }
+    // Copy required properties according to the schema
+    if (backupVault.backupVaultType)
+        result.backupVaultType = backupVault.backupVaultType;
+    if (backupVault.sourceRegion)
+        result.sourceRegion = backupVault.sourceRegion;
+    if (backupVault.backupRegion)
+        result.backupRegion = backupVault.backupRegion;
+    if (backupVault.sourceBackupVault)
+        result.sourceBackupVault = backupVault.sourceBackupVault;
+    if (backupVault.destinationBackupVault)
+        result.destinationBackupVault = backupVault.destinationBackupVault;
+    // Copy backup retention policy if it exists
+    if (backupVault.backupRetentionPolicy) {
+        result.backupRetentionPolicy = {
+            backupMinimumEnforcedRetentionDays: backupVault.backupRetentionPolicy.backupMinimumEnforcedRetentionDays || 0,
+            dailyBackupImmutable: backupVault.backupRetentionPolicy.dailyBackupImmutable || false,
+            weeklyBackupImmutable: backupVault.backupRetentionPolicy.weeklyBackupImmutable || false,
+            monthlyBackupImmutable: backupVault.backupRetentionPolicy.monthlyBackupImmutable || false,
+            manualBackupImmutable: backupVault.backupRetentionPolicy.manualBackupImmutable || false,
+        };
+    }
+    // Copy optional properties
+    if (backupVault.description)
+        result.description = backupVault.description;
+    if (backupVault.labels)
+        result.labels = backupVault.labels;
+    return result;
+}
+// Create Backup Vault Handler
+export const createBackupVaultHandler = async (args) => {
+    try {
+        const { projectId, location, backupVaultId, description, labels } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the parent path for the backup vault
+        const parent = `projects/${projectId}/locations/${location}`;
+        // Create the backup vault request
+        const request = {
+            parent,
+            backupVaultId,
+            backupVault: {
+                description,
+                labels,
+            },
+        };
+        // Create the backup vault
+        const [operation] = await netAppClient.createBackupVault(request);
+        // Extract the operation name for tracking
+        const operationName = operation.name;
+        // Construct the backup vault name
+        const backupVaultName = `${parent}/backupVaults/${backupVaultId}`;
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Backup vault creation initiated. Operation ID: ${operationName}`,
+                },
+            ],
+            structuredContent: {
+                name: backupVaultName,
+                operationId: operationName,
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error creating backup vault');
+        let errorMessage = `Failed to create backup vault: ${error.message}`;
+        // Handle specific error types and provide useful error messages
+        if (error.code === 6) {
+            // ALREADY_EXISTS
+            errorMessage = `Backup vault ${args.backupVaultId} already exists in project ${args.projectId}, location ${args.location}`;
+        }
+        else if (error.code === 7) {
+            // PERMISSION_DENIED
+            errorMessage = 'Permission denied. Please check your credentials and access rights.';
+        }
+        else if (error.code === 5) {
+            // NOT_FOUND
+            errorMessage = `Project ${args.projectId} or location ${args.location} not found`;
+        }
+        else if (error.code === 3) {
+            // INVALID_ARGUMENT
+            errorMessage = `Invalid argument: ${error.message}`;
+        }
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: errorMessage,
+                },
+            ],
+        };
+    }
+};
+// Delete Backup Vault Handler
+export const deleteBackupVaultHandler = async (args) => {
+    try {
+        const { projectId, location, backupVaultId } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the name for the backup vault
+        const name = `projects/${projectId}/locations/${location}/backupVaults/${backupVaultId}`;
+        // Delete the backup vault
+        const request = { name };
+        const [operation] = await netAppClient.deleteBackupVault(request);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Backup vault deletion initiated. Operation ID: ${operation.name}`,
+                },
+            ],
+            structuredContent: {
+                success: true,
+                operationId: operation.name,
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error deleting backup vault');
+        let errorMessage = `Failed to delete backup vault: ${error.message}`;
+        // Handle specific error types
+        if (error.code === 5) {
+            // NOT_FOUND
+            errorMessage = `Backup vault not found: projects/${args.projectId}/locations/${args.location}/backupVaults/${args.backupVaultId}`;
+        }
+        else if (error.code === 7) {
+            // PERMISSION_DENIED
+            errorMessage = 'Permission denied. Please check your credentials and access rights.';
+        }
+        else if (error.code === 9) {
+            // FAILED_PRECONDITION
+            errorMessage =
+                'Failed precondition. The backup vault may have dependent backups that need to be deleted first.';
+        }
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: errorMessage,
+                },
+            ],
+        };
+    }
+};
+// Get Backup Vault Handler
+export const getBackupVaultHandler = async (args) => {
+    try {
+        const { projectId, location, backupVaultId } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the name for the backup vault
+        const name = `projects/${projectId}/locations/${location}/backupVaults/${backupVaultId}`;
+        // Get the backup vault
+        const [backupVault] = await netAppClient.getBackupVault({ name });
+        // Format the backup vault data
+        const formattedData = formatBackupVaultData(backupVault);
+        // Default values for required fields if they're not present in the API response
+        if (!formattedData.backupVaultType)
+            formattedData.backupVaultType = 'STANDARD';
+        if (!formattedData.sourceRegion)
+            formattedData.sourceRegion = location;
+        if (!formattedData.backupRegion)
+            formattedData.backupRegion = location;
+        if (!formattedData.sourceBackupVault)
+            formattedData.sourceBackupVault = '';
+        if (!formattedData.destinationBackupVault)
+            formattedData.destinationBackupVault = '';
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(formattedData, null, 2),
+                },
+            ],
+            structuredContent: formattedData,
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error getting backup vault');
+        let errorMessage = `Failed to get backup vault: ${error.message}`;
+        // Handle specific error types
+        if (error.code === 5) {
+            // NOT_FOUND
+            errorMessage = `Backup vault not found: projects/${args.projectId}/locations/${args.location}/backupVaults/${args.backupVaultId}`;
+        }
+        else if (error.code === 7) {
+            // PERMISSION_DENIED
+            errorMessage = 'Permission denied. Please check your credentials and access rights.';
+        }
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: errorMessage,
+                },
+            ],
+        };
+    }
+};
+// List Backup Vaults Handler
+export const listBackupVaultsHandler = 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 backup vaults
+        const parent = `projects/${projectId}/locations/${location}`;
+        // List the backup vaults
+        const options = {
+            parent,
+            filter,
+            pageSize,
+            pageToken,
+        };
+        const [backupVaultsResponse] = await netAppClient.listBackupVaults(options);
+        // Process the response
+        let backupVaults = [];
+        let nextPageToken;
+        // Handle the response structure correctly
+        if (backupVaultsResponse) {
+            // If it's an array, map each vault
+            if (Array.isArray(backupVaultsResponse)) {
+                backupVaults = backupVaultsResponse.map((vault) => formatBackupVaultData(vault));
+            }
+            // Handle as a generic object with any fields
+            else {
+                const response = backupVaultsResponse;
+                // Check for different possible response structures
+                if (response.backupVaults && Array.isArray(response.backupVaults)) {
+                    backupVaults = response.backupVaults.map((vault) => formatBackupVaultData(vault));
+                }
+                if (response.nextPageToken) {
+                    nextPageToken = response.nextPageToken;
+                }
+            }
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Retrieved ${backupVaults.length} backup vault(s) from project ${projectId}, location ${location}.\n` +
+                        JSON.stringify(backupVaults, null, 2),
+                },
+            ],
+            structuredContent: {
+                backupVaults,
+                nextPageToken,
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error listing backup vaults');
+        let errorMessage = `Failed to list backup vaults: ${error.message}`;
+        // Handle specific error types
+        if (error.code === 5) {
+            // NOT_FOUND
+            errorMessage = `Project or location not found: projects/${args.projectId}/locations/${args.location}`;
+        }
+        else if (error.code === 7) {
+            // PERMISSION_DENIED
+            errorMessage = 'Permission denied. Please check your credentials and access rights.';
+        }
+        else if (error.code === 3) {
+            // INVALID_ARGUMENT
+            errorMessage = `Invalid argument: ${error.message}`;
+        }
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: errorMessage,
+                },
+            ],
+        };
+    }
+};
+// Update Backup Vault Handler
+export const updateBackupVaultHandler = async (args) => {
+    try {
+        const { projectId, location, backupVaultId, description, labels } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the name for the backup vault
+        const name = `projects/${projectId}/locations/${location}/backupVaults/${backupVaultId}`;
+        // Create update mask based on provided fields
+        const updateMask = [];
+        if (description !== undefined)
+            updateMask.push('description');
+        if (labels !== undefined)
+            updateMask.push('labels');
+        // Update the backup vault
+        const [operation] = await netAppClient.updateBackupVault({
+            backupVault: {
+                name,
+                description,
+                labels,
+            },
+            updateMask: {
+                paths: updateMask,
+            },
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Backup vault update initiated. Operation ID: ${operation.name}`,
+                },
+            ],
+            structuredContent: {
+                name,
+                operationId: operation.name,
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error updating backup vault');
+        let errorMessage = `Failed to update backup vault: ${error.message}`;
+        // Handle specific error types
+        if (error.code === 5) {
+            // NOT_FOUND
+            errorMessage = `Backup vault not found: projects/${args.projectId}/locations/${args.location}/backupVaults/${args.backupVaultId}`;
+        }
+        else if (error.code === 7) {
+            // PERMISSION_DENIED
+            errorMessage = 'Permission denied. Please check your credentials and access rights.';
+        }
+        else if (error.code === 3) {
+            // INVALID_ARGUMENT
+            errorMessage = `Invalid argument: ${error.message}`;
+        }
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: errorMessage,
+                },
+            ],
+        };
+    }
+};