vagrant_utm 0.0.1

data/lib/vagrant_utm/driver/version_4_5.rb

@@ -0,0 +1,307 @@
+# frozen_string_literal: true
+
+require "log4r"
+require "etc"
+require "vagrant/util/platform"
+
+require File.expand_path("base", __dir__)
+
+module VagrantPlugins
+  module Utm
+    module Driver
+      # Driver for UTM 4.5.x
+      class Version_4_5 < Base # rubocop:disable Naming/ClassAndModuleCamelCase,Metrics/ClassLength
+        def initialize(uuid)
+          super()
+
+          @logger = Log4r::Logger.new("vagrant::provider::utm_4_5")
+          @uuid = uuid
+        end
+
+        def clear_forwarded_ports
+          args = []
+          read_forwarded_ports(@uuid).each do |nic, name, _, _|
+            args.concat(["--index", nic.to_s, name])
+          end
+
+          command = ["clear_port_forwards.applescript", @uuid] + args
+          execute_osa_script(command) unless args.empty?
+        end
+
+        def check_qemu_guest_agent
+          # Check if the qemu-guest-agent is installed and running
+          # Ideally do: utmctl exec id --cmd systemctl is-active qemu-guest-agent
+          # But this is not returning anything, so we just do any utmctl exec command
+          # Here we check if the user is root
+          output = execute("exec", @uuid, "--cmd", "whoami")
+          # check if output contains 'root'
+          output.include?("root")
+        end
+
+        def create_snapshot(machine_id, snapshot_name)
+          list_result = list
+          machine_name = list_result.find(uuid: machine_id).name
+          machine_file = get_vm_file(machine_name)
+          execute_shell("qemu-img", "snapshot", "-c", snapshot_name, machine_file)
+        end
+
+        def delete_snapshot(machine_id, snapshot_name)
+          list_result = list
+          machine_name = list_result.find(uuid: machine_id).name
+          machine_file = get_vm_file(machine_name)
+          execute_shell("qemu-img", "snapshot", "-d", snapshot_name, machine_file)
+        end
+
+        def list_snapshots(machine_id) # rubocop:disable Metrics/AbcSize
+          list_result = list
+          machine_name = list_result.find(uuid: machine_id).name
+          machine_file = get_vm_file(machine_name)
+          output = execute_shell("qemu-img", "snapshot", "-l", machine_file)
+
+          return [] if output.nil? || output.strip.empty?
+
+          @logger.debug("list_snapshots_here: #{output}")
+
+          result = []
+          output.split("\n").map do |line|
+            result << ::Regexp.last_match(1).to_s if line =~ /^\d+\s+(\w+)/
+          end
+
+          result.sort
+        end
+
+        def restore_snapshot(machine_id, snapshot_name)
+          list_result = list
+          machine_name = list_result.find(uuid: machine_id).name
+          machine_file = get_vm_file(machine_name)
+          execute_shell("qemu-img", "snapshot", "-a", snapshot_name, machine_file)
+        end
+
+        def forward_ports(ports) # rubocop:disable Metrics/CyclomaticComplexity
+          args = []
+          ports.each do |options|
+            # Convert to UTM protcol enum
+            protocol_code = case options[:protocol]
+                            when "tcp"
+                              "TcPp"
+                            when "udp"
+                              "UdPp"
+                            else
+                              raise Errors::ForwardedPortInvalidProtocol
+                            end
+
+            pf_builder = [
+              # options[:name], # Name is not supported in UTM
+              protocol_code || "TcPp", # Default to TCP
+              options[:guestip] || "",
+              options[:guestport],
+              options[:hostip] || "",
+              options[:hostport]
+            ]
+
+            args.concat(["--index", options[:adapter].to_s,
+                         pf_builder.join(",")])
+          end
+
+          command = ["add_port_forwards.applescript", @uuid] + args
+          execute_osa_script(command) unless args.empty?
+        end
+
+        def get_vm_file(vm_name)
+          # Get the current username
+          username = ENV["USER"] || Etc.getlogin
+
+          data_path = "/Users/#{username}/Library/Containers/com.utmapp.UTM/Data/Documents/#{vm_name}.utm/Data"
+          # Define the regex for UUID pattern
+          pattern = /^\b[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}\b.qcow2$/
+
+          # List the files in the directory and filter by regex
+          matching_files = Dir.entries(data_path).select do |file|
+            file.match?(pattern)
+          end
+
+          if matching_files.length == 1
+            # If there is exactly one matching file, return full path to file
+            "#{data_path}/#{matching_files[0]}"
+          elsif matching_files.length > 1
+            # If there are multiple matching files, raise an error
+            raise Errors::SnapShotMultipleVMFiles, directory: data_path, files: matching_files
+          else
+            # If there are no matching files, raise an error
+            raise Errors::SnapShotVMFileNotFound, directory: data_path
+          end
+        end
+
+        # Check if the VM with the given UUID  exists.
+        def vm_exists?(uuid)
+          list_result = list
+          list_result.any?(uuid)
+        end
+
+        def read_forwarded_ports(uuid = nil)
+          uuid ||= @uuid
+
+          @logger.debug("read_forward_ports: uuid=#{uuid}")
+
+          # If we care about active VMs only, then we check the state
+          # to verify the VM is running.
+          # This is taken care by the caller , read used ports
+          # return [] if active_only && check_state != :started
+
+          # Get the forwarded ports from emulated Network interface
+          # Format: [nicIndex, name, hostPort, guestPort]
+          # We use hostPort as the name, since UTM does not support name
+          # Because hostport is and should be unique
+          results = []
+          command = ["read_forwarded_ports.applescript", uuid]
+          info = execute_osa_script(command)
+          info.split("\n").each do |line|
+            # Parse info, Forwarding(nicIndex)(ruleIndex)="Protocol,GuestIP,GuestPort,HostIP,HostPort"
+            next unless (matcher = /^Forwarding\((\d+)\)\((\d+)\)="(.+?),.*?,(.+?),.*?,(.+?)"$/.match(line))
+
+            #        nicIndex         name( our hostPort)   hostport        guestport
+            result = [matcher[1].to_i, matcher[5], matcher[5].to_i, matcher[4].to_i]
+            @logger.debug("  - #{result.inspect}")
+            results << result
+          end
+
+          results
+        end
+
+        def read_guest_ip
+          command = ["read_guest_ip.applescript", @uuid]
+          output = execute_osa_script(command)
+          output.strip
+        end
+
+        def read_network_interfaces
+          nics = {}
+          command = ["read_network_interfaces.applescript", @uuid]
+          info = execute_osa_script(command)
+          info.split("\n").each do |line|
+            next unless (matcher = /^nic(\d+),(.+?)$/.match(line))
+
+            adapter = matcher[1].to_i
+            type = matcher[2].to_sym
+            nics[adapter] ||= {}
+            nics[adapter][:type] = type
+          end
+
+          nics
+        end
+
+        def ssh_port(expected_port)
+          @logger.debug("Searching for SSH port: #{expected_port.inspect}")
+
+          # Look for the forwarded port only by comparing the guest port
+          read_forwarded_ports.each do |_, _, hostport, guestport|
+            return hostport if guestport == expected_port
+          end
+
+          nil
+        end
+
+        # virtualbox plugin style
+        def read_state
+          output = execute("status", @uuid)
+          output.strip.to_sym
+        end
+
+        # We handle the active only case here
+        # So we can avoid calling the utmctl status command
+        # for each VM
+        def read_used_ports(active_only = true) # rubocop:disable Style/OptionalBooleanParameter
+          @logger.debug("read_used_ports: active_only=#{active_only}")
+          ports = []
+          list.machines.each do |machine|
+            # Ignore our own used ports
+            next if machine.uuid == @uuid
+            # Ignore inactive VMs if we only care about active VMs
+            next if active_only && machine.state != :started
+
+            read_forwarded_ports(machine.uuid).each do |_, _, hostport, _|
+              ports << hostport
+            end
+          end
+
+          ports
+        end
+
+        def set_name(name) # rubocop:disable Naming/AccessorMethodName
+          command = ["customize_vm.applescript", @uuid, "--name", name.to_s]
+          execute_osa_script(command)
+        end
+
+        def delete
+          execute("delete", @uuid)
+        end
+
+        def start
+          execute("start", @uuid)
+        end
+
+        def start_disposable
+          execute("start", @uuid, "--disposable")
+        end
+
+        def halt
+          execute("stop", @uuid)
+        end
+
+        def suspend
+          execute("suspend", @uuid)
+        end
+
+        def execute_osa_script(command)
+          script_path = @script_path.join(command[0])
+          cmd = ["osascript", script_path.to_s] + command[1..]
+          execute_shell(*cmd)
+        end
+
+        # Execute the 'list' command and returns the list of machines.
+        # @return [ListResult] The list of machines.
+        def list
+          script_path = @script_path.join("list_vm.js")
+          cmd = ["osascript", script_path.to_s]
+          result = execute_shell(*cmd)
+          data = JSON.parse(result)
+          Model::ListResult.new(data)
+        end
+
+        # Execute the 'utm://downloadVM?url='
+        # See https://docs.getutm.app/advanced/remote-control/
+        # @param utm_file_url [String] The url to the UTM file.
+        # @return [uuid] The UUID of the imported machine.
+        def import(utm_file_url)
+          script_path = @script_path.join("downloadVM.sh")
+          cmd = [script_path.to_s, utm_file_url]
+          execute_shell(*cmd)
+          # wait for the VM to be imported
+          # TODO: UTM API to give the progress of the import
+          # along with the UUID of the imported VM
+          # sleep(60)
+          # Get the UUID of the imported VM
+          # HACK: Currently we do not know the UUID of the imported VM
+          # So, we just get the UUID of the last VM in the list
+          # which is the last imported VM (unless UTM changes the order)
+          # TODO: Use UTM API to get the UUID of the imported VM
+          # last_uuid
+        end
+
+        # Return UUID of the last VM in the list.
+        # @return [uuid] The UUID of the VM.
+        def last_uuid
+          list_result = list
+          list_result.last.uuid
+        end
+
+        def verify!
+          # Verify proper functionality of UTM
+          # add any command that should be checked
+          # we now only check if the 'utmctl' command is available
+          execute("--list")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/errors.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Utm
+    module Errors
+      # Base class for all errors raised by the UTM provider.
+      class UtmError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_utm.errors")
+      end
+
+      # This error is raised if the platform is not MacOS.
+      class MacOSRequired < UtmError
+        error_key(:macos_required)
+      end
+
+      # This error is raised if the UTM is not found.
+      class UtmNotDetected < UtmError
+        error_key(:utm_not_detected)
+      end
+
+      # This error is raised if the UTM version is not supported.
+      class UtmInvalidVersion < UtmError
+        error_key(:utm_invalid_version)
+      end
+
+      # This error is raised if the utmctl is not found.
+      class UtmctlNotFoundError < UtmError
+        error_key(:utmctl_not_found)
+      end
+
+      # This error is raised if the utmctl command fails.
+      class UtmctlError < UtmError
+        error_key(:utmctl_error)
+      end
+
+      # This error is raised if the utm or other binary like osa fail to launch.
+      class UtmLaunchError < UtmError
+        error_key(:utm_launch_error)
+      end
+
+      # This error is raised if a shell/osascript command fails.
+      class CommandError < UtmError
+        error_key(:command_error)
+      end
+
+      # This error is raised if UTM file was failed to import.
+      class UtmImportFailed < UtmError
+        error_key(:utm_import_failed)
+      end
+
+      # This error is raised if invalid protocol is used in forwarded ports.
+      class ForwardedPortInvalidProtocol < UtmError
+        error_key(:forwarded_port_invalid_protocol)
+      end
+
+      # This error is raised if the qemu-img is not detected.
+      class QemuImgRequired < UtmError
+        error_key(:qemu_img_required)
+      end
+
+      # This error is raised if the snapshot command failed.
+      class SnapShotCommandFailed < UtmError
+        error_key(:snapshot_command_failed)
+      end
+
+      # This error is raised if multiple VM files are found during snapshot.
+      class SnapShotMultipleVMFiles < UtmError
+        error_key(:snapshot_multiple_vm_files)
+      end
+
+      # This error is raised if the VM is not found.
+      class SnapShotVMFileNotFound < UtmError
+        error_key(:snapshot_vm_file_not_found)
+      end
+    end
+  end
+end

data/lib/vagrant_utm/model/forwarded_port.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module Utm
+    module Model
+      # Represents a single forwarded port for UTM. This has various
+      # helpers and defaults for a forwarded port.
+      class ForwardedPort
+        # The 'Emulated VLAN' adapter on which to attach the forwarded port.
+        #
+        # @return [Integer]
+        attr_reader :adapter
+
+        # If true, this port should be auto-corrected.
+        # TODO: This is not implemented yet.
+        # @return [Boolean]
+        attr_reader :auto_correct
+
+        # The unique ID for the forwarded port.
+        #
+        # @return [String]
+        attr_reader :id
+
+        # The protocol to forward.
+        #
+        # @return [String]
+        attr_reader :protocol
+
+        # The IP that the forwarded port will connect to on the guest machine.
+        #
+        # @return [String]
+        attr_reader :guest_ip
+
+        # The port on the guest to be exposed on the host.
+        #
+        # @return [Integer]
+        attr_reader :guest_port
+
+        # The IP that the forwarded port will bind to on the host machine.
+        #
+        # @return [String]
+        attr_reader :host_ip
+
+        # The port on the host used to access the port on the guest.
+        #
+        # @return [Integer]
+        attr_reader :host_port
+
+        def initialize(id, host_port, guest_port, options)
+          @id         = id
+          @guest_port = guest_port
+          @host_port  = host_port
+
+          options ||= {}
+          @auto_correct = false
+          @auto_correct = options[:auto_correct] if options.key?(:auto_correct)
+          @adapter  = (options[:adapter] || 1).to_i # if adapter is not set, use 1. index 0 is the default adapter
+          @guest_ip = options[:guest_ip] || nil
+          @host_ip = options[:host_ip] || nil
+          @protocol = options[:protocol] || "tcp" # default to TCP
+        end
+
+        # This corrects the host port and changes it to the given new port.
+        # TODO: This is not implemented yet.
+        # @param [Integer] new_port The new port
+        def correct_host_port(new_port)
+          @host_port = new_port
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/model/list_result.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Utm
+    module Model
+      # Represents the result of a 'utmctl 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 UUID exists.
+        # @param uuid [String]  The UUID of the machine.
+        # @return [Boolean]
+        def any?(uuid)
+          @machines.any? { |i| i.uuid == uuid }
+        end
+
+        # Finds a machine with the given name or uuid.
+        # @param [String] name The name of the machine.
+        # @return [ListResultItem]
+        def find(name: nil, uuid: nil)
+          if name
+            @machines.find { |i| i.name == name }
+          elsif uuid
+            @machines.find { |i| i.uuid == uuid }
+          end
+        end
+
+        # Return the last machine in the list.
+        # @return [ListResultItem]
+        def last
+          @machines.last
+        end
+
+        # Represents an item in the list result.
+        class ListResultItem
+          # @return [String] The UUID of the machine.
+          attr_accessor :uuid
+          # @return [String] The name of the machine.
+          attr_accessor :name
+          # @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)
+            @uuid = data["UUID"]
+            @name = data["Name"]
+            @state = data["Status"]
+          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_utm/plugin.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# check if the Vagrant gem is available
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The 'vagrant' gem could not be found. Please make sure it is installed."
+end
+
+# check if the Vagrant version is sufficient
+raise "The Vagrant UTM plugin is only compatible with Vagrant 2.3 or later" if Vagrant::VERSION < "2.3.0"
+
+module VagrantPlugins
+  module Utm
+    # This is the main entry point for the UTM provider plugin.
+    class Plugin < Vagrant.plugin("2")
+      name "utm"
+      description <<-DESCRIPTION
+      UTM provider allows Vagrant to manage and control
+      VMs using UTM through Apple Scripting Bridge.
+      DESCRIPTION
+
+      # Register the provider
+      # TODO: Define box format for UTM
+      # IDEA: UTM file comes as a zip file containing
+      # directory with Data/qcow2, Data/efi_vars.fd and config.plist
+      # Box format will only require additional metadata.json file
+      # Till then use UTM file directly and so box_optional: true
+      provider(:utm, box_optional: true, parallel: false) do
+        setup_i18n
+        require_relative "provider"
+        Provider
+      end
+
+      # Register the configuration
+      config(:utm, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      # Register capabilities
+      provider_capability(:utm, :forwarded_ports) do
+        require_relative "cap"
+        Cap
+      end
+
+      provider_capability(:utm, :snapshot_list) do
+        require_relative "cap"
+        Cap
+      end
+
+      # Register the command
+      command "disposable" do
+        require_relative "disposable"
+        Disposable
+      end
+
+      # Load the translation files
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", Utm.source_root)
+        I18n.reload!
+      end
+    end
+  end
+end