rails_nexus 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b3560dacbd2f1c044a47737102cf9cf3a12d158663d36842b901f8bcb83f375
-  data.tar.gz: f5301d5c1f68c608d8f856203c55d12416d528e489b1fd0acd596b4e2b2752bb
+  metadata.gz: 1d639de5385a9975d43e4cb943e95e1080fc982bf39363d8ca650ffa4e413807
+  data.tar.gz: d0ee669e29976192aba3b2215b9d804772d3e362669252e545e340fc5c80a337
 SHA512:
-  metadata.gz: 1082abffeb01634510cce7be4760b28f595e45f55b4fc86b8eb981b804e16962ee67061d893f12041bfbde8e287d977e3f07814932365aec26b4039b0979ad75
-  data.tar.gz: e2e8691ea3e6463161f1ac3e7fd2d846a472d34278b6c3e133cabcb21cbeb0bc0ca8d03c8b082b7cceff3c4692b4adad0064d1353c2651066bff08616798e30d
+  metadata.gz: a0e758654cfebfdd74880b6e9ea2c415ad8ed1cb3ce63ec2e619664597ff7fbfd8c449e277228d0dbcce66c8f59db400ac8fd0326d2a97a1afa05eab68ae6347
+  data.tar.gz: 5c68c28e6debd2b86d76653e8b6a24b83c33b506dc84acdbd919e560e781445653771b19993acc30a35e334f8f49ecced1b2cbc78236ea28cb7aaffc5d6c6661

data/app/controllers/rails_nexus/backup_controller.rb

@@ -4,51 +4,105 @@ 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
-      @service = BackupService.new
-      @health = @service.health_status
-      @summary = @service.summary
-      @records = @service.backup_records
+      @configs = RailsNexus::BackupConfig.order(:name)
+      @records = RailsNexus::Backup.order(started_at: :desc).limit(20)
+      @stats = {
+        total_configs: RailsNexus::BackupConfig.count,
+        enabled_configs: RailsNexus::BackupConfig.enabled.count,
+        total_backups: RailsNexus::Backup.count,
+        successful: RailsNexus::Backup.successful.count,
+        failed: RailsNexus::Backup.failed.count
+      }
     end
 
-    # GET /rails_nexus/backup/files
-    def files
-      @service = BackupService.new
-      @records = @service.backup_records(limit: 100)
+    # 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/trigger/:model
+    # 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
+      if @config.update(config_params)
+        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
-      @service = BackupService.new
-      result = @service.trigger_backup(params[:model])
+      result = RailsNexus::BackupService.run(@config)
 
       if result[:success]
-        redirect_to backup_path, notice: "Backup '#{params[:model]}' completed successfully."
+        redirect_to backup_path, notice: "Backup '#{@config.name}' completed successfully."
       else
         redirect_to backup_path, alert: "Backup failed: #{result[:error]}"
       end
     end
 
-    # DELETE /rails_nexus/backup/:id
-    def destroy
-      record = RailsNexus::Backup.find(params[:id])
-      # Delete the file if it exists
-      File.delete(record.file_path) if record.file_path && File.exist?(record.file_path)
-      record.destroy
-      redirect_to backup_path, notice: "Backup record deleted."
+    # GET /rails_nexus/backup/:id/history
+    def history
+      @config = RailsNexus::BackupConfig.find(params[:id])
+      @records = RailsNexus::Backup.where(model_name: @config.name)
+        .order(started_at: :desc)
+        .limit(50)
     end
 
-    # GET /rails_nexus/backup/health
-    def health
-      @service = BackupService.new
-      @health = @service.health_status
-      @summary = @service.summary
+    # GET /rails_nexus/backup/history
+    def all_history
+      @records = RailsNexus::Backup.order(started_at: :desc).limit(100)
     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, :encrypt, :encrypt_password,
+        :rsync_enabled, :rsync_host, :rsync_port, :rsync_user, :rsync_path, :rsync_mirror,
+        :notify_command, :notify_on_success, :notify_on_failure,
+        :schedule_cron, :enabled,
+        skip_tables: []
+      )
+    end
+
     def check_backup_enabled
       unless RailsNexus.configuration.backup_enabled
         render plain: "Backup management not enabled", status: :forbidden

data/app/models/rails_nexus/backup_config.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RailsNexus
+  class BackupConfig < BaseRecord
+    self.table_name = "rails_nexus_backup_configs"
+
+    ADAPTERS = %w[mysql postgresql sqlite].freeze
+
+    validates :name, presence: true, uniqueness: true
+    validates :database_name, presence: true
+    validates :adapter, presence: true, inclusion: { in: ADAPTERS }
+    validates :storage_path, presence: true
+    validates :keep_count, numericality: { greater_than: 0 }
+    validates :encrypt_password, presence: true, if: :encrypt?
+    validates :rsync_host, presence: true, if: :rsync_enabled?
+    validates :rsync_user, presence: true, if: :rsync_enabled?
+
+    scope :enabled,  -> { where(enabled: true) }
+    scope :disabled, -> { where(enabled: false) }
+
+    serialize :skip_tables, coder: JSON
+
+    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=(list)
+      self.skip_tables = list
+    end
+
+    def mysql?
+      adapter == "mysql"
+    end
+
+    def postgresql?
+      adapter == "postgresql"
+    end
+
+    def sqlite?
+      adapter == "sqlite"
+    end
+
+    def storage_path_expanded
+      storage_path.gsub("~", Dir.home)
+    end
+
+    def dump_filename
+      timestamp = Time.current.strftime("%Y%m%d_%H%M%S")
+      ext = compress? ? "sql.gz" : "sql"
+      "#{name}_#{timestamp}.#{ext}"
+    end
+
+    def dump_filepath
+      File.join(storage_path_expanded, dump_filename)
+    end
+
+    # Get recent backup records for this config
+    def recent_backups(limit: 10)
+      RailsNexus::Backup.where(model_name: name).order(started_at: :desc).limit(limit)
+    end
+
+    # Summary stats
+    def stats
+      backups = RailsNexus::Backup.where(model_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 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

@@ -0,0 +1,62 @@
+# 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