rails_nexus 2.0.0 → 2.0.2

data/app/services/rails_nexus/backup_service.rb

@@ -1,275 +1,276 @@
 # frozen_string_literal: true
 
-require "yaml"
+require "open3"
+require "json"
 
 module RailsNexus
   class BackupService
-    attr_reader :config_path, :models_path, :dump_path
-
-    CONFIG_FILE = "rails_nexus_backup.yml"
-
-    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
+    # Execute a backup for a given config
+    def self.run(config)
+      new(config).run
     end
 
-    # Load saved config from YAML file
-    def self.load_config
-      path = config_file_path
-      return default_config unless File.exist?(path)
+    def initialize(config)
+      @config = config
+      @record = nil
+      @errors = []
+    end
 
-      data = YAML.safe_load_file(path, permitted_classes: [Symbol, Date, Time]) || {}
-      default_config.merge(data.transform_keys(&:to_sym))
-    rescue StandardError
-      default_config
+    def run
+      @record = RailsNexus::Backup.start!(
+        model_name: @config.name,
+        triggered_by: "service"
+      )
+
+      begin
+        # Ensure storage directory exists
+        FileUtils.mkdir_p(@config.storage_path_expanded)
+
+        # Step 1: Dump database
+        dump_path = dump_database
+        return fail_record("Database dump failed") unless dump_path
+
+        # Step 2: Compress if configured
+        final_path = @config.compress? ? compress(dump_path) : dump_path
+
+        # Step 3: Encrypt if configured
+        final_path = encrypt(final_path) if @config.encrypt?
+
+        # Step 4: Sync to remote if configured
+        rsync_result = sync_remote(final_path) if @config.rsync_enabled?
+
+        # Step 5: Cleanup old backups
+        cleanup_old_backups
+
+        # Step 6: Record success
+        file_size = File.exist?(final_path) ? File.size(final_path) : 0
+        @record.succeed!(
+          file_path: final_path,
+          file_size: file_size
+        )
+
+        # Step 7: Notify
+        notify_success
+
+        { success: true, record: @record, file_path: final_path }
+      rescue StandardError => e
+        @record.fail!(error_message: e.message) if @record
+        notify_failure(e.message)
+        { success: false, error: e.message, record: @record }
+      ensure
+        # Clean up temp files
+        cleanup_temp_files
+      end
     end
 
-    # Save config to YAML file
-    def self.save_config(params)
-      config = load_config
+    private
 
-      # Merge new params
-      params.each do |key, value|
-        config[key.to_sym] = value
+    def dump_database
+      case @config.adapter
+      when "mysql"
+        dump_mysql
+      when "postgresql"
+        dump_postgresql
+      when "sqlite"
+        dump_sqlite
+      else
+        raise "Unsupported adapter: #{@config.adapter}"
       end
+    end
 
-      # Ensure directory exists
-      dir = File.dirname(config_file_path)
-      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+    # ─── MySQL Dump ──────────────────────────────────────────────────
+    def dump_mysql
+      raw_path = @config.dump_filepath.gsub(/\.gz$/, "")
+      cmd = build_mysql_command(raw_path)
 
-      # Write YAML
-      File.write(config_file_path, config.to_yaml)
+      stdout, stderr, status = Open3.capture3(cmd)
+      unless status.success?
+        @errors << "mysqldump failed: #{stderr}"
+        return nil
+      end
 
-      { success: true }
-    rescue StandardError => e
-      { success: false, error: e.message }
+      raw_path
     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 }
+    def build_mysql_command(output_path)
+      parts = ["mysqldump"]
+      parts << "--user=#{@config.username}" if @config.username.present?
+      parts << "--password=#{@config.password}" if @config.password.present?
+      parts << "--host=#{@config.host}" if @config.host.present?
+      parts << "--port=#{@config.port}" if @config.port.present?
+      parts << "--result-file=#{output_path}"
+      parts << "--quick"
+      parts << "--single-transaction" if @config.mysql?
+
+      # Skip tables
+      skip = @config.skip_tables_list
+      skip.each { |t| parts << "--ignore-table=#{@config.database_name}.#{t}" }
+
+      parts << @config.database_name
+      parts.join(" ")
     end
 
-    # Check if backup gem is configured
-    def configured?
-      File.exist?(@config_path) && Dir.exist?(@models_path)
-    end
+    # ─── PostgreSQL Dump ─────────────────────────────────────────────
+    def dump_postgresql
+      raw_path = @config.dump_filepath.gsub(/\.gz$/, "")
+      cmd = build_postgresql_command(raw_path)
 
-    # Get all backup models
-    def models
-      return [] unless configured?
+      env = {}
+      env["PGPASSWORD"] = @config.password if @config.password.present?
 
-      Dir.glob(File.join(@models_path, "*.rb")).map do |path|
-        parse_model_file(path)
-      end.compact
-    end
+      stdout, stderr, status = Open3.capture3(env, cmd)
+      unless status.success?
+        @errors << "pg_dump failed: #{stderr}"
+        return nil
+      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 }
+      raw_path
     end
 
-    # Get backup summary stats
-    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
+    def build_postgresql_command(output_path)
+      parts = ["pg_dump"]
+      parts << "--username=#{@config.username}" if @config.username.present?
+      parts << "--host=#{@config.host}" if @config.host.present?
+      parts << "--port=#{@config.port}" if @config.port.present?
+      parts << "--file=#{output_path}"
+      parts << "--format=plain"
 
-    # 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)
-      {
-        file: schedule_file,
-        entries: parse_schedule(content),
-        raw: content
-      }
-    end
+      # Skip tables
+      skip = @config.skip_tables_list
+      skip.each { |t| parts << "--exclude-table=#{t}" }
 
-    # 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)
+      parts << @config.database_name
+      parts.join(" ")
+    end
 
-      runner = find_runner_script
-      return { success: false, error: "Runner script not found" } unless runner
+    # ─── SQLite Dump ─────────────────────────────────────────────────
+    def dump_sqlite
+      raw_path = @config.dump_filepath.gsub(/\.gz$/, "")
+      db_path = @config.database_name
 
-      log_file = File.join(File.dirname(@config_path), "log", "cron.log")
-      error_log = File.join(File.dirname(@config_path), "log", "cron-error.log")
+      unless File.exist?(db_path)
+        @errors << "SQLite database not found: #{db_path}"
+        return nil
+      end
 
-      command = "bash #{runner} #{model_name} >> #{log_file} 2>> #{error_log}"
-      pid = Process.spawn(command)
-      Process.detach(pid)
+      stdout, stderr, status = Open3.capture3("sqlite3 #{db_path} .dump")
+      unless status.success?
+        @errors << "sqlite3 dump failed: #{stderr}"
+        return nil
+      end
 
-      { success: true, pid: pid, model: model_name }
+      File.write(raw_path, stdout)
+      raw_path
     end
 
-    # Get backup health status
-    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
-
-      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 }
-      else
-        { status: "healthy", message: "Last backup #{summary_data[:last_backup_age_hours]}h ago", details: summary_data }
+    # ─── Compression ─────────────────────────────────────────────────
+    def compress(file_path)
+      gz_path = "#{file_path}.gz"
+      File.open(file_path, "rb") do |input|
+        Zlib::GzipWriter.open(gz_path) do |gz|
+          gz.write(input.read)
+        end
       end
+      File.delete(file_path) if File.exist?(gz_path)
+      gz_path
     end
 
-    # Get saved config
-    def saved_config
-      @saved_config ||= self.class.load_config
-    end
+    # ─── Encryption ──────────────────────────────────────────────────
+    def encrypt(file_path)
+      enc_path = "#{file_path}.enc"
+      password = @config.encrypt_password
 
-    private
+      cmd = "openssl aes-256-cbc -salt -pbkdf2 -in #{file_path} -out #{enc_path} -pass pass:#{password}"
+      stdout, stderr, status = Open3.capture3(cmd)
 
-    def self.config_file_path
-      Rails.root.join("config", CONFIG_FILE)
-    end
+      unless status.success?
+        @errors << "Encryption failed: #{stderr}"
+        return file_path
+      end
 
-    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
-      }
+      File.delete(file_path) if File.exist?(enc_path)
+      enc_path
     end
 
-    def default_config_path
-      Rails.root.join("config", "backup", "config.rb").to_s
-    end
+    # ─── RSync Remote Sync ──────────────────────────────────────────
+    def sync_remote(file_path)
+      return unless @config.rsync_enabled?
+      return unless @config.rsync_host.present?
+
+      remote = "#{@config.rsync_user}@#{@config.rsync_host}:#{@config.rsync_path}/"
+
+      cmd = [
+        "rsync",
+        "-avz",
+        "--progress",
+        "-e", "ssh -p #{@config.rsync_port}",
+        file_path,
+        remote
+      ].join(" ")
+
+      stdout, stderr, status = Open3.capture3(cmd)
+      unless status.success?
+        @errors << "RSync failed: #{stderr}"
+      end
 
-    def default_models_path
-      Rails.root.join("config", "backup", "models").to_s
+      { success: status.success?, output: stdout }
     end
 
-    def default_dump_path
-      Rails.root.join("storage", "rails_nexus", "backups").to_s
-    end
+    # ─── Cleanup ─────────────────────────────────────────────────────
+    def cleanup_old_backups
+      storage = @config.storage_path_expanded
+      return unless Dir.exist?(storage)
 
-    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
-
-      {
-        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
+      pattern = File.join(storage, "#{@config.name}_*")
+      files = Dir.glob(pattern).sort_by { |f| File.mtime(f) }
 
-    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]
-        }
+      # Keep only keep_count most recent
+      while files.size > @config.keep_count
+        old_file = files.shift
+        File.delete(old_file) if File.exist?(old_file)
       end
-      entries
     end
 
-    def find_runner_script
-      runner = File.join(File.dirname(@config_path), "bin", "run-backup")
-      runner if File.exist?(runner)
-    end
+    def cleanup_temp_files
+      # Clean up any intermediate files (uncompressed, unencrypted)
+      storage = @config.storage_path_expanded
+      return unless Dir.exist?(storage)
 
-    def valid_model?(name)
-      models.any? { |m| m[:name] == name }
+      Dir.glob(File.join(storage, "#{@config.name}_*.sql")).each do |f|
+        File.delete(f) if File.exist?("#{f}.gz") || File.exist?("#{f}.enc")
+      end
     end
 
-    def last_backup_healthy?
-      files = backup_files
-      return false if files.empty?
+    # ─── Notifications ───────────────────────────────────────────────
+    def notify_success
+      return unless @config.notify_on_success?
+      execute_notify_command("success")
+    end
 
-      threshold = saved_config[:alert_threshold_hours]&.to_i || RailsNexus.configuration.backup_alert_threshold_hours || 24
-      files.first[:age_hours] <= threshold
+    def notify_failure(error_message)
+      return unless @config.notify_on_failure?
+      execute_notify_command("failure", error_message)
     end
 
-    def generate_alerts
-      alerts = []
-      files = backup_files
-      threshold = saved_config[:alert_threshold_hours]&.to_i || RailsNexus.configuration.backup_alert_threshold_hours || 24
+    def execute_notify_command(status, error = nil)
+      return if @config.notify_command.blank?
 
-      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
+      cmd = @config.notify_command
+        .gsub("{STATUS}", status.to_s)
+        .gsub("{MODEL}", @config.name)
+        .gsub("{ERROR}", error.to_s)
+        .gsub("{TIME}", Time.current.iso8601)
 
-      # 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] })})" }
-      end
-
-      alerts
+      Open3.capture3(cmd)
+    rescue StandardError
+      # Don't fail backup because notification failed
     end
 
-    def human_size(bytes)
-      return "0 B" if bytes == 0
-
-      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]]
+    # ─── Fail Record ─────────────────────────────────────────────────
+    def fail_record(message)
+      @record.fail!(error_message: message) if @record
+      notify_failure(message)
+      { success: false, error: message, record: @record }
     end
   end
 end

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>