rails_nexus 2.0.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33e67e4702cc5b31061fc12c76dc25c647717f12fbecf14fa485a0b910c969ad
-  data.tar.gz: d4f46f7b519cd0a8d99212f03aba8537b761fbce9ddbce081198d9c4d9204f44
+  metadata.gz: 1d639de5385a9975d43e4cb943e95e1080fc982bf39363d8ca650ffa4e413807
+  data.tar.gz: d0ee669e29976192aba3b2215b9d804772d3e362669252e545e340fc5c80a337
 SHA512:
-  metadata.gz: d31501ea96c117ce8b2f86867760be1982e7af7ed89ed21cfad27681a9dc5cd0a1260bc907abf1288cf1b45bdd5613989c6b31a518a028d641500d54ca5db7dd
-  data.tar.gz: 9cb09061f96d7d2478c5147867c90029859737b2dbfdd939721ec4c9c5a50103a0da94bb0e2e6d1ed4582186d2cc86e300ab5ccc9339755041870f3f3cbc9f37
+  metadata.gz: a0e758654cfebfdd74880b6e9ea2c415ad8ed1cb3ce63ec2e619664597ff7fbfd8c449e277228d0dbcce66c8f59db400ac8fd0326d2a97a1afa05eab68ae6347
+  data.tar.gz: 5c68c28e6debd2b86d76653e8b6a24b83c33b506dc84acdbd919e560e781445653771b19993acc30a35e334f8f49ecced1b2cbc78236ea28cb7aaffc5d6c6661

data/app/controllers/rails_nexus/backup_controller.rb

@@ -2,67 +2,105 @@
 
 module RailsNexus
   class BackupController < ApplicationController
-    before_action :verify_access
+    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
-      @backup_service = BackupService.new
-      @health = @backup_service.health_status
-      @summary = @backup_service.summary
-      @models = @backup_service.models
-      @schedule = @backup_service.cron_schedule
+      @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
-      @backup_service = BackupService.new
-      @files = @backup_service.backup_files
+    # 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
-    def trigger
-      @backup_service = BackupService.new
-      result = @backup_service.trigger_backup(params[:model])
+    # POST /rails_nexus/backup
+    def create
+      @config = RailsNexus::BackupConfig.new(config_params)
 
-      if result[:success]
-        redirect_to backup_path, notice: "Backup '#{params[:model]}' triggered (PID: #{result[:pid]})"
+      if @config.save
+        redirect_to backup_path, notice: "Backup config '#{@config.name}' created."
       else
-        redirect_to backup_path, alert: "Failed: #{result[:error]}"
+        render :new, status: :unprocessable_entity
       end
     end
 
-    # GET /rails_nexus/backup/health
-    def health
-      @backup_service = BackupService.new
-      @health = @backup_service.health_status
-      @summary = @backup_service.summary
+    # 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
 
-    # GET /rails_nexus/backup/settings
-    def settings
-      @backup_config = BackupService.load_config
+    # DELETE /rails_nexus/backup/:id
+    def destroy
+      name = @config.name
+      @config.destroy
+      redirect_to backup_path, notice: "Backup config '#{name}' deleted."
     end
 
-    # PATCH /rails_nexus/backup/settings
-    def update_settings
-      result = BackupService.save_config(backup_settings_params)
+    # POST /rails_nexus/backup/:id/trigger
+    def trigger
+      result = RailsNexus::BackupService.run(@config)
 
       if result[:success]
-        redirect_to backup_settings_path, notice: "Backup settings saved successfully."
+        redirect_to backup_path, notice: "Backup '#{@config.name}' completed successfully."
       else
-        redirect_to backup_settings_path, alert: "Failed to save: #{result[:error]}"
+        redirect_to backup_path, alert: "Backup failed: #{result[:error]}"
       end
     end
 
+    # 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/history
+    def all_history
+      @records = RailsNexus::Backup.order(started_at: :desc).limit(100)
+    end
+
     private
 
-    def verify_access
-      config = RailsNexus.configuration
-      return if config.auth_block.nil?
-      unless config.auth_block&.call(self)
-        render plain: "Forbidden", status: :forbidden
-      end
+    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
@@ -70,22 +108,5 @@ module RailsNexus
         render plain: "Backup management not enabled", status: :forbidden
       end
     end
-
-    def backup_settings_params
-      params.require(:backup_config).permit(
-        :enabled,
-        :config_path,
-        :models_path,
-        :dump_path,
-        :notify_command,
-        :alert_threshold_hours,
-        :rsync_host,
-        :rsync_port,
-        :rsync_user,
-        :rsync_path,
-        :encrypt_password,
-        :auto_cleanup_days
-      )
-    end
   end
 end

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