backup_nexus 0.1.0

data/config/routes.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+BackupNexus::Engine.routes.draw do
+  get "backup", to: "backup#index", as: :backup
+  get "backup/new", to: "backup#new", as: :new_backup
+  post "backup", to: "backup#create"
+  get "backup/history", to: "backup#all_history", as: :backup_history
+  get "backup/:id/edit", to: "backup#edit", as: :edit_backup
+  patch "backup/:id", to: "backup#update"
+  delete "backup/:id", to: "backup#destroy", as: :backup_destroy
+  post "backup/:id/trigger", to: "backup#trigger", as: :backup_trigger
+  get "backup/:id/history", to: "backup#history", as: :backup_config_history
+
+  root to: "backup#index"
+end

data/db/seeds/backup_configs_safe.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# Safe example backup configuration.
+#
+# This seed intentionally contains no real hosts, usernames, paths, or
+# passwords. Keep application-specific values in environment variables or
+# Rails encrypted credentials, never in a committed seed file.
+#
+# Run with:
+#   rails runner db/seeds/backup_configs_safe.rb
+#
+# Or from the engine:
+#   backup_nexus:seed_backups
+
+configs = [
+  {
+    name: "local_backup_example",
+    description: "Disabled local backup example; configure before enabling",
+    adapter: "mysql",
+    database_name: "app_development",
+    host: "localhost",
+    port: 3306,
+    username: "ENV[DATABASE_USERNAME]",
+    password: "ENV[DATABASE_PASSWORD]",
+    skip_tables: [],
+
+    storage_path: Rails.root.join("tmp", "backup_nexus_backups").to_s,
+    keep_count: 7,
+
+    compress: true,
+    bzip2_compress: false,
+    encrypted: false,
+    gpg_enabled: false,
+
+    rsync_enabled: false,
+    s3_enabled: false,
+    archive_enabled: false,
+
+    notify_on_success: false,
+    notify_on_failure: false,
+    email_notify: false,
+
+    schedule_cron: "",
+    enabled: false
+  }
+]
+
+puts "Seeding #{configs.size} safe backup config..."
+
+configs.each do |attrs|
+  config = BackupNexus::BackupConfig.find_or_initialize_by(name: attrs[:name])
+  config.assign_attributes(attrs)
+
+  if config.save
+    puts "  ✓ #{config.name} (#{config.adapter}/#{config.database_name})"
+  else
+    puts "  ✗ #{config.name}: #{config.errors.full_messages.join(', ')}"
+  end
+end
+
+puts "Done. #{BackupNexus::BackupConfig.count} configs total."

data/lib/backup_nexus/base_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module BackupNexus
+  class BaseRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/lib/backup_nexus/configuration.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module BackupNexus
+  class Configuration
+    attr_accessor :enabled
+    attr_accessor :database_url
+    attr_accessor :database_name
+    attr_accessor :database_yml
+    attr_accessor :table_prefix
+
+    def initialize
+      @enabled = false
+      @database_url = nil
+      @database_name = nil
+      @database_yml = nil
+      @table_prefix = "backup_nexus_"
+    end
+  end
+end

data/lib/backup_nexus/engine.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "rake"
+
+module BackupNexus
+  class Engine < ::Rails::Engine
+    isolate_namespace BackupNexus
+
+    engine_name "backup_nexus"
+
+    initializer "backup_nexus.database" do
+      ActiveSupport.on_load(:active_record) do
+        config = BackupNexus.configuration
+
+        if config.database_url.present?
+          uri = URI.parse(config.database_url)
+          BackupNexus::BaseRecord.establish_connection(
+            adapter: uri.scheme,
+            host: uri.host,
+            port: uri.port&.to_i,
+            username: URI.decode_www_form_component(uri.user || ""),
+            password: URI.decode_www_form_component(uri.password || ""),
+            database: uri.path&.gsub(%r{^/}, "")
+          )
+        elsif config.database_name.present?
+          yaml_path = Rails.root.join("config", "database.yml")
+          if yaml_path.exist?
+            yaml = YAML.safe_load(ERB.new(yaml_path.read).result, aliases: true) || {}
+            env_config = yaml[Rails.env.to_s] || yaml[Rails.env]
+            if env_config.is_a?(Hash)
+              db_config = env_config.symbolize_keys
+              db_config[:database] = config.database_name
+              BackupNexus::BaseRecord.establish_connection(**db_config)
+            end
+          end
+        elsif config.database_yml.present?
+          yaml_path = Rails.root.join(config.database_yml)
+          if yaml_path.exist?
+            yaml = YAML.safe_load(ERB.new(yaml_path.read).result, aliases: true) || {}
+            env_config = yaml[Rails.env.to_s] || yaml[Rails.env]
+            BackupNexus::BaseRecord.establish_connection(**env_config.symbolize_keys) if env_config.is_a?(Hash)
+          end
+        end
+      end
+    end
+
+    initializer "backup_nexus.rake_tasks" do
+      load "tasks/backup_nexus.rake" if Rake.respond_to?(:application)
+    end
+  end
+end

data/lib/backup_nexus/version.rb

@@ -0,0 +1,3 @@
+module BackupNexus
+  VERSION = "0.1.0"
+end

data/lib/backup_nexus.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "rails"
+require "rails_nexus"
+require "pagy"
+require "uri"
+require "yaml"
+require "erb"
+require "backup_nexus/version"
+require "backup_nexus/configuration"
+require "backup_nexus/base_record"
+require "backup_nexus/engine"
+
+module BackupNexus
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+  end
+end

data/lib/generators/backup_nexus/backup_generator.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/erb"
+
+module BackupNexus
+  module Generators
+    class BackupGenerator < Rails::Generators::Base
+      desc "Set up backup_nexus backup directory structure and models"
+      source_root File.expand_path("templates/backup/backup", __dir__)
+
+      def create_backup_directories
+        empty_directory "config/backup"
+        empty_directory "config/backup/models"
+        empty_directory "config/backup/mysql-config"
+        empty_directory "storage/backup_nexus/backups"
+        empty_directory "storage/backup_nexus/backups/sync"
+        empty_directory "storage/backup_nexus/backups/logs"
+      end
+
+      def create_config_template
+        template "config.rb", "config/backup/config.rb"
+      end
+
+      def create_model_templates
+        template "models/daily_backup.rb", "config/backup/models/daily_backup.rb"
+        template "models/full_backup.rb", "config/backup/models/full_backup.rb"
+        template "models/sync_backup.rb", "config/backup/models/sync_backup.rb"
+      end
+
+      def create_schedule_template
+        template "schedule.rb", "config/backup/schedule.rb"
+      end
+
+      def create_helper_script
+        template "backup_helper.sh", "bin/backup_nexus-backup"
+        chmod "bin/backup_nexus-backup", 0o755
+      end
+
+      def create_mysql_config
+        template "mysql-config/db_config.cnf", "config/backup/mysql-config/db_config.cnf"
+      end
+
+      def add_to_gitignore
+        append_to_file ".gitignore", <<~GITIGNORE unless File.exist?(".gitignore") && File.read(".gitignore").include?("backup_nexus/backups")
+          \n# BackupNexus backups
+          storage/backup_nexus/backups/
+          config/backup/mysql-config/db_config.cnf
+        GITIGNORE
+      end
+
+      def show_readme
+        say ""
+        say "✅ Backup directory structure created!", :green
+        say ""
+        say "Next steps:"
+        say "  1. Edit config/backup/config.rb with your database credentials"
+        say "  2. Customize models in config/backup/models/"
+        say "  3. Install the schedule: whenever --write-crontab"
+        say "  4. Test: bin/backup_nexus-backup status"
+        say ""
+        say "Backup models created:"
+        say "  - daily_backup:  Incremental (skips large tables), local + remote"
+        say "  - full_backup:   All tables, local only"
+        say "  - sync_backup:   Remote sync to backup server"
+        say ""
+      end
+    end
+  end
+end

data/lib/generators/backup_nexus/install_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module BackupNexus
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      def create_migration
+        migration_template "migration.rb", "db/migrate/create_backup_nexus_tables.rb"
+      end
+
+      def mount_engine
+        route 'mount BackupNexus::Engine => "/backup_nexus", as: "backup_nexus"'
+      end
+
+      def create_backup_files
+        generate "backup_nexus:backup"
+      end
+
+      def show_readme
+        say "BackupNexus installed at /backup_nexus. Run bin/rails db:migrate next.", :green
+      end
+    end
+  end
+end

data/lib/generators/backup_nexus/templates/backup/backup/backup_helper.sh

@@ -0,0 +1,152 @@
+#!/bin/bash
+# BackupNexus Backup Helper Script
+# Generated by: rails generate backup_nexus:backup
+#
+# Usage:
+#   ./backup_helper.sh run <model>     Run a backup model
+#   ./backup_helper.sh list            List backup files
+#   ./backup_helper.sh status          Show backup health status
+#   ./backup_helper.sh clean <days>    Remove backups older than N days
+
+set -e
+
+# Configuration
+BACKUP_DIR="${BACKUP_DUMP_PATH:-storage/backup_nexus/backups}"
+BUNDLE_PATH="${BUNDLE_PATH:-.bundle}"
+RUBY_ENV="${RUBY_ENV:-production}"
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+log_info() { echo -e "${GREEN}[INFO]${NC} $1"; }
+log_warn() { echo -e "${YELLOW}[WARN]${NC} $1"; }
+log_error() { echo -e "${RED}[ERROR]${NC} $1"; }
+
+# Run a backup
+run_backup() {
+  local model="$1"
+  if [ -z "$model" ]; then
+    log_error "Usage: $0 run <model_name>"
+    exit 1
+  fi
+
+  # Lock to prevent concurrent runs
+  LOCKFILE="/tmp/backup_nexus_backup_${model}.lock"
+  exec 200>"$LOCKFILE"
+  if ! flock -n 200; then
+    log_warn "Backup '$model' is already running. Skipping."
+    exit 0
+  fi
+
+  log_info "Running backup: $model"
+  cd "$(dirname "$0")/../../.."
+
+  if bundle exec backup perform -t "$model" --triggered_by backup_nexus; then
+    log_info "Backup '$model' completed successfully."
+  else
+    log_error "Backup '$model' FAILED."
+    exit 1
+  fi
+}
+
+# List backup files
+list_backups() {
+  local dir="$BACKUP_DIR"
+  if [ ! -d "$dir" ]; then
+    log_warn "No backup directory found at: $dir"
+    exit 0
+  fi
+
+  echo "Backup files in: $dir"
+  echo "─────────────────────────────────────────────"
+  printf "%-40s %10s %s\n" "FILE" "SIZE" "MODIFIED"
+  echo "─────────────────────────────────────────────"
+
+  find "$dir" -maxdepth 1 -type f -name "*.tar.gz*" -o -name "*.sql.gz*" | sort -r | head -20 | while read -r f; do
+    size=$(du -h "$f" | cut -f1)
+    modified=$(stat -c "%y" "$f" 2>/dev/null | cut -d'.' -f1 || date -r "$f" "+%Y-%m-%d %H:%M")
+    printf "%-40s %10s %s\n" "$(basename "$f")" "$size" "$modified"
+  done
+}
+
+# Show backup status
+show_status() {
+  local dir="$BACKUP_DIR"
+  if [ ! -d "$dir" ]; then
+    echo "Status: NOT_CONFIGURED"
+    echo "No backup directory at: $dir"
+    exit 0
+  fi
+
+  local total_files
+  total_files=$(find "$dir" -maxdepth 1 -type f | wc -l)
+  local total_size
+  total_size=$(du -sh "$dir" 2>/dev/null | cut -f1 || echo "0B")
+
+  local latest_file
+  latest_file=$(find "$dir" -maxdepth 1 -type f -name "*.tar.gz*" -o -name "*.sql.gz*" 2>/dev/null | sort -r | head -1)
+
+  if [ -z "$latest_file" ]; then
+    echo "Status: WARNING - No backup files found"
+  else
+    local age_hours
+    age_hours=$(( ($(date +%s) - $(stat -c "%Y" "$latest_file" 2>/dev/null || stat -f "%m" "$latest_file")) / 3600 ))
+
+    if [ "$age_hours" -lt 24 ]; then
+      echo "Status: HEALTHY"
+    elif [ "$age_hours" -lt 72 ]; then
+      echo "Status: WARNING - Last backup ${age_hours}h ago"
+    else
+      echo "Status: CRITICAL - Last backup ${age_hours}h ago"
+    fi
+  fi
+
+  echo "Files: $total_files"
+  echo "Size: $total_size"
+  [ -n "$latest_file" ] && echo "Latest: $(basename "$latest_file")"
+}
+
+# Clean old backups
+clean_backups() {
+  local days="${1:-30}"
+  local dir="$BACKUP_DIR"
+
+  if [ ! -d "$dir" ]; then
+    log_warn "No backup directory found at: $dir"
+    exit 0
+  fi
+
+  log_info "Removing backups older than $days days..."
+  find "$dir" -maxdepth 1 -type f -mtime +"$days" -delete
+  log_info "Cleanup complete."
+}
+
+# Main
+case "${1:-help}" in
+  run)
+    run_backup "$2"
+    ;;
+  list)
+    list_backups
+    ;;
+  status)
+    show_status
+    ;;
+  clean)
+    clean_backups "$2"
+    ;;
+  *)
+    echo "BackupNexus Backup Helper"
+    echo ""
+    echo "Usage: $0 <command> [args]"
+    echo ""
+    echo "Commands:"
+    echo "  run <model>    Run a backup model (e.g., daily_backup)"
+    echo "  list           List recent backup files"
+    echo "  status         Show backup health status"
+    echo "  clean [days]   Remove backups older than N days (default: 30)"
+    ;;
+esac

data/lib/generators/backup_nexus/templates/backup/backup/config.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+##
+# Backup v5.x Configuration
+# Generated by backup_nexus
+#
+# Documentation: http://backup.github.io/backup
+#
+
+# Logging
+# Logger.configure do
+#   console.quiet     = true
+#   logfile.max_bytes = 2_000_000
+#   syslog.enabled    = true
+#   syslog.ident      = '<%= Rails.application.class.module_parent_name.underscore %>_backup'
+# end
+
+# Storage defaults
+# Storage::Local.defaults do |local|
+#   local.path = 'storage/backup_nexus/backups'
+# end
+
+# Notifier defaults
+# Notifier::Mail.defaults do |mail|
+#   mail.from = 'backup@<%= Rails.application.class.module_parent_name.underscore %>.com'
+#   mail.to   = 'admin@<%= Rails.application.class.module_parent_name.underscore %>.com'
+# end

data/lib/generators/backup_nexus/templates/backup/backup/models/daily_backup.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+# Daily Backup - Generated by backup_nexus
+# Skips large/temporary tables for faster backups
+
+Model.new(:daily_backup, '<%= Rails.application.class.module_parent_name %> Daily Backup') do
+
+  ## MySQL [Database]
+  database MySQL do |db|
+    db.name               = "<%= Rails.configuration.database_configuration[Rails.env]['database'] %>"
+    db.port               = <%= Rails.configuration.database_configuration[Rails.env]['port'] || 3306 %>
+    db.skip_tables        = []
+    db.additional_options = ["--quick"]
+  end
+
+  ## Local [Storage]
+  store_with Local do |local|
+    local.path = 'storage/backup_nexus/backups'
+    local.keep = 30
+  end
+
+  ## Gzip [Compressor]
+  compress_with Gzip
+end

data/lib/generators/backup_nexus/templates/backup/backup/models/full_backup.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+# Full backup template — all tables, local storage only
+
+model :full_backup do
+  # Database
+  database Mysql do |db|
+    db.name = ENV["DATABASE_NAME"] || "myapp_production"
+    db.username = ENV["DATABASE_USER"] || "root"
+    db.password = ENV["DATABASE_PASSWORD"] || ""
+    db.host = ENV["DATABASE_HOST"] || "localhost"
+    db.port = (ENV["DATABASE_PORT"] || 3306).to_i
+    db.dump_options = {
+      single_transaction: true,
+      add_lock_tables: false
+    }
+  end
+
+  # Compress with Gzip
+  compress_with Gzip
+
+  # Store locally
+  store_with Local do |local|
+    local.path = ENV["BACKUP_DUMP_PATH"] || File.expand_path("storage/backup_nexus/backups", Rails.root)
+    local.keep = 10
+  end
+
+  # Notify on failure (optional)
+  notify_by Mail do |mail|
+    mail.on_success = false
+    mail.on_failure = true
+    mail.from = ENV["BACKUP_MAIL_FROM"] || "backup@example.com"
+    mail.to = ENV["BACKUP_MAIL_TO"] || "admin@example.com"
+    mail.smtp = { address: ENV["SMTP_HOST"] || "localhost", port: ENV["SMTP_PORT"] || 587 }
+  end
+end

data/lib/generators/backup_nexus/templates/backup/backup/models/sync_backup.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+# Sync backup template — remote sync to backup server
+
+model :sync_backup do
+  # Database
+  database Mysql do |db|
+    db.name = ENV["DATABASE_NAME"] || "myapp_production"
+    db.username = ENV["DATABASE_USER"] || "root"
+    db.password = ENV["DATABASE_PASSWORD"] || ""
+    db.host = ENV["DATABASE_HOST"] || "localhost"
+    db.port = (ENV["DATABASE_PORT"] || 3306).to_i
+
+    # Skip large/temporary tables
+    skip_tables = ENV["BACKUP_SKIP_TABLES"] || "sessions,caches,active_storage"
+    skip_tables.split(",").each { |t| db.skip_tables << t.strip }
+  end
+
+  # Compress with Gzip
+  compress_with Gzip
+
+  # Store locally (staging area)
+  store_with Local do |local|
+    local.path = ENV["BACKUP_DUMP_PATH"] || File.expand_path("storage/backup_nexus/backups/sync", Rails.root)
+    local.keep = 1
+  end
+
+  # Sync to remote server
+  notify_by Sync do |sync|
+    sync.directories do |directory|
+      directory.path = ENV["BACKUP_DUMP_PATH"] || File.expand_path("storage/backup_nexus/backups/sync", Rails.root)
+    end
+
+    connection do |conn|
+      conn.host = ENV["BACKUP_RSYNC_HOST"] || "backup.example.com"
+      conn.port = ENV["BACKUP_RSYNC_PORT"] || 22
+      conn.username = ENV["BACKUP_RSYNC_USER"] || "backup"
+      conn.ssh_options = {
+        keys: ENV["BACKUP_SSH_KEY"] || File.expand_path("~/.ssh/id_rsa"),
+        timeout: 30
+      }
+    end
+  end
+end

data/lib/generators/backup_nexus/templates/backup/backup/mysql-config/db_config.cnf

@@ -0,0 +1,15 @@
+# BackupNexus Backup MySQL Configuration
+# Generated by: rails generate backup_nexus:backup
+#
+# This file is used by the backup gem for database authentication.
+# Keep this file secure and do not commit to version control.
+
+[client]
+user=<%= ENV['DATABASE_USER'] || 'root' %>
+password=<%= ENV['DATABASE_PASSWORD'] || '' %>
+host=<%= ENV['DATABASE_HOST'] || 'localhost' %>
+port=<%= (ENV['DATABASE_PORT'] || 3306).to_i %>
+database=<%= ENV['DATABASE_NAME'] || 'myapp_production' %>
+
+# Dump options
+default-character-set=utf8mb4

data/lib/generators/backup_nexus/templates/backup/backup/schedule.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+# BackupNexus Backup Schedule
+# Generated by: rails generate backup_nexus:backup
+#
+# This file is parsed by the BackupService to show schedule info in the UI.
+# Actual cron should be installed separately: whenever --write-crontab
+
+# ─── Backup Schedule ──────────────────────────────────────────────
+
+# Full backup daily at 2:00 AM (all tables, local only)
+every 1.day, at: "2:00 am" do
+  command "cd #{File.expand_path('../..', __FILE__)} && bundle exec backup perform -t full_backup --triggered_by system"
+end
+
+# Incremental backup every 4 hours (skipping large tables)
+every 4.hours do
+  command "cd #{File.expand_path('../..', __FILE__)} && bundle exec backup perform -t incremental_backup --triggered_by system"
+end
+
+# Remote sync weekly on Sunday at 3:00 AM
+every 1.week, at: "3:00 am" do
+  command "cd #{File.expand_path('../..', __FILE__)} && bundle exec backup perform -t sync_backup --triggered_by system"
+end
+
+# Cleanup old backups monthly
+every 1.month, at: "4:00 am" do
+  command "cd #{File.expand_path('../..', __FILE__)} && bundle exec backup perform -t full_backup --cleanup"
+end