nvoi 0.1.5 → 0.1.6

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Nvoi
+  class Cli
+    module Delete
+      module Steps
+        # TeardownVolume handles volume deletion after detachment
+        class TeardownVolume
+          def initialize(config, provider, log)
+            @config = config
+            @provider = provider
+            @log = log
+            @namer = config.namer
+          end
+
+          def run
+            volume_names = collect_volume_names
+            return if volume_names.empty?
+
+            @log.info "Deleting %d volume(s)", volume_names.size
+
+            volume_names.each do |vol_name|
+              delete_volume(vol_name)
+            end
+          end
+
+          private
+
+            def collect_volume_names
+              names = []
+
+              @config.deploy.application.servers.each do |server_name, server_config|
+                next unless server_config.volumes && !server_config.volumes.empty?
+
+                server_config.volumes.each_key do |vol_name|
+                  names << @namer.server_volume_name(server_name, vol_name)
+                end
+              end
+
+              names
+            end
+
+            def delete_volume(vol_name)
+              @log.info "Deleting volume: %s", vol_name
+
+              volume = @provider.get_volume_by_name(vol_name)
+              unless volume
+                @log.info "Volume not found: %s", vol_name
+                return
+              end
+
+              @provider.delete_volume(volume.id)
+              @log.success "Volume deleted: %s", vol_name
+            rescue StandardError => e
+              @log.warning "Failed to delete volume %s: %s", vol_name, e.message
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Nvoi
+  class Cli
+    module Deploy
+      # Command orchestrates the full deployment process
+      class Command
+        def initialize(options)
+          @options = options
+          @log = Nvoi.logger
+        end
+
+        def run
+          @log.info "Deploy CLI %s", VERSION
+
+          # Load configuration
+          config_path = resolve_config_path
+          working_dir = @options[:dir] || "."
+          dockerfile_path = @options[:dockerfile_path] || File.join(working_dir, "Dockerfile")
+
+          @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)
+          validate_provider_config
+
+          @log.info "Using %s Cloud provider", @config.provider_name
+          @log.info "Starting deployment"
+          @log.separator
+
+          # Step 1: Provision infrastructure (network, servers)
+          main_server_ip = provision_infrastructure
+
+          # Step 2: Configure Cloudflare tunnels
+          tunnels = configure_tunnels
+
+          # Step 3: Deploy application
+          deploy_application(main_server_ip, tunnels, working_dir)
+
+          # Success
+          @log.separator
+          @log.success "Deployment complete"
+
+          # Log service URLs
+          tunnels.each do |tunnel|
+            @log.info "Service %s: https://%s", tunnel.service_name, tunnel.hostname
+          end
+        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
+
+          def validate_provider_config
+            case @config.provider_name
+            when "hetzner"
+              h = @config.hetzner
+              @provider.validate_credentials
+              @provider.validate_instance_type(h.server_type)
+              @provider.validate_region(h.server_location)
+            when "aws"
+              a = @config.aws
+              @provider.validate_credentials
+              @provider.validate_instance_type(a.instance_type)
+              @provider.validate_region(a.region)
+            when "scaleway"
+              s = @config.scaleway
+              @provider.validate_credentials
+              @provider.validate_instance_type(s.server_type)
+              @provider.validate_region(s.zone)
+            end
+          end
+
+          def provision_infrastructure
+            require_relative "steps/provision_network"
+            require_relative "steps/provision_server"
+            require_relative "steps/provision_volume"
+            require_relative "steps/setup_k3s"
+
+            # Step 1: Provision network and firewall
+            network, firewall = Steps::ProvisionNetwork.new(@config, @provider, @log).run
+
+            # Step 2: Provision servers
+            main_server_ip = Steps::ProvisionServer.new(@config, @provider, @log, network, firewall).run
+
+            # Step 3: Provision and mount volumes
+            Steps::ProvisionVolume.new(@config, @provider, @log).run
+
+            # Step 4: Setup K3s cluster
+            Steps::SetupK3s.new(@config, @provider, @log, main_server_ip).run
+
+            main_server_ip
+          end
+
+          def configure_tunnels
+            require_relative "steps/configure_tunnel"
+            Steps::ConfigureTunnel.new(@config, @log).run
+          end
+
+          def deploy_application(server_ip, tunnels, working_dir)
+            require_relative "steps/build_image"
+            require_relative "steps/deploy_service"
+            require_relative "steps/cleanup_images"
+
+            ssh = External::Ssh.new(server_ip, @config.ssh_key_path)
+
+            # Acquire deployment lock
+            acquire_lock(ssh)
+
+            begin
+              # Build and push image
+              timestamp = Time.now.strftime("%Y%m%d%H%M%S")
+              image_tag = @config.namer.image_tag(timestamp)
+
+              Steps::BuildImage.new(@config, ssh, @log).run(working_dir, image_tag)
+
+              # Deploy all services
+              Steps::DeployService.new(@config, ssh, tunnels, @log).run(image_tag, timestamp)
+
+              # Cleanup old images
+              Steps::CleanupImages.new(@config, ssh, @log).run(timestamp)
+            ensure
+              release_lock(ssh)
+            end
+          end
+
+          def acquire_lock(ssh)
+            lock_file = @config.namer.deployment_lock_file_path
+
+            output = ssh.execute("test -f #{lock_file} && cat #{lock_file} || echo ''")
+            output = output.strip
+
+            unless output.empty?
+              timestamp = output.to_i
+              if timestamp > 0
+                lock_time = Time.at(timestamp)
+                age = Time.now - lock_time
+
+                if age < Utils::Constants::STALE_DEPLOYMENT_LOCK_AGE
+                  raise Errors::DeploymentError.new(
+                    "lock",
+                    "deployment already in progress (started #{age.round}s ago). Wait or remove lock file: #{lock_file}"
+                  )
+                end
+
+                @log.warning "Removing stale deployment lock (age: #{age.round}s)"
+              end
+            end
+
+            ssh.execute("echo #{Time.now.to_i} > #{lock_file}")
+            @log.info "Deployment lock acquired: %s", lock_file
+          end
+
+          def release_lock(ssh)
+            lock_file = @config.namer.deployment_lock_file_path
+            @log.info "Releasing deployment lock"
+            ssh.execute("rm -f #{lock_file}")
+          rescue StandardError
+            # Ignore errors during lock release
+          end
+      end
+    end
+  end
+end

data/lib/nvoi/cli/deploy/steps/build_image.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Nvoi
+  class Cli
+    module Deploy
+      module Steps
+        # BuildImage handles Docker image building and pushing to cluster
+        class BuildImage
+          def initialize(config, ssh, log)
+            @config = config
+            @ssh = ssh
+            @log = log
+          end
+
+          def run(working_dir, image_tag)
+            @log.info "Building Docker image: %s", image_tag
+
+            containerd = External::Containerd.new(@ssh)
+            containerd.build_and_deploy_image(working_dir, image_tag, cache_from: @config.namer.latest_image_tag)
+
+            @log.success "Image built: %s", image_tag
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nvoi/cli/deploy/steps/cleanup_images.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Nvoi
+  class Cli
+    module Deploy
+      module Steps
+        # CleanupImages handles cleanup of old container images
+        class CleanupImages
+          def initialize(config, ssh, log)
+            @config = config
+            @ssh = ssh
+            @log = log
+          end
+
+          def run(current_tag)
+            keep_count = @config.keep_count_value
+            prefix = @config.container_prefix
+
+            @log.info "Cleaning up old images (keeping %d)", keep_count
+
+            containerd = External::Containerd.new(@ssh)
+
+            # List all images
+            all_tags = containerd.list_images("#{prefix}:*")
+
+            # Sort by tag (timestamp), keep newest
+            sorted_tags = all_tags.sort.reverse
+            keep_tags = sorted_tags.take(keep_count)
+
+            # Make sure current tag is kept
+            keep_tags << current_tag unless keep_tags.include?(current_tag)
+            keep_tags << "latest"
+
+            containerd.cleanup_old_images(prefix, keep_tags.uniq)
+
+            @log.success "Old images cleaned up"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nvoi/cli/deploy/steps/configure_tunnel.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Nvoi
+  class Cli
+    module Deploy
+      module Steps
+        # ConfigureTunnel handles Cloudflare tunnel setup for services
+        class ConfigureTunnel
+          def initialize(config, log)
+            @config = config
+            @log = log
+
+            cf = config.cloudflare
+            @cf_client = External::Dns::Cloudflare.new(cf.api_token, cf.account_id)
+          end
+
+          def run
+            @log.info "Configuring Cloudflare tunnels"
+
+            tunnels = []
+
+            @config.deploy.application.app.each do |service_name, service_config|
+              next unless service_config.domain && !service_config.domain.empty?
+              next unless service_config.port && service_config.port.positive?
+              next if service_config.subdomain.nil?
+
+              tunnel_info = configure_service_tunnel(service_name, service_config)
+              tunnels << tunnel_info
+            end
+
+            @log.success "All tunnels configured (%d)", tunnels.size
+            tunnels
+          end
+
+          private
+
+            def configure_service_tunnel(service_name, service_config)
+              tunnel_name = @config.namer.tunnel_name(service_name)
+              hostname = Utils::Namer.build_hostname(service_config.subdomain, service_config.domain)
+
+              # Service URL points to the NGINX Ingress Controller
+              service_url = "http://ingress-nginx-controller.ingress-nginx.svc.cluster.local:80"
+
+              tunnel = setup_tunnel(tunnel_name, hostname, service_url, service_config.domain)
+
+              Objects::Tunnel::Info.new(
+                service_name:,
+                hostname:,
+                tunnel_id: tunnel.tunnel_id,
+                tunnel_token: tunnel.tunnel_token
+              )
+            end
+
+            def setup_tunnel(tunnel_name, hostname, service_url, domain)
+              @log.info "Setting up tunnel: %s -> %s", tunnel_name, hostname
+
+              # Find or create tunnel
+              tunnel = @cf_client.find_tunnel(tunnel_name)
+
+              if tunnel
+                @log.info "Using existing tunnel: %s", tunnel_name
+              else
+                @log.info "Creating new tunnel: %s", tunnel_name
+                tunnel = @cf_client.create_tunnel(tunnel_name)
+              end
+
+              # Get tunnel token
+              token = tunnel.token
+              if token.nil? || token.empty?
+                token = @cf_client.get_tunnel_token(tunnel.id)
+              end
+
+              # Configure tunnel ingress
+              @log.info "Configuring tunnel ingress: %s -> %s", hostname, service_url
+              @cf_client.update_tunnel_configuration(tunnel.id, hostname, service_url)
+
+              # Verify configuration propagated
+              @log.info "Verifying tunnel configuration..."
+              @cf_client.verify_tunnel_configuration(tunnel.id, hostname, service_url, Utils::Constants::TUNNEL_CONFIG_VERIFY_ATTEMPTS)
+
+              # Create DNS record
+              @log.info "Creating DNS CNAME record: %s", hostname
+              zone = @cf_client.find_zone(domain)
+              raise Errors::CloudflareError, "zone not found: #{domain}" unless zone
+
+              tunnel_cname = "#{tunnel.id}.cfargotunnel.com"
+              @cf_client.create_or_update_dns_record(zone.id, hostname, "CNAME", tunnel_cname, proxied: true)
+
+              @log.success "Tunnel configured: %s", tunnel_name
+
+              Objects::Tunnel::Info.new(
+                tunnel_id: tunnel.id,
+                tunnel_token: token
+              )
+            end
+        end
+      end
+    end
+  end
+end