CmdSendMetadata.go

// Copyright 2025 IBM Corp
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Package main provides the send-metadata command implementation.
//
// This file implements the send-metadata command which sends cluster metadata
// to a remote server for creation or deletion. The command supports two mutually
// exclusive operations:
//
//   - Create: Sends metadata to the server to create cluster resources
//   - Delete: Sends metadata to the server to delete cluster resources
//
// The command accepts the following flags:
//   - createMetadata: Path to metadata file for creation (mutually exclusive with deleteMetadata)
//   - deleteMetadata: Path to metadata file for deletion (mutually exclusive with createMetadata)
//   - serverIP: IP address of the remote server (required)
//   - shouldDebug: Enable debug output (true/false, default: false)
//   - timeout: Timeout for send operation (e.g., 5m, 10m, 30s, default: 5m)
//
// Example usage:
//   # Create metadata with default timeout
//   ./tool send-metadata --createMetadata metadata.json --serverIP 192.168.1.100
//
//   # Delete metadata with custom timeout
//   ./tool send-metadata --deleteMetadata metadata.json --serverIP 192.168.1.100 --timeout 10m

package main

import (
	"context"
	"encoding/json"
	"flag"
	"fmt"
	"os"
	"strings"
	"time"
)

const (
	// Flag names for send-metadata command
	flagSendCreateMetadata = "createMetadata"
	flagSendDeleteMetadata = "deleteMetadata"
	flagSendServerIP       = "serverIP"
	flagSendShouldDebug    = "shouldDebug"
	flagSendTimeout        = "timeout"

	// Flag default values
	defaultSendCreateMetadata = ""
	defaultSendDeleteMetadata = ""
	defaultSendServerIP       = ""
	defaultSendShouldDebug    = "false"
	defaultSendTimeout        = "1m"

	// Usage messages
	usageSendCreateMetadata = "Create the metadata from this file"
	usageSendDeleteMetadata = "Delete the metadata from this file"
	usageSendServerIP       = "The IP address of the server to send the command to"
	usageSendShouldDebug    = "Enable debug output (true/false)"
	usageSendTimeout        = "Timeout for send operation (e.g., 5m, 10m, 30s)"

	// Operation names
	operationCreate  = "create"
	operationDelete  = "delete"
	operationCreated = "created"
	operationDeleted = "deleted"

	// Error message prefix
	errPrefixSend = "Error: "
)

// operationType represents the type of metadata operation to perform
type operationType int

const (
	// operationTypeCreate indicates a create operation
	operationTypeCreate operationType = iota
	// operationTypeDelete indicates a delete operation
	operationTypeDelete
)

// String returns the string representation of the operation type
func (o operationType) String() string {
	switch o {
	case operationTypeCreate:
		return operationCreate
	case operationTypeDelete:
		return operationDelete
	default:
		return "unknown"
	}
}

// pastTense returns the past tense form of the operation
func (o operationType) pastTense() string {
	switch o {
	case operationTypeCreate:
		return operationCreated
	case operationTypeDelete:
		return operationDeleted
	default:
		return "unknown"
	}
}

// sendMetadataError represents a structured error for send-metadata operations
type sendMetadataError struct {
	operation string
	phase     string
	cause     error
}

// Error implements the error interface
func (e *sendMetadataError) Error() string {
	if e.cause != nil {
		return fmt.Sprintf("%s%s failed during %s: %v", errPrefixSend, e.operation, e.phase, e.cause)
	}
	return fmt.Sprintf("%s%s failed during %s", errPrefixSend, e.operation, e.phase)
}

// Unwrap returns the underlying error
func (e *sendMetadataError) Unwrap() error {
	return e.cause
}

// newSendMetadataError creates a new structured error
func newSendMetadataError(operation, phase string, cause error) error {
	return &sendMetadataError{
		operation: operation,
		phase:     phase,
		cause:     cause,
	}
}

// validateMetadataContent validates the JSON structure and required fields of a metadata file.
// This function reads and parses the metadata file to ensure it contains valid JSON with
// all required fields before attempting to send it to the server.
//
// Parameters:
//   - filePath: Path to the metadata JSON file
//
// Returns:
//   - error: Any error encountered during reading, parsing, or validation
//
// The function validates:
//   - File can be read
//   - Content is valid JSON
//   - Required fields are present and non-empty (ClusterName, InfraID)
//   - At least one platform metadata is present (OpenStack or PowerVC)
func validateMetadataContent(filePath string) error {
	// Read the file
	content, err := os.ReadFile(filePath)
	if err != nil {
		return fmt.Errorf("failed to read metadata file: %w", err)
	}

	// Parse JSON structure
	var metadata CreateMetadata
	if err := json.Unmarshal(content, &metadata); err != nil {
		return fmt.Errorf("invalid JSON format: %w", err)
	}

	// Validate required fields
	if strings.TrimSpace(metadata.ClusterName) == "" {
		return fmt.Errorf("required field 'clusterName' is missing or empty")
	}

	if strings.TrimSpace(metadata.InfraID) == "" {
		return fmt.Errorf("required field 'infraID' is missing or empty")
	}

	// Validate that at least one platform metadata exists
	hasOpenStack := metadata.OpenStack != nil && strings.TrimSpace(metadata.OpenStack.Cloud) != ""
	hasPowerVC := metadata.PowerVC != nil && strings.TrimSpace(metadata.PowerVC.Cloud) != ""

	if !hasOpenStack && !hasPowerVC {
		return fmt.Errorf("metadata must contain either 'openstack' or 'powervc' platform configuration")
	}

	return nil
}

// sendMetadataWithRetry attempts to send metadata with exponential backoff retry logic.
// It will retry transient failures up to maxRetries times with increasing delays between attempts.
//
// Parameters:
//   - ctx: Context for cancellation and timeout
//   - metadataFile: Path to the metadata file
//   - serverIP: IP address or hostname of the server
//   - shouldCreate: true for create operation, false for delete
//
// Returns:
//   - error: Any error encountered, or nil on success
func sendMetadataWithRetry(ctx context.Context, metadataFile, serverIP string, shouldCreate bool) error {
	var lastErr error
	backoff := initialRetryDelay

	for attempt := 0; attempt <= maxRetries; attempt++ {
		// Wait before retry (skip on first attempt)
		if attempt > 0 {
			log.Printf("[INFO] Retry attempt %d/%d after %v delay", attempt, maxRetries, backoff)

			// Wait with context cancellation support
			select {
			case <-time.After(backoff):
				// Continue with retry
			case <-ctx.Done():
				return fmt.Errorf("operation cancelled during retry backoff: %w", ctx.Err())
			}

			// Increase backoff for next retry (exponential backoff)
			backoff = time.Duration(float64(backoff) * retryMultiplier)
			if backoff > maxRetryDelay {
				backoff = maxRetryDelay
			}
		}

		// Attempt to send metadata
		log.Debugf("Attempting to send metadata (attempt %d/%d)", attempt+1, maxRetries+1)
		err := sendMetadata(ctx, metadataFile, serverIP, shouldCreate)

		// Success - return immediately
		if err == nil {
			if attempt > 0 {
				log.Printf("[INFO] Metadata sent successfully after %d retries", attempt)
			}
			return nil
		}

		// Check if error is retryable
		if !isRetryableError(err) {
			log.Printf("[INFO] Non-retryable error encountered: %v", err)
			return err
		}

		// Store error for potential final return
		lastErr = err
		log.Printf("[WARN] Retryable error encountered: %v", err)

		// Check if we've exhausted retries
		if attempt == maxRetries {
			break
		}
	}

	// All retries exhausted
	return fmt.Errorf("failed after %d retries: %w", maxRetries, lastErr)
}

// sendMetadataCommand is the top-level handler for the send-metadata command.
// It delegates to innerSendMetadataCommand and, on failure, prints the error
// and displays flag usage before returning the error.
func sendMetadataCommand(sendMetadataFlags *flag.FlagSet, args []string) error {
	err := innerSendMetadataCommand(sendMetadataFlags, args)
	if err != nil {
		fmt.Printf("%+v\n", err)
		if sendMetadataFlags != nil {
			sendMetadataFlags.Usage()
		}
	}
	return err
}

// innerSendMetadataCommand executes the send-metadata command with the given flags and arguments.
//
// This function handles both metadata creation and deletion operations. It validates
// that exactly one operation is specified, validates the metadata file and server IP,
// and sends the metadata to the remote server with timeout support.
//
// Parameters:
//   - sendMetadataFlags: The FlagSet containing command-line flags (must not be nil)
//   - args: Command-line arguments to parse
//
// Returns:
//   - error: Any error encountered during flag parsing, validation, or operation execution
//
// The function executes the following steps:
//  1. Validates input parameters
//  2. Displays program version information
//  3. Defines and parses command-line flags
//  4. Validates mutual exclusivity of create/delete operations
//  5. Validates metadata file existence and readability
//  6. Validates server IP address format
//  7. Initializes logger based on debug flag
//  8. Creates context with timeout for operation
//  9. Sends metadata to remote server
//  10. Provides user feedback on success
func innerSendMetadataCommand(sendMetadataFlags *flag.FlagSet, args []string) error {
	// Validate input parameters
	if sendMetadataFlags == nil {
		return newSendMetadataError("send-metadata", "initialization", fmt.Errorf("flag set cannot be nil"))
	}

	// Display version information
	fmt.Fprintf(os.Stderr, "Program version is %v, release = %v\n", version, release)

	// Define command-line flags
	ptrCreateMetadata := sendMetadataFlags.String(flagSendCreateMetadata, defaultSendCreateMetadata, usageSendCreateMetadata)
	ptrDeleteMetadata := sendMetadataFlags.String(flagSendDeleteMetadata, defaultSendDeleteMetadata, usageSendDeleteMetadata)
	ptrServerIP := sendMetadataFlags.String(flagSendServerIP, defaultSendServerIP, usageSendServerIP)
	ptrShouldDebug := sendMetadataFlags.String(flagSendShouldDebug, defaultSendShouldDebug, usageSendShouldDebug)
	ptrTimeout := sendMetadataFlags.String(flagSendTimeout, defaultSendTimeout, usageSendTimeout)

	// Parse flags
	if err := sendMetadataFlags.Parse(args); err != nil {
		return newSendMetadataError("send-metadata", "flag parsing", err)
	}

	// Parse and validate operation flags
	createFile := strings.TrimSpace(*ptrCreateMetadata)
	deleteFile := strings.TrimSpace(*ptrDeleteMetadata)

	shouldCreateMetadata := createFile != ""
	shouldDeleteMetadata := deleteFile != ""

	// Ensure exactly one operation is specified
	if shouldCreateMetadata && shouldDeleteMetadata {
		return newSendMetadataError("send-metadata", "flag validation",
			fmt.Errorf("cannot specify both --%s and --%s", flagSendCreateMetadata, flagSendDeleteMetadata))
	}
	if !shouldCreateMetadata && !shouldDeleteMetadata {
		return newSendMetadataError("send-metadata", "flag validation",
			fmt.Errorf("required flag --%s or --%s must be specified", flagSendCreateMetadata, flagSendDeleteMetadata))
	}

	// Parse debug flag
	shouldDebug, err := parseBoolFlag(*ptrShouldDebug, flagSendShouldDebug)
	if err != nil {
		return newSendMetadataError("send-metadata", "debug flag parsing", err)
	}

	// Parse timeout flag
	timeout, err := time.ParseDuration(strings.TrimSpace(*ptrTimeout))
	if err != nil {
		return newSendMetadataError("send-metadata", "timeout parsing",
			fmt.Errorf("invalid timeout value %q: %w", *ptrTimeout, err))
	}
	if timeout <= 0 {
		return newSendMetadataError("send-metadata", "timeout validation",
			fmt.Errorf("timeout must be positive, got %v", timeout))
	}

	// Initialize logger
	log = initLogger(shouldDebug)
	if shouldDebug {
		log.Debugf("Debug mode enabled")
	}

	// Determine which file to use and operation type
	var metadataFile string
	var opType operationType
	if shouldCreateMetadata {
		metadataFile = createFile
		opType = operationTypeCreate
	} else {
		metadataFile = deleteFile
		opType = operationTypeDelete
	}

	log.Printf("[INFO] Starting send-metadata command")
	log.Printf("[INFO] Operation: %s", opType.String())
	log.Printf("[INFO] Metadata file: %s", metadataFile)
	log.Printf("[INFO] Timeout: %v", timeout)

	// Create context with timeout for the operation
	ctx, cancel := context.WithTimeout(context.Background(), timeout)
	defer cancel()

	// Validate metadata file exists and is readable
	log.Printf("[INFO] Validating metadata file...")
	if err := validateFileExists(metadataFile); err != nil {
		return newSendMetadataError(opType.String(), "file validation", err)
	}
	log.Printf("[INFO] Metadata file validated successfully")

	// Check if context was cancelled after file validation
	if err := ctx.Err(); err != nil {
		return newSendMetadataError(opType.String(), "operation cancelled", err)
	}

	// Validate metadata content (JSON structure and required fields)
	log.Printf("[INFO] Validating metadata content...")
	if err := validateMetadataContent(metadataFile); err != nil {
		return newSendMetadataError(opType.String(), "metadata content validation", err)
	}
	log.Printf("[INFO] Metadata content validated successfully")

	// Check if context was cancelled after content validation
	if err := ctx.Err(); err != nil {
		return newSendMetadataError(opType.String(), "operation cancelled", err)
	}

	// Validate required server IP flag
	serverIP := strings.TrimSpace(*ptrServerIP)
	if serverIP == "" {
		return newSendMetadataError(opType.String(), "server IP validation",
			fmt.Errorf("required flag --%s not specified", flagSendServerIP))
	}
	log.Printf("[INFO] Server IP: %s", serverIP)

	// Validate server IP format
	log.Printf("[INFO] Validating server IP format...")
	if err := validateServerIP(serverIP); err != nil {
		return newSendMetadataError(opType.String(), "server IP validation", err)
	}
	log.Printf("[INFO] Server IP validated successfully")

	// Check if context was cancelled after IP validation
	if err := ctx.Err(); err != nil {
		return newSendMetadataError(opType.String(), "operation cancelled", err)
	}

	log.Debugf("sendMetadataCommand: operation=%s, file=%s, server=%s",
		opType.String(),
		metadataFile,
		serverIP)

	deadline, ok := ctx.Deadline()
	if ok {
		log.Printf("[INFO] Sending metadata to server (timeout: %v, deadline: %v)...",
			timeout, deadline.Format(time.RFC3339))
	} else {
		log.Printf("[INFO] Sending metadata to server (timeout: %v)...", timeout)
	}
	startTime := time.Now()

	// Send metadata command to server with context and retry logic
	if err := sendMetadataWithRetry(ctx, metadataFile, serverIP, shouldCreateMetadata); err != nil {
		return newSendMetadataError(opType.String(), "metadata transmission", err)
	}

	duration := time.Since(startTime)
	log.Printf("[INFO] Metadata sent successfully (took %v)", duration)

	// Provide user feedback
	fmt.Printf("Metadata %s successfully (source file: %s)\n", opType.pastTense(), metadataFile)
	log.Printf("[INFO] Send-metadata command completed successfully")

	return nil
}