859 lines
26 KiB
Bash
Executable File
859 lines
26 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# manage-dashboards - Manage Grafana dashboards for the Incus observability stack
|
|
#
|
|
# Push, export, validate, and inspect Grafana dashboards via the Grafana HTTP
|
|
# API. Dashboards are organized into folders and use datasource UID variables
|
|
# for portability across deployments.
|
|
#
|
|
# Usage: manage-dashboards [OPTIONS]
|
|
# Run 'manage-dashboards --help' for full usage information.
|
|
|
|
set -euo pipefail
|
|
|
|
readonly VERSION="0.1.0"
|
|
readonly SCRIPT_NAME="manage-dashboards"
|
|
readonly SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
|
readonly DASHBOARDS_DIR="${SCRIPT_DIR}/data/observability-dashboards"
|
|
readonly MANIFEST_FILE="${DASHBOARDS_DIR}/dashboard.yaml"
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Defaults (overridden by CLI flags)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
CLUSTER_REMOTE="oc-node-01"
|
|
MONITORING_CONTAINER="monitoring"
|
|
GRAFANA_URL="http://localhost:3000"
|
|
GRAFANA_USER="admin"
|
|
GRAFANA_PASSWORD="admin"
|
|
|
|
# Runtime flags
|
|
DRY_RUN=false
|
|
VERBOSE=false
|
|
QUIET=false
|
|
ACTION=""
|
|
FILTER_CATEGORY=""
|
|
FILTER_FILE=""
|
|
FILTER_UID=""
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Color and formatting
|
|
# ---------------------------------------------------------------------------
|
|
|
|
setup_colors() {
|
|
if [[ -t 1 ]] && [[ "${NO_COLOR:-}" != "1" ]] && [[ "${TERM:-}" != "dumb" ]]; then
|
|
RED='\033[0;31m'
|
|
GREEN='\033[0;32m'
|
|
YELLOW='\033[0;33m'
|
|
BLUE='\033[0;34m'
|
|
CYAN='\033[0;36m'
|
|
BOLD='\033[1m'
|
|
DIM='\033[2m'
|
|
RESET='\033[0m'
|
|
else
|
|
RED='' GREEN='' YELLOW='' BLUE='' CYAN='' BOLD='' DIM='' RESET=''
|
|
fi
|
|
}
|
|
|
|
info() { [[ "$QUIET" == true ]] && return; echo -e "${BLUE}[info]${RESET} $*"; }
|
|
success() { [[ "$QUIET" == true ]] && return; echo -e "${GREEN}[ok]${RESET} $*"; }
|
|
warn() { echo -e "${YELLOW}[warn]${RESET} $*" >&2; }
|
|
error() { echo -e "${RED}[error]${RESET} $*" >&2; }
|
|
step() { [[ "$QUIET" == true ]] && return; echo -e "${CYAN}[step]${RESET} ${BOLD}$*${RESET}"; }
|
|
detail() { [[ "$VERBOSE" != true ]] && return; echo -e "${DIM} $*${RESET}"; }
|
|
|
|
dry_run_guard() {
|
|
if [[ "$DRY_RUN" == true ]]; then
|
|
info "(dry-run) $*"
|
|
return 1
|
|
fi
|
|
return 0
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Help
|
|
# ---------------------------------------------------------------------------
|
|
|
|
usage() {
|
|
cat <<EOF
|
|
${BOLD}${SCRIPT_NAME}${RESET} v${VERSION} - Manage Grafana dashboards for the Incus observability stack
|
|
|
|
${BOLD}USAGE${RESET}
|
|
${SCRIPT_NAME} [OPTIONS]
|
|
|
|
${BOLD}ACTIONS${RESET}
|
|
--install Push dashboards to Grafana via API, organized into folders
|
|
--export Export dashboards from Grafana to clean JSON files
|
|
--list Show available dashboards with install status
|
|
--validate Check JSON quality and portability
|
|
--status Compare installed vs local versions
|
|
|
|
${BOLD}FILTERS${RESET}
|
|
--category NAME Only process dashboards in this category/folder
|
|
--file PATH Only process this specific dashboard file
|
|
--uid UID Only process the dashboard with this UID (for --export)
|
|
|
|
${BOLD}OPTIONS${RESET}
|
|
-r, --remote NAME Incus remote (default: ${CLUSTER_REMOTE})
|
|
-n, --dry-run Preview actions without executing
|
|
-v, --verbose Show detailed output
|
|
-q, --quiet Suppress informational output
|
|
-h, --help Show this help message
|
|
|
|
${BOLD}DATASOURCE PORTABILITY${RESET}
|
|
Dashboard JSON files use \${DS_PROMETHEUS} and \${DS_LOKI} variables
|
|
instead of hardcoded datasource UIDs. The --install action resolves
|
|
these to the actual UIDs from the target Grafana instance. The --export
|
|
action normalizes UIDs back to variables.
|
|
|
|
${BOLD}DASHBOARD MANIFEST${RESET}
|
|
${MANIFEST_FILE}
|
|
YAML file listing each dashboard with file path, UID, title, folder,
|
|
category, and version. Used by --install and --list.
|
|
|
|
${BOLD}EXAMPLES${RESET}
|
|
# Validate all dashboard JSON files
|
|
${SCRIPT_NAME} --validate
|
|
|
|
# Install all dashboards into Grafana
|
|
${SCRIPT_NAME} --install
|
|
|
|
# Install only dashboards in the "core" category
|
|
${SCRIPT_NAME} --install --category core
|
|
|
|
# Export a single dashboard by UID
|
|
${SCRIPT_NAME} --export --uid incus-cluster-overview
|
|
|
|
# Compare installed versions with local files
|
|
${SCRIPT_NAME} --status
|
|
|
|
# Preview what would be installed
|
|
${SCRIPT_NAME} --install --dry-run
|
|
EOF
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Helpers
|
|
# ---------------------------------------------------------------------------
|
|
|
|
grafana_api() {
|
|
local method="$1" path="$2"
|
|
shift 2
|
|
incus exec "${CLUSTER_REMOTE}:${MONITORING_CONTAINER}" -- \
|
|
curl -s -u "${GRAFANA_USER}:${GRAFANA_PASSWORD}" \
|
|
-X "$method" "${GRAFANA_URL}${path}" "$@"
|
|
}
|
|
|
|
# Resolve datasource UID variables to actual UIDs from Grafana
|
|
resolve_datasource_uids() {
|
|
local ds_json
|
|
ds_json=$(grafana_api GET "/api/datasources")
|
|
|
|
PROMETHEUS_UID=$(echo "$ds_json" | python3 -c "
|
|
import sys, json
|
|
ds = json.load(sys.stdin)
|
|
for d in ds:
|
|
if d.get('type') == 'prometheus':
|
|
print(d['uid'])
|
|
break
|
|
" 2>/dev/null || echo "")
|
|
|
|
LOKI_UID=$(echo "$ds_json" | python3 -c "
|
|
import sys, json
|
|
ds = json.load(sys.stdin)
|
|
for d in ds:
|
|
if d.get('type') == 'loki':
|
|
print(d['uid'])
|
|
break
|
|
" 2>/dev/null || echo "")
|
|
|
|
if [[ -z "$PROMETHEUS_UID" ]]; then
|
|
error "Could not find Prometheus datasource in Grafana"
|
|
return 1
|
|
fi
|
|
detail "Prometheus datasource UID: ${PROMETHEUS_UID}"
|
|
detail "Loki datasource UID: ${LOKI_UID:-not found}"
|
|
}
|
|
|
|
# Get or create a Grafana folder, returns folder ID
|
|
ensure_folder() {
|
|
local folder_title="$1"
|
|
|
|
# Check if folder exists
|
|
local folder_id
|
|
folder_id=$(grafana_api GET "/api/folders" | python3 -c "
|
|
import sys, json
|
|
folders = json.load(sys.stdin)
|
|
for f in folders:
|
|
if f.get('title') == '${folder_title}':
|
|
print(f['id'])
|
|
break
|
|
" 2>/dev/null || echo "")
|
|
|
|
if [[ -n "$folder_id" ]]; then
|
|
detail "Folder '${folder_title}' exists (ID: ${folder_id})" >&2
|
|
echo "$folder_id"
|
|
return 0
|
|
fi
|
|
|
|
# Create folder
|
|
local folder_uid
|
|
folder_uid=$(echo "$folder_title" | tr '[:upper:]' '[:lower:]' | tr ' ' '-')
|
|
local result
|
|
result=$(grafana_api POST "/api/folders" \
|
|
-H "Content-Type: application/json" \
|
|
-d "{\"title\": \"${folder_title}\", \"uid\": \"${folder_uid}\"}")
|
|
|
|
folder_id=$(echo "$result" | python3 -c "
|
|
import sys, json
|
|
print(json.load(sys.stdin).get('id', ''))
|
|
" 2>/dev/null || echo "")
|
|
|
|
if [[ -n "$folder_id" ]]; then
|
|
detail "Created folder '${folder_title}' (ID: ${folder_id})" >&2
|
|
echo "$folder_id"
|
|
else
|
|
error "Failed to create folder '${folder_title}': ${result}"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Read manifest and output entries as tab-separated lines
|
|
read_manifest() {
|
|
if [[ ! -f "$MANIFEST_FILE" ]]; then
|
|
error "Dashboard manifest not found: ${MANIFEST_FILE}"
|
|
error "Expected a YAML file listing dashboard metadata."
|
|
return 1
|
|
fi
|
|
|
|
python3 -c "
|
|
import sys, re
|
|
|
|
entries = []
|
|
current = {}
|
|
|
|
with open('${MANIFEST_FILE}') as f:
|
|
for line in f:
|
|
stripped = line.rstrip()
|
|
# New entry starts with ' - file:'
|
|
m = re.match(r'^ - file:\s*(.*)', stripped)
|
|
if m:
|
|
if current:
|
|
entries.append(current)
|
|
current = {'file': m.group(1).strip()}
|
|
continue
|
|
# Key-value within an entry
|
|
m = re.match(r'^ (\w+):\s*(.*)', stripped)
|
|
if m and current:
|
|
key, val = m.group(1), m.group(2).strip()
|
|
# Strip YAML >- multiline indicators and quotes
|
|
if val in ('>-', '>', '|'):
|
|
val = ''
|
|
val = val.strip('\"').strip(\"'\")
|
|
if key in current and not val:
|
|
continue
|
|
current[key] = val
|
|
continue
|
|
# Continuation line (multiline description)
|
|
if current and stripped.startswith(' ') and stripped.strip():
|
|
if 'description' in current:
|
|
sep = ' ' if current['description'] else ''
|
|
current['description'] = current['description'] + sep + stripped.strip()
|
|
|
|
if current:
|
|
entries.append(current)
|
|
|
|
for d in entries:
|
|
parts = [
|
|
d.get('file', ''),
|
|
d.get('uid', ''),
|
|
d.get('title', ''),
|
|
d.get('folder', 'General'),
|
|
d.get('category', ''),
|
|
d.get('version', '1'),
|
|
d.get('description', ''),
|
|
]
|
|
print('\t'.join(parts))
|
|
"
|
|
}
|
|
|
|
# Substitute datasource variables in JSON content
|
|
inject_datasource_uids() {
|
|
local json_content="$1"
|
|
echo "$json_content" \
|
|
| sed "s/\\\${DS_PROMETHEUS}/${PROMETHEUS_UID}/g" \
|
|
| sed "s/\\\${DS_LOKI}/${LOKI_UID}/g"
|
|
}
|
|
|
|
# Normalize datasource UIDs back to variables for portability
|
|
normalize_datasource_uids() {
|
|
local json_content="$1"
|
|
local prom_uid="$2"
|
|
local loki_uid="$3"
|
|
|
|
local result="$json_content"
|
|
if [[ -n "$prom_uid" ]]; then
|
|
result=$(echo "$result" | sed "s/${prom_uid}/\\\${DS_PROMETHEUS}/g")
|
|
fi
|
|
if [[ -n "$loki_uid" ]]; then
|
|
result=$(echo "$result" | sed "s/${loki_uid}/\\\${DS_LOKI}/g")
|
|
fi
|
|
echo "$result"
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Install action
|
|
# ---------------------------------------------------------------------------
|
|
|
|
action_install() {
|
|
step "Installing dashboards to Grafana"
|
|
echo
|
|
|
|
if ! dry_run_guard "Resolve datasource UIDs and push dashboards"; then
|
|
info "(dry-run) Would install dashboards from ${DASHBOARDS_DIR}"
|
|
|
|
local count=0
|
|
while IFS=$'\t' read -r file uid title folder category version description <&3; do
|
|
if [[ -n "$FILTER_CATEGORY" && "$category" != "$FILTER_CATEGORY" ]]; then
|
|
continue
|
|
fi
|
|
if [[ -n "$FILTER_FILE" && "$file" != "$FILTER_FILE" ]]; then
|
|
continue
|
|
fi
|
|
info "(dry-run) Would install: ${title} -> folder '${folder}'"
|
|
count=$((count + 1))
|
|
done 3< <(read_manifest)
|
|
|
|
info "(dry-run) ${count} dashboard(s) would be installed"
|
|
return 0
|
|
fi
|
|
|
|
resolve_datasource_uids
|
|
|
|
local installed=0
|
|
local failed=0
|
|
|
|
while IFS=$'\t' read -r file uid title folder category version description <&3; do
|
|
if [[ -n "$FILTER_CATEGORY" && "$category" != "$FILTER_CATEGORY" ]]; then
|
|
continue
|
|
fi
|
|
if [[ -n "$FILTER_FILE" && "$file" != "$FILTER_FILE" ]]; then
|
|
continue
|
|
fi
|
|
|
|
local full_path="${DASHBOARDS_DIR}/${file}"
|
|
if [[ ! -f "$full_path" ]]; then
|
|
warn "Dashboard file not found: ${full_path}"
|
|
failed=$((failed + 1))
|
|
continue
|
|
fi
|
|
|
|
# Get or create the target folder
|
|
local folder_id
|
|
folder_id=$(ensure_folder "$folder") || { failed=$((failed + 1)); continue; }
|
|
|
|
# Build Grafana API payload: inject datasource UIDs and wrap in envelope
|
|
local api_payload
|
|
api_payload=$(python3 - "$full_path" "$PROMETHEUS_UID" "${LOKI_UID:-}" "$folder_id" << 'PYEOF'
|
|
import json, sys
|
|
|
|
with open(sys.argv[1]) as f:
|
|
dashboard = json.load(f)
|
|
|
|
# Inject actual datasource UIDs
|
|
json_str = json.dumps(dashboard)
|
|
json_str = json_str.replace('${DS_PROMETHEUS}', sys.argv[2])
|
|
if sys.argv[3]:
|
|
json_str = json_str.replace('${DS_LOKI}', sys.argv[3])
|
|
dashboard = json.loads(json_str)
|
|
|
|
# Remove Grafana-internal fields
|
|
for key in ('id', 'version', 'iteration'):
|
|
dashboard.pop(key, None)
|
|
|
|
payload = {
|
|
'dashboard': dashboard,
|
|
'folderId': int(sys.argv[4]),
|
|
'overwrite': True,
|
|
'message': 'Installed by manage-dashboards'
|
|
}
|
|
print(json.dumps(payload))
|
|
PYEOF
|
|
)
|
|
|
|
if [[ -z "$api_payload" ]]; then
|
|
error "Failed to process dashboard JSON: ${file}"
|
|
failed=$((failed + 1))
|
|
continue
|
|
fi
|
|
|
|
# Push via API - write payload to temp file to avoid command-line size limits
|
|
local tmpfile
|
|
tmpfile=$(mktemp /tmp/dashboard-payload.XXXXXX)
|
|
echo "$api_payload" > "$tmpfile"
|
|
|
|
incus file push "$tmpfile" "${CLUSTER_REMOTE}:${MONITORING_CONTAINER}/tmp/dashboard-payload.json" >/dev/null 2>&1
|
|
|
|
local result
|
|
result=$(grafana_api POST "/api/dashboards/db" \
|
|
-H "Content-Type: application/json" \
|
|
-d @/tmp/dashboard-payload.json 2>/dev/null)
|
|
rm -f "$tmpfile"
|
|
|
|
local status_str
|
|
status_str=$(echo "$result" | python3 -c "
|
|
import sys, json
|
|
try:
|
|
d = json.load(sys.stdin)
|
|
print(d.get('status', d.get('message', 'unknown')))
|
|
except:
|
|
print('error')
|
|
" 2>/dev/null || echo "error")
|
|
|
|
if [[ "$status_str" == "success" ]]; then
|
|
success " ${title} -> ${folder}"
|
|
installed=$((installed + 1))
|
|
else
|
|
error " ${title}: ${status_str}"
|
|
detail " Response: ${result}"
|
|
failed=$((failed + 1))
|
|
fi
|
|
|
|
# Clean up temp file in container
|
|
incus exec "${CLUSTER_REMOTE}:${MONITORING_CONTAINER}" -- rm -f /tmp/dashboard-payload.json 2>/dev/null || true
|
|
|
|
done 3< <(read_manifest)
|
|
|
|
echo
|
|
if [[ $failed -eq 0 ]]; then
|
|
success "Installed ${installed} dashboard(s)"
|
|
else
|
|
warn "Installed ${installed}, failed ${failed}"
|
|
fi
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Export action
|
|
# ---------------------------------------------------------------------------
|
|
|
|
action_export() {
|
|
step "Exporting dashboards from Grafana"
|
|
echo
|
|
|
|
resolve_datasource_uids
|
|
|
|
local exported=0
|
|
|
|
if [[ -n "$FILTER_UID" ]]; then
|
|
# Export a single dashboard by UID
|
|
export_single_dashboard "$FILTER_UID"
|
|
return $?
|
|
fi
|
|
|
|
# Export all dashboards listed in the manifest
|
|
while IFS=$'\t' read -r file uid title folder category version description <&3; do
|
|
if [[ -n "$FILTER_CATEGORY" && "$category" != "$FILTER_CATEGORY" ]]; then
|
|
continue
|
|
fi
|
|
|
|
if export_single_dashboard "$uid" "${DASHBOARDS_DIR}/${file}"; then
|
|
exported=$((exported + 1))
|
|
fi
|
|
done 3< <(read_manifest)
|
|
|
|
echo
|
|
success "Exported ${exported} dashboard(s)"
|
|
}
|
|
|
|
export_single_dashboard() {
|
|
local uid="$1"
|
|
local output_file="${2:-}"
|
|
|
|
# Fetch from Grafana API
|
|
local raw_response
|
|
raw_response=$(grafana_api GET "/api/dashboards/uid/${uid}" 2>/dev/null)
|
|
|
|
local has_dashboard
|
|
has_dashboard=$(echo "$raw_response" | python3 -c "
|
|
import sys, json
|
|
try:
|
|
d = json.load(sys.stdin)
|
|
if 'dashboard' in d:
|
|
print('yes')
|
|
else:
|
|
print('no')
|
|
except:
|
|
print('no')
|
|
" 2>/dev/null || echo "no")
|
|
|
|
if [[ "$has_dashboard" != "yes" ]]; then
|
|
warn "Dashboard '${uid}' not found in Grafana"
|
|
return 1
|
|
fi
|
|
|
|
# If no output file specified, find it in the manifest
|
|
if [[ -z "$output_file" ]]; then
|
|
output_file=$(read_manifest | while IFS=$'\t' read -r file muid title folder category version description; do
|
|
if [[ "$muid" == "$uid" ]]; then
|
|
echo "${DASHBOARDS_DIR}/${file}"
|
|
break
|
|
fi
|
|
done)
|
|
fi
|
|
|
|
if [[ -z "$output_file" ]]; then
|
|
output_file="${DASHBOARDS_DIR}/core/${uid}.json"
|
|
warn "Dashboard '${uid}' not in manifest, exporting to ${output_file}"
|
|
fi
|
|
|
|
if ! dry_run_guard "Export ${uid} to ${output_file}"; then
|
|
return 0
|
|
fi
|
|
|
|
# Clean and normalize the dashboard JSON
|
|
python3 << PYEOF > "$output_file"
|
|
import json, sys
|
|
|
|
raw = json.loads('''$(echo "$raw_response" | sed "s/'/\\\\'/g")''')
|
|
dashboard = raw['dashboard']
|
|
|
|
# Remove Grafana-internal fields
|
|
for key in ['id', 'version', 'iteration']:
|
|
dashboard.pop(key, None)
|
|
|
|
# Normalize datasource UIDs to variables
|
|
json_str = json.dumps(dashboard, indent=2)
|
|
prom_uid = "${PROMETHEUS_UID}"
|
|
loki_uid = "${LOKI_UID:-}"
|
|
if prom_uid:
|
|
json_str = json_str.replace(prom_uid, r'\${DS_PROMETHEUS}')
|
|
if loki_uid:
|
|
json_str = json_str.replace(loki_uid, r'\${DS_LOKI}')
|
|
|
|
# Re-parse to ensure valid JSON
|
|
dashboard = json.loads(json_str.replace(r'\${DS_PROMETHEUS}', '\${DS_PROMETHEUS}').replace(r'\${DS_LOKI}', '\${DS_LOKI}'))
|
|
|
|
# Write with consistent formatting
|
|
json_str = json.dumps(dashboard, indent=2)
|
|
# Restore the variable syntax that json.dumps may have escaped
|
|
json_str = json_str.replace(r'\${DS_PROMETHEUS}', '\${DS_PROMETHEUS}')
|
|
json_str = json_str.replace(r'\${DS_LOKI}', '\${DS_LOKI}')
|
|
print(json_str)
|
|
PYEOF
|
|
|
|
if [[ $? -eq 0 ]]; then
|
|
success " Exported: ${uid} -> $(basename "$output_file")"
|
|
return 0
|
|
else
|
|
error " Failed to export: ${uid}"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# List action
|
|
# ---------------------------------------------------------------------------
|
|
|
|
action_list() {
|
|
step "Dashboard Inventory"
|
|
echo
|
|
|
|
# Try to get installed dashboards from Grafana
|
|
local installed_json=""
|
|
installed_json=$(grafana_api GET "/api/search?type=dash-db" 2>/dev/null || echo "[]")
|
|
|
|
printf " ${BOLD}%-35s %-30s %-20s %s${RESET}\n" "UID" "Title" "Folder" "Status"
|
|
printf " %-35s %-30s %-20s %s\n" "---" "-----" "------" "------"
|
|
|
|
while IFS=$'\t' read -r file uid title folder category version description <&3; do
|
|
if [[ -n "$FILTER_CATEGORY" && "$category" != "$FILTER_CATEGORY" ]]; then
|
|
continue
|
|
fi
|
|
|
|
local full_path="${DASHBOARDS_DIR}/${file}"
|
|
local local_status="missing"
|
|
if [[ -f "$full_path" ]]; then
|
|
local_status="local"
|
|
fi
|
|
|
|
# Check if installed in Grafana
|
|
local grafana_status
|
|
grafana_status=$(echo "$installed_json" | python3 -c "
|
|
import sys, json
|
|
try:
|
|
dashboards = json.load(sys.stdin)
|
|
for d in dashboards:
|
|
if d.get('uid') == '${uid}':
|
|
print('installed')
|
|
break
|
|
else:
|
|
print('not installed')
|
|
except:
|
|
print('unknown')
|
|
" 2>/dev/null || echo "unknown")
|
|
|
|
local status_display
|
|
if [[ "$local_status" == "missing" ]]; then
|
|
status_display="${RED}file missing${RESET}"
|
|
elif [[ "$grafana_status" == "installed" ]]; then
|
|
status_display="${GREEN}installed${RESET}"
|
|
elif [[ "$grafana_status" == "not installed" ]]; then
|
|
status_display="${YELLOW}not installed${RESET}"
|
|
else
|
|
status_display="${DIM}${local_status}${RESET}"
|
|
fi
|
|
|
|
printf " %-35s %-30s %-20s " "$uid" "$title" "$folder"
|
|
echo -e "$status_display"
|
|
|
|
done 3< <(read_manifest)
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Validate action
|
|
# ---------------------------------------------------------------------------
|
|
|
|
action_validate() {
|
|
step "Validating dashboard JSON files"
|
|
echo
|
|
|
|
local total=0
|
|
local passed=0
|
|
local warnings=0
|
|
local errors=0
|
|
|
|
while IFS=$'\t' read -r file uid title folder category version description <&3; do
|
|
if [[ -n "$FILTER_CATEGORY" && "$category" != "$FILTER_CATEGORY" ]]; then
|
|
continue
|
|
fi
|
|
|
|
local full_path="${DASHBOARDS_DIR}/${file}"
|
|
total=$((total + 1))
|
|
|
|
if [[ ! -f "$full_path" ]]; then
|
|
error " ${file}: FILE NOT FOUND"
|
|
errors=$((errors + 1))
|
|
continue
|
|
fi
|
|
|
|
local issues=0
|
|
local warns=0
|
|
local basename_file
|
|
basename_file=$(basename "$full_path")
|
|
|
|
# Check 1: Valid JSON
|
|
if ! python3 -c "import json; json.load(open('${full_path}'))" 2>/dev/null; then
|
|
error " ${basename_file}: INVALID JSON"
|
|
errors=$((errors + 1))
|
|
continue
|
|
fi
|
|
|
|
# Run all checks via python
|
|
local check_result
|
|
check_result=$(python3 << PYEOF
|
|
import json
|
|
|
|
with open('${full_path}') as f:
|
|
d = json.load(f)
|
|
|
|
issues = []
|
|
warns = []
|
|
|
|
# Check 2: UID present and matches manifest
|
|
json_uid = d.get('uid', '')
|
|
if not json_uid:
|
|
issues.append('missing uid field')
|
|
elif json_uid != '${uid}':
|
|
issues.append(f'uid mismatch: JSON has "{json_uid}", manifest has "${uid}"')
|
|
|
|
# Check 3: Title present
|
|
if not d.get('title'):
|
|
issues.append('missing title field')
|
|
|
|
# Check 4: Description present
|
|
if not d.get('description'):
|
|
warns.append('missing description field')
|
|
|
|
# Check 5: No hardcoded datasource UIDs (should use variables)
|
|
json_str = json.dumps(d)
|
|
# Known Grafana internal UIDs that are OK
|
|
safe_uids = ['-- Grafana --']
|
|
# Check for UIDs that look like Grafana-generated ones
|
|
import re
|
|
# Match patterns like "uid": "PBFA97CFB590B2093" (hex-like, not a variable)
|
|
uid_pattern = re.compile(r'"uid":\s*"([A-Za-z0-9]{16,})"')
|
|
for match in uid_pattern.finditer(json_str):
|
|
found_uid = match.group(1)
|
|
if found_uid not in safe_uids and not found_uid.startswith('\${'):
|
|
issues.append(f'hardcoded datasource UID: {found_uid}')
|
|
break
|
|
|
|
# Check 6: Datasource variable usage
|
|
if '\${DS_PROMETHEUS}' not in json_str and '\${DS_LOKI}' not in json_str:
|
|
# Check if it has any datasource references at all
|
|
if '"type": "prometheus"' in json_str or '"type": "loki"' in json_str:
|
|
warns.append('no datasource variables found (uses hardcoded UIDs?)')
|
|
|
|
# Check 7: Has panels
|
|
panels = d.get('panels', [])
|
|
if not panels:
|
|
warns.append('no panels defined')
|
|
|
|
# Check 8: Check for id field (should not be present in stored files)
|
|
if 'id' in d and d['id'] is not None:
|
|
warns.append('contains "id" field (should be null or absent for portability)')
|
|
|
|
for i in issues:
|
|
print(f'ERROR:{i}')
|
|
for w in warns:
|
|
print(f'WARN:{w}')
|
|
if not issues:
|
|
print('OK')
|
|
PYEOF
|
|
)
|
|
|
|
local has_error=false
|
|
while IFS= read -r line; do
|
|
case "$line" in
|
|
ERROR:*)
|
|
error " ${basename_file}: ${line#ERROR:}"
|
|
issues=$((issues + 1))
|
|
has_error=true
|
|
;;
|
|
WARN:*)
|
|
warn " ${basename_file}: ${line#WARN:}"
|
|
warns=$((warns + 1))
|
|
;;
|
|
OK)
|
|
;;
|
|
esac
|
|
done <<< "$check_result"
|
|
|
|
if [[ "$has_error" == true ]]; then
|
|
errors=$((errors + 1))
|
|
else
|
|
if [[ $warns -gt 0 ]]; then
|
|
warnings=$((warnings + warns))
|
|
fi
|
|
passed=$((passed + 1))
|
|
success " ${basename_file}: valid"
|
|
fi
|
|
|
|
done 3< <(read_manifest)
|
|
|
|
echo
|
|
info "${total} dashboard(s) checked: ${passed} passed, ${errors} errors, ${warnings} warnings"
|
|
|
|
if [[ $errors -gt 0 ]]; then
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Status action
|
|
# ---------------------------------------------------------------------------
|
|
|
|
action_status() {
|
|
step "Dashboard Status (local vs installed)"
|
|
echo
|
|
|
|
local installed_json
|
|
installed_json=$(grafana_api GET "/api/search?type=dash-db" 2>/dev/null || echo "[]")
|
|
|
|
printf " ${BOLD}%-30s %-15s %-15s %s${RESET}\n" "Dashboard" "Local" "Grafana" "Match"
|
|
printf " %-30s %-15s %-15s %s\n" "---------" "-----" "-------" "-----"
|
|
|
|
while IFS=$'\t' read -r file uid title folder category version description <&3; do
|
|
local full_path="${DASHBOARDS_DIR}/${file}"
|
|
|
|
local local_ver="missing"
|
|
if [[ -f "$full_path" ]]; then
|
|
local_ver="v${version}"
|
|
fi
|
|
|
|
local grafana_ver
|
|
grafana_ver=$(echo "$installed_json" | python3 -c "
|
|
import sys, json
|
|
try:
|
|
for d in json.load(sys.stdin):
|
|
if d.get('uid') == '${uid}':
|
|
print('installed')
|
|
break
|
|
else:
|
|
print('absent')
|
|
except:
|
|
print('unknown')
|
|
" 2>/dev/null || echo "unknown")
|
|
|
|
local match_str
|
|
if [[ "$local_ver" == "missing" ]]; then
|
|
match_str="${RED}file missing${RESET}"
|
|
elif [[ "$grafana_ver" == "absent" ]]; then
|
|
match_str="${YELLOW}not installed${RESET}"
|
|
elif [[ "$grafana_ver" == "installed" ]]; then
|
|
match_str="${GREEN}synced${RESET}"
|
|
else
|
|
match_str="${DIM}unknown${RESET}"
|
|
fi
|
|
|
|
printf " %-30s %-15s %-15s " "$title" "$local_ver" "$grafana_ver"
|
|
echo -e "$match_str"
|
|
|
|
done 3< <(read_manifest)
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Argument parsing
|
|
# ---------------------------------------------------------------------------
|
|
|
|
parse_args() {
|
|
while [[ $# -gt 0 ]]; do
|
|
case "$1" in
|
|
--install) ACTION="install";;
|
|
--export) ACTION="export";;
|
|
--list) ACTION="list";;
|
|
--validate) ACTION="validate";;
|
|
--status) ACTION="status";;
|
|
--category) FILTER_CATEGORY="$2"; shift;;
|
|
--file) FILTER_FILE="$2"; shift;;
|
|
--uid) FILTER_UID="$2"; shift;;
|
|
-r|--remote) CLUSTER_REMOTE="$2"; shift;;
|
|
-n|--dry-run) DRY_RUN=true;;
|
|
-v|--verbose) VERBOSE=true;;
|
|
-q|--quiet) QUIET=true;;
|
|
-h|--help) usage; exit 0;;
|
|
*)
|
|
error "Unknown option: $1"
|
|
echo "Run '${SCRIPT_NAME} --help' for usage."
|
|
exit 1
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
if [[ -z "$ACTION" ]]; then
|
|
error "No action specified"
|
|
echo "Run '${SCRIPT_NAME} --help' for usage."
|
|
exit 1
|
|
fi
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Main
|
|
# ---------------------------------------------------------------------------
|
|
|
|
main() {
|
|
setup_colors
|
|
parse_args "$@"
|
|
|
|
echo
|
|
case "$ACTION" in
|
|
install) action_install;;
|
|
export) action_export;;
|
|
list) action_list;;
|
|
validate) action_validate;;
|
|
status) action_status;;
|
|
esac
|
|
}
|
|
|
|
main "$@"
|