nvoi 0.1.5 → 0.1.6

data/lib/nvoi/deployer/types.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module Nvoi
-  module Deployer
-    # TunnelInfo holds information about a configured tunnel
-    TunnelInfo = Struct.new(:service_name, :hostname, :tunnel_id, :tunnel_token, :port, keyword_init: true)
-  end
-end

data/lib/nvoi/k8s/renderer.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Nvoi
-  module K8s
-    # TemplateBinding provides a clean binding for ERB templates
-    class TemplateBinding
-      def initialize(data)
-        data.each do |key, value|
-          instance_variable_set("@#{key}", value)
-          define_singleton_method(key) { instance_variable_get("@#{key}") }
-        end
-      end
-
-      def get_binding
-        binding
-      end
-    end
-
-    # Renderer handles K8s manifest rendering and application
-    module Renderer
-      class << self
-        # Render a template with the provided data
-        def render_template(name, data)
-          template = Templates.load_template(name)
-          binding_obj = TemplateBinding.new(data)
-          template.result(binding_obj.get_binding)
-        end
-
-        # Render a template and apply it via kubectl
-        def apply_manifest(ssh, template_name, data)
-          manifest = render_template(template_name, data)
-
-          cmd = "cat <<'EOF' | kubectl apply -f -\n#{manifest}\nEOF"
-          ssh.execute(cmd)
-        end
-
-        # Wait for a deployment to be ready
-        def wait_for_deployment(ssh, name, namespace: "default", timeout: 300)
-          ssh.execute("kubectl rollout status deployment/#{name} -n #{namespace} --timeout=#{timeout}s")
-        end
-      end
-    end
-  end
-end

data/lib/nvoi/k8s/templates.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require "erb"
-
-module Nvoi
-  module K8s
-    # Templates handles K8s manifest template loading
-    module Templates
-      class << self
-        def template_path(name)
-          File.join(Nvoi.templates_path, "#{name}.erb")
-        end
-
-        def load_template(name)
-          path = template_path(name)
-          raise TemplateError, "template #{name} not found at #{path}" unless File.exist?(path)
-
-          ERB.new(File.read(path), trim_mode: "-")
-        end
-
-        def template_names
-          Dir.glob(File.join(Nvoi.templates_path, "*.erb")).map do |path|
-            File.basename(path, ".erb")
-          end
-        end
-      end
-    end
-  end
-end

data/lib/nvoi/logger.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module Nvoi
-  class Logger
-    COLORS = {
-      reset: "\e[0m",
-      red: "\e[31m",
-      green: "\e[32m",
-      yellow: "\e[33m",
-      blue: "\e[34m",
-      magenta: "\e[35m",
-      cyan: "\e[36m",
-      white: "\e[37m",
-      bold: "\e[1m"
-    }.freeze
-
-    def initialize(output: $stdout, color: true)
-      @output = output
-      @color = color && output.tty?
-    end
-
-    def info(message, *args)
-      log(:blue, "INFO", format_message(message, args))
-    end
-
-    def success(message, *args)
-      log(:green, "SUCCESS", format_message(message, args))
-    end
-
-    def warning(message, *args)
-      log(:yellow, "WARNING", format_message(message, args))
-    end
-
-    def error(message, *args)
-      log(:red, "ERROR", format_message(message, args))
-    end
-
-    def debug(message, *args)
-      return unless ENV["NVOI_DEBUG"]
-
-      log(:magenta, "DEBUG", format_message(message, args))
-    end
-
-    def separator
-      @output.puts colorize(:cyan, "-" * 60)
-    end
-
-    def blank
-      @output.puts
-    end
-
-    private
-
-      def format_message(message, args)
-        return message if args.empty?
-
-        format(message, *args)
-      end
-
-      def log(color, level, message)
-        timestamp = Time.now.strftime("%H:%M:%S")
-        prefix = colorize(color, "[#{timestamp}] [#{level}]")
-        @output.puts "#{prefix} #{message}"
-      end
-
-      def colorize(color, text)
-        return text unless @color
-
-        "#{COLORS[color]}#{text}#{COLORS[:reset]}"
-      end
-  end
-end

data/lib/nvoi/providers/aws.rb

@@ -1,403 +0,0 @@
-# frozen_string_literal: true
-
-require "aws-sdk-ec2"
-
-module Nvoi
-  module Providers
-    # AWS provider implements the compute provider interface for AWS EC2
-    class AWS < Base
-      def initialize(access_key_id, secret_access_key, region)
-        @region = region || "us-east-1"
-        @client = Aws::EC2::Client.new(
-          region: @region,
-          credentials: Aws::Credentials.new(access_key_id, secret_access_key)
-        )
-      end
-
-      # Network operations
-
-      def find_or_create_network(name)
-        # Find existing VPC by tag
-        vpc = find_vpc_by_name(name)
-        if vpc
-          return Network.new(
-            id: vpc.vpc_id,
-            name:,
-            ip_range: vpc.cidr_block
-          )
-        end
-
-        # Create new VPC
-        create_resp = @client.create_vpc(
-          cidr_block: "10.0.0.0/16",
-          tag_specifications: [{
-            resource_type: "vpc",
-            tags: [{ key: "Name", value: name }]
-          }]
-        )
-        vpc_id = create_resp.vpc.vpc_id
-
-        # Enable DNS hostnames
-        @client.modify_vpc_attribute(
-          vpc_id:,
-          enable_dns_hostnames: { value: true }
-        )
-
-        # Create subnet
-        subnet_resp = @client.create_subnet(
-          vpc_id:,
-          cidr_block: "10.0.1.0/24",
-          tag_specifications: [{
-            resource_type: "subnet",
-            tags: [{ key: "Name", value: "#{name}-subnet" }]
-          }]
-        )
-
-        # Create internet gateway
-        igw_resp = @client.create_internet_gateway(
-          tag_specifications: [{
-            resource_type: "internet-gateway",
-            tags: [{ key: "Name", value: "#{name}-igw" }]
-          }]
-        )
-        igw_id = igw_resp.internet_gateway.internet_gateway_id
-
-        # Attach internet gateway to VPC
-        @client.attach_internet_gateway(vpc_id:, internet_gateway_id: igw_id)
-
-        # Create route table
-        rtb_resp = @client.create_route_table(
-          vpc_id:,
-          tag_specifications: [{
-            resource_type: "route-table",
-            tags: [{ key: "Name", value: "#{name}-rtb" }]
-          }]
-        )
-        rtb_id = rtb_resp.route_table.route_table_id
-
-        # Add route to internet gateway
-        @client.create_route(
-          route_table_id: rtb_id,
-          destination_cidr_block: "0.0.0.0/0",
-          gateway_id: igw_id
-        )
-
-        # Associate route table with subnet
-        @client.associate_route_table(
-          route_table_id: rtb_id,
-          subnet_id: subnet_resp.subnet.subnet_id
-        )
-
-        Network.new(
-          id: vpc_id,
-          name:,
-          ip_range: create_resp.vpc.cidr_block
-        )
-      end
-
-      def get_network_by_name(name)
-        vpc = find_vpc_by_name(name)
-        raise NetworkError, "network not found: #{name}" unless vpc
-
-        Network.new(
-          id: vpc.vpc_id,
-          name:,
-          ip_range: vpc.cidr_block
-        )
-      end
-
-      def delete_network(id)
-        @client.delete_vpc(vpc_id: id)
-      end
-
-      # Firewall operations
-
-      def find_or_create_firewall(name)
-        # Find existing security group
-        sg = find_security_group_by_name(name)
-        if sg
-          return Firewall.new(id: sg.group_id, name:)
-        end
-
-        # Get default VPC
-        vpcs = @client.describe_vpcs(filters: [{ name: "isDefault", values: ["true"] }])
-        raise NetworkError, "no default VPC found" if vpcs.vpcs.empty?
-
-        # Create security group
-        create_resp = @client.create_security_group(
-          group_name: name,
-          description: "Managed by nvoi",
-          vpc_id: vpcs.vpcs[0].vpc_id,
-          tag_specifications: [{
-            resource_type: "security-group",
-            tags: [{ key: "Name", value: name }]
-          }]
-        )
-
-        # Add SSH ingress rule
-        @client.authorize_security_group_ingress(
-          group_id: create_resp.group_id,
-          ip_permissions: [{
-            ip_protocol: "tcp",
-            from_port: 22,
-            to_port: 22,
-            ip_ranges: [{ cidr_ip: "0.0.0.0/0" }]
-          }]
-        )
-
-        Firewall.new(id: create_resp.group_id, name:)
-      end
-
-      def get_firewall_by_name(name)
-        sg = find_security_group_by_name(name)
-        raise FirewallError, "firewall not found: #{name}" unless sg
-
-        Firewall.new(id: sg.group_id, name:)
-      end
-
-      def delete_firewall(id)
-        @client.delete_security_group(group_id: id)
-      end
-
-      # Server operations
-
-      def find_server(name)
-        instance = find_instance_by_name(name)
-        return nil unless instance
-
-        instance_to_server(instance)
-      end
-
-      def list_servers
-        result = @client.describe_instances(
-          filters: [{
-            name: "instance-state-name",
-            values: %w[pending running stopping stopped]
-          }]
-        )
-
-        servers = []
-        result.reservations.each do |reservation|
-          reservation.instances.each do |instance|
-            servers << instance_to_server(instance)
-          end
-        end
-        servers
-      end
-
-      def create_server(opts)
-        # Get AMI ID for Ubuntu 22.04
-        ami_id = get_ubuntu_ami
-
-        input = {
-          image_id: ami_id,
-          instance_type: opts.type,
-          min_count: 1,
-          max_count: 1,
-          user_data: opts.user_data ? Base64.encode64(opts.user_data) : nil,
-          tag_specifications: [{
-            resource_type: "instance",
-            tags: [{ key: "Name", value: opts.name }]
-          }]
-        }
-
-        # Add network configuration if provided
-        if opts.network_id && !opts.network_id.empty?
-          subnets = @client.describe_subnets(
-            filters: [{ name: "vpc-id", values: [opts.network_id] }]
-          )
-          input[:subnet_id] = subnets.subnets[0].subnet_id unless subnets.subnets.empty?
-        end
-
-        # Add security group if provided
-        if opts.firewall_id && !opts.firewall_id.empty?
-          input[:security_group_ids] = [opts.firewall_id]
-        end
-
-        result = @client.run_instances(input)
-        raise ServerCreationError, "no instance created" if result.instances.empty?
-
-        instance_to_server(result.instances[0])
-      end
-
-      def wait_for_server(server_id, max_attempts)
-        max_attempts.times do
-          resp = @client.describe_instances(instance_ids: [server_id])
-
-          if resp.reservations.any? && resp.reservations[0].instances.any?
-            instance = resp.reservations[0].instances[0]
-            return instance_to_server(instance) if instance.state.name == "running"
-          end
-
-          sleep(5)
-        end
-
-        raise ServerCreationError, "instance did not become running after #{max_attempts} attempts"
-      end
-
-      def delete_server(id)
-        @client.terminate_instances(instance_ids: [id])
-      end
-
-      # Volume operations
-
-      def create_volume(opts)
-        # Get instance to derive availability zone
-        resp = @client.describe_instances(instance_ids: [opts.server_id])
-        raise VolumeError, "instance not found: #{opts.server_id}" if resp.reservations.empty?
-
-        instance = resp.reservations[0].instances[0]
-        az = instance.placement.availability_zone
-
-        create_resp = @client.create_volume(
-          availability_zone: az,
-          size: opts.size,
-          volume_type: "gp3",
-          tag_specifications: [{
-            resource_type: "volume",
-            tags: [{ key: "Name", value: opts.name }]
-          }]
-        )
-
-        Volume.new(
-          id: create_resp.volume_id,
-          name: opts.name,
-          size: create_resp.size,
-          location: create_resp.availability_zone,
-          status: create_resp.state
-        )
-      end
-
-      def get_volume(id)
-        resp = @client.describe_volumes(volume_ids: [id])
-        return nil if resp.volumes.empty?
-
-        volume_to_compute(resp.volumes[0])
-      end
-
-      def get_volume_by_name(name)
-        resp = @client.describe_volumes(
-          filters: [{ name: "tag:Name", values: [name] }]
-        )
-        return nil if resp.volumes.empty?
-
-        volume_to_compute(resp.volumes[0])
-      end
-
-      def delete_volume(id)
-        @client.delete_volume(volume_id: id)
-      end
-
-      def attach_volume(volume_id, server_id)
-        @client.attach_volume(
-          volume_id:,
-          instance_id: server_id,
-          device: "/dev/xvdf"
-        )
-      end
-
-      def detach_volume(volume_id)
-        @client.detach_volume(volume_id:)
-      end
-
-      # Validation operations
-
-      def validate_instance_type(instance_type)
-        resp = @client.describe_instance_types(instance_types: [instance_type])
-        raise ValidationError, "invalid AWS instance type: #{instance_type}" if resp.instance_types.empty?
-
-        true
-      end
-
-      def validate_region(region)
-        resp = @client.describe_regions(region_names: [region])
-        raise ValidationError, "invalid AWS region: #{region}" if resp.regions.empty?
-
-        true
-      end
-
-      def validate_credentials
-        @client.describe_regions
-        true
-      rescue StandardError => e
-        raise ValidationError, "aws credentials invalid: #{e.message}"
-      end
-
-      private
-
-        def find_vpc_by_name(name)
-          resp = @client.describe_vpcs(
-            filters: [{ name: "tag:Name", values: [name] }]
-          )
-          resp.vpcs.first
-        end
-
-        def find_security_group_by_name(name)
-          resp = @client.describe_security_groups(
-            filters: [{ name: "group-name", values: [name] }]
-          )
-          resp.security_groups.first
-        end
-
-        def find_instance_by_name(name)
-          resp = @client.describe_instances(
-            filters: [
-              { name: "tag:Name", values: [name] },
-              { name: "instance-state-name", values: %w[pending running stopping stopped] }
-            ]
-          )
-
-          resp.reservations.each do |reservation|
-            return reservation.instances.first unless reservation.instances.empty?
-          end
-          nil
-        end
-
-        def get_ubuntu_ami
-          resp = @client.describe_images(
-            owners: ["099720109477"], # Canonical's AWS account ID
-            filters: [
-              { name: "name", values: ["ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-*"] },
-              { name: "state", values: ["available"] }
-            ]
-          )
-
-          raise ProviderError, "no Ubuntu 22.04 AMI found" if resp.images.empty?
-
-          # Return the most recent AMI
-          latest = resp.images.max_by(&:creation_date)
-          latest.image_id
-        end
-
-        def instance_to_server(instance)
-          name = instance.tags&.find { |t| t.key == "Name" }&.value || ""
-
-          Server.new(
-            id: instance.instance_id,
-            name:,
-            status: instance.state.name,
-            public_ipv4: instance.public_ip_address
-          )
-        end
-
-        def volume_to_compute(vol)
-          name = vol.tags&.find { |t| t.key == "Name" }&.value || ""
-
-          v = Volume.new(
-            id: vol.volume_id,
-            name:,
-            size: vol.size,
-            location: vol.availability_zone,
-            status: vol.state
-          )
-
-          if vol.attachments.any?
-            v.server_id = vol.attachments[0].instance_id
-            v.device_path = vol.attachments[0].device
-          end
-
-          v
-        end
-    end
-  end
-end

data/lib/nvoi/providers/base.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module Nvoi
-  module Providers
-    # Network represents a virtual network
-    Network = Struct.new(:id, :name, :ip_range, keyword_init: true)
-
-    # Firewall represents a firewall configuration
-    Firewall = Struct.new(:id, :name, keyword_init: true)
-
-    # Server represents a compute server/instance
-    Server = Struct.new(:id, :name, :status, :public_ipv4, keyword_init: true)
-
-    # Volume represents a block storage volume
-    Volume = Struct.new(:id, :name, :size, :location, :status, :server_id, :device_path, keyword_init: true)
-
-    # ServerCreateOptions contains options for creating a server
-    ServerCreateOptions = Struct.new(:name, :type, :image, :location, :user_data, :network_id, :firewall_id, keyword_init: true)
-
-    # VolumeCreateOptions contains options for creating a volume
-    VolumeCreateOptions = Struct.new(:name, :size, :server_id, keyword_init: true)
-
-    # Base provider interface - all providers must implement these methods
-    class Base
-      # Network operations
-      def find_or_create_network(name)
-        raise NotImplementedError
-      end
-
-      def get_network_by_name(name)
-        raise NotImplementedError
-      end
-
-      def delete_network(id)
-        raise NotImplementedError
-      end
-
-      # Firewall operations
-      def find_or_create_firewall(name)
-        raise NotImplementedError
-      end
-
-      def get_firewall_by_name(name)
-        raise NotImplementedError
-      end
-
-      def delete_firewall(id)
-        raise NotImplementedError
-      end
-
-      # Server operations
-      def find_server(name)
-        raise NotImplementedError
-      end
-
-      def list_servers
-        raise NotImplementedError
-      end
-
-      def create_server(opts)
-        raise NotImplementedError
-      end
-
-      def wait_for_server(server_id, max_attempts)
-        raise NotImplementedError
-      end
-
-      def delete_server(id)
-        raise NotImplementedError
-      end
-
-      # Volume operations
-      def create_volume(opts)
-        raise NotImplementedError
-      end
-
-      def get_volume(id)
-        raise NotImplementedError
-      end
-
-      def get_volume_by_name(name)
-        raise NotImplementedError
-      end
-
-      def delete_volume(id)
-        raise NotImplementedError
-      end
-
-      def attach_volume(volume_id, server_id)
-        raise NotImplementedError
-      end
-
-      def detach_volume(volume_id)
-        raise NotImplementedError
-      end
-
-      # Validation operations
-      def validate_instance_type(instance_type)
-        raise NotImplementedError
-      end
-
-      def validate_region(region)
-        raise NotImplementedError
-      end
-
-      def validate_credentials
-        raise NotImplementedError
-      end
-    end
-  end
-end