rubydb 0.1.4 → 0.1.6

data/lib/rubydb/cli/commands/snapshot.rb

@@ -1,79 +1,79 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module CLI
-    module Commands
-      # Snapshot - Create a database snapshot
-      class Snapshot
-        def initialize(output, formatter)
-          @output = output
-          @formatter = formatter
-        end
-
-        def execute(args, options)
-          parser = OptionParser.new do |opts|
-            opts.banner = "Usage: rubydb snapshot [options]"
-            opts.on("-n", "--name NAME", "Snapshot name") do |name|
-              options[:name] = name
-            end
-            opts.on("-l", "--list", "List snapshots") do
-              options[:list] = true
-            end
-            opts.on("-d", "--delete NAME", "Delete snapshot") do |name|
-              options[:delete] = name
-            end
-            opts.on("-r", "--restore NAME", "Restore snapshot") do |name|
-              options[:restore] = name
-            end
-            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
-            opts.on("--dir DIR", "Snapshot directory") { |path| options[:snapshot_dir] = path }
-            opts.on("-h", "--help", "Show help") do
-              @output.puts opts
-              exit(0)
-            end
-          end
-
-          parser.parse!(args)
-
-          database = RubyDB::Database.new(options[:database] || "data/rubydb.rdb", auto_connect: false).connect
-          snapshots = RubyDB::Backup::Snapshot.new(
-            database.engine, snapshot_dir: options[:snapshot_dir] || "snapshots"
-          )
-
-          if options[:list]
-            @formatter.format_snapshots(snapshots.list_snapshots)
-            return 0
-          end
-
-          if options[:delete]
-            result = snapshots.delete_snapshot(options[:delete])
-            raise result[:error] unless result[:success]
-            @output.success("Snapshot #{options[:delete]} deleted")
-            return 0
-          end
-
-          if options[:restore]
-            @output.warn("This will overwrite the current database")
-            @output.print("Are you sure? (yes/no): ", nil, false)
-            response = $stdin.gets.chomp
-            return unless response.downcase == "yes"
-
-            result = snapshots.restore_snapshot(options[:restore])
-            raise result[:error] unless result[:success]
-            @output.success("Snapshot #{options[:restore]} restored")
-            return 0
-          end
-
-          name = options[:name] || "snapshot_#{Time.now.strftime('%Y%m%d_%H%M%S')}"
-
-          result = snapshots.create_snapshot(name)
-          raise result[:error] unless result[:success]
-          @output.success("Snapshot #{name} created")
-          0
-        ensure
-          database&.close
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      # Snapshot - Create a database snapshot
+      class Snapshot
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb snapshot [options]"
+            opts.on("-n", "--name NAME", "Snapshot name") do |name|
+              options[:name] = name
+            end
+            opts.on("-l", "--list", "List snapshots") do
+              options[:list] = true
+            end
+            opts.on("-d", "--delete NAME", "Delete snapshot") do |name|
+              options[:delete] = name
+            end
+            opts.on("-r", "--restore NAME", "Restore snapshot") do |name|
+              options[:restore] = name
+            end
+            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
+            opts.on("--dir DIR", "Snapshot directory") { |path| options[:snapshot_dir] = path }
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          database = RubyDB::Database.new(options[:database] || "data/rubydb.rdb", auto_connect: false).connect
+          snapshots = RubyDB::Backup::Snapshot.new(
+            database.engine, snapshot_dir: options[:snapshot_dir] || "snapshots"
+          )
+
+          if options[:list]
+            @formatter.format_snapshots(snapshots.list_snapshots)
+            return 0
+          end
+
+          if options[:delete]
+            result = snapshots.delete_snapshot(options[:delete])
+            raise result[:error] unless result[:success]
+            @output.success("Snapshot #{options[:delete]} deleted")
+            return 0
+          end
+
+          if options[:restore]
+            @output.warn("This will overwrite the current database")
+            @output.print("Are you sure? (yes/no): ", nil, false)
+            response = $stdin.gets.chomp
+            return unless response.downcase == "yes"
+
+            result = snapshots.restore_snapshot(options[:restore])
+            raise result[:error] unless result[:success]
+            @output.success("Snapshot #{options[:restore]} restored")
+            return 0
+          end
+
+          name = options[:name] || "snapshot_#{Time.now.strftime("%Y%m%d_%H%M%S")}"
+
+          result = snapshots.create_snapshot(name)
+          raise result[:error] unless result[:success]
+          @output.success("Snapshot #{name} created")
+          0
+        ensure
+          database&.close
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/cli/commands/start.rb

@@ -1,82 +1,88 @@
-# frozen_string_literal: true
-
-require "optparse"
-
-module RubyDB
-  module CLI
-    module Commands
-      # Start - Start the database server
-      class Start
-        def initialize(output, formatter)
-          @output = output
-          @formatter = formatter
-        end
-
-        def execute(args, options)
-          parser = OptionParser.new do |opts|
-            opts.banner = "Usage: rubydb start [options]"
-            opts.on("-d", "--daemon", "Run as daemon") do
-              options[:daemon] = true
-            end
-            opts.on("-p", "--port PORT", Integer, "Server port") do |port|
-              options[:port] = port
-            end
-            opts.on("--data-dir DIR", "Database data directory") { |dir| options[:data_dir] = dir }
-            opts.on("--log-dir DIR", "Server log directory") { |dir| options[:log_dir] = dir }
-            opts.on("-H", "--host HOST", "Server host") do |host|
-              options[:host] = host
-            end
-            opts.on("--pid-file FILE", "PID file") do |file|
-              options[:pid_file] = file
-            end
-            opts.on("-h", "--help", "Show help") do
-              @output.puts opts
-              exit(0)
-            end
-          end
-
-          parser.parse!(args)
-
-          configured = load_runtime_config(options)
-          server_config = configured[:server] || {}
-
-          server_options = {
-            host: options[:host] || server_config[:host] || "localhost",
-            port: options[:port] || server_config[:port] || 7432,
-            data_dir: options[:data_dir] || configured.dig(:storage, :data_dir) || "data",
-            log_dir: options[:log_dir] || configured.dig(:logging, :log_dir) || "log",
-            pid_file: options[:pid_file] || server_config[:pid_file] || "rubydb.pid",
-            daemonize: options[:daemon] == true || server_config[:daemonize] == true,
-            max_connections: server_config[:max_connections],
-            min_workers: server_config[:min_workers],
-            max_workers: server_config[:max_workers],
-            read_timeout: server_config[:read_timeout],
-            write_timeout: server_config[:write_timeout],
-            idle_timeout: server_config[:idle_timeout],
-            max_request_size: server_config[:max_request_size],
-            authentication: (options[:config] || options[:env].to_s == "production") ? configured[:auth] : { method: "none" },
-            ssl: configured[:ssl] || { enabled: false }
-          }.compact
-          server = RubyDB::Server::Server.new(server_options)
-          server.start
-          @output.success("RubyDB server started on #{server.config[:host]}:#{server.config[:port]}")
-          return 0 if options[:daemon]
-
-          trap("INT") { server.stop; exit(0) }
-          trap("TERM") { server.stop; exit(0) }
-          sleep
-        end
-
-        private
-
-        def load_runtime_config(options)
-          RubyDB::Configuration::Config.environment = options[:env] if options[:env]
-          config = RubyDB::Configuration::Config.load(options[:config])
-          raise "Invalid configuration: #{RubyDB::Configuration::Config.errors.join('; ')}" unless config && RubyDB::Configuration::Config.valid?
-
-          config
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "optparse"
+
+module RubyDB
+  module CLI
+    module Commands
+      # Start - Start the database server
+      class Start
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb start [options]"
+            opts.on("-d", "--daemon", "Run as daemon") do
+              options[:daemon] = true
+            end
+            opts.on("-p", "--port PORT", Integer, "Server port") do |port|
+              options[:port] = port
+            end
+            opts.on("--data-dir DIR", "Database data directory") { |dir| options[:data_dir] = dir }
+            opts.on("--log-dir DIR", "Server log directory") { |dir| options[:log_dir] = dir }
+            opts.on("-H", "--host HOST", "Server host") do |host|
+              options[:host] = host
+            end
+            opts.on("--pid-file FILE", "PID file") do |file|
+              options[:pid_file] = file
+            end
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          configured = load_runtime_config(options)
+          server_config = configured[:server] || {}
+
+          server_options = {
+            host: options[:host] || server_config[:host] || "localhost",
+            port: options[:port] || server_config[:port] || 7432,
+            data_dir: options[:data_dir] || configured.dig(:storage, :data_dir) || "data",
+            log_dir: options[:log_dir] || configured.dig(:logging, :log_dir) || "log",
+            pid_file: options[:pid_file] || server_config[:pid_file] || "rubydb.pid",
+            daemonize: options[:daemon] == true || server_config[:daemonize] == true,
+            max_connections: server_config[:max_connections],
+            min_workers: server_config[:min_workers],
+            max_workers: server_config[:max_workers],
+            read_timeout: server_config[:read_timeout],
+            write_timeout: server_config[:write_timeout],
+            idle_timeout: server_config[:idle_timeout],
+            max_request_size: server_config[:max_request_size],
+            authentication: (options[:config] || options[:env].to_s == "production") ? configured[:auth] : {method: "none"},
+            ssl: configured[:ssl] || {enabled: false}
+          }.compact
+          server = RubyDB::Server::Server.new(server_options)
+          server.start
+          @output.success("RubyDB server started on #{server.config[:host]}:#{server.config[:port]}")
+          return 0 if options[:daemon]
+
+          trap("INT") {
+            server.stop
+            exit(0)
+          }
+          trap("TERM") {
+            server.stop
+            exit(0)
+          }
+          sleep
+        end
+
+        private
+
+        def load_runtime_config(options)
+          RubyDB::Configuration::Config.environment = options[:env] if options[:env]
+          config = RubyDB::Configuration::Config.load(options[:config])
+          raise "Invalid configuration: #{RubyDB::Configuration::Config.errors.join("; ")}" unless config && RubyDB::Configuration::Config.valid?
+
+          config
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/cli/commands/status.rb

@@ -1,92 +1,96 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module CLI
-    module Commands
-      class Status
-        def initialize(output, formatter)
-          @output = output
-          @formatter = formatter
-        end
-
-        def execute(args, options)
-          parser = OptionParser.new do |opts|
-            opts.banner = "Usage: rubydb status [options]"
-            opts.on("--json", "Output as JSON") do
-              options[:json] = true
-            end
-            opts.on("-h", "--help", "Show help") do
-              @output.puts opts
-              exit(0)
-            end
-          end
-
-          parser.parse!(args)
-
-          # Get real status from engine
-          config = RubyDB::Configuration::Config.instance
-          db_path = config.get("storage.data_dir") || "data/rubydb.rdb"
-
-          status_data = {
-            database: File.basename(db_path, ".rdb"),
-            mode: "server",
-            status: "unavailable",
-            version: RubyDB::VERSION,
-            pid: Process.pid,
-            uptime: Process.clock_gettime(Process::CLOCK_MONOTONIC).to_i,
-            connections: 0,
-            tables: 0,
-            storage_size: File.exist?(db_path) ? File.size(db_path) : 0,
-            memory_usage: get_memory_usage,
-            wal_enabled: true,
-            replication: { role: "unknown", status: "not_configured", lag_ms: nil },
-            branch: { current: "unknown", total: nil }
-          }
-
-          engine = nil
-          begin
-            engine = RubyDB::Storage::Engine.new(db_path, {})
-            status_data[:status] = "running"
-            status_data[:tables] = engine.list_tables.size
-            status_data[:connections] = engine.connection_count rescue 0
-            status_data[:wal_enabled] = !engine.wal.nil?
-          rescue => error
-            status_data[:error] = error.message
-          ensure
-            engine&.close if engine&.open?
-          end
-
-          if options[:json]
-            @output.json(status_data)
-          else
-            @formatter.format_status(status_data)
-          end
-
-          0
-        end
-
-        private
-
-        def get_memory_usage
-          if File.exist?("/proc/self/status")
-            File.read("/proc/self/status").each_line do |line|
-              if line.start_with?("VmRSS:")
-                return line.split[1].to_i * 1024
-              end
-            end
-          end
-
-          # Fallback - run ps command
-          begin
-            output = `ps -o rss= -p #{Process.pid}`
-            return output.strip.to_i * 1024 if output && !output.empty?
-          rescue
-            # Ignore
-          end
-
-          0
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      class Status
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb status [options]"
+            opts.on("--json", "Output as JSON") do
+              options[:json] = true
+            end
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          # Get real status from engine
+          config = RubyDB::Configuration::Config.instance
+          db_path = config.get("storage.data_dir") || "data/rubydb.rdb"
+
+          status_data = {
+            database: File.basename(db_path, ".rdb"),
+            mode: "server",
+            status: "unavailable",
+            version: RubyDB::VERSION,
+            pid: Process.pid,
+            uptime: Process.clock_gettime(Process::CLOCK_MONOTONIC).to_i,
+            connections: 0,
+            tables: 0,
+            storage_size: File.exist?(db_path) ? File.size(db_path) : 0,
+            memory_usage: get_memory_usage,
+            wal_enabled: true,
+            replication: {role: "unknown", status: "not_configured", lag_ms: nil},
+            branch: {current: "unknown", total: nil}
+          }
+
+          engine = nil
+          begin
+            engine = RubyDB::Storage::Engine.new(db_path, {})
+            status_data[:status] = "running"
+            status_data[:tables] = engine.list_tables.size
+            status_data[:connections] = begin
+              engine.connection_count
+            rescue
+              0
+            end
+            status_data[:wal_enabled] = !engine.wal.nil?
+          rescue => error
+            status_data[:error] = error.message
+          ensure
+            engine&.close if engine&.open?
+          end
+
+          if options[:json]
+            @output.json(status_data)
+          else
+            @formatter.format_status(status_data)
+          end
+
+          0
+        end
+
+        private
+
+        def get_memory_usage
+          if File.exist?("/proc/self/status")
+            File.read("/proc/self/status").each_line do |line|
+              if line.start_with?("VmRSS:")
+                return line.split[1].to_i * 1024
+              end
+            end
+          end
+
+          # Fallback - run ps command
+          begin
+            output = `ps -o rss= -p #{Process.pid}`
+            return output.strip.to_i * 1024 if output && !output.empty?
+          rescue
+            # Ignore
+          end
+
+          0
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/cli/commands/stop.rb

@@ -1,47 +1,47 @@
-# frozen_string_literal: true
-
-require "optparse"
-
-module RubyDB
-  module CLI
-    module Commands
-      # Stop - Stop the database server
-      class Stop
-        def initialize(output, formatter)
-          @output = output
-          @formatter = formatter
-        end
-
-        def execute(args, options)
-          parser = OptionParser.new do |opts|
-            opts.banner = "Usage: rubydb stop [options]"
-            opts.on("-f", "--force", "Force stop") do
-              options[:force] = true
-            end
-            opts.on("--pid-file FILE", "PID file") do |file|
-              options[:pid_file] = file
-            end
-            opts.on("-h", "--help", "Show help") do
-              @output.puts opts
-              exit(0)
-            end
-          end
-
-          parser.parse!(args)
-
-          pid_file = options[:pid_file] || "rubydb.pid"
-          raise "PID file not found: #{pid_file}" unless File.file?(pid_file)
-          pid = Integer(File.read(pid_file).strip, 10)
-          Process.kill(0, pid)
-          Process.kill(options[:force] ? "KILL" : "TERM", pid)
-          @output.success("RubyDB server stop signal sent to PID #{pid}")
-          0
-        rescue Errno::ESRCH
-          raise "RubyDB process #{pid} is not running"
-        rescue ArgumentError
-          raise "Invalid PID in #{pid_file}"
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "optparse"
+
+module RubyDB
+  module CLI
+    module Commands
+      # Stop - Stop the database server
+      class Stop
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb stop [options]"
+            opts.on("-f", "--force", "Force stop") do
+              options[:force] = true
+            end
+            opts.on("--pid-file FILE", "PID file") do |file|
+              options[:pid_file] = file
+            end
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          pid_file = options[:pid_file] || "rubydb.pid"
+          raise "PID file not found: #{pid_file}" unless File.file?(pid_file)
+          pid = Integer(File.read(pid_file).strip, 10)
+          Process.kill(0, pid)
+          Process.kill(options[:force] ? "KILL" : "TERM", pid)
+          @output.success("RubyDB server stop signal sent to PID #{pid}")
+          0
+        rescue Errno::ESRCH
+          raise "RubyDB process #{pid} is not running"
+        rescue ArgumentError
+          raise "Invalid PID in #{pid_file}"
+        end
+      end
+    end
+  end
+end