vagrant_utm 0.0.1

data/lib/vagrant_utm/action/export.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Utm
+    module Action
+      # This action destroys the running machine.
+      class Export
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          # UTM 'Share' feature in UI will Export the virtual machine and all its data.
+          # Till 'Share' is exposed via API, show a message to manually export.
+          env[:ui].info I18n.t("vagrant_utm.actions.vm.export.manual_exporting",
+                               name: env[:machine].provider_config.name)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/action/forced_halt.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Utm
+    module Action
+      # This action is responsible for halting (stopping) the VM.
+      class ForcedHalt
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          current_state = env[:machine].state.id
+          if current_state == :started
+            env[:ui].info I18n.t("vagrant.actions.vm.halt.force")
+            env[:machine].provider.driver.halt
+          end
+
+          # Sleep for a second to verify that the VM properly
+          # cleans itself up.
+          sleep 1 unless env["vagrant.test"]
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/action/forward_ports.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module Utm
+    module Action
+      # This action forwards ports on VM based on user configuration.
+      class ForwardPorts
+        include Util::CompileForwardedPorts
+
+        def initialize(app, _env)
+          @app = app
+        end
+
+        #--------------------------------------------------------------
+        # Execution
+        #--------------------------------------------------------------
+        def call(env)
+          @env = env
+
+          # Get the ports we're forwarding
+          env[:forwarded_ports] ||= compile_forwarded_ports(env[:machine].config)
+
+          # Warn if we're port forwarding to any privileged ports...
+          env[:forwarded_ports].each do |fp|
+            if fp.host_port <= 1024
+              env[:ui].warn I18n.t("vagrant.actions.vm.forward_ports.privileged_ports")
+              break
+            end
+          end
+
+          env[:ui].output(I18n.t("vagrant.actions.vm.forward_ports.forwarding"))
+          forward_ports
+
+          @app.call(env)
+        end
+
+        def forward_ports # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          ports = []
+
+          interfaces = @env[:machine].provider.driver.read_network_interfaces
+
+          @env[:forwarded_ports].each do |fp| # rubocop:disable Metrics/BlockLength
+            message_attributes = {
+              adapter: fp.adapter,
+              guest_port: fp.guest_port,
+              host_port: fp.host_port
+            }
+
+            @env[:ui].detail(I18n.t("vagrant.actions.vm.forward_ports.forwarding_entry", **message_attributes))
+
+            # Verify we have the network interface to attach to
+            unless interfaces[fp.adapter]
+              raise Vagrant::Errors::ForwardPortAdapterNotFound,
+                    adapter: fp.adapter.to_s,
+                    guest: fp.guest_port.to_s,
+                    host: fp.host_port.to_s
+            end
+
+            # Port forwarding requires the network interface to be a 'Emulated VLAN' interface,
+            # so verify that that is the case.
+            if interfaces[fp.adapter][:type] != :emulated
+              @env[:ui].detail(I18n.t("vagrant_utm.actions.vm.forward_ports.non_emulated",
+                                      **message_attributes))
+              next
+            end
+
+            # Add the options to the ports array to send to the driver later
+            ports << {
+              adapter: fp.adapter,
+              guestip: fp.guest_ip,
+              guestport: fp.guest_port,
+              hostip: fp.host_ip,
+              hostport: fp.host_port,
+              name: fp.id,
+              protocol: fp.protocol
+            }
+          end
+
+          # We only need to forward ports if there are any to forward
+          return if ports.empty?
+
+          @env[:machine].provider.driver.forward_ports(ports)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/action/import.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Utm
+    module Action
+      # This action imports the virtual machine to UTM.
+      class Import
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          import(env)
+        end
+
+        def import(env)
+          machine = env[:machine]
+          config = machine.provider_config
+          driver = machine.provider.driver
+          utm_file_url = config.utm_file_url
+
+          env[:ui].info I18n.t("vagrant_utm.messages.importing_utm_file", name: utm_file_url)
+
+          # Import the UTM VM file
+          driver.import(utm_file_url)
+
+          # Set the UID of Vagrant machine to the UUID of the VM in UTM.
+          # UTM maintains UUID as primary key for VMs, but even the name works for all commands
+          # However, name is not unique.
+
+          # So we set the machine.id to UUID in next step after import.
+          # TODO: Set the machine.id to UUID after import returns the UUID (yet to be supported by UTM).
+          # machine.id = return value of import
+
+          @app.call(env)
+        end
+
+        def recover(env)
+          return unless env[:machine] && env[:machine].state.id != Vagrant::MachineState::NOT_CREATED_ID
+          return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)
+
+          # If we're not supposed to destroy on error then just return
+          return unless env[:destroy_on_error]
+
+          # Interrupted, destroy the VM. We note that we don't want to
+          # validate the configuration here, and we don't want to confirm
+          # we want to destroy.
+          destroy_env = env.clone
+          destroy_env[:config_validate] = false
+          destroy_env[:force_confirm_destroy] = true
+
+          # We don't want to double-execute any hooks attached to
+          # machine_action_up. Instead we should be honoring destroy hooks.
+          # Changing the action name here should make the Builder do the
+          # right thing.
+          destroy_env[:raw_action_name] = :destroy
+          destroy_env[:action_name] = :machine_action_destroy
+          env[:action_runner].run(Action.action_destroy, destroy_env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/action/is_paused.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module Utm
+    module Action
+      # This middleware checks if the machine is paused and sets the result.
+      class IsPaused
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          # Set the result to be true if the machine is paused.
+          env[:result] = env[:machine].state.id == :paused
+
+          # Call the next if we have one (but we shouldn't, since this
+          # middleware is built to run with the Call-type middlewares)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/action/is_running.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module Utm
+    module Action
+      # This middleware checks if the machine is running (UTM started) and sets the result.
+      class IsRunning
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          # Set the result to be true if the machine is running.
+          env[:result] = env[:machine].state.id == :started
+
+          # Call the next if we have one (but we shouldn't, since this
+          # middleware is built to run with the Call-type middlewares)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/action/is_stopped.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module Utm
+    module Action
+      # This middleware checks if the machine is stopped and sets the result.
+      class IsStopped
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          # Set the result to be true if the machine is stopped.
+          env[:result] = env[:machine].state.id == :stopped
+
+          # Call the next if we have one (but we shouldn't, since this
+          # middleware is built to run with the Call-type middlewares)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/action/message_already_running.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module Utm
+    module Action
+      # Print VM is already running message.
+      class MessageAlreadyRunning
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.commands.common.vm_already_running")
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/action/message_not_created.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module Utm
+    module Action
+      # Print VM not created message.
+      class MessageNotCreated
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.commands.common.vm_not_created")
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/action/message_not_running.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module Utm
+    module Action
+      # Print VM not running message.
+      class MessageNotRunning
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.commands.common.vm_not_running")
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/action/message_not_stopped.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module Utm
+    module Action
+      # Print VM not stopped message.
+      class MessageNotStopped
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant_utm.commands.common.vm_not_stopped")
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/action/message_will_not_create.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module Utm
+    module Action
+      # Print VM will not be created message.
+      class MessageWillNotCreate
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant_utm.commands.up.will_not_create",
+                               name: env[:machine].name)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/action/message_will_not_destroy.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module Utm
+    module Action
+      # Print VM will not be destroyed message.
+      class MessageWillNotDestroy
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.commands.destroy.will_not_destroy",
+                               name: env[:machine].name)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/action/prepare_forwarded_port_collision_params.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module Utm
+    module Action
+      # This middleware class is responsible for preparing forwarded port
+      class PrepareForwardedPortCollisionParams
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env) # rubocop:disable Metrics/AbcSize
+          # Get the forwarded ports used by other virtual machines and
+          # consider those in use as well.
+          env[:port_collision_extra_in_use] = env[:machine].provider.driver.read_used_ports
+
+          # Build the remap for any existing collision detections
+          remap = {}
+          env[:port_collision_remap] = remap
+          env[:machine].provider.driver.read_forwarded_ports.each do |_nic, name, hostport, _guestport|
+            env[:machine].config.vm.networks.each do |type, options|
+              next if type != :forwarded_port
+
+              # UTM port forwarding does not have name field
+              # We use the host port as the name (key) since that is what should be unique
+              # If the host port matches the name(host port) of the forwarded port, then
+              # remap.
+              if options[:host] == name
+                remap[options[:host]] = hostport
+                break
+              end
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/action/resume.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Utm
+    module Action
+      # This action is responsible for resuming the VM.
+      class Resume
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          current_state = env[:machine].state.id
+          if current_state == :paused
+            env[:ui].info I18n.t("vagrant.actions.vm.resume.unpausing")
+            env[:machine].provider.driver.start
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/action/set_id.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Utm
+    module Action
+      # This action destroys the running machine.
+      class SetId
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:machine].id = env[:machine].provider.driver.last_uuid
+          env[:ui].info I18n.t("vagrant_utm.messages.setting_id", id: env[:machine].id)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/action/set_name.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+module VagrantPlugins
+  module Utm
+    module Action
+      # This action sets the name of the VM (UTM 'Name' field)
+      class SetName
+        def initialize(app, _env)
+          @logger = Log4r::Logger.new("vagrant::action::vm::setname")
+          @app = app
+        end
+
+        def call(env) # rubocop:disable Metrics/AbcSize
+          name = env[:machine].provider_config.name
+
+          # If we already set the name before, then don't do anything
+          sentinel = env[:machine].data_dir.join("action_set_name")
+          if !name && sentinel.file?
+            @logger.info("Default name was already set before, not doing it again.")
+            return @app.call(env)
+          end
+
+          # If no name was manually set, then use a default
+          unless name
+            prefix = "#{env[:root_path].basename}_#{env[:machine].name}"
+            prefix.gsub!(/[^-a-z0-9_]/i, "")
+
+            # milliseconds + random number suffix to allow for simultaneous
+            # `vagrant up` of the same box in different dirs
+            name = prefix + "_#{(Time.now.to_f * 1000.0).to_i}_#{rand(100_000)}"
+          end
+
+          # TODO: Verify the name is not taken
+          # vms = env[:machine].provider.driver.read_vms
+          # raise Vagrant::Errors::VMNameExists, name: name if \
+          #   vms.key?(name) && vms[name] != env[:machine].id
+
+          # if vms.key?(name)
+          #   @logger.info("Not setting the name because our name is already set.")
+          # else
+          env[:ui].info(I18n.t(
+                          "vagrant.actions.vm.set_name.setting_name", name: name
+                        ))
+          env[:machine].provider.driver.set_name(name)
+          # end
+
+          # Create the sentinel
+          sentinel.open("w") do |f|
+            f.write(Time.now.to_i.to_s)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/action/snapshot_delete.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module Utm
+    module Action
+      # This action deletes a snapshot of the machine.
+      class SnapshotDelete
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t(
+                          "vagrant.actions.vm.snapshot.deleting",
+                          name: env[:snapshot_name]
+                        ))
+          env[:machine].provider.driver.delete_snapshot(
+            env[:machine].id, env[:snapshot_name]
+          )
+
+          env[:ui].success(I18n.t(
+                             "vagrant.actions.vm.snapshot.deleted",
+                             name: env[:snapshot_name]
+                           ))
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/action/snapshot_restore.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module Utm
+    module Action
+      class SnapshotRestore # rubocop:disable Style/Documentation
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t(
+                          "vagrant.actions.vm.snapshot.restoring",
+                          name: env[:snapshot_name]
+                        ))
+          env[:machine].provider.driver.restore_snapshot(
+            env[:machine].id, env[:snapshot_name]
+          )
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/action/snapshot_save.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module Utm
+    module Action
+      # This action saves a snapshot of the VM.
+      class SnapshotSave
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t(
+                          "vagrant.actions.vm.snapshot.saving",
+                          name: env[:snapshot_name]
+                        ))
+          env[:machine].provider.driver.create_snapshot(
+            env[:machine].id, env[:snapshot_name]
+          )
+
+          env[:ui].success(I18n.t(
+                             "vagrant.actions.vm.snapshot.saved",
+                             name: env[:snapshot_name]
+                           ))
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end