nvoi 0.1.5 → 0.1.7

data/lib/nvoi/cli/db/command.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+module Nvoi
+  class Cli
+    module Db
+      # Command handles database branch operations (backup/restore)
+      class Command
+        BRANCHES_DIR = "/mnt/db-branches"
+
+        def initialize(options)
+          @options = options
+          @log = Nvoi.logger
+        end
+
+        def branch_create(name = nil)
+          init_db_context
+
+          name ||= generate_branch_id
+
+          @log.info "Creating database branch: %s", name
+          @log.separator
+
+          with_ssh do |ssh|
+            opts = build_dump_options
+
+            @log.step "Dumping database"
+            dump_data = @db_provider.dump(ssh, opts)
+            @log.ok "Dump complete (%d bytes)", dump_data.bytesize
+
+            @log.step "Saving branch"
+            app_name = @config.deploy.application.name
+            branches_path = "#{BRANCHES_DIR}/#{app_name}"
+
+            ssh.execute("mkdir -p #{branches_path}")
+
+            dump_file = "#{branches_path}/#{name}.#{@db_provider.extension}"
+            write_file_via_ssh(ssh, dump_file, dump_data)
+
+            update_branch_metadata(ssh, branches_path, name, dump_data.bytesize)
+
+            @log.ok "Branch saved: %s", dump_file
+          end
+
+          @log.separator
+          @log.success "Branch created: %s", name
+
+          name
+        end
+
+        def branch_list
+          init_db_context
+
+          branches = []
+
+          with_ssh do |ssh|
+            app_name = @config.deploy.application.name
+            branches_path = "#{BRANCHES_DIR}/#{app_name}"
+            metadata_file = "#{branches_path}/branches.json"
+
+            result = ssh.execute("test -f #{metadata_file} && cat #{metadata_file} || echo '{}'")
+
+            begin
+              metadata = Objects::Database::BranchMetadata.from_json(result)
+              branches = metadata.branches
+            rescue JSON::ParserError
+              branches = []
+            end
+          end
+
+          if branches.empty?
+            @log.info "No branches found"
+          else
+            @log.info "Database branches:"
+            @log.info ""
+            @log.info "%-20s %-20s %-12s %-10s", "ID", "Created", "Size", "Adapter"
+            @log.info "-" * 70
+
+            branches.each do |b|
+              size_str = format_size(b.size)
+              created = b.created_at[0, 19].gsub("T", " ") rescue b.created_at
+              @log.info "%-20s %-20s %-12s %-10s", b.id, created, size_str, b.adapter
+            end
+          end
+
+          branches
+        end
+
+        def branch_restore(branch_id, new_db_name = nil)
+          init_db_context
+
+          new_db_name ||= "#{@creds.database}_#{branch_id.gsub('-', '_')}"
+
+          @log.info "Restoring branch %s to database %s", branch_id, new_db_name
+          @log.separator
+
+          with_ssh do |ssh|
+            app_name = @config.deploy.application.name
+            branches_path = "#{BRANCHES_DIR}/#{app_name}"
+            dump_file = "#{branches_path}/#{branch_id}.#{@db_provider.extension}"
+
+            unless ssh.execute("test -f #{dump_file} && echo yes || echo no").strip == "yes"
+              raise Errors::ServiceError, "Branch not found: #{branch_id}"
+            end
+
+            @log.step "Reading branch data"
+            dump_data = ssh.execute("cat #{dump_file}")
+
+            opts = build_restore_options(new_db_name)
+
+            @log.step "Restoring to new database"
+            result = @db_provider.restore(ssh, dump_data, opts)
+            @log.ok "Restore complete"
+
+            if @db_provider.is_a?(External::Database::Sqlite)
+              @log.info "New database path: %s", result
+            end
+          end
+
+          @log.separator
+          @log.success "Branch restored: %s -> %s", branch_id, new_db_name
+
+          output_credentials_helper(new_db_name)
+
+          new_db_name
+        end
+
+        def branch_download(branch_id)
+          init_db_context
+
+          output_path = @options[:path] || "#{branch_id}.#{@db_provider.extension}"
+
+          @log.info "Downloading branch: %s", branch_id
+
+          dump_data = nil
+
+          with_ssh do |ssh|
+            app_name = @config.deploy.application.name
+            branches_path = "#{BRANCHES_DIR}/#{app_name}"
+            dump_file = "#{branches_path}/#{branch_id}.#{@db_provider.extension}"
+
+            unless ssh.execute("test -f #{dump_file} && echo yes || echo no").strip == "yes"
+              raise Errors::ServiceError, "Branch not found: #{branch_id}"
+            end
+
+            dump_data = ssh.execute("cat #{dump_file}")
+          end
+
+          File.write(output_path, dump_data)
+
+          @log.success "Downloaded to: %s (%d bytes)", output_path, dump_data.bytesize
+
+          output_path
+        end
+
+        private
+
+          def init_db_context
+            config_path = resolve_config_path
+            @config = Utils::ConfigLoader.load(config_path)
+
+            apply_branch_override if @options[:branch]
+
+            @provider = External::Cloud.for(@config)
+
+            @db_config = @config.deploy.application.database
+            raise Errors::ServiceError, "No database configured" unless @db_config
+
+            adapter = @db_config.adapter&.downcase
+            raise Errors::ServiceError, "No database adapter configured" unless adapter
+
+            @db_provider = External::Database.provider_for(adapter)
+            @creds = Utils::ConfigLoader.get_database_credentials(@db_config, @config.namer)
+          end
+
+          def resolve_config_path
+            config_path = @options[:config] || "deploy.enc"
+            working_dir = @options[:dir]
+
+            if config_path == "deploy.enc" && working_dir && working_dir != "."
+              File.join(working_dir, "deploy.enc")
+            else
+              config_path
+            end
+          end
+
+          def apply_branch_override
+            branch = @options[:branch]
+            return if branch.nil? || branch.empty?
+
+            override = Objects::ConfigOverride.new(branch:)
+            override.apply(@config)
+          end
+
+          def with_ssh
+            server_name = @db_config.servers.first
+            resolved_name = @config.namer.server_name(server_name, 1)
+            server = @provider.find_server(resolved_name)
+            raise Errors::ServiceError, "Could not find server: #{server_name}" unless server
+
+            ssh = External::Ssh.new(server.public_ipv4, @config.ssh_key_path)
+
+            yield ssh
+          end
+
+          def build_dump_options
+            if @db_provider.is_a?(External::Database::Sqlite)
+              Objects::Database::DumpOptions.new(
+                host_path: @creds.host_path,
+                database: @creds.database
+              )
+            else
+              Objects::Database::DumpOptions.new(
+                pod_name: @config.namer.database_pod_name,
+                database: @creds.database,
+                user: @creds.user,
+                password: @creds.password
+              )
+            end
+          end
+
+          def build_restore_options(new_db_name)
+            sanitized_name = sanitize_db_name(new_db_name)
+
+            if @db_provider.is_a?(External::Database::Sqlite)
+              Objects::Database::RestoreOptions.new(
+                host_path: @creds.host_path,
+                database: sanitized_name
+              )
+            else
+              Objects::Database::RestoreOptions.new(
+                pod_name: @config.namer.database_pod_name,
+                database: sanitized_name,
+                user: @creds.user,
+                password: @creds.password
+              )
+            end
+          end
+
+          def sanitize_db_name(name)
+            name.gsub(/[^a-zA-Z0-9_]/, "_")
+          end
+
+          def generate_branch_id
+            Time.now.strftime("%Y%m%d-%H%M%S")
+          end
+
+          def write_file_via_ssh(ssh, path, content)
+            cmd = "cat > #{path} << 'NVOI_DUMP_EOF'\n#{content}\nNVOI_DUMP_EOF"
+            ssh.execute(cmd)
+          end
+
+          def update_branch_metadata(ssh, branches_path, branch_id, size)
+            metadata_file = "#{branches_path}/branches.json"
+
+            result = ssh.execute("test -f #{metadata_file} && cat #{metadata_file} || echo '{}'")
+
+            metadata = begin
+              Objects::Database::BranchMetadata.from_json(result)
+            rescue JSON::ParserError
+              Objects::Database::BranchMetadata.new
+            end
+
+            metadata.branches << Objects::Database::Branch.new(
+              id: branch_id,
+              created_at: Time.now.iso8601,
+              size:,
+              adapter: @db_config.adapter,
+              database: @creds.database
+            )
+
+            ssh.execute("cat > #{metadata_file} << 'NVOI_META_EOF'\n#{metadata.to_json}\nNVOI_META_EOF")
+          end
+
+          def format_size(bytes)
+            return "0 B" unless bytes
+
+            units = %w[B KB MB GB]
+            unit_index = 0
+            size = bytes.to_f
+
+            while size >= 1024 && unit_index < units.length - 1
+              size /= 1024
+              unit_index += 1
+            end
+
+            format("%.1f %s", size, units[unit_index])
+          end
+
+          def output_credentials_helper(new_db_name)
+            adapter = @db_config.adapter&.downcase
+
+            @log.info ""
+            @log.info "To persist this change, run:"
+
+            case adapter
+            when "postgres", "postgresql"
+              @log.info "  nvoi credentials set database.secrets.POSTGRES_DB %s", new_db_name
+            when "mysql"
+              @log.info "  nvoi credentials set database.secrets.MYSQL_DATABASE %s", new_db_name
+            when "sqlite", "sqlite3"
+              new_url = "sqlite://#{File.dirname(@creds.path || 'data')}/#{new_db_name}.sqlite3"
+              @log.info "  nvoi credentials set database.url %s", new_url
+            end
+          end
+      end
+    end
+  end
+end

data/lib/nvoi/cli/delete/command.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Nvoi
+  class Cli
+    module Delete
+      # Command handles cleanup of all cloud resources
+      class Command
+        def initialize(options)
+          @options = options
+          @log = Nvoi.logger
+        end
+
+        def run
+          @log.info "Delete CLI %s", VERSION
+
+          # Load configuration
+          config_path = resolve_config_path
+          @config = Utils::ConfigLoader.load(config_path)
+
+          # Apply branch override if specified
+          apply_branch_override if @options[:branch]
+
+          # Initialize cloud provider
+          @provider = External::Cloud.for(@config)
+
+          # Initialize Cloudflare client
+          cf = @config.cloudflare
+          @cf_client = External::Dns::Cloudflare.new(cf.api_token, cf.account_id)
+
+          @log.info "Using %s Cloud provider", @config.provider_name
+
+          # Run teardown steps in order
+          require_relative "steps/detach_volumes"
+          require_relative "steps/teardown_server"
+          require_relative "steps/teardown_volume"
+          require_relative "steps/teardown_firewall"
+          require_relative "steps/teardown_network"
+          require_relative "steps/teardown_tunnel"
+          require_relative "steps/teardown_dns"
+
+          Steps::DetachVolumes.new(@config, @provider, @log).run
+          Steps::TeardownServer.new(@config, @provider, @log).run
+          Steps::TeardownVolume.new(@config, @provider, @log).run
+          Steps::TeardownFirewall.new(@config, @provider, @log).run
+          Steps::TeardownNetwork.new(@config, @provider, @log).run
+          Steps::TeardownTunnel.new(@config, @cf_client, @log).run
+          Steps::TeardownDns.new(@config, @cf_client, @log).run
+
+          @log.success "Cleanup complete"
+        end
+
+        private
+
+          def resolve_config_path
+            config_path = @options[:config] || "deploy.enc"
+            working_dir = @options[:dir]
+
+            if config_path == "deploy.enc" && working_dir && working_dir != "."
+              File.join(working_dir, "deploy.enc")
+            else
+              config_path
+            end
+          end
+
+          def apply_branch_override
+            branch = @options[:branch]
+            return if branch.nil? || branch.empty?
+
+            override = Objects::ConfigOverride.new(branch:)
+            override.apply(@config)
+          end
+      end
+    end
+  end
+end

data/lib/nvoi/cli/delete/steps/detach_volumes.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Nvoi
+  class Cli
+    module Delete
+      module Steps
+        # DetachVolumes handles volume detachment before server deletion
+        class DetachVolumes
+          def initialize(config, provider, log)
+            @config = config
+            @provider = provider
+            @log = log
+            @namer = config.namer
+          end
+
+          def run
+            volume_configs = collect_volume_configs
+            return if volume_configs.empty?
+
+            @log.info "Detaching %d volume(s)", volume_configs.size
+
+            volume_configs.each do |vol_config|
+              detach_volume(vol_config)
+            end
+          end
+
+          private
+
+            def collect_volume_configs
+              configs = []
+
+              @config.deploy.application.servers.each do |server_name, server_config|
+                next unless server_config.volumes && !server_config.volumes.empty?
+
+                resolved_server = @namer.server_name(server_name, 1)
+
+                server_config.volumes.each_key do |vol_name|
+                  configs << {
+                    name: @namer.server_volume_name(server_name, vol_name),
+                    server_name: resolved_server,
+                    mount_path: @namer.server_volume_host_path(server_name, vol_name)
+                  }
+                end
+              end
+
+              configs
+            end
+
+            def detach_volume(vol_config)
+              volume = @provider.get_volume_by_name(vol_config[:name])
+              return unless volume&.server_id && !volume.server_id.empty?
+
+              @log.info "Detaching volume: %s", vol_config[:name]
+
+              # Unmount from server before detaching via provider API
+              unmount_volume(volume, vol_config[:mount_path])
+
+              @provider.detach_volume(volume.id)
+              @log.success "Volume detached: %s", vol_config[:name]
+            rescue StandardError => e
+              @log.warning "Failed to detach volume %s: %s", vol_config[:name], e.message
+            end
+
+            def unmount_volume(volume, mount_path)
+              server = @provider.find_server_by_id(volume.server_id)
+              return unless server&.public_ipv4
+
+              ssh = External::Ssh.new(server.public_ipv4, @config.ssh_key_path)
+
+              # Check if mounted
+              return unless mounted?(ssh, mount_path)
+
+              @log.info "Unmounting volume from %s", mount_path
+
+              # Unmount the volume
+              ssh.execute("sudo umount #{mount_path}")
+
+              # Remove from fstab to prevent boot issues
+              remove_from_fstab(ssh, mount_path)
+            rescue StandardError => e
+              @log.warning "Failed to unmount %s: %s", mount_path, e.message
+            end
+
+            def mounted?(ssh, mount_path)
+              output = ssh.execute("mountpoint -q #{mount_path} && echo 'mounted' || echo 'not_mounted'")
+              output.strip == "mounted"
+            rescue StandardError
+              false
+            end
+
+            def remove_from_fstab(ssh, mount_path)
+              ssh.execute("sudo sed -i '\\|#{mount_path}|d' /etc/fstab")
+            end
+        end
+      end
+    end
+  end
+end

data/lib/nvoi/cli/delete/steps/teardown_dns.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Nvoi
+  class Cli
+    module Delete
+      module Steps
+        # TeardownDns handles DNS record deletion
+        class TeardownDns
+          def initialize(config, cf_client, log)
+            @config = config
+            @cf_client = cf_client
+            @log = log
+          end
+
+          def run
+            @config.deploy.application.app.each do |_service_name, service|
+              next unless service&.domain && !service.domain.empty?
+
+              delete_dns_records(service.domain, service.subdomain)
+            end
+          end
+
+          private
+
+            def delete_dns_records(domain, subdomain)
+              hostnames = Utils::Namer.build_hostnames(subdomain, domain)
+
+              zone = @cf_client.find_zone(domain)
+              unless zone
+                @log.warning "Zone not found: %s", domain
+                return
+              end
+
+              hostnames.each do |hostname|
+                @log.info "Deleting DNS record: %s", hostname
+
+                record = @cf_client.find_dns_record(zone.id, hostname, "CNAME")
+                if record
+                  @cf_client.delete_dns_record(zone.id, record.id)
+                  @log.success "DNS record deleted: %s", hostname
+                end
+              end
+            rescue StandardError => e
+              @log.warning "Failed to delete DNS records: %s", e.message
+            end
+        end
+      end
+    end
+  end
+end

data/lib/nvoi/cli/delete/steps/teardown_firewall.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Nvoi
+  class Cli
+    module Delete
+      module Steps
+        # TeardownFirewall handles firewall deletion
+        class TeardownFirewall
+          def initialize(config, provider, log)
+            @config = config
+            @provider = provider
+            @log = log
+          end
+
+          def run
+            @log.info "Deleting firewall: %s", @config.firewall_name
+
+            firewall = @provider.get_firewall_by_name(@config.firewall_name)
+            delete_firewall_with_retry(firewall.id) if firewall
+          rescue Errors::FirewallError => e
+            @log.warning "Firewall not found: %s", e.message
+          end
+
+          private
+
+            def delete_firewall_with_retry(firewall_id, max_retries: 5)
+              max_retries.times do |i|
+                begin
+                  @provider.delete_firewall(firewall_id)
+                  @log.success "Firewall deleted"
+                  return
+                rescue StandardError => e
+                  if i == max_retries - 1
+                    raise Errors::ServiceError, "failed to delete firewall after #{max_retries} attempts: #{e.message}"
+                  end
+
+                  @log.info "Firewall still in use, waiting 3s before retry (%d/%d)", i + 1, max_retries
+                  sleep(3)
+                end
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/nvoi/cli/delete/steps/teardown_network.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Nvoi
+  class Cli
+    module Delete
+      module Steps
+        # TeardownNetwork handles network deletion
+        class TeardownNetwork
+          def initialize(config, provider, log)
+            @config = config
+            @provider = provider
+            @log = log
+          end
+
+          def run
+            @log.info "Deleting network: %s", @config.network_name
+
+            network = @provider.get_network_by_name(@config.network_name)
+            if network
+              @provider.delete_network(network.id)
+              @log.success "Network deleted"
+            end
+          rescue Errors::NetworkError => e
+            @log.warning "Network not found: %s", e.message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nvoi/cli/delete/steps/teardown_server.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Nvoi
+  class Cli
+    module Delete
+      module Steps
+        # TeardownServer handles server deletion
+        class TeardownServer
+          def initialize(config, provider, log)
+            @config = config
+            @provider = provider
+            @log = log
+            @namer = config.namer
+          end
+
+          def run
+            servers = @config.deploy.application.servers
+            return if servers.empty?
+
+            servers.each do |group_name, group_config|
+              next unless group_config
+
+              count = group_config.count.positive? ? group_config.count : 1
+              @log.info "Deleting %d server(s) from group '%s'", count, group_name
+
+              (1..count).each do |i|
+                server_name = @namer.server_name(group_name, i)
+                delete_server(server_name)
+              end
+            end
+          end
+
+          private
+
+            def delete_server(server_name)
+              @log.info "Deleting server: %s", server_name
+
+              server = @provider.find_server(server_name)
+              if server
+                @provider.delete_server(server.id)
+                @log.success "Server deleted: %s", server_name
+              end
+            rescue StandardError => e
+              @log.warning "Failed to delete server %s: %s", server_name, e.message
+            end
+        end
+      end
+    end
+  end
+end

data/lib/nvoi/cli/delete/steps/teardown_tunnel.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Nvoi
+  class Cli
+    module Delete
+      module Steps
+        # TeardownTunnel handles Cloudflare tunnel deletion
+        class TeardownTunnel
+          def initialize(config, cf_client, log)
+            @config = config
+            @cf_client = cf_client
+            @log = log
+            @namer = config.namer
+          end
+
+          def run
+            @config.deploy.application.app.each do |service_name, service|
+              next unless service&.domain && !service.domain.empty?
+              next if service.subdomain.nil?
+
+              delete_tunnel(service_name)
+            end
+          end
+
+          private
+
+            def delete_tunnel(service_name)
+              tunnel_name = @namer.tunnel_name(service_name)
+
+              @log.info "Deleting Cloudflare tunnel: %s", tunnel_name
+
+              tunnel = @cf_client.find_tunnel(tunnel_name)
+              if tunnel
+                @cf_client.delete_tunnel(tunnel.id)
+                @log.success "Tunnel deleted: %s", tunnel_name
+              end
+            rescue StandardError => e
+              @log.warning "Failed to delete tunnel: %s", e.message
+            end
+        end
+      end
+    end
+  end
+end