rails_nexus 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33e67e4702cc5b31061fc12c76dc25c647717f12fbecf14fa485a0b910c969ad
-  data.tar.gz: d4f46f7b519cd0a8d99212f03aba8537b761fbce9ddbce081198d9c4d9204f44
+  metadata.gz: 4b3560dacbd2f1c044a47737102cf9cf3a12d158663d36842b901f8bcb83f375
+  data.tar.gz: f5301d5c1f68c608d8f856203c55d12416d528e489b1fd0acd596b4e2b2752bb
 SHA512:
-  metadata.gz: d31501ea96c117ce8b2f86867760be1982e7af7ed89ed21cfad27681a9dc5cd0a1260bc907abf1288cf1b45bdd5613989c6b31a518a028d641500d54ca5db7dd
-  data.tar.gz: 9cb09061f96d7d2478c5147867c90029859737b2dbfdd939721ec4c9c5a50103a0da94bb0e2e6d1ed4582186d2cc86e300ab5ccc9339755041870f3f3cbc9f37
+  metadata.gz: 1082abffeb01634510cce7be4760b28f595e45f55b4fc86b8eb981b804e16962ee67061d893f12041bfbde8e287d977e3f07814932365aec26b4039b0979ad75
+  data.tar.gz: e2e8691ea3e6463161f1ac3e7fd2d846a472d34278b6c3e133cabcb21cbeb0bc0ca8d03c8b082b7cceff3c4692b4adad0064d1353c2651066bff08616798e30d

data/app/controllers/rails_nexus/backup_controller.rb

@@ -2,90 +2,57 @@
 
 module RailsNexus
   class BackupController < ApplicationController
-    before_action :verify_access
+    before_action :rails_nexus_require_auth!
     before_action :check_backup_enabled
 
     # 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
+      @service = BackupService.new
+      @health = @service.health_status
+      @summary = @service.summary
+      @records = @service.backup_records
     end
 
     # GET /rails_nexus/backup/files
     def files
-      @backup_service = BackupService.new
-      @files = @backup_service.backup_files
+      @service = BackupService.new
+      @records = @service.backup_records(limit: 100)
     end
 
     # POST /rails_nexus/backup/trigger/:model
     def trigger
-      @backup_service = BackupService.new
-      result = @backup_service.trigger_backup(params[:model])
+      @service = BackupService.new
+      result = @service.trigger_backup(params[:model])
 
       if result[:success]
-        redirect_to backup_path, notice: "Backup '#{params[:model]}' triggered (PID: #{result[:pid]})"
+        redirect_to backup_path, notice: "Backup '#{params[:model]}' completed successfully."
       else
-        redirect_to backup_path, alert: "Failed: #{result[:error]}"
+        redirect_to backup_path, alert: "Backup failed: #{result[:error]}"
       end
     end
 
-    # GET /rails_nexus/backup/health
-    def health
-      @backup_service = BackupService.new
-      @health = @backup_service.health_status
-      @summary = @backup_service.summary
-    end
-
-    # GET /rails_nexus/backup/settings
-    def settings
-      @backup_config = BackupService.load_config
+    # 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."
     end
 
-    # PATCH /rails_nexus/backup/settings
-    def update_settings
-      result = BackupService.save_config(backup_settings_params)
-
-      if result[:success]
-        redirect_to backup_settings_path, notice: "Backup settings saved successfully."
-      else
-        redirect_to backup_settings_path, alert: "Failed to save: #{result[:error]}"
-      end
+    # GET /rails_nexus/backup/health
+    def health
+      @service = BackupService.new
+      @health = @service.health_status
+      @summary = @service.summary
     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
-    end
-
     def check_backup_enabled
       unless RailsNexus.configuration.backup_enabled
         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/services/rails_nexus/backup_service.rb

@@ -1,269 +1,170 @@
 # frozen_string_literal: true
 
-require "yaml"
-
 module RailsNexus
   class BackupService
-    attr_reader :config_path, :models_path, :dump_path
-
-    CONFIG_FILE = "rails_nexus_backup.yml"
+    attr_reader :dump_path
 
     def initialize
-      saved = self.class.load_config
-      @config_path = saved[:config_path] || RailsNexus.configuration.backup_config_path || default_config_path
-      @models_path = saved[:models_path] || RailsNexus.configuration.backup_models_path || default_models_path
-      @dump_path = saved[:dump_path] || RailsNexus.configuration.backup_dump_path || default_dump_path
-    end
-
-    # Load saved config from YAML file
-    def self.load_config
-      path = config_file_path
-      return default_config unless File.exist?(path)
-
-      data = YAML.safe_load_file(path, permitted_classes: [Symbol, Date, Time]) || {}
-      default_config.merge(data.transform_keys(&:to_sym))
-    rescue StandardError
-      default_config
+      @dump_path = RailsNexus.configuration.backup_dump_path || default_dump_path
     end
 
-    # Save config to YAML file
-    def self.save_config(params)
-      config = load_config
-
-      # Merge new params
-      params.each do |key, value|
-        config[key.to_sym] = value
+    # Run a backup for a model and record it in the table
+    def trigger_backup(model_name)
+      record = RailsNexus::Backup.start!(model_name: model_name, triggered_by: "ui")
+
+      begin
+        FileUtils.mkdir_p(@dump_path)
+
+        timestamp = Time.current.strftime("%Y%m%d_%H%M%S")
+        filename = "#{model_name}_#{timestamp}.sql"
+        file_path = File.join(@dump_path, filename)
+
+        # Detect database adapter and run appropriate dump
+        result = run_dump(model_name, file_path)
+
+        if result[:success]
+          file_size = File.exist?(file_path) ? File.size(file_path) : 0
+          record.succeed!(file_path: file_path, file_size: file_size)
+          { success: true, record_id: record.id, file_path: file_path }
+        else
+          record.fail!(error_message: result[:error])
+          # Clean up failed file
+          File.delete(file_path) if File.exist?(file_path)
+          { success: false, error: result[:error], record_id: record.id }
+        end
+      rescue StandardError => e
+        record.fail!(error_message: e.message)
+        { success: false, error: e.message, record_id: record.id }
       end
-
-      # Ensure directory exists
-      dir = File.dirname(config_file_path)
-      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
-
-      # Write YAML
-      File.write(config_file_path, config.to_yaml)
-
-      { success: true }
-    rescue StandardError => e
-      { success: false, error: e.message }
-    end
-
-    # Delete saved config
-    def self.reset_config
-      File.delete(config_file_path) if File.exist?(config_file_path)
-      { success: true }
-    rescue StandardError => e
-      { success: false, error: e.message }
     end
 
-    # Check if backup gem is configured
-    def configured?
-      File.exist?(@config_path) && Dir.exist?(@models_path)
-    end
-
-    # Get all backup models
-    def models
-      return [] unless configured?
-
-      Dir.glob(File.join(@models_path, "*.rb")).map do |path|
-        parse_model_file(path)
-      end.compact
+    # Get backup records from the table
+    def backup_records(limit: 50)
+      RailsNexus::Backup.order(started_at: :desc).limit(limit)
     end
 
-    # Get backup files
-    def backup_files
-      return [] unless @dump_path && Dir.exist?(@dump_path)
-
-      Dir.glob(File.join(@dump_path, "*")).select { |f| File.file?(f) }.map do |path|
-        {
-          name: File.basename(path),
-          path: path,
-          size: File.size(path),
-          size_human: human_size(File.size(path)),
-          created_at: File.mtime(path),
-          age_hours: ((Time.current - File.mtime(path)) / 3600).round(1),
-          encrypted: path.end_with?(".enc"),
-          compressed: path.end_with?(".gz") || path.end_with?(".tar.gz")
-        }
-      end.sort_by { |f| -f[:created_at].to_i }
-    end
-
-    # Get backup summary stats
+    # Get summary stats from the table
     def summary
-      files = backup_files
-      {
-        total_files: files.size,
-        total_size: files.sum { |f| f[:size] },
-        total_size_human: human_size(files.sum { |f| f[:size] }),
-        last_backup: files.first&.dig(:created_at),
-        last_backup_age_hours: files.first&.dig(:age_hours),
-        oldest_backup: files.last&.dig(:created_at),
-        models_count: models.size,
-        healthy: last_backup_healthy?,
-        alerts: generate_alerts
-      }
-    end
-
-    # Get cron schedule from whenever config
-    def cron_schedule
-      schedule_file = File.join(File.dirname(@config_path), "config", "schedule.rb")
-      return nil unless File.exist?(schedule_file)
-
-      content = File.read(schedule_file)
+      recent = RailsNexus::Backup.where("started_at >= ?", 7.days.ago)
       {
-        file: schedule_file,
-        entries: parse_schedule(content),
-        raw: content
+        total: RailsNexus::Backup.count,
+        successful: RailsNexus::Backup.successful.count,
+        failed: RailsNexus::Backup.failed.count,
+        recent_count: recent.count,
+        recent_success: recent.successful.count,
+        recent_failed: recent.failed.count,
+        total_size: RailsNexus::Backup.sum(:file_size).to_i,
+        total_size_human: human_size(RailsNexus::Backup.sum(:file_size).to_i),
+        last_backup: RailsNexus::Backup.successful.latest_first.first
       }
     end
 
-    # Run a backup model
-    def trigger_backup(model_name)
-      return { success: false, error: "Backup not configured" } unless configured?
-      return { success: false, error: "Invalid model: #{model_name}" } unless valid_model?(model_name)
-
-      runner = find_runner_script
-      return { success: false, error: "Runner script not found" } unless runner
-
-      log_file = File.join(File.dirname(@config_path), "log", "cron.log")
-      error_log = File.join(File.dirname(@config_path), "log", "cron-error.log")
-
-      command = "bash #{runner} #{model_name} >> #{log_file} 2>> #{error_log}"
-      pid = Process.spawn(command)
-      Process.detach(pid)
-
-      { success: true, pid: pid, model: model_name }
-    end
-
-    # Get backup health status
+    # Get health status based on table records
     def health_status
-      return { status: "not_configured", message: "Backup not configured" } unless configured?
-
-      summary_data = summary
-      threshold = saved_config[:alert_threshold_hours]&.to_i || RailsNexus.configuration.backup_alert_threshold_hours || 24
+      last = RailsNexus::Backup.successful.latest_first.first
+      threshold = RailsNexus.configuration.backup_alert_threshold_hours || 24
 
-      if summary_data[:last_backup].nil?
-        { status: "warning", message: "No backups found", details: summary_data }
-      elsif summary_data[:last_backup_age_hours] > threshold * 2
-        { status: "critical", message: "Last backup #{summary_data[:last_backup_age_hours]}h ago (>#{threshold * 2}h)", details: summary_data }
-      elsif summary_data[:last_backup_age_hours] > threshold
-        { status: "warning", message: "Last backup #{summary_data[:last_backup_age_hours]}h ago (>#{threshold}h)", details: summary_data }
+      if last.nil?
+        { status: "warning", message: "No backups recorded yet" }
+      elsif last.duration && last.duration > threshold * 3600
+        { status: "critical", message: "Last backup #{((Time.current - last.started_at) / 3600).round(1)}h ago" }
       else
-        { status: "healthy", message: "Last backup #{summary_data[:last_backup_age_hours]}h ago", details: summary_data }
+        { status: "healthy", message: "Last backup #{last.model_name} — #{last.duration_human}" }
       end
     end
 
-    # Get saved config
-    def saved_config
-      @saved_config ||= self.class.load_config
-    end
-
-    private
-
-    def self.config_file_path
-      Rails.root.join("config", CONFIG_FILE)
-    end
+    # Cleanup old backup records and files
+    def cleanup!(retention_days: nil)
+      days = retention_days || RailsNexus.configuration.backup_alert_threshold_hours&.div(24) || 30
+      old_records = RailsNexus::Backup.where("started_at < ?", days.days.ago)
 
-    def self.default_config
-      {
-        enabled: true,
-        config_path: nil,
-        models_path: nil,
-        dump_path: nil,
-        notify_command: nil,
-        alert_threshold_hours: 24,
-        rsync_host: nil,
-        rsync_port: 22,
-        rsync_user: nil,
-        rsync_path: nil,
-        encrypt_password: nil,
-        auto_cleanup_days: 30
-      }
-    end
+      # Delete files first
+      old_records.find_each do |record|
+        File.delete(record.file_path) if record.file_path && File.exist?(record.file_path)
+      end
 
-    def default_config_path
-      Rails.root.join("config", "backup", "config.rb").to_s
+      count = old_records.delete_all
+      { deleted: count }
     end
 
-    def default_models_path
-      Rails.root.join("config", "backup", "models").to_s
-    end
+    private
 
     def default_dump_path
       Rails.root.join("storage", "rails_nexus", "backups").to_s
     end
 
-    def parse_model_file(path)
-      content = File.read(path)
-      name_match = content.match(/Model\.new\(:(\w+)/)
-      desc_match = content.match(/'([^']+)'/)
-
-      return nil unless name_match
+    # Detect adapter and run appropriate dump command
+    def run_dump(model_name, file_path)
+      config = ActiveRecord::Base.connection_db_config.configuration_hash
+      adapter = config[:adapter]
 
-      {
-        name: name_match[1],
-        description: desc_match ? desc_match[1] : name_match[1],
-        file: path,
-        has_mysql: content.include?("database MySQL"),
-        has_local: content.include?("store_with Local"),
-        has_rsync: content.include?("sync_with RSync"),
-        has_encryption: content.include?("encrypt_with OpenSSL"),
-        has_compression: content.include?("compress_with Gzip"),
-        skip_tables: content.scan(/skip_tables\s*=\s*\[([^\]]+)\]/).flatten.first,
-        keep_count: content.scan(/keep\s*=\s*(\d+)/).flatten.first&.to_i
-      }
-    end
-
-    def parse_schedule(content)
-      entries = []
-      content.scan(/every\s+([^,]+)(?:,\s*at:\s*"([^"]+)")?\s+do\s+command\s+"([^"]+)"/) do |match|
-        entries << {
-          frequency: match[0].strip,
-          time: match[1],
-          command: match[2]
-        }
+      case adapter
+      when /sqlite/
+        run_sqlite_dump(config, file_path)
+      when /mysql/
+        run_mysql_dump(config, file_path)
+      when /postgresql/, /postgres/
+        run_postgresql_dump(config, file_path)
+      else
+        { success: false, error: "Unsupported adapter: #{adapter}" }
       end
-      entries
     end
 
-    def find_runner_script
-      runner = File.join(File.dirname(@config_path), "bin", "run-backup")
-      runner if File.exist?(runner)
-    end
+    def run_sqlite_dump(config, file_path)
+      db_path = config[:database]
+      return { success: false, error: "No database path configured" } unless db_path
 
-    def valid_model?(name)
-      models.any? { |m| m[:name] == name }
+      # SQLite: .dump produces SQL output
+      output = `sqlite3 "#{db_path}" .dump 2>&1`
+      if $?.success?
+        File.write(file_path, output)
+        { success: true }
+      else
+        { success: false, error: "sqlite3 dump failed: #{output}" }
+      end
     end
 
-    def last_backup_healthy?
-      files = backup_files
-      return false if files.empty?
-
-      threshold = saved_config[:alert_threshold_hours]&.to_i || RailsNexus.configuration.backup_alert_threshold_hours || 24
-      files.first[:age_hours] <= threshold
+    def run_mysql_dump(config, file_path)
+      cmd = [
+        "mysqldump",
+        "--user=#{config[:username] || 'root'}",
+        config[:password] ? "--password=#{config[:password]}" : nil,
+        "--host=#{config[:host] || 'localhost'}",
+        "--port=#{config[:port] || 3306}",
+        "--result-file=#{file_path}",
+        config[:database]
+      ].compact.join(" ")
+
+      output = `#{cmd} 2>&1`
+      if $?.success?
+        { success: true }
+      else
+        { success: false, error: "mysqldump failed: #{output}" }
+      end
     end
 
-    def generate_alerts
-      alerts = []
-      files = backup_files
-      threshold = saved_config[:alert_threshold_hours]&.to_i || RailsNexus.configuration.backup_alert_threshold_hours || 24
+    def run_postgresql_dump(config, file_path)
+      cmd = [
+        "pg_dump",
+        "--username=#{config[:username] || 'postgres'}",
+        config[:host] ? "--host=#{config[:host]}" : nil,
+        config[:port] ? "--port=#{config[:port]}" : nil,
+        "--file=#{file_path}",
+        config[:database]
+      ].compact.join(" ")
 
-      if files.empty?
-        alerts << { level: "warning", message: "No backup files found" }
-      elsif files.first[:age_hours] > threshold
-        alerts << { level: "critical", message: "No backup in #{files.first[:age_hours]}h (threshold: #{threshold}h)" }
-      end
+      env = config[:password] ? { "PGPASSWORD" => config[:password].to_s } : {}
 
-      # Check for old backups consuming space
-      old_files = files.select { |f| f[:age_hours] > 720 } # 30 days
-      if old_files.size > 10
-        alerts << { level: "info", message: "#{old_files.size} backups older than 30 days (#{human_size(old_files.sum { |f| f[:size] })})" }
+      output = IO.capture2e(env, cmd)
+      if output.last.success?
+        { success: true }
+      else
+        { success: false, error: "pg_dump failed: #{output.first}" }
       end
-
-      alerts
     end
 
     def human_size(bytes)
-      return "0 B" if bytes == 0
+      return "0 B" if bytes.zero?
 
       units = %w[B KB MB GB TB]
       exp = (Math.log(bytes) / Math.log(1024)).to_i

data/app/views/layouts/rails_nexus/application.html.erb

@@ -82,6 +82,14 @@
         <%# ─── Tools section ──────────────────────────────────────── %>
         <div class="rn-sidebar-section-divider"></div>
 
+        <% if main_app.respond_to?(:root_path) %>
+          <%= link_to main_app.root_path,
+            class: "rn-nav-item rn-nav-item--muted" do %>
+            <svg class="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor"><path stroke-linecap="round" stroke-linejoin="round" d="M13.5 6H5.25A2.25 2.25 0 003 8.25v10.5A2.25 2.25 0 005.25 21h10.5A2.25 2.25 0 0018 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25" /></svg>
+            Admin Panel
+          <% end %>
+        <% end %>
+
         <%= link_to feed_logged_exceptions_path(format: :rss),
           class: "rn-nav-item rn-nav-item--muted" do %>
           <svg class="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor"><path stroke-linecap="round" stroke-linejoin="round" d="M12.75 19.5v-.75a7.5 7.5 0 00-7.5-7.5H4.5m0-6.75h.75c7.87 0 14.25 6.38 14.25 14.25v.75M6 18.75a.375.375 0 11-.75 0 .375.375 0 01.75 0z" /></svg>

data/app/views/rails_nexus/backup/files.html.erb

@@ -1,7 +1,6 @@
 <% page_title t(".title", default: "Backup Files") %>
 
 <div class="space-y-6">
-  <%# ─── Header ──────────────────────────────────────────────── %>
   <nav class="rn-breadcrumbs" aria-label="Breadcrumb">
     <a href="<%= root_path %>" class="rn-breadcrumb">Dashboard</a>
     <span class="rn-breadcrumb-sep">/</span>
@@ -10,34 +9,49 @@
     <span class="rn-breadcrumb-current">Files</span>
   </nav>
 
-  <h1 class="text-2xl font-bold" style="color: var(--rn-text)">Backup Files</h1>
-
-  <%# ─── Files Table ─────────────────────────────────────────── %>
   <div class="rn-card">
-    <% if @files.any? %>
+    <div class="p-4" style="border-bottom: 1px solid var(--rn-border-light)">
+      <h2 class="text-sm font-semibold" style="color: var(--rn-text)">All Backup Records</h2>
+      <p class="text-xs mt-1" style="color: var(--rn-text-muted)">Complete history of backup runs</p>
+    </div>
+
+    <% if @records.any? %>
       <div class="rn-table-wrap">
         <table class="rn-table">
           <thead>
             <tr>
+              <th>ID</th>
+              <th>Model</th>
+              <th>Status</th>
               <th>File</th>
               <th>Size</th>
-              <th>Created</th>
-              <th>Age</th>
-              <th>Format</th>
+              <th>Duration</th>
+              <th>Triggered By</th>
+              <th>Started</th>
+              <th></th>
             </tr>
           </thead>
           <tbody>
-            <% @files.each do |file| %>
+            <% @records.each do |record| %>
               <tr>
+                <td><span class="text-xs rn-mono" style="color: var(--rn-text-muted)">#<%= record.id %></span></td>
+                <td><span class="font-medium" style="color: var(--rn-text)"><%= record.model_name %></span></td>
+                <td>
+                  <span class="rn-badge rn-badge-<%= record.status == 'success' ? 'success' : record.status == 'failed' ? 'danger' : 'warning' %>">
+                    <%= record.status.capitalize %>
+                  </span>
+                </td>
                 <td>
-                  <span class="rn-mono text-xs" style="color: var(--rn-text)"><%= file[:name] %></span>
+                  <span class="text-xs rn-mono" style="color: var(--rn-text-secondary)"><%= record.file_path ? File.basename(record.file_path) : "—" %></span>
                 </td>
-                <td><span class="text-sm" style="color: var(--rn-text-secondary)"><%= file[:size_human] %></span></td>
-                <td><span class="text-xs" style="color: var(--rn-text-muted)"><%= file[:created_at].strftime("%b %d, %Y %I:%M %p") %></span></td>
-                <td><span class="text-xs" style="color: var(--rn-text-muted)"><%= file[:age_hours] %>h</span></td>
+                <td><span class="text-xs" style="color: var(--rn-text-secondary)"><%= record.file_size ? number_to_human_size(record.file_size) : "—" %></span></td>
+                <td><span class="text-xs" style="color: var(--rn-text-secondary)"><%= record.duration ? "#{record.duration.round(1)}s" : "—" %></span></td>
+                <td><span class="text-xs" style="color: var(--rn-text-muted)"><%= record.triggered_by || "—" %></span></td>
+                <td><span class="text-xs" style="color: var(--rn-text-muted)"><%= record.started_at&.strftime("%b %d %H:%M") %></span></td>
                 <td>
-                  <span class="rn-badge <%= file[:encrypted] ? 'rn-badge-success' : '' %>"><%= file[:encrypted] ? 'Encrypted' : 'Plain' %></span>
-                  <span class="rn-badge <%= file[:compressed] ? 'rn-badge-info' : '' %>"><%= file[:compressed] ? 'Gzipped' : 'Raw' %></span>
+                  <% if record.error_message.present? %>
+                    <span class="text-xs" style="color: var(--rn-danger)" title="<%= record.error_message %>">⚠</span>
+                  <% end %>
                 </td>
               </tr>
             <% end %>
@@ -46,7 +60,7 @@
       </div>
     <% else %>
       <div class="p-8 text-center">
-        <p class="text-sm" style="color: var(--rn-text-muted)">No backup files found.</p>
+        <p class="text-sm" style="color: var(--rn-text-muted)">No backup records found.</p>
       </div>
     <% end %>
   </div>