Migration guide

#!/bin/bash

set -e

# Function to perform curl requests with error handling and retries
perform_curl_request() {
    local url=$1
    local max_retries=3
    local retry_count=0
    local wait_time=5
    local curl_opts="-s -w '\n%{http_code}' -H 'Accept: application/json' -u '$FUSION_USERNAME:$FUSION_PASSWORD'"
    
    while [ $retry_count -le $max_retries ]; do
        # Execute curl and capture response with status code
        local response=$(eval "curl $curl_opts '$url'")
        local status_code=$(echo "$response" | tail -n1)
        local body=$(echo "$response" | sed '$d')
        
        # Check if status code is in 2xx range
        if [[ $status_code =~ ^2[0-9][0-9]$ ]]; then
            echo "$body"
            return 0
        else
            # Report the error
            echo "Error: HTTP request failed with status code $status_code" >&2
            echo "URL: $url" >&2
            
            # If it's a 4xx error, don't retry
            if [[ $status_code =~ ^4[0-9][0-9]$ ]]; then
                echo "Client error. Not retrying." >&2
                exit 1
            fi
            
            # For other errors (5xx), retry if we haven't reached max retries
            if [ $retry_count -lt $max_retries ]; then
                retry_count=$((retry_count + 1))
                echo "Retrying in $wait_time seconds... (Attempt $retry_count of $max_retries)" >&2
                sleep $wait_time
            else
                echo "Maximum retries reached. Giving up." >&2
                exit 1
            fi
        fi
    done
    
    exit 1
}

# Function to validate JSON blob rules
validate_json_blob_rule() {
    local doc="$1"
    local doc_id="$2"

    local json_blob_s=$(echo "$doc" | jq -r '.json_blob_s // empty')
    # Guard: Exit early if no json_blob_s field
    [ -z "$json_blob_s" ] && return 0

    # Decode base64 and validate JSON structure
    local decoded_json=$(echo "$json_blob_s" | base64 -d 2>/dev/null || echo "")
    # Guard: Exit early if decoding failed
    [ -z "$decoded_json" ] && return 0

    # Check if the decoded JSON is valid
    if ! echo "$decoded_json" | jq empty 2>/dev/null; then
        # Invalid JSON in blob
        bad_json_blob_rule_ids+=("$doc_id")
        echo "found JSON blob rule with invalid JSON: $doc_id"

        # Add this entry to our JSON structure for bad JSON blobs
        local content_entry=$(jq -n --arg id "$doc_id" \
                              --argjson content "$doc" \
                              --arg decoded_content "$decoded_json" \
                              '{
                                "id": $id,
                                "ruleContent": $content,
                                "decodedJsonBlob": $decoded_content,
                                "error": "Invalid JSON syntax"
                              }')

        # Add this entry to the second problem (index 1) in our JSON structure
        json_output=$(echo "$json_output" | jq --argjson entry "$content_entry" '.problems[1].content += [$entry]')
        return 0
    fi

    # Valid JSON - now check if it's multiple objects
    # A simple heuristic: if we can't parse it as a single JSON value, it's likely multiple objects
    if echo "$decoded_json" | jq -e 'type' >/dev/null 2>&1; then
        # Guard: Exit early if it's a valid single JSON object
        return 0
    fi

    # This means jq couldn't parse it as a single value, likely multiple objects
    bad_json_blob_rule_ids+=("$doc_id")
    echo "found JSON blob rule with multiple objects: $doc_id"

    # Add this entry to our JSON structure for bad JSON blobs
    local content_entry=$(jq -n --arg id "$doc_id" \
                          --argjson content "$doc" \
                          --arg decoded_content "$decoded_json" \
                          '{
                            "id": $id,
                            "ruleContent": $content,
                            "decodedJsonBlob": $decoded_content
                          }')

    # Add this entry to the second problem (index 1) in our JSON structure
    json_output=$(echo "$json_output" | jq --argjson entry "$content_entry" '.problems[1].content += [$entry]')
}

# Function to check for staged published rules
check_staged_published_rule() {
    local doc="$1"
    local doc_id="$2"
    local deployed="$3"

    # Guard: Exit early if rule is deployed (not staged)
    [ "$deployed" != "false" ] && return 0

    # Check if the doc exists in the live rewrites collection
    local live_url="$FUSION_BASE_URL/api/apps/$FUSION_APP_ID/query-rewrite/search?q=id:$doc_id&isLive=true&doc_type=rule&fl&rows=1&start=0"
    echo "fetching live rule via $live_url"
    local live_response=$(perform_curl_request "$live_url")

    # Check if we have any rules in the live response array
    local live_docs_count=$(echo "$live_response" | jq -r '.response.docs | length')

    # Guard: Exit early if doc doesn't exist in live collection
    [ "$live_docs_count" -eq 0 ] && return 0

    # Found a published rule with staged changes
    staged_published_rule_ids+=("$doc_id")
    echo "found published rule with staged changes: $doc_id"

    # Extract the live doc from the response
    local live_doc=$(echo "$live_response" | jq '.response.docs[0]')

    # Create a new entry for this rule with both staging and live content
    local content_entry=$(jq -n --arg id "$doc_id" \
                      --argjson staging "$doc" \
                      --argjson live "$live_doc" \
                      '{
                        "id": $id,
                        "stagingContent": $staging,
                        "liveContent": $live
                      }')

    # Add this entry to our JSON structure
    json_output=$(echo "$json_output" | jq --argjson entry "$content_entry" '.problems[0].content += [$entry]')
}

# Function to display help message
show_help() {
    echo "Usage: $0 <fusion_username> <fusion_password> <fusion_base_url> <fusion_app_id> [output_file]"
    echo "Example: $0 admin password https://fusion.example.com MyFusionApp precheck_results.json"
    echo "This script performs pre-checks for Fusion content before migration."
    echo "Arguments:"
    echo "  fusion_username   Fusion username"
    echo "  fusion_password   Fusion password"
    echo "  fusion_base_url   Base URL of the Fusion instance"
    echo "  fusion_app_id     Application ID of the Fusion app to check"
    echo "  output_file       (Optional) Output file to save results (default: precheck_results.json)"
}

# Check if required arguments are provided
if [ "$#" -lt 4 ]; then
  show_help
  exit 1
fi

FUSION_USERNAME=$1
FUSION_PASSWORD=$2
FUSION_BASE_URL=$3
FUSION_APP_ID=$4
OUTPUT_FILE=${5:-precheck_results.json}

# Input validation
if [ -z "$FUSION_USERNAME" ]; then
  echo "Error: fusion_username is required"
  show_help
  exit 1
fi

if [ -z "$FUSION_PASSWORD" ]; then
  echo "Error: fusion_password is required"
  show_help
  exit 1
fi

if [ -z "$FUSION_BASE_URL" ]; then
  echo "Error: fusion_base_url is required"
  show_help
  exit 1
fi

if [ -z "$FUSION_APP_ID" ]; then
  echo "Error: fusion_app_id ID is required"
  show_help
  exit 1
fi

# Check if jq is installed
if ! command -v jq &> /dev/null; then
    echo "Error: jq command line tool is required but not installed. Please install jq and try again: https://jqlang.org/"
    exit 1
fi

# Check if output file exists
if [ -f "$OUTPUT_FILE" ]; then
    read -p "File $OUTPUT_FILE already exists. Overwrite? (y/n): " -n 1 -r
    echo
    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
        echo "Operation cancelled."
        exit 1
    fi
fi

# Ensure the output file is writeable
if ! touch "$OUTPUT_FILE" &> /dev/null; then
    echo "Error: Output file $OUTPUT_FILE is not writeable. Check output path / permissions and try again."
    exit 1
fi

# Initialize JSON structure
json_output='{
  "problems": [
    {
      "problem": "Published rule with staged changes will be skipped during migration",
      "fix": "Publish or revert the changes, or manually re-create the skipped content after migrating",
      "content": []
    },
    {
      "problem": "JSON blob rule contains multiple JSON objects instead of a single object",
      "fix": "Update the JSON blob rule to contain only a single JSON object at the top level",
      "content": []
    }
  ]
}'

# Initialize array to store staged published rule IDs
declare -a staged_published_rule_ids

# Initialize array to store bad JSON blob rule IDs
declare -a bad_json_blob_rule_ids

# Fetch query rewrite instances with pagination
start=0
rows=10
processed_docs=0

while true; do
    page_url="$FUSION_BASE_URL/api/apps/$FUSION_APP_ID/query-rewrite/instances?sort=id+asc&doc_type=rule&rows=$rows&editSessionId=*&start=$start"
    echo "fetching next page of rules via $page_url"
    response=$(perform_curl_request "$page_url")

    # Check if we got an empty array, which means we're done paginating
    array_length=$(echo "$response" | jq -r '. | length')
    if [ "$array_length" -eq 0 ]; then
        break
    fi

    echo "Retrieved $array_length rules at offset $start"

    # Process each doc in the array
    while read -r doc; do
        doc_id=$(echo "$doc" | jq -r '.id')
        deployed=$(echo "$doc" | jq -r '.deployed')
        doc_type=$(echo "$doc" | jq -r '.type // empty')

        # Check for bad JSON blob rules
        if [ "$doc_type" = "json_blob" ]; then
            validate_json_blob_rule "$doc" "$doc_id"
        fi

        # Check for staged published rules
        check_staged_published_rule "$doc" "$doc_id" "$deployed"

        processed_docs=$((processed_docs + 1))
    done < <(echo "$response" | jq -c '.[]')

    # Move to the next page
    start=$((start + rows))
done

# Write the final JSON output to file
echo "$json_output" | jq '.' > "$OUTPUT_FILE"

# Output results
total_staged_issues=0
total_json_blob_issues=0
if [ -n "${staged_published_rule_ids[*]:-}" ]; then
    total_staged_issues=${#staged_published_rule_ids[@]}
fi
if [ -n "${bad_json_blob_rule_ids[*]:-}" ]; then
    total_json_blob_issues=${#bad_json_blob_rule_ids[@]}
fi

total_issues=$((total_staged_issues + total_json_blob_issues))

# Guard: Exit early if no issues found
if [ $total_issues -eq 0 ]; then
    echo "All pre-checks passed. No issues found."
    echo "Processed $processed_docs rules."
    exit 0
fi

# Report issues found
echo "The following pre-checks failed:"

# Report staged published rule issues
if [ $total_staged_issues -gt 0 ]; then
    echo "  Found published rules with staged changes. Publish or revert the changes to fix this issue."

    # Display up to 10 IDs
    display_count=$([ $total_staged_issues -gt 10 ] && echo 10 || echo $total_staged_issues)
    for ((i=0; i<display_count; i++)); do
        echo "  - ${staged_published_rule_ids[$i]}"
    done

    # Indicate if there are more
    [ $total_staged_issues -gt 10 ] && echo "  ... and $((total_staged_issues - 10)) more."
fi

# Report JSON blob rule issues
if [ $total_json_blob_issues -gt 0 ]; then
    echo "  Found JSON blob rules with multiple JSON objects instead of a single object."

    # Display up to 10 IDs
    display_count=$([ $total_json_blob_issues -gt 10 ] && echo 10 || echo $total_json_blob_issues)
    for ((i=0; i<display_count; i++)); do
        echo "  - ${bad_json_blob_rule_ids[$i]}"
    done

    # Indicate if there are more
    [ $total_json_blob_issues -gt 10 ] && echo "  ... and $((total_json_blob_issues - 10)) more."
fi

echo "See $OUTPUT_FILE for the full list of invalid content with complete document details"
echo "Processed $processed_docs rules."
exit 0