vagrant-tart 0.0.2

data/lib/vagrant-tart/config.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "etc"
+require "i18n"
+require "vagrant"
+
+module VagrantPlugins
+  module Tart
+    # Holds the configuration for the Tart provider.
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    class Config < Vagrant.plugin("2", :config)
+      # @return [String] The image registry
+      attr_accessor :registry
+      # @return [String] The image registry username
+      attr_accessor :username
+      # @return [String] The image registry password
+      attr_accessor :password
+
+      # @return [String] The image source
+      attr_accessor :image
+      # @return [String] The name
+      attr_accessor :name
+
+      # @return [Integer] Number of CPUs
+      attr_accessor :cpu
+      # @return [Integer] Memory size in MB
+      attr_accessor :memory
+      # @return [Integer] Disk storage size in GB
+      attr_accessor :disk
+      # @return [Boolean] Show a GUI window on boot, or run headless
+      attr_accessor :gui
+      # @return [String] Display screen resolution
+      attr_accessor :display
+      # @return [Boolean] Whether the machine is suspendable
+      attr_accessor :suspendable
+
+      # @return [Array<String>] List of volumes to mount
+      attr_accessor :volumes
+
+      # Initialize the configuration with unset values
+      def initialize
+        super
+
+        @registry = UNSET_VALUE
+        @username = UNSET_VALUE
+        @password = UNSET_VALUE
+
+        @image = UNSET_VALUE
+        @name = UNSET_VALUE
+
+        @cpu = UNSET_VALUE
+        @memory = UNSET_VALUE
+        @disk = UNSET_VALUE
+        @gui = UNSET_VALUE
+        @display = UNSET_VALUE
+        @suspendable = UNSET_VALUE
+
+        @volumes = []
+      end
+
+      # Make sure the configuration has defined all the necessary values
+      def finalize!
+        @registry = nil if @registry == UNSET_VALUE
+        @username = nil if @username == UNSET_VALUE
+        @password = nil if @password == UNSET_VALUE
+
+        @image = nil if @image == UNSET_VALUE
+        @name = nil if @name == UNSET_VALUE
+
+        @cpu = 1 if @cpu == UNSET_VALUE
+        @memory = 1024 if @memory == UNSET_VALUE
+        @disk = 10 if @disk == UNSET_VALUE
+        @gui = false if @gui == UNSET_VALUE
+        @display = "1024x768" if @display == UNSET_VALUE
+        @suspendable = false if @suspendable == UNSET_VALUE
+      end
+
+      # Validate the configuration
+      def validate(_machine)
+        errors = _detected_errors
+
+        # Sanity checks for the registry
+        unless @registry.nil?
+          errors << I18n.t("vagrant_tart.config.username_required") if @username.nil? || @username.empty?
+          errors << I18n.t("vagrant_tart.config.password_required") if @password.nil? || @password.empty?
+        end
+
+        # Sanity checks for the image and the name
+        errors << I18n.t("vagrant_tart.config.image_required") if @image.nil? || @image.empty?
+        errors << I18n.t("vagrant_tart.config.name_required") if @name.nil? || @name.empty?
+
+        # Check that the GUI flag is a valid boolean
+        errors << I18n.t("vagrant_tart.config.gui_invalid") unless @gui == true || @gui == false
+
+        # Check that CPU is a valid number and between 1 and the maximum available CPUs
+        max_cpus = Etc.nprocessors
+        unless (@cpu.is_a? Integer) && @cpu >= 1 && @cpu <= max_cpus
+          errors << I18n.t("vagrant_tart.config.cpu_invalid", max_cpus: max_cpus)
+        end
+
+        # Check that memory is a valid number and between 1 and the maximum available memory
+        max_memory = `sysctl -n hw.memsize`.to_i / 1024 / 1024
+        unless (@memory.is_a? Integer) && @memory >= 1 && @memory <= max_memory
+          errors << I18n.t("vagrant_tart.config.memory_invalid", max_memory: max_memory)
+        end
+
+        # Check that disk is a valid number and greater than 1
+        errors << I18n.t("vagrant_tart.config.disk_invalid") unless (@disk.is_a? Integer) && @disk >= 1
+
+        # Check that the display resolution is a valid string conforming to the format "WIDTHxHEIGHT"
+        errors << I18n.t("vagrant_tart.config.display_invalid") unless @display.match?(/^\d+x\d+$/)
+
+        { "Tart Provider" => errors }
+      end
+
+      def suspendable?
+        @suspendable
+      end
+
+      def use_registry?
+        !@registry.nil? && !@username.nil? && !@password.nil?
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+  end
+end

data/lib/vagrant-tart/errors.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Tart
+    module Errors
+      # The base class for all plugin errors.
+      class TartError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_tart.errors")
+      end
+
+      # This error is raised if the platform is not MacOS.
+      class MacOSRequired < TartError
+        error_key(:macos_required)
+      end
+
+      # This error is raised if the Tart binary is not found.
+      class TartRequired < TartError
+        error_key(:tart_required)
+      end
+
+      # This error is raised if a Tart command fails.
+      class CommandError < TartError
+        error_key(:command_error)
+      end
+
+      # This error is raised if the virutal machine is not created.
+      class InstanceNotCreatedError < TartError
+        error_key(:instance_not_created)
+      end
+
+      # This error is raised if the virtual machine is not running.
+      class InstanceNotRunningError < TartError
+        error_key(:instance_not_running)
+      end
+
+      # This error is raised if the synced folder are not for Tart.
+      class SyncedFolderNonTart < TartError
+        error_key(:synced_folder_not_tart)
+      end
+    end
+  end
+end

data/lib/vagrant-tart/model/get_result.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Tart
+    module Model
+      # Represents the result of a Tart 'get' operation.
+      class GetResult
+        # @return [Integer] The number of CPUs of the machine.
+        attr_accessor :cpu
+        # @return [Integer] The size of the machine's disk.
+        attr_accessor :disk
+        # @return [Boolean] Whether the machine is running.
+        attr_accessor :running
+        # @return [Integer] The memory of the machine.
+        attr_accessor :memory
+        # @return [String] The operating system of the machine.
+        attr_accessor :os
+        # @return [String] The size of the machine.
+        attr_accessor :size
+        # @return [String] The state of the machine.
+        attr_accessor :state
+        # @return [String] The size of the display
+        attr_accessor :display
+
+        # Initialize the result from raw data.
+        # @param [Hash] data The raw data.
+        def initialize(data)
+          @cpu = data["CPU"]
+          @disk = data["Disk"]
+          @running = data["Running"]
+          @memory = data["Memory"]
+          @os = data["OS"]
+          @size = data["Size"]
+          @state = data["State"]
+          @display = data["Display"]
+        end
+
+        # Returns the state of the machine using Vagrant symbols.
+        def vagrant_state
+          case @state
+          when "running"
+            :running
+          when "stopped", "suspended"
+            :stopped
+          else
+            :host_state_unknown
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-tart/model/list_result.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Tart
+    module Model
+      # Represents the result of a Tart 'list' operation.
+      class ListResult
+        # @return [Array<ListResultItem>] The list of machines.
+        attr_accessor :machines
+
+        # Initialize the result from raw data.
+        # @param [Array<Hash>] data The raw data.
+        def initialize(data)
+          @machines = []
+          data.each do |machine|
+            item = ListResultItem.new(machine)
+            @machines << item
+          end
+        end
+
+        # Checks if a machine with the given name exists.
+        # @param [String] name The name of the machine.
+        # @return [Boolean]
+        def any?(name)
+          @machines.any? { |i| i.name == name }
+        end
+
+        # Finds a machine with the given name.
+        # @param [String] name The name of the machine.
+        # @return [ListResultItem]
+        def find(name)
+          @machines.find { |i| i.name == name }
+        end
+
+        # Represents an item in the list result.
+        class ListResultItem
+          # @return [Integer] The size of the machine's disk.
+          attr_accessor :disk
+          # @return [String] The name of the machine.
+          attr_accessor :name
+          # @return [Boolean] Whether the machine is running.
+          attr_accessor :running
+          # @return [Integer] The size of the machine's image.
+          attr_accessor :size
+          # @return [String] The source of the machine (local or oci).
+          attr_accessor :source
+          # @return [String] The state of the machine.
+          attr_accessor :state
+
+          # Initialize the result from raw data.
+          # @param [Hash] data The raw data.
+          def initialize(data)
+            @disk = data["Disk"]
+            @name = data["Name"]
+            @running = data["Running"]
+            @size = data["Size"]
+            @source = data["Source"]
+            @state = data["State"]
+          end
+
+          # Returns the state of the machine using Vagrant symbols.
+          def vagrant_state
+            case @state
+            when "running"
+              :running
+            when "stopped", "suspended"
+              :stopped
+            else
+              :host_state_unknown
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-tart/model/tart_disk.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Tart
+    module Model
+      # Represents a synced folder for the Tart provider.
+      class TartDisk
+        # The default tag for auto-mounted folders.
+        AUTO_MOUNT ||= "com.apple.virtio-fs.automount" # rubocop:disable Lint/OrAssignmentToConstant
+        # The default path for auto-mounted folders on Darwin.
+        DARWIN_SHARED_FILES ||= "/Volumes/My Shared Files" # rubocop:disable Lint/OrAssignmentToConstant
+
+        # The path on the host machine.
+        attr_accessor :host_path
+        # The path on the guest machine.
+        attr_accessor :guest_path
+        # The mode of the folder (either "ro" or "rw"). Default is "rw".
+        attr_accessor :mode
+        # The tag of the folder.
+        attr_accessor :tag
+        # The prefix of the folder.
+        attr_accessor :prefix
+
+        # Initialize the folder from configuration data.
+        # @param [Hash] data The configuration data.
+        def initialize(data)
+          @host_path = data[:hostpath]
+          @guest_path = data[:guestpath]
+          parse_mount_options(data[:mount_options] || [])
+        end
+
+        # Check if the disk is auto-mounted.
+        def automount?
+          @tag == AUTO_MOUNT
+        end
+
+        # Convert the disk to a Tart command line option.
+        def to_tart_disk
+          # Create options
+          options = []
+          options << "ro" if @mode == "ro"
+          options << "tag=#{tag}" if @tag
+
+          result = @host_path.to_s
+          if @guest_path.start_with?(DARWIN_SHARED_FILES)
+            prefix = @guest_path[DARWIN_SHARED_FILES.length + 1..]
+            result = "#{prefix}:#{result}" if prefix
+          end
+          result += ":#{options.join(",")}" if options.any?
+          result
+        end
+
+        # Convert the disk to a human readable string.
+        def to_s
+          "#{@host_path} -> #{@guest_path} (mode=#{@mode || "rw"}, tag=#{@tag || "none"})"
+        end
+
+        private
+
+        # Parse the mount options.
+        def parse_mount_options(mount_options)
+          # Mode option
+          mode = mount_options.find { |option| option.start_with?("mode=") }
+          @mode = mode.split("=")[1] if mode
+
+          # Tag option
+          tag = mount_options.find { |option| option.start_with?("tag=") }
+          @tag = if tag
+                   tag.split("=")[1]
+                 else
+                   AUTO_MOUNT
+                 end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-tart/plugin.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Check if the Vagrant gem is available
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant Tart plugin must be run within Vagrant."
+end
+
+# Make sure no one is attempting to install this plugin into an early Vagrant version.
+raise "The Vagrant Tart plugin is only compatible with Vagrant 2.3 or higher" if Vagrant::VERSION < "2.3.0"
+
+module VagrantPlugins
+  module Tart
+    # Provides the capabilities to manage Tart virtual machines.
+    class Plugin < Vagrant.plugin("2")
+      name "tart"
+      description "Allows Vagrant to manage Tart virtual machines."
+
+      # Register the configuration.
+      config(:tart, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      # Register the provider.
+      provider(:tart, box_optional: true, parallel: true) do
+        setup_i18n
+
+        require_relative "provider"
+        Provider
+      end
+
+      # Register the synced folder implementation.
+      synced_folder(:tart) do
+        require_relative "synced_folder"
+        SyncedFolder
+      end
+
+      # Load the translation files
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", Tart.source_root)
+        I18n.reload!
+      end
+    end
+  end
+end

data/lib/vagrant-tart/provider.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "log4r"
+require_relative "util/driver"
+
+module VagrantPlugins
+  module Tart
+    # Provider that is responsible for managing the virtual machine and exposing it to Vagrant.
+    class Provider < Vagrant.plugin("2", :provider)
+      # The associated driver
+      attr_reader :driver
+
+      # Initialize the provider with the given machine.
+      def initialize(machine)
+        super
+        @logger = Log4r::Logger.new("vagrant::provider::tart")
+        @machine = machine
+        @driver  = Util::Driver.new
+      end
+
+      # Check if the provider can be used.
+      # rubocop:disable Style/OptionalBooleanParameter
+      def self.usable?(raise_error = false)
+        raise Errors::MacOSRequired unless Vagrant::Util::Platform.darwin?
+
+        tart_present = Vagrant::Util::Which.which("tart")
+        raise Errors::TartRequired unless tart_present
+
+        true
+      rescue Errors::TartError
+        raise if raise_error
+
+        false
+      end
+      # rubocop:enable Style/OptionalBooleanParameter
+
+      # Execute the action with the given name.
+      def action(name)
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+
+        nil
+      end
+
+      # Return the state of the virtual machine.
+      def state
+        @logger.info("Getting state '#{@machine.id}'")
+
+        state_id = nil
+        state_id = :not_created unless @machine.id
+
+        unless state_id
+          env = @machine.action(:get_state)
+          state_id = env[:machine_state_id]
+        end
+
+        # Get the short and long description
+        short = state_id.to_s
+        long  = ""
+
+        # If we're not created, then specify the special ID flag
+        state_id = Vagrant::MachineState::NOT_CREATED_ID if state_id == :not_created
+
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      # Return the SSH info for the virtual machine.
+      def ssh_info
+        # We can only SSH into a running machine
+        return nil if state.id != :running
+
+        # Retrieve the IP address
+        instance_ip = nil
+        begin
+          instance_ip = @driver.ip(@machine.provider_config.name)
+        rescue Errors::CommandError
+          @logger.warn("Failed to read guest IP #{$ERROR_INFO}")
+        end
+
+        return nil if instance_ip.nil?
+
+        @logger.info("IP: #{instance_ip}")
+
+        # Return the information
+        {
+          host: instance_ip,
+          port: 22
+        }
+      end
+
+      def to_s
+        id = @machine.id.nil? ? "nil" : @machine.id
+        "Tart[#{id}]"
+      end
+    end
+  end
+end

data/lib/vagrant-tart/scripts/login.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env zsh
+set -eo pipefail
+
+HOST="$1"
+USERNAME="$2"
+PASSWORD="$3"
+
+# Login to the registry with the provided credentials
+echo "$PASSWORD" | tart login "$HOST" --username "$USERNAME" --password-stdin

data/lib/vagrant-tart/scripts/run.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env zsh
+set -eo pipefail
+
+# Run the virtual machine in the background with the arguments passed to the script
+nohup tart run "$@" &
+
+# Save the PID of the virtual machine
+TART_VM_PID=$!
+
+# Give the process 3 seconds to start.
+sleep 3
+
+# If the process is not alive, then exit with an error message
+if ! ps -p $TART_VM_PID > /dev/null; then
+  echo "Failed to start the virtual machine." 1>&2
+  exit 1
+fi

data/lib/vagrant-tart/synced_folder.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "log4r"
+require "vagrant/util/platform"
+require_relative "model/tart_disk"
+
+module VagrantPlugins
+  module Tart
+    # Manages the synced folders for the Tart provider.
+    class SyncedFolder < Vagrant.plugin("2", :synced_folder)
+      def initialize(*args)
+        super
+        @logger = Log4r::Logger.new("vagrant::provider::tart")
+        @disks = []
+      end
+
+      # rubocop:disable Style/OptionalBooleanParameter
+      def usable?(machine, raise_errors = false)
+        # These synced folders only work if the provider if Tart
+        if machine.provider_name != :tart
+          raise Errors::SyncedFolderNonTart, provider: machine.provider_name.to_s if raise_errors
+
+          return false
+        end
+
+        true
+      end
+      # rubocop:enable Style/OptionalBooleanParameter
+
+      def prepare(machine, folders, _opts)
+        @logger.info("Preparing synced folders for Tart provider.")
+
+        # Get the shared folder options
+        folders.each_value do |data|
+          disk = Model::TartDisk.new(data)
+          @disks << disk
+        end
+
+        # Add the synced folders to the configuration
+        @disks.each do |disk|
+          machine.ui.output("Adding disk '#{disk}'.")
+          machine.provider_config.volumes << disk.to_tart_disk
+        end
+
+        @logger.info("#{@disks.size} synced folders added to the configuration.")
+      end
+
+      def enable(machine, _folders, _opts)
+        darwin = machine.guest.capability?(:darwin_version)
+
+        @disks.each do |disk|
+          enable_disk(machine, disk, darwin)
+        end
+      end
+
+      def disable(_machine, _folders, _opts)
+        # Do nothing
+      end
+
+      def cleanup(_machine, _opts)
+        @disks.clear
+      end
+
+      private
+
+      def enable_disk(machine, disk, darwin)
+        machine.ui.output("Mounting disk '#{disk.host_path}' -> '#{disk.guest_path}'...")
+        if darwin
+          enable_disk_darwin(machine, disk)
+        else
+          enable_disk_linux(machine, disk)
+        end
+        machine.ui.success("Disk mounted.")
+      end
+
+      def enable_disk_darwin(machine, disk)
+        # Create the guest path if it doesn't exist
+        machine.communicate.sudo("mkdir -p #{disk.guest_path}") unless disk.automount?
+
+        return if disk.automount? || machine.communicate.test("mount | grep #{disk.guest_path}")
+
+        # Mount the disk
+        machine.communicate.sudo("mount_virtiofs #{disk.tag} #{disk.guest_path}")
+      end
+
+      def enable_disk_linux(machine, disk)
+        # Create the guest path if it doesn't exist
+        machine.communicate.sudo("mkdir -p #{disk.guest_path}")
+
+        return if machine.communicate.test("mountpoint -q #{disk.guest_path}")
+
+        # Mount the disk
+        machine.communicate.sudo("mount -t virtiofs #{disk.tag} #{disk.guest_path}")
+      end
+    end
+  end
+end