driver: import execute function of virtualbox

Author: naveenrajm7

lib/vagrant_utm/driver/base.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require "log4r"
 require "pathname"
 require "vagrant/util/busy"
 require "vagrant/util/subprocess"
+require "vagrant/util/which"
 require_relative "../model/list_result"
 
 module VagrantPlugins
@@ -15,10 +17,19 @@ class Base
         include Vagrant::Util::Retryable
 
         def initialize
+          @logger = Log4r::Logger.new("vagrant::provider::utm::base")
+
           # This flag is used to keep track of interrupted state (SIGINT)
           @interrupted = false
           # The path to the scripts directory.
           @script_path = Pathname.new(File.expand_path("../scripts", __dir__))
+
+          # Set 'utmctl' path
+          @utmctl_path = Vagrant::Util::Which.which("utmctl")
+
+          # if not found, fall back to /usr/local/bin/utmctl
+          @utmctl_path ||= "/Applications/UTM.app/Contents/MacOS/utmctl"
+          @logger.info("utmctl path: #{@utmctl_path}")
         end
 
         # Check if the VM with the given UUID (Name) exists.
@@ -94,6 +105,130 @@ def execute(*cmd, &block)
           # Return the outputs of the command
           "#{result.stdout} #{result.stderr}"
         end
+
+        # Execute the given subcommand for utmctl and return the output.
+        # Heavily inspired from https://github.com/hashicorp/vagrant/blob/main/plugins/providers/virtualbox/driver/base.rb.
+        # @param [String] subcommand The subcommand to execute.
+        # @return [String] The output of the command.
+        def utmctl_execute(*command, &block)
+          # Get the options hash if it exists
+          opts = {}
+          opts = command.pop if command.last.is_a?(Hash)
+
+          tries = 0
+          tries = 3 if opts[:retryable]
+
+          # Variable to store our execution result
+          r = nil
+
+          retryable(on: Errors::UtmctlError, tries: tries, sleep: 1) do
+            # if there is an error with utmctl, this gets set to true
+            errored = false
+
+            # Execute the command
+            r = raw(*command, &block)
+
+            # If the command was a failure, then raise an exception that is
+            # nicely handled by Vagrant.
+            if r.exit_code != 0
+              if @interrupted
+                @logger.info("Exit code != 0, but interrupted. Ignoring.")
+              elsif r.exit_code == 126
+                # To be consistent with VBoxManage
+                raise Errors::UtmctlNotFoundError
+              else
+                errored = true
+              end
+            elsif r.stdout.include?("Error:")
+              # if utmctl fails but doesn't return a non-zero exit code
+              # Handle that here
+              errored = true
+            end
+
+            # If there was an error running utmctl, show the error and the output
+            return unless errored
+
+            raise Errors::UtmctlError,
+                  command: command.inspect,
+                  stderr: r.stderr,
+                  stdout: r.stdout
+          end
+
+          # Return the output, making sure to replace any Windows-style
+          # newlines with Unix-style.
+          r.stdout.gsub("\r\n", "\n")
+        end
+
+        # Executes a command and returns the raw result object.
+        def raw(*command, &block)
+          int_callback = lambda do
+            @interrupted = true
+
+            # We have to execute this in a thread due to trap contexts
+            # and locks.
+            Thread.new { @logger.info("Interrupted.") }.join
+          end
+
+          # Append in the options for subprocess
+          # NOTE: We include the LANG env var set to C to prevent command output
+          #       from being localized
+          command << { notify: %i[stdout stderr], env: env_lang }
+
+          Vagrant::Util::Busy.busy(int_callback) do
+            Vagrant::Util::Subprocess.execute(@utmctl_path, *command, &block)
+          end
+        rescue Vagrant::Util::Subprocess::LaunchError => e
+          raise Vagrant::Errors::UtmctlLaunchError,
+                message: e.to_s
+        end
+
+        private
+
+        # List of LANG values to attempt to use
+        LANG_VARIATIONS = %w[C.UTF-8 C.utf8 en_US.UTF-8 en_US.utf8 C POSIX].map(&:freeze).freeze
+
+        # By default set the LANG to C. If the host has the locale command
+        # available, check installed locales and verify C is included (or
+        # use C variant if available).
+        def env_lang
+          # If already set, just return immediately
+          return @env_lang if @env_lang
+
+          # Default the LANG to C
+          @env_lang = { LANG: "C" }
+
+          # If the locale command is not available, return default
+          return @env_lang unless Vagrant::Util::Which.which("locale")
+
+          return @env_lang = @@env_lang if defined?(@@env_lang)
+
+          @logger.debug("validating LANG value for virtualbox cli commands")
+          # Get list of available locales on the system
+          result = Vagrant::Util::Subprocess.execute("locale", "-a")
+
+          # If the command results in an error, just log the error
+          # and return the default value
+          if result.exit_code != 0
+            @logger.warn("locale command failed (exit code: #{result.exit_code}): #{result.stderr}")
+            return @env_lang
+          end
+          available = result.stdout.lines.map(&:chomp).find_all do |l|
+            l == "C" || l == "POSIX" || l.start_with?("C.") || l.start_with?("en_US.")
+          end
+          @logger.debug("list of available C locales: #{available.inspect}")
+
+          # Attempt to find a valid LANG from locale list
+          lang = LANG_VARIATIONS.detect { |l| available.include?(l) }
+
+          if lang
+            @logger.debug("valid variation found for LANG value: #{lang}")
+            @env_lang[:LANG] = lang
+            @@env_lang = @env_lang
+          end
+
+          @logger.debug("LANG value set: #{@env_lang[:LANG].inspect}")
+          @env_lang
+        end
       end
     end
   end

lib/vagrant_utm/errors.rb

@@ -13,11 +13,21 @@ class MacOSRequired < UtmError
         error_key(:macos_required)
       end
 
-      # This error is raised if the utmctl binary is not found.
+      # This error is raised if the UTM is not found.
       class UtmRequired < UtmError
         error_key(:utm_required)
       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 a UTM command fails.
       class CommandError < UtmError
         error_key(:command_error)

locales/en.yml

@@ -29,7 +29,7 @@ en:
         pausing: |-
           The VM is pausing.
         paused: |-
-          The VM is paused. To resume this VM, simply run `vagrant up`.
+          The VM is paused. To resume this VM, simply run `vagrant resume`.
         resuming: |-
           The VM is resuming.   
         stopping: |-