vagrant-eryph 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9decd72160b533c3c04d1c06ab3e7d05e3c28b4415940c05af982ce66cbb2f8b
+  data.tar.gz: 914506e8dc13c6665743360f03c4b8ebcedd180bf73e0f2daed82b290c8d27f6
+SHA512:
+  metadata.gz: 02354e91939f344f23cef10df4d263fcb0612339288483e16579c160a3e4e9e11652ef26c13b5ff28dec8a39192cb185085294fb123539d5af52efa7954679c2
+  data.tar.gz: 17e138e16fd7b7eb09e750e41a98de186a6c8a39519c18c53b20e6bfef9283c5ebe8519a3a0be0be2eb8817af29dde47d287d0a764b6a1b611988a910023976e

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 dbosoft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,79 @@
+# Vagrant Eryph Provider
+
+A Vagrant provider plugin for [Eryph](https://www.eryph.io/) that allows you to manage catlets using Eryph's compute API.
+
+## Features
+
+- Full catlet lifecycle management (create, start, stop, destroy)
+- Automatic Vagrant user setup via cloud-init
+- Cross-platform support (Linux and Windows catlets)
+- SSH and WinRM communication support
+- Local-scoped credential discovery
+- Configurable cloud-init fodder merging
+
+## Installation
+
+```bash
+gem install vagrant-eryph
+```
+
+## Usage
+
+```ruby
+Vagrant.configure("2") do |config|
+  config.vm.provider :eryph do |eryph|
+    eryph.project = "my-project"
+    eryph.parent = "dbosoft/ubuntu-22.04/latest"
+    eryph.auto_config = true  # Enable automatic Vagrant user setup
+  end
+end
+```
+
+## Configuration
+
+### Basic Settings
+- `project` - Eryph project name
+- `parent` - Parent gene for the catlet
+- `auto_create_project` - Auto-create project if it doesn't exist (default: true)
+
+### Auto-configuration
+- `auto_config` - Enable/disable automatic Vagrant user setup (default: true)
+- `enable_winrm` - Enable WinRM for Windows catlets (default: true)
+- `vagrant_password` - Password for Windows vagrant user (default: "vagrant")
+- `ssh_key_injection` - SSH key injection method (:direct or :variable)
+
+### Resources
+- `cpus` - Number of CPUs
+- `memory` - Memory in MB
+- `drives` - Custom drives configuration
+- `networks` - Custom networks configuration
+
+### Cloud-init
+- `fodder` - Custom cloud-init configuration (merged with auto-generated config)
+
+## Project Management
+
+The plugin includes commands to manage Eryph projects:
+
+```bash
+# List projects
+vagrant eryph project list
+
+# Create project
+vagrant eryph project create my-project --description "My development project"
+
+# Manage project networks
+vagrant eryph network get my-project
+vagrant eryph network set my-project --file networks.yml
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec vagrant --help
+```
+
+## License
+
+MIT

data/lib/vagrant-eryph/actions/connect_eryph.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../helpers/eryph_client'
+
+module VagrantPlugins
+  module Eryph
+    module Actions
+      class ConnectEryph
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          # Initialize Eryph client and store it in the environment
+          env[:eryph_client] = Helpers::EryphClient.new(env[:machine])
+
+          # Test the connection by calling client (which tests connectivity)
+          env[:eryph_client].client
+
+          # Ensure the project exists (create if needed and auto_create_project is enabled)
+          config = env[:machine].provider_config
+          env[:eryph_client].ensure_project_exists(config.project) if config.project
+
+          @app.call(env)
+        rescue ::Eryph::ClientRuntime::CredentialsNotFoundError => e
+          env[:ui].error("Eryph credentials not found: #{e.message}")
+          env[:ui].error('Please set up your Eryph configuration or check your .eryph directory')
+          raise Vagrant::Errors::VagrantError, e.message
+        rescue ::Eryph::ClientRuntime::TokenRequestError => e
+          env[:ui].error("Eryph authentication failed: #{e.message}")
+          env[:ui].error('Check your client credentials and network connectivity')
+          raise Vagrant::Errors::VagrantError, e.message
+        rescue StandardError => e
+          env[:ui].error("Failed to connect to Eryph: #{e.message}")
+          raise Vagrant::Errors::VagrantError, e.message
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-eryph/actions/create_catlet.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'json'
+
+module VagrantPlugins
+  module Eryph
+    module Actions
+      class CreateCatlet
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:machine].provider_config
+          ui = env[:ui]
+          client = env[:eryph_client]
+
+          # Build catlet creation request as hash (like AWS provider)
+          catlet_config = build_catlet_config(env)
+
+          ui.info('Creating catlet with configuration:')
+          ui.info("  Name: #{catlet_config[:name]}")
+          ui.info("  Parent Gene: #{catlet_config[:parent]}")
+          ui.info("  Project: #{catlet_config[:project]}")
+
+          # Create and start the catlet (client handles the full lifecycle)
+          operation_result = client.create_catlet(catlet_config)
+
+          # Store the catlet ID from the operation result
+          # The client handles creation and starting, now extract the catlet
+          raise 'Catlet creation failed' unless operation_result&.completed?
+
+          catlet = operation_result.catlet
+          raise 'Failed to get catlet from operation result' unless catlet
+
+          env[:machine].id = catlet.id
+          ui.info("Catlet provisioned successfully with ID: #{catlet.id}")
+
+          # Clear cached catlet status to force refresh on next lookup
+          Provider.instance_variable_set(:@eryph_catlets, nil)
+
+          @app.call(env)
+        rescue StandardError => e
+          ui.error("Failed to create catlet: #{e.message}")
+          raise e
+        end
+
+        private
+
+        def build_catlet_config(env)
+          config = env[:machine].provider_config
+          fodder = env[:catlet_fodder] || []
+
+          # Use the new effective_catlet_configuration method
+          catlet_config = config.effective_catlet_configuration(env[:machine])
+
+          # Add fodder configuration if present
+          if fodder.any?
+            catlet_config[:fodder] = fodder.map do |item|
+              if item[:content]
+                # Regular fodder with content - serialize the content
+                item.merge(content: serialize_fodder_content(item[:content]))
+              else
+                # Gene fodder or other - copy as-is
+                item
+              end
+            end
+          end
+
+          catlet_config
+        end
+
+        def serialize_fodder_content(content)
+          case content
+          when Hash
+            # Convert hash to YAML for cloud-config (remove YAML document separator)
+            content.to_yaml.sub(/^---\n/, '')
+          when String
+            content
+          else
+            content.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-eryph/actions/destroy_catlet.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Eryph
+    module Actions
+      class DestroyCatlet
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          return @app.call(env) unless env[:machine].id
+
+          ui = env[:ui]
+          client = env[:eryph_client]
+
+          ui.info('Destroying catlet...')
+          client.destroy_catlet(env[:machine].id)
+
+          # Clear the machine ID since it no longer exists
+          env[:machine].id = nil
+
+          ui.info('Catlet destroyed successfully')
+
+          @app.call(env)
+        rescue StandardError => e
+          ui.error("Failed to destroy catlet: #{e.message}")
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-eryph/actions/is_created.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Eryph
+    module Actions
+      class IsCreated
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          # Check if the machine has been created by looking for a machine ID
+          # and verifying the catlet exists in Eryph
+          env[:result] = env[:machine].id && catlet_exists?(env)
+          @app.call(env)
+        end
+
+        private
+
+        def catlet_exists?(env)
+          return false unless env[:machine].id
+
+          begin
+            catlet = Provider.eryph_catlet(env[:machine])
+            catlet.respond_to?(:status) && catlet.status != 'not_created'
+          rescue StandardError => e
+            env[:ui].warn("Error checking catlet existence: #{e.message}")
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-eryph/actions/is_stopped.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Eryph
+    module Actions
+      class IsStopped
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          # Check if the catlet is in a stopped state
+          catlet = Provider.eryph_catlet(env[:machine])
+          env[:result] = catlet && catlet.status&.downcase == 'stopped'
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-eryph/actions/message_already_created.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Eryph
+    module Actions
+      class MessageAlreadyCreated
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info('Catlet is already created and running.')
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-eryph/actions/message_not_created.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Eryph
+    module Actions
+      class MessageNotCreated
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].error('Catlet has not been created. Run `vagrant up` first.')
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-eryph/actions/message_will_not_destroy.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Eryph
+    module Actions
+      class MessageWillNotDestroy
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info('Catlet will not be destroyed, since the confirmation was declined.')
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-eryph/actions/prepare_cloud_init.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative '../helpers/cloud_init'
+
+module VagrantPlugins
+  module Eryph
+    module Actions
+      class PrepareCloudInit
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:machine].provider_config
+          ui = env[:ui]
+
+          # Initialize cloud-init helper
+          cloud_init = Helpers::CloudInit.new(env[:machine])
+
+          ui.info('Preparing cloud-init configuration...')
+
+          # Generate complete fodder configuration (auto + user)
+          fodder = cloud_init.generate_complete_fodder
+
+          if fodder.any?
+            ui.info("Generated #{fodder.length} cloud-init fodder entries:")
+
+            # Log fodder details with content
+            fodder.each do |item|
+              if item[:source]
+                # Gene fodder - show name if available, otherwise source
+                display_name = item[:name] || item[:source]
+                ui.detail("  - #{display_name} (gene)")
+              else
+                # Regular fodder
+                ui.detail("  - #{item[:name]} (#{item[:type]})")
+              end
+            end
+          end
+
+          # Store fodder in environment for use by create action
+          env[:catlet_fodder] = fodder
+
+          @app.call(env)
+        rescue StandardError => e
+          ui.error("Failed to prepare cloud-init configuration: #{e.message}")
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-eryph/actions/read_ssh_info.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Eryph
+    module Actions
+      class ReadSSHInfo
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          # Delegate to the provider's ssh_info method for consistency
+          provider = env[:machine].provider
+          env[:machine_ssh_info] = provider.ssh_info
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-eryph/actions/read_state.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Eryph
+    module Actions
+      class ReadState
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env)
+          @app.call(env)
+        end
+
+        private
+
+        def read_state(env)
+          return :not_created unless env[:machine].id
+
+          begin
+            catlet = Provider.eryph_catlet(env[:machine], refresh: true)
+
+            if catlet.respond_to?(:status) && catlet.status
+              map_catlet_state_to_vagrant(catlet.status)
+            else
+              :not_created
+            end
+          rescue StandardError => e
+            env[:ui].warn("Error reading catlet state: #{e.message}")
+            :unknown
+          end
+        end
+
+        def map_catlet_state_to_vagrant(eryph_status)
+          case eryph_status.downcase
+          when 'running'
+            :running
+          when 'stopped'
+            :stopped
+          when 'pending'
+            :unknown
+          when 'error'
+            :error
+          else
+            :unknown
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-eryph/actions/start_catlet.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Eryph
+    module Actions
+      class StartCatlet
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          return @app.call(env) unless env[:machine].id
+
+          ui = env[:ui]
+          client = env[:eryph_client]
+
+          # Check current state
+          catlet = Provider.eryph_catlet(env[:machine])
+
+          if catlet.status&.downcase == 'running'
+            ui.info('Catlet is already running')
+            return @app.call(env)
+          end
+
+          ui.info('Starting catlet...')
+          client.start_catlet(env[:machine].id)
+          ui.info('Catlet started successfully')
+
+          # Clear cached catlet status to force refresh on next lookup
+          Provider.instance_variable_set(:@eryph_catlets, nil)
+
+          @app.call(env)
+        rescue StandardError => e
+          ui.error("Failed to start catlet: #{e.message}")
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-eryph/actions/stop_catlet.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Eryph
+    module Actions
+      class StopCatlet
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          return @app.call(env) unless env[:machine].id
+
+          ui = env[:ui]
+          client = env[:eryph_client]
+
+          # Check current state
+          catlet = Provider.eryph_catlet(env[:machine])
+
+          if catlet.status&.downcase == 'stopped'
+            ui.info('Catlet is already stopped')
+            return @app.call(env)
+          end
+
+          ui.info('Stopping catlet...')
+          client.stop_catlet(env[:machine].id, 'graceful')
+          ui.info('Catlet stopped successfully')
+
+          # Clear cached catlet status to force refresh on next lookup
+          Provider.instance_variable_set(:@eryph_catlets, nil)
+
+          @app.call(env)
+        rescue StandardError => e
+          ui.error("Failed to stop catlet: #{e.message}")
+          raise e
+        end
+      end
+    end
+  end
+end