rails_nexus 2.1.0 → 2.1.3

data/app/controllers/rails_nexus/backup_controller.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-module RailsNexus
-  class BackupController < ApplicationController
-    before_action :rails_nexus_require_auth!
-    before_action :check_backup_enabled
-    before_action :set_config, only: %i[edit update destroy trigger]
-
-    # GET /rails_nexus/backup
-    def index
-      @configs = RailsNexus::BackupConfig.order(:name)
-    end
-
-    # GET /rails_nexus/backup/new
-    def new
-      @config = RailsNexus::BackupConfig.new(
-        adapter: "mysql",
-        host: "localhost",
-        port: 3306,
-        storage_path: "~/dumps",
-        keep_count: 30,
-        compress: true
-      )
-    end
-
-    # POST /rails_nexus/backup
-    def create
-      @config = RailsNexus::BackupConfig.new(config_params)
-
-      if @config.save
-        redirect_to backup_path, notice: "Backup config '#{@config.name}' created."
-      else
-        render :new, status: :unprocessable_entity
-      end
-    end
-
-    # GET /rails_nexus/backup/:id/edit
-    def edit; end
-
-    # PATCH /rails_nexus/backup/:id
-    def update
-      # Strip blank password fields so they don't overwrite stored values
-      filtered = config_params
-      %w[password encryption_password gpg_password].each do |attr|
-        filtered = filtered.except(attr) if filtered[attr].blank?
-      end
-
-      if @config.update(filtered)
-        redirect_to backup_path, notice: "Backup config '#{@config.name}' updated."
-      else
-        render :edit, status: :unprocessable_entity
-      end
-    end
-
-    # DELETE /rails_nexus/backup/:id
-    def destroy
-      name = @config.name
-      @config.destroy
-      redirect_to backup_path, notice: "Backup config '#{name}' deleted."
-    end
-
-    # POST /rails_nexus/backup/:id/trigger
-    def trigger
-      begin
-        RailsNexus::BackupJob.perform_later(@config.id)
-        redirect_to backup_path, notice: "Backup '#{@config.name}' started in background."
-      rescue => e
-        # Fallback to synchronous if Active Job is not configured
-        result = RailsNexus::BackupService.run(@config)
-        if result[:success]
-          redirect_to backup_path, notice: "Backup '#{@config.name}' completed successfully."
-        else
-          redirect_to backup_path, alert: "Backup failed: #{result[:error]}"
-        end
-      end
-    end
-
-    # GET /rails_nexus/backup/:id/history
-    def history
-      @config = RailsNexus::BackupConfig.find(params[:id])
-      @records = RailsNexus::Backup.where(config_name: @config.name)
-        .order(started_at: :desc)
-        .limit(50)
-    end
-
-    # GET /rails_nexus/backup/history
-    def all_history
-      @records = RailsNexus::Backup.order(started_at: :desc).limit(100)
-      render :history
-    end
-
-    private
-
-    def set_config
-      @config = RailsNexus::BackupConfig.find(params[:id])
-    end
-
-    def config_params
-      params.require(:backup_config).permit(
-        :name, :description, :database_name, :adapter, :host, :port,
-        :username, :password, :storage_path, :keep_count,
-        :compress, :encrypted, :encryption_password,
-        :rsync_enabled, :rsync_host, :rsync_port, :rsync_user, :rsync_path, :rsync_mirror, :rsync_archive, :rsync_directories, :rsync_excludes,
-        :notify_command, :notify_on_success, :notify_on_failure,
-        :schedule_cron, :enabled,
-        :s3_enabled, :s3_access_key, :s3_secret_key, :s3_bucket, :s3_region, :s3_prefix,
-        :gpg_enabled, :gpg_password,
-        :email_notify, :email_to,
-        :archive_enabled, :bzip2_compress, :split_chunks, :encrypt_base64, :mysql_additional_options,
-        skip_tables: [], archive_paths: [], archive_excludes: []
-      )
-    end
-
-    def check_backup_enabled
-      unless RailsNexus.configuration.backup_enabled
-        render plain: "Backup management not enabled", status: :forbidden
-      end
-    end
-  end
-end

data/app/jobs/rails_nexus/backup_job.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module RailsNexus
-  class BackupJob < ApplicationJob
-    queue_as :rails_nexus_backups
-
-    # Accept either a BackupConfig record ID or a BackupConfig record
-    def perform(backup_config_id_or_record)
-      config = if backup_config_id_or_record.is_a?(RailsNexus::BackupConfig)
-        backup_config_id_or_record
-      else
-        RailsNexus::BackupConfig.find(backup_config_id_or_record)
-      end
-
-      RailsNexus::BackupService.run(config)
-    end
-  end
-end

data/app/models/rails_nexus/backup.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module RailsNexus
-  class Backup < BaseRecord
-    self.table_name = "rails_nexus_backups"
-
-    validates :config_name, presence: true
-    validates :status, presence: true, inclusion: { in: %w[running success failed] }
-    validates :started_at, presence: true
-
-    scope :recent, ->(hours = 24) { where("started_at >= ?", hours.hours.ago) }
-    scope :successful, -> { where(status: "success") }
-    scope :failed, -> { where(status: "failed") }
-    scope :running, -> { where(status: "running") }
-    scope :by_config, ->(name) { where(config_name: name) }
-    scope :latest_first, -> { order(started_at: :desc) }
-
-    # Start tracking a backup run
-    def self.start!(config_name:, triggered_by: "system")
-      create!(
-        config_name: config_name,
-        status: "running",
-        triggered_by: triggered_by,
-        started_at: Time.current
-      )
-    end
-
-    # Mark backup as completed
-    def succeed!(file_path: nil, file_size: nil)
-      update!(
-        status: "success",
-        file_path: file_path,
-        file_size: file_size,
-        duration: (Time.current - started_at).round(2),
-        completed_at: Time.current
-      )
-    end
-
-    # Mark backup as failed
-    def fail!(error_message:)
-      update!(
-        status: "failed",
-        error_message: error_message,
-        duration: (Time.current - started_at).round(2),
-        completed_at: Time.current
-      )
-    end
-
-    # Get success rate for a model over the last N days
-    def self.success_rate(config_name:, days: 7)
-      records = by_config(config_name).where("started_at >= ?", days.days.ago).where.not(status: "running")
-      return 0 if records.empty?
-      (records.successful.count.to_f / records.count * 100).round(1)
-    end
-
-    # Get backup health summary
-    def self.health_summary(alert_threshold_hours: 24)
-      configs = RailsNexus::BackupConfig.pluck(:name)
-      results = configs.map do |config_name|
-        latest = by_config(config_name).successful.latest_first.first
-        age_hours = latest ? ((Time.current - latest.started_at) / 3600).round(1) : nil
-
-        {
-          config_name: config_name,
-          last_backup: latest&.started_at,
-          age_hours: age_hours,
-          status: age_hours.nil? ? "unknown" : (age_hours < alert_threshold_hours ? "healthy" : "stale"),
-          success_rate: success_rate(config_name: config_name),
-          last_file_size: latest&.file_size
-        }
-      end
-
-      {
-        healthy: results.all? { |r| r[:status] == "healthy" },
-        models: results,
-        alerts: results.select { |r| r[:status] == "stale" || r[:status] == "unknown" }
-      }
-    end
-
-    # Cleanup old backup records
-    def self.cleanup!(retention_days: 30)
-      where("started_at < ?", retention_days.days.ago).delete_all
-    end
-
-    # Format file size
-    def file_size_human
-      return "—" unless file_size
-      units = ["B", "KB", "MB", "GB"]
-      size = file_size.to_f
-      units.each do |unit|
-        return "#{size.round(1)} #{unit}" if size < 1024
-        size /= 1024
-      end
-      "#{size.round(1)} TB"
-    end
-
-    # Duration formatted
-    def duration_human
-      return "—" unless duration
-      if duration < 60
-        "#{duration.round(1)}s"
-      else
-        "#{(duration / 60).floor}m #{(duration % 60).round}s"
-      end
-    end
-  end
-end

data/app/models/rails_nexus/backup_config.rb

@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-
-module RailsNexus
-  class BackupConfig < BaseRecord
-    self.table_name = "rails_nexus_backup_configs"
-
-    ADAPTERS = %w[mysql postgresql sqlite mongodb redis].freeze
-
-    # ─── Boolean defaults ──────────────────────────────────────────
-    # Rails doesn't apply DB defaults to new in-memory records, so
-    # check_box helpers in form_for render unchecked. These declarations
-    # ensure the form reflects the intended defaults.
-    attribute :enabled,            :boolean, default: true
-    attribute :compress,           :boolean, default: true
-    attribute :encrypted,          :boolean, default: false
-    attribute :encrypt_base64,     :boolean, default: false
-    attribute :rsync_enabled,      :boolean, default: false
-    attribute :rsync_mirror,       :boolean, default: false
-    attribute :notify_on_success,  :boolean, default: true
-    attribute :notify_on_failure,  :boolean, default: true
-    attribute :s3_enabled,         :boolean, default: false
-    attribute :gpg_enabled,        :boolean, default: false
-    attribute :email_notify,       :boolean, default: false
-    attribute :archive_enabled,    :boolean, default: false
-    attribute :bzip2_compress,     :boolean, default: false
-    attribute :split_chunks,       :boolean, default: false
-
-    validates :name, presence: true, uniqueness: true
-    validates :database_name, presence: true, if: -> { adapter != "redis" }
-    validates :adapter, presence: true, inclusion: { in: ADAPTERS }
-    validates :storage_path, presence: true
-    validates :keep_count, numericality: { greater_than: 0 }
-    validates :encryption_password, presence: true, if: :encrypted?
-    validates :rsync_host, presence: true, if: :rsync_enabled?
-    validates :rsync_user, presence: true, if: :rsync_enabled?
-    validates :s3_bucket, presence: true, if: :s3_enabled?
-    validates :s3_access_key, presence: true, if: :s3_enabled?
-    validates :s3_secret_key, presence: true, if: :s3_enabled?
-    validates :gpg_password, presence: true, if: :gpg_enabled?
-    validates :email_to, presence: true, if: :email_notify?
-
-    scope :enabled,  -> { where(enabled: true) }
-    scope :disabled, -> { where(enabled: false) }
-
-    serialize :skip_tables, coder: JSON
-    serialize :archive_paths, coder: JSON
-    serialize :archive_excludes, coder: JSON
-
-    # ─── Skip Tables ───────────────────────────────────────────────
-    def skip_tables_list
-      return [] if skip_tables.blank?
-      skip_tables.is_a?(Array) ? skip_tables : JSON.parse(skip_tables.to_s) rescue []
-    end
-
-    def skip_tables_list=(value)
-      return if value.blank?
-      self.skip_tables = if value.is_a?(String)
-        value.split(",").map(&:strip).reject(&:blank?)
-      else
-        value
-      end
-    end
-
-    # ─── Archive Paths ─────────────────────────────────────────────
-    def archive_paths_list
-      return [] if archive_paths.blank?
-      archive_paths.is_a?(Array) ? archive_paths : JSON.parse(archive_paths.to_s) rescue []
-    end
-
-    def archive_paths_list=(value)
-      return if value.blank?
-      self.archive_paths = if value.is_a?(String)
-        value.split(",").map(&:strip).reject(&:blank?)
-      else
-        value
-      end
-    end
-
-    def archive_excludes_list
-      return [] if archive_excludes.blank?
-      archive_excludes.is_a?(Array) ? archive_excludes : JSON.parse(archive_excludes.to_s) rescue []
-    end
-
-    def archive_excludes_list=(value)
-      return if value.blank?
-      self.archive_excludes = if value.is_a?(String)
-        value.split(",").map(&:strip).reject(&:blank?)
-      else
-        value
-      end
-    end
-
-    # ─── Adapter checks ────────────────────────────────────────────
-    def mysql?;         adapter == "mysql";        end
-    def postgresql?;    adapter == "postgresql";    end
-    def sqlite?;        adapter == "sqlite";        end
-    def mongodb?;       adapter == "mongodb";       end
-    def redis?;         adapter == "redis";         end
-
-    # ─── Path helpers ──────────────────────────────────────────────
-    def storage_path_expanded
-      storage_path.gsub("~", Dir.home)
-    end
-
-    def dump_filename
-      timestamp = Time.current.strftime("%Y%m%d_%H%M%S")
-      ext = dump_extension
-      "#{name}_#{timestamp}.#{ext}"
-    end
-
-    def dump_filepath
-      File.join(storage_path_expanded, dump_filename)
-    end
-
-    # ─── Stats ─────────────────────────────────────────────────────
-    def recent_backups(limit: 10)
-      RailsNexus::Backup.where(config_name: name).order(started_at: :desc).limit(limit)
-    end
-
-    def last_failure
-      RailsNexus::Backup.where(config_name: name, status: "failed").order(started_at: :desc).first
-    end
-
-    def stats
-      backups = RailsNexus::Backup.where(config_name: name)
-      recent = backups.where("started_at >= ?", 7.days.ago)
-      {
-        total: backups.count,
-        successful: backups.successful.count,
-        failed: backups.failed.count,
-        recent_count: recent.count,
-        recent_success: recent.successful.count,
-        recent_failed: recent.failed.count,
-        last_backup: backups.successful.latest_first.first,
-        total_size: backups.sum(:file_size).to_i,
-        total_size_human: human_size(backups.sum(:file_size).to_i)
-      }
-    end
-
-    private
-
-    def dump_extension
-      parts = ["sql"]
-      parts << "gz" if compress? && !bzip2_compress?
-      parts << "bz2" if bzip2_compress?
-      parts << "enc" if encrypted?
-      parts.join(".")
-    end
-
-    def human_size(bytes)
-      return "0 B" if bytes.zero?
-      units = %w[B KB MB GB TB]
-      exp = (Math.log(bytes) / Math.log(1024)).to_i
-      exp = units.size - 1 if exp >= units.size
-      "%.1f %s" % [bytes.to_f / (1024**exp), units[exp]]
-    end
-  end
-end

data/app/services/rails_nexus/backup_runner.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module RailsNexus
-  class BackupRunner
-    # Run a specific backup config by name
-    def self.run(name)
-      config = RailsNexus::BackupConfig.find_by!(name: name)
-      RailsNexus::BackupService.run(config)
-    rescue ActiveRecord::RecordNotFound
-      { success: false, error: "Backup config '#{name}' not found" }
-    end
-
-    # Run all enabled backup configs
-    def self.run_all
-      results = []
-      RailsNexus::BackupConfig.enabled.find_each do |config|
-        results << RailsNexus::BackupService.run(config)
-      end
-      results
-    end
-
-    # Run backups matching a cron schedule
-    def self.run_scheduled
-      now = Time.current
-      results = []
-
-      RailsNexus::BackupConfig.enabled.where.not(schedule_cron: [nil, ""]).find_each do |config|
-        if matches_cron?(config.schedule_cron, now)
-          results << RailsNexus::BackupService.run(config)
-        end
-      end
-
-      results
-    end
-
-    # Check if a cron expression matches the current time
-    def self.matches_cron?(cron_expression, time)
-      return false if cron_expression.blank?
-
-      parts = cron_expression.strip.split(/\s+/)
-      return false unless parts.size == 5
-
-      minute, hour, day, month, wday = parts
-
-      match_field(minute, time.min) &&
-        match_field(hour, time.hour) &&
-        match_field(day, time.day) &&
-        match_field(month, time.mon) &&
-        match_field(wday, time.wday)
-    end
-
-    def self.match_field(pattern, value)
-      return true if pattern == "*"
-      return true if pattern.include?(",") && pattern.split(",").map(&:strip).include?(value.to_s)
-      return true if pattern.include?("-")
-      return true if pattern.include?("/")
-
-      pattern.to_i == value
-    end
-    private_class_method :match_field
-  end
-end