nvoi 0.1.5 → 0.1.6

data/lib/nvoi/providers/hetzner.rb

@@ -1,288 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "hetzner_client"
-
-module Nvoi
-  module Providers
-    # Hetzner provider implements the compute provider interface for Hetzner Cloud
-    class Hetzner < Base
-      def initialize(token)
-        @client = HetznerClient.new(token)
-      end
-
-      # Network operations
-
-      def find_or_create_network(name)
-        network = find_network_by_name(name)
-        return to_network(network) if network
-
-        network = @client.create_network(
-          name:,
-          ip_range: Constants::NETWORK_CIDR,
-          subnets: [{
-            type: "cloud",
-            ip_range: Constants::SUBNET_CIDR,
-            network_zone: "eu-central"
-          }]
-        )
-
-        to_network(network)
-      end
-
-      def get_network_by_name(name)
-        network = find_network_by_name(name)
-        raise NetworkError, "network not found: #{name}" unless network
-
-        to_network(network)
-      end
-
-      def delete_network(id)
-        @client.delete_network(id.to_i)
-      end
-
-      # Firewall operations
-
-      def find_or_create_firewall(name)
-        firewall = find_firewall_by_name(name)
-        return to_firewall(firewall) if firewall
-
-        firewall = @client.create_firewall(
-          name:,
-          rules: [{
-            direction: "in",
-            protocol: "tcp",
-            port: "22",
-            source_ips: ["0.0.0.0/0", "::/0"]
-          }]
-        )
-
-        to_firewall(firewall)
-      end
-
-      def get_firewall_by_name(name)
-        firewall = find_firewall_by_name(name)
-        raise FirewallError, "firewall not found: #{name}" unless firewall
-
-        to_firewall(firewall)
-      end
-
-      def delete_firewall(id)
-        @client.delete_firewall(id.to_i)
-      end
-
-      # Server operations
-
-      def find_server(name)
-        server = find_server_by_name(name)
-        return nil unless server
-
-        to_server(server)
-      end
-
-      def list_servers
-        @client.list_servers.map { |s| to_server(s) }
-      end
-
-      def create_server(opts)
-        # Resolve IDs
-        server_type = find_server_type(opts.type)
-        raise ValidationError, "invalid server type: #{opts.type}" unless server_type
-
-        image = find_image(opts.image)
-        raise ValidationError, "invalid image: #{opts.image}" unless image
-
-        location = find_location(opts.location)
-        raise ValidationError, "invalid location: #{opts.location}" unless location
-
-        create_opts = {
-          name: opts.name,
-          server_type: server_type["name"],
-          image: image["name"],
-          location: location["name"],
-          user_data: opts.user_data,
-          start_after_create: true
-        }
-
-        # Add network if provided
-        if opts.network_id && !opts.network_id.empty?
-          create_opts[:networks] = [opts.network_id.to_i]
-        end
-
-        # Add firewall if provided
-        if opts.firewall_id && !opts.firewall_id.empty?
-          create_opts[:firewalls] = [{ firewall: opts.firewall_id.to_i }]
-        end
-
-        server = @client.create_server(create_opts)
-        to_server(server)
-      end
-
-      def wait_for_server(server_id, max_attempts)
-        max_attempts.times do
-          server = @client.get_server(server_id.to_i)
-
-          if server["status"] == "running"
-            return to_server(server)
-          end
-
-          sleep(Constants::SERVER_READY_INTERVAL)
-        end
-
-        raise ServerCreationError, "server did not become running after #{max_attempts} attempts"
-      end
-
-      def delete_server(id)
-        server = @client.get_server(id.to_i)
-
-        # Remove from firewalls
-        @client.list_firewalls.each do |fw|
-          fw["applied_to"]&.each do |applied|
-            next unless applied["type"] == "server" && applied.dig("server", "id") == id.to_i
-
-            @client.remove_firewall_from_server(fw["id"], id.to_i)
-          rescue StandardError
-            # Ignore cleanup errors
-          end
-        end
-
-        # Detach from networks
-        server["private_net"]&.each do |pn|
-          @client.detach_server_from_network(id.to_i, pn["network"])
-        rescue StandardError
-          # Ignore cleanup errors
-        end
-
-        @client.delete_server(id.to_i)
-      end
-
-      # Volume operations
-
-      def create_volume(opts)
-        server = @client.get_server(opts.server_id.to_i)
-        raise VolumeError, "server not found: #{opts.server_id}" unless server
-
-        volume = @client.create_volume(
-          name: opts.name,
-          size: opts.size,
-          location: server.dig("datacenter", "location", "name"),
-          format: "xfs"
-        )
-
-        to_volume(volume)
-      end
-
-      def get_volume(id)
-        volume = @client.get_volume(id.to_i)
-        return nil unless volume
-
-        to_volume(volume)
-      end
-
-      def get_volume_by_name(name)
-        volume = @client.list_volumes.find { |v| v["name"] == name }
-        return nil unless volume
-
-        to_volume(volume)
-      end
-
-      def delete_volume(id)
-        @client.delete_volume(id.to_i)
-      end
-
-      def attach_volume(volume_id, server_id)
-        @client.attach_volume(volume_id.to_i, server_id.to_i)
-      end
-
-      def detach_volume(volume_id)
-        @client.detach_volume(volume_id.to_i)
-      end
-
-      # Validation operations
-
-      def validate_instance_type(instance_type)
-        server_type = find_server_type(instance_type)
-        raise ValidationError, "invalid hetzner server type: #{instance_type}" unless server_type
-
-        true
-      end
-
-      def validate_region(region)
-        location = find_location(region)
-        raise ValidationError, "invalid hetzner location: #{region}" unless location
-
-        true
-      end
-
-      def validate_credentials
-        @client.list_server_types
-        true
-      rescue AuthenticationError => e
-        raise ValidationError, "hetzner credentials invalid: #{e.message}"
-      end
-
-      private
-
-        def find_network_by_name(name)
-          @client.list_networks.find { |n| n["name"] == name }
-        end
-
-        def find_firewall_by_name(name)
-          @client.list_firewalls.find { |f| f["name"] == name }
-        end
-
-        def find_server_by_name(name)
-          @client.list_servers.find { |s| s["name"] == name }
-        end
-
-        def find_server_type(name)
-          @client.list_server_types.find { |t| t["name"] == name }
-        end
-
-        def find_image(name)
-          # Images endpoint requires filtering
-          response = @client.get("/images?name=#{name}")
-          response["images"]&.first
-        end
-
-        def find_location(name)
-          @client.list_locations.find { |l| l["name"] == name }
-        end
-
-        def to_network(data)
-          Network.new(
-            id: data["id"].to_s,
-            name: data["name"],
-            ip_range: data["ip_range"]
-          )
-        end
-
-        def to_firewall(data)
-          Firewall.new(
-            id: data["id"].to_s,
-            name: data["name"]
-          )
-        end
-
-        def to_server(data)
-          Server.new(
-            id: data["id"].to_s,
-            name: data["name"],
-            status: data["status"],
-            public_ipv4: data.dig("public_net", "ipv4", "ip")
-          )
-        end
-
-        def to_volume(data)
-          Volume.new(
-            id: data["id"].to_s,
-            name: data["name"],
-            size: data["size"],
-            location: data.dig("location", "name"),
-            status: data["status"],
-            server_id: data["server"]&.to_s,
-            device_path: data["linux_device"]
-          )
-        end
-    end
-  end
-end

data/lib/nvoi/providers/hetzner_client.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-require "faraday"
-require "json"
-
-module Nvoi
-  module Providers
-    # Raw HTTP client for Hetzner Cloud API
-    class HetznerClient
-      BASE_URL = "https://api.hetzner.cloud/v1"
-
-      def initialize(token)
-        @token = token
-        @conn = Faraday.new do |f|
-          f.request :json
-          f.response :json
-          f.headers["Authorization"] = "Bearer #{token}"
-        end
-      end
-
-      def get(path)
-        response = @conn.get("#{BASE_URL}#{path}")
-        handle_response(response)
-      end
-
-      def post(path, payload = {})
-        response = @conn.post("#{BASE_URL}#{path}", payload)
-        handle_response(response)
-      end
-
-      def delete(path)
-        response = @conn.delete("#{BASE_URL}#{path}")
-        return nil if response.status == 204
-        handle_response(response)
-      end
-
-      # Server types
-      def list_server_types
-        get("/server_types")["server_types"]
-      end
-
-      # Locations
-      def list_locations
-        get("/locations")["locations"]
-      end
-
-      # Servers
-      def list_servers
-        get("/servers")["servers"]
-      end
-
-      def get_server(id)
-        get("/servers/#{id}")["server"]
-      end
-
-      def create_server(payload)
-        post("/servers", payload)["server"]
-      end
-
-      def delete_server(id)
-        delete("/servers/#{id}")
-      end
-
-      # Networks
-      def list_networks
-        get("/networks")["networks"]
-      end
-
-      def create_network(payload)
-        post("/networks", payload)["network"]
-      end
-
-      def delete_network(id)
-        delete("/networks/#{id}")
-      end
-
-      # Firewalls
-      def list_firewalls
-        get("/firewalls")["firewalls"]
-      end
-
-      def create_firewall(payload)
-        post("/firewalls", payload)["firewall"]
-      end
-
-      def delete_firewall(id)
-        delete("/firewalls/#{id}")
-      end
-
-      def apply_firewall_to_server(firewall_id, server_id)
-        payload = {
-          apply_to: [{
-            type: "server",
-            server: { id: server_id }
-          }]
-        }
-        post("/firewalls/#{firewall_id}/actions/apply_to_resources", payload)
-      end
-
-      def remove_firewall_from_server(firewall_id, server_id)
-        payload = {
-          remove_from: [{
-            type: "server",
-            server: { id: server_id }
-          }]
-        }
-        post("/firewalls/#{firewall_id}/actions/remove_from_resources", payload)
-      end
-
-      # Volumes
-      def list_volumes
-        get("/volumes")["volumes"]
-      end
-
-      def get_volume(id)
-        get("/volumes/#{id}")["volume"]
-      end
-
-      def create_volume(payload)
-        post("/volumes", payload)["volume"]
-      end
-
-      def delete_volume(id)
-        delete("/volumes/#{id}")
-      end
-
-      def attach_volume(volume_id, server_id)
-        post("/volumes/#{volume_id}/actions/attach", { server: server_id })
-      end
-
-      def detach_volume(volume_id)
-        post("/volumes/#{volume_id}/actions/detach", {})
-      end
-
-      # Server network attachment
-      def attach_server_to_network(server_id, network_id)
-        post("/servers/#{server_id}/actions/attach_to_network", { network: network_id })
-      end
-
-      def detach_server_from_network(server_id, network_id)
-        post("/servers/#{server_id}/actions/detach_from_network", { network: network_id })
-      end
-
-      private
-
-        def handle_response(response)
-          case response.status
-          when 200..299
-            response.body
-          when 401
-            raise AuthenticationError, "Invalid Hetzner API token"
-          when 404
-            raise NotFoundError, parse_error(response)
-          when 422
-            raise ValidationError, parse_error(response)
-          else
-            raise APIError, parse_error(response)
-          end
-        end
-
-        def parse_error(response)
-          if response.body.is_a?(Hash) && response.body["error"]
-            response.body["error"]["message"]
-          else
-            "HTTP #{response.status}: #{response.body}"
-          end
-        end
-    end
-  end
-end

data/lib/nvoi/remote/docker_manager.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-module Nvoi
-  module Remote
-    # ContainerRunOptions contains options for running a container
-    ContainerRunOptions = Struct.new(:name, :image, :network, :volumes, :environment, :command, keyword_init: true)
-
-    # WaitForHealthOptions contains options for health checking
-    WaitForHealthOptions = Struct.new(:container, :utility_container, :health_check_path, :port,
-                                      :max_attempts, :interval, :logger, keyword_init: true)
-
-    # DockerManager manages Docker operations on remote servers
-    class DockerManager
-      attr_reader :ssh
-
-      def initialize(ssh)
-        @ssh = ssh
-      end
-
-      # Create a Docker network
-      def create_network(name)
-        @ssh.execute("docker network create #{name} 2>/dev/null || true")
-      end
-
-      # Build image locally, save to tar, rsync to remote, load on remote
-      def build_image(path, tag, cache_from = nil)
-        # 1. Build locally
-        cache_args = cache_from ? "--cache-from #{cache_from}" : ""
-        local_build_cmd = "cd #{path} && DOCKER_BUILDKIT=1 docker build --platform linux/amd64 #{cache_args} --build-arg BUILDKIT_INLINE_CACHE=1 -t #{tag} ."
-
-        unless system("bash", "-c", local_build_cmd)
-          raise SSHError, "local build failed"
-        end
-
-        # 2. Save to tar
-        tar_file = "/tmp/#{tag.tr(':', '_')}.tar"
-        unless system("docker", "save", tag, "-o", tar_file)
-          raise SSHError, "docker save failed"
-        end
-
-        begin
-          # 3. Rsync to remote
-          remote_tar_path = "/tmp/#{tag.tr(':', '_')}.tar"
-          rsync_cmd = ["rsync", "-avz",
-                       "-e", "ssh -i #{@ssh.ssh_key} -o StrictHostKeyChecking=no",
-                       tar_file,
-                       "#{@ssh.user}@#{@ssh.ip}:#{remote_tar_path}"]
-
-          unless system(*rsync_cmd)
-            raise SSHError, "rsync failed"
-          end
-
-          # 4. Load on remote with ctr (containerd)
-          output = @ssh.execute("sudo ctr -n k8s.io images import #{remote_tar_path}")
-
-          # Docker saves images with docker.io/library/ prefix
-          full_image_ref = "docker.io/library/#{tag}"
-
-          # Tag the imported image with the simple name
-          begin
-            @ssh.execute("sudo ctr -n k8s.io images tag #{full_image_ref} #{tag}")
-          rescue SSHCommandError => e
-            list_output = @ssh.execute("sudo ctr -n k8s.io images ls") rescue ""
-            raise SSHError, "failed to tag imported image: #{e.message}\nAvailable images:\n#{list_output}"
-          end
-
-          # Cleanup tar file
-          @ssh.execute_quiet("rm #{remote_tar_path}")
-        ensure
-          File.delete(tar_file) if File.exist?(tar_file)
-        end
-      end
-
-      # Run a container
-      def run_container(opts)
-        cmd = "docker run -d --name #{opts.name} --network #{opts.network}"
-
-        opts.volumes&.each do |vol|
-          cmd += " -v #{vol}"
-        end
-
-        opts.environment&.each do |k, v|
-          # Escape single quotes in value
-          escaped_v = v.to_s.gsub("'", "'\\''")
-          cmd += " -e #{k}='#{escaped_v}'"
-        end
-
-        cmd += " --restart unless-stopped #{opts.image}"
-        cmd += " #{opts.command}" if opts.command && !opts.command.empty?
-
-        @ssh.execute(cmd)
-      end
-
-      # Execute a command inside a running container
-      def exec(container, command)
-        @ssh.execute("docker exec #{container} #{command}")
-      end
-
-      # Wait for a container to be healthy
-      def wait_for_health(opts)
-        interval = opts.interval || 3
-
-        opts.max_attempts.times do |i|
-          # Check container status
-          begin
-            status = @ssh.execute(
-              "docker inspect --format='{{.State.Status}}' #{opts.container} 2>/dev/null || echo 'none'"
-            )
-          rescue SSHCommandError
-            opts.logger&.info("[%d/%d] Failed to get container status", i + 1, opts.max_attempts)
-            sleep(interval)
-            next
-          end
-
-          # Get last log line
-          log_line = @ssh.execute("docker logs --tail 1 #{opts.container} 2>&1") rescue ""
-
-          opts.logger&.info("[%d/%d] Status: %s | %s", i + 1, opts.max_attempts, status, log_line.strip)
-
-          if status == "running"
-            # Check if app responds using utility container
-            health_cmd = "docker exec #{opts.utility_container} curl -s -o /dev/null -w '%{http_code}' -m 2 http://#{opts.container}:#{opts.port}#{opts.health_check_path} 2>&1 || echo '000'"
-
-            http_code = @ssh.execute(health_cmd) rescue "000"
-            if http_code.include?("200")
-              return true
-            else
-              code = http_code.length >= 3 ? http_code[-3..] : "000"
-              opts.logger&.info("  App not ready yet (HTTP %s)", code)
-            end
-          end
-
-          sleep(interval)
-        end
-
-        false
-      end
-
-      # Get container status
-      def container_status(name)
-        @ssh.execute("docker inspect --format='{{.State.Status}}' #{name} 2>/dev/null || echo 'none'")
-      end
-
-      # Get container logs
-      def container_logs(name, lines)
-        @ssh.execute("docker logs --tail #{lines} #{name} 2>&1")
-      end
-
-      # Stop a container
-      def stop_container(name)
-        @ssh.execute("docker stop #{name} 2>/dev/null || true")
-      end
-
-      # Remove a container
-      def remove_container(name)
-        @ssh.execute("docker rm #{name} 2>/dev/null || true")
-      end
-
-      # List containers matching a filter
-      def list_containers(filter)
-        output = @ssh.execute("docker ps -a --filter '#{filter}' --format '{{.Names}}' --no-trunc | sort -r")
-        return [] if output.empty?
-
-        output.split("\n")
-      end
-
-      # List images matching a filter
-      def list_images(filter)
-        output = @ssh.execute("docker images --filter '#{filter}' --format '{{.Tag}}' | sort -r")
-        return [] if output.empty?
-
-        output.split("\n")
-      end
-
-      # Cleanup old Docker images
-      def cleanup_old_images(prefix, keep_tags)
-        all_tags = list_images("reference=#{prefix}:*")
-
-        remove_tags = all_tags.reject { |tag| keep_tags.include?(tag) }
-        return if remove_tags.empty?
-
-        images = remove_tags.map { |tag| "#{prefix}:#{tag}" }
-        @ssh.execute("docker rmi #{images.join(' ')} 2>/dev/null || true")
-      end
-
-      # Check if a container is running
-      def container_running?(name)
-        output = @ssh.execute("docker ps -q -f name=^#{name}$ -f status=running 2>/dev/null")
-        !output.empty?
-      end
-
-      # Setup a Cloudflare tunnel sidecar
-      def setup_cloudflared(network, token, name)
-        create_network(network)
-
-        cmd = "docker run -d --name #{name} --network #{network} --restart always " \
-              "cloudflare/cloudflared:latest tunnel run --token #{token}"
-
-        @ssh.execute(cmd)
-      end
-    end
-  end
-end