vagrant-xapi 0.0.1 → 1.0.0

data/lib/vagrant-xapi/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Xapi
+    VERSION = "1.0.0"
+  end
+end

data/lib/vagrant-xapi/xenserver/config.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "../config"
+
+module VagrantPlugins
+  module Xapi
+    module Xenserver
+      # config.vm.provider :xenserver do |xs| ... end: the options of
+      # vagrant-xenserver, on top of every option of :xapi.
+      #
+      # After finalize! the xs_* readers return the values in effect, for
+      # code in Vagrantfiles that reads them (e.g. triggers that connect with
+      # XenApi::Client): xs_use_ssl is always true and xs_port the HTTPS port.
+      class Config < Xapi::Config
+        LEGACY_OPTIONS = %i[xs_host xs_port xs_use_ssl xs_username xs_password name pv use_himn].freeze
+
+        attr_accessor(*LEGACY_OPTIONS)
+
+        def initialize
+          super
+          LEGACY_OPTIONS.each { |opt| instance_variable_set(:"@#{opt}", UNSET_VALUE) }
+        end
+
+        def finalize!
+          @host = @xs_host if @host == UNSET_VALUE && set?(@xs_host)
+          @username = @xs_username if @username == UNSET_VALUE && set?(@xs_username)
+          @password = @xs_password if @password == UNSET_VALUE && set?(@xs_password)
+          @name_label = @name if @name_label == UNSET_VALUE && set?(@name)
+          @port = https_port if @port == UNSET_VALUE && set?(@xs_port)
+          if @use_himn == true
+            @ip_detection = [:himn] if @ip_detection == UNSET_VALUE
+            @ssh_via_host = true if @ssh_via_host == UNSET_VALUE
+          end
+          super
+          @pv = @pv == UNSET_VALUE ? nil : @pv
+          @use_himn = @use_himn == true
+          @xs_host = @host
+          @xs_port = @port
+          @xs_use_ssl = true
+          @xs_username = @username
+          @xs_password = @password
+          @name = @name_label
+        end
+
+        def validate(machine)
+          machine.ui.warn(I18n.t("vagrant_xapi.xenserver.pv_ignored")) if @pv
+          super
+        end
+
+        def instance_variables_hash
+          super.tap { |h| h["xs_password"] = "[REDACTED]" if h["xs_password"] }
+        end
+
+        private
+
+        def set?(value)
+          value != UNSET_VALUE && !value.nil? && !value.to_s.empty?
+        end
+
+        # vagrant-xenserver defaulted to port 80, where its xenapi gem spoke
+        # plain HTTP whatever xs_use_ssl said (TLS only on port 443).
+        # vagrant-xapi always uses HTTPS, so that port becomes 443.
+        def https_port
+          @xs_port.to_i == 80 ? 443 : @xs_port.to_i
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/xenserver/migrate.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+require_relative "../command/base"
+require_relative "../services/adoption"
+require_relative "../services/lookup"
+
+module VagrantPlugins
+  module Xapi
+    module Command
+      # vagrant xapi migrate: moves this project's machines from the provider
+      # :xenserver to :xapi, after `config.vm.provider :xenserver` in the
+      # Vagrantfile became `:xapi`. Vagrant keeps a machine's id under
+      # .vagrant/machines/<name>/<provider>; without the move it would create
+      # new VMs. The VM's exclusive disks are marked as its own, so that
+      # `vagrant destroy` under :xapi still removes disks that triggers
+      # attached, as it did under :xenserver. Machines whose id is still an
+      # OpaqueRef of vagrant-xenserver are left alone: any vagrant command
+      # with the :xenserver Vagrantfile (e.g. `vagrant status`) takes them
+      # over first.
+      class Migrate < Base
+
+        def execute
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant xapi migrate"
+            o.separator ""
+            o.separator "Moves this project's :xenserver machines to the :xapi provider."
+          end
+          argv = parse_options(opts)
+          return 0 if argv.nil?
+          raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp unless argv.empty?
+
+          moved = machine_dirs.count { |dir| migrate(dir) }
+          @env.ui.info(t("migrate_done", count: moved))
+          0
+        end
+
+        private
+
+        def machine_dirs
+          root = @env.local_data_path && Pathname.new(@env.local_data_path.to_s).join("machines")
+          return [] unless root&.directory?
+
+          root.glob("*/xenserver").select(&:directory?).sort
+        end
+
+        def migrate(dir)
+          name = dir.parent.basename.to_s
+          id = dir.join("id").file? ? dir.join("id").read.strip : ""
+          return false if id.empty?
+
+          unless Services::Lookup.uuid?(id)
+            @env.ui.warn(t("migrate_needs_takeover", machine: name))
+            return false
+          end
+          target = dir.parent.join("xapi")
+          if target.exist?
+            @env.ui.warn(t("migrate_target_exists", machine: name))
+            return false
+          end
+
+          # Lock the index entry first: if another Vagrant process holds the
+          # machine, nothing has moved yet.
+          entry = index_entry(dir)
+          begin
+            File.rename(dir.to_s, target.to_s)
+            if entry
+              entry.provider = "xapi"
+              @env.machine_index.set(entry)
+            end
+          ensure
+            @env.machine_index.release(entry) if entry
+          end
+          mark_disks(name, id)
+          @env.ui.info(t("migrated", machine: name, uuid: id))
+          true
+        rescue Vagrant::Errors::MachineLocked
+          @env.ui.warn(t("migrate_locked", machine: name))
+          false
+        end
+
+        def mark_disks(name, uuid)
+          machine = @env.machine(name.to_sym, :xapi)
+          ctx = Glue.context(machine)
+          vm = Errors.wrap { Services::Lookup.new(ctx).vm_by_uuid(uuid) }
+          Errors.wrap { Services::Adoption.new(ctx).mark_disks(vm) } if vm
+        rescue Vagrant::Errors::VagrantError => e
+          @env.ui.warn(t("migrate_disks_not_marked", machine: name, error: e.message))
+        end
+
+        # The machine's entry in Vagrant's machine index (`vagrant
+        # global-status`), locked; nil when it has none.
+        def index_entry(dir)
+          index_uuid = dir.join("index_uuid")
+          return nil unless index_uuid.file?
+
+          @env.machine_index.get(index_uuid.read.strip)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/xenserver/plugin.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+# Compatibility with vagrant-xenserver: Vagrantfiles written for it keep
+# working, with everything that plugin did.
+#
+# - the provider :xenserver with the xs_* options (config.rb, provider.rb),
+# - machines that vagrant-xenserver created (takeover.rb),
+# - its `vagrant destroy`, which removed every disk of the VM,
+# - `vagrant xapi migrate` to move machines to :xapi (migrate.rb).
+#
+# It hooks into the core through VagrantPlugins::Xapi::Extensions; see
+# docs/architecture.md, section 17. The XenApi::Client stand-in for triggers
+# is not part of this: it is temporary and lives in its own directory.
+
+require_relative "../extensions"
+
+module VagrantPlugins
+  module Xapi
+    module Xenserver
+      PROVIDER = :xenserver
+
+      # Both plugins would register :xenserver; the old one keeps it.
+      def self.old_plugin_installed?
+        Vagrant::Plugin::Manager.instance.installed_plugins.key?("vagrant-xenserver")
+      rescue StandardError
+        false
+      end
+
+      def self.machine?(machine)
+        machine.provider_name.to_s == PROVIDER.to_s
+      end
+
+      # Once per process, the first time a :xenserver machine is loaded.
+      def self.notice(machine)
+        return if @noticed
+
+        @noticed = true
+        machine.env.ui.info(I18n.t("vagrant_xapi.xenserver.notice"), prefix: false)
+      end
+    end
+
+    if Xenserver.old_plugin_installed?
+      # Not Kernel#warn: it prints nothing when Ruby runs without warnings,
+      # as Vagrant's installer does.
+      $stderr.puts "vagrant-xapi: vagrant-xenserver is installed too, so vagrant-xapi leaves the :xenserver " \
+                   "provider to it. Remove it with `vagrant plugin uninstall vagrant-xenserver`."
+    else
+      class XenserverPlugin < Vagrant.plugin("2")
+        name "xapi (vagrant-xenserver compatibility)"
+        description "Runs Vagrantfiles of vagrant-xenserver (provider :xenserver) with vagrant-xapi."
+
+        # Not defaultable, like :xapi: Vagrant still picks it when a
+        # Vagrantfile configures :xenserver.
+        provider(Xenserver::PROVIDER, parallel: true, defaultable: false, priority: 5,
+                                      box_format: %w[xenserver xapi libvirt]) do
+          require_relative "provider"
+          Xenserver::Provider
+        end
+
+        config(Xenserver::PROVIDER, :provider) do
+          require_relative "config"
+          Xenserver::Config
+        end
+
+        Plugin::CAPABILITIES.each do |cap|
+          provider_capability(Xenserver::PROVIDER, cap) do
+            require_relative "../cap"
+            Cap
+          end
+        end
+      end
+
+      Extensions.add_provider_name(Xenserver::PROVIDER)
+
+      Extensions.on_foreign_id do |machine, ctx|
+        if Xenserver.machine?(machine)
+          require_relative "takeover"
+          Xenserver::Takeover.new(machine, ctx).run
+        end
+      end
+
+      # vagrant-xenserver removed every disk of the VM on destroy, also disks
+      # that triggers attached; mark the VM's exclusive disks as its own so
+      # they go as well. Sharable disks and disks of other VMs stay.
+      Extensions.on_before_destroy do |machine, ctx, vm|
+        if Xenserver.machine?(machine)
+          require_relative "../services/adoption"
+          Services::Adoption.new(ctx).mark_disks(vm)
+        end
+      end
+
+      Extensions.add_subcommand(:migrate, "../xenserver/migrate", "Migrate",
+                                "move machines of vagrant-xenserver Vagrantfiles to :xapi")
+    end
+  end
+end

data/lib/vagrant-xapi/xenserver/provider.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../provider"
+
+module VagrantPlugins
+  module Xapi
+    module Xenserver
+      # The :xapi provider under the name :xenserver, saying once per run
+      # that the compatibility with vagrant-xenserver is in use.
+      class Provider < Xapi::Provider
+        def initialize(machine)
+          super
+          Xenserver.notice(machine)
+        end
+
+        def to_s
+          "XAPI as :xenserver (#{@machine.id || "new VM"})"
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/xenserver/takeover.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "../glue"
+require_relative "../services/adoption"
+require_relative "../services/lookup"
+
+module VagrantPlugins
+  module Xapi
+    module Xenserver
+      # Takes over a VM that vagrant-xenserver created. Its machine id is the
+      # VM's OpaqueRef. The VM and its exclusive disks get this machine's
+      # marking, and the id becomes the VM UUID. A reference that no longer
+      # exists means the VM is gone: not created, as vagrant-xenserver did.
+      # It is never looked up by name: another VM with the same name (say a
+      # colleague's, from the same Vagrantfile) would be marked as this
+      # machine's and later destroyed.
+      class Takeover
+        def initialize(machine, ctx)
+          @machine = machine
+          @ctx = ctx
+          @client = ctx.client
+        end
+
+        def run
+          return unless @machine.id.to_s.start_with?("OpaqueRef:")
+
+          vm = by_ref(@machine.id.to_s)
+          return @machine.id = nil unless vm
+
+          rec = @client.call("VM.get_record", vm)
+          return @machine.id = nil if rec["is_a_template"] || rec["is_a_snapshot"] || rec["is_control_domain"]
+
+          return @machine.id = nil unless own_or_unmarked?(rec)
+
+          adoption = Services::Adoption.new(@ctx)
+          adoption.mark_vm(vm, marking)
+          adoption.mark_disks(vm)
+          @machine.ui.info(I18n.t("vagrant_xapi.xenserver.taken_over", name: rec["name_label"], uuid: rec["uuid"]))
+          @machine.id = rec["uuid"]
+        end
+
+        private
+
+        # nil when XAPI no longer knows the reference; other errors go up.
+        def by_ref(ref)
+          @client.call("VM.get_uuid", ref)
+          ref
+        rescue Api::XapiError => e
+          raise unless e.code == "HANDLE_INVALID"
+
+          nil
+        end
+
+        # A VM that vagrant-xapi already marked for another machine is not
+        # taken: this machine no longer refers to it (not created), and the
+        # VM stays as it is. A warning names its owner, for `vagrant xapi
+        # adopt --force` if it is this machine's after all. This machine's own
+        # marking (an earlier takeover) is fine.
+        def own_or_unmarked?(rec)
+          oc = rec["other_config"] || {}
+          return true unless Services::Marking.marked?(oc)
+          return true if oc[Services::Marking::MACHINE] == @machine.name.to_s &&
+                         oc[Services::Marking::PROJECT] == Glue.project_path(@machine)
+
+          @machine.ui.warn(I18n.t("vagrant_xapi.xenserver.other_owner", uuid: rec["uuid"],
+                                                                         machine: oc[Services::Marking::MACHINE].to_s,
+                                                                         project: oc[Services::Marking::PROJECT].to_s))
+          false
+        end
+
+        def marking
+          Services::Marking.vm_marking(machine_name: @machine.name, project: Glue.project_path(@machine),
+                                       client_id: Glue.client_id(@machine.env))
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xapi.rb

@@ -1,2 +1,21 @@
-warn "vagrant-xapi 0.0.1 from rubygems.org is a placeholder without a plugin. " \
-     "Remove it with `vagrant plugin uninstall vagrant-xapi`."
+# frozen_string_literal: true
+
+require "pathname"
+
+module VagrantPlugins
+  module Xapi
+    lib_path = Pathname.new(File.expand_path("vagrant-xapi", __dir__))
+    autoload :Action, lib_path.join("action").to_s
+    autoload :Errors, lib_path.join("errors").to_s
+
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path("..", __dir__))
+    end
+  end
+end
+
+require_relative "vagrant-xapi/version"
+require_relative "vagrant-xapi/plugin"
+
+I18n.load_path << VagrantPlugins::Xapi.source_root.join("locales", "en.yml").to_s
+I18n.reload!

data/lib/xenapi.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# `require "xenapi"` in Vagrantfiles written for vagrant-xenserver loads
+# vagrant-xapi's stand-in. Part of the temporary compatibility in
+# lib/vagrant-xapi/legacy; delete this file with it.
+#
+# When vagrant-xenserver is installed too, vagrant-xapi leaves it alone: its
+# own `require "xenapi"`, and the triggers, get the real gem it brought
+# along, also when this file comes first on the load path.
+module XenApi
+  def self.real_gem_file
+    return nil unless defined?(VagrantPlugins::Xapi::Xenserver) && VagrantPlugins::Xapi::Xenserver.old_plugin_installed?
+
+    Gem.find_files("xenapi.rb").find { |file| File.expand_path(file) != File.expand_path(__FILE__) }
+  end
+end
+
+if (real = XenApi.real_gem_file)
+  require real
+else
+  require_relative "vagrant-xapi/legacy/xenapi" unless defined?(XenApi::Client)
+end