vagrant-vrealize 0.0.4

data/lib/vagrant-vrealize/action/terminate_instance.rb

@@ -0,0 +1,23 @@
+require "log4r"
+require "json"
+
+module VagrantPlugins
+  module Vrealize
+    module Action
+      # This terminates the running instance.
+      class TerminateInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_vrealize::action::terminate_instance")
+        end
+
+        def call(env)
+          vra = env[:vra]
+          vra.destroy(env[:machine].id) if env[:machine].id
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vrealize/action/timed_provision.rb

@@ -0,0 +1,21 @@
+require "vagrant-vrealize/util/timer"
+
+module VagrantPlugins
+  module Vrealize
+    module Action
+      # This is the same as the builtin provision except it times the
+      # provisioner runs.
+      class TimedProvision < Vagrant::Action::Builtin::Provision
+        def run_provisioner(env, name, p)
+          timer = Util::Timer.time do
+            super
+          end
+
+          env[:metrics] ||= {}
+          env[:metrics]["provisioner_times"] ||= []
+          env[:metrics]["provisioner_times"] << [name, timer]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vrealize/action/wait_for_state.rb

@@ -0,0 +1,25 @@
+require "log4r"
+require "timeout"
+
+module VagrantPlugins
+  module Vrealize
+    module Action
+      # This action will wait for a machine to reach a specific state or quit by timeout
+      class WaitForState
+        # env[:result] will be false in case of timeout.
+        # @param [Symbol] state Target machine state.
+        # @param [Number] timeout Timeout in seconds.
+        def initialize(app, env, state, timeout)
+          @app     = app
+          @logger  = Log4r::Logger.new("vagrant_vrealize::action::wait_for_state")
+          @state   = state
+          @timeout = timeout
+        end
+
+        def call(env)
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vrealize/action/warn_networks.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module Vrealize
+    module Action
+      class WarnNetworks
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].config.vm.networks.length > 0
+            env[:ui].warn(I18n.t("vagrant_vrealize.warn_networks"))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vrealize/action.rb

@@ -0,0 +1,191 @@
+require "pathname"
+
+require "vagrant/action/builder"
+require 'vagrant/action'
+
+module VagrantPlugins
+  module Vrealize
+    module Action
+      # Include the built-in modules so we can use them as top-level things.
+      include Vagrant::Action::Builtin
+
+      # This action is called to halt the remote machine.
+      def self.action_halt
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use ConnectVrealize
+            b2.use StopInstance
+          end
+        end
+      end
+
+      # This action is called to terminate the remote machine.
+      def self.action_destroy
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, DestroyConfirm do |env, b2|
+            if env[:result]
+              b2.use ConfigValidate
+              b2.use Call, IsCreated do |env2, b3|
+                if !env2[:result]
+                  b3.use MessageNotCreated
+                  next
+                end
+                b3.use ConnectVrealize
+                b3.use TerminateInstance
+                b3.use ProvisionerCleanup if defined?(ProvisionerCleanup)
+              end
+            else
+              b2.use MessageWillNotDestroy
+            end
+          end
+        end
+      end
+
+      # This action is called when `vagrant provision` is called.
+      def self.action_provision
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use Provision
+          end
+        end
+      end
+
+      # This action is called to read the SSH info of the machine. The
+      # resulting state is expected to be put into the `:machine_ssh_info`
+      # key.
+      def self.action_read_ssh_info
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectVrealize
+          b.use ReadSSHInfo
+        end
+      end
+
+      # This action is called to read the state of the machine. The
+      # resulting state is expected to be put into the `:machine_state_id`
+      # key.
+      def self.action_read_state
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectVrealize
+          b.use ReadState
+        end
+      end
+
+      # This action is called to SSH into the machine.
+      def self.action_ssh
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use SSHExec
+          end
+        end
+      end
+
+      def self.action_ssh_run
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use SSHRun
+          end
+        end
+      end
+
+      def self.action_prepare_boot
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Provision
+          b.use SyncedFolders
+          b.use WarnNetworks
+        end
+      end
+
+      # This action is called to bring the box up from nothing.
+      def self.action_up
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use HandleBox
+          b.use ConfigValidate
+          b.use BoxCheckOutdated
+          b.use ConnectVrealize
+          b.use Call, IsCreated do |env1, b1|
+            if env1[:result]
+              b1.use Call, IsStopped do |env2, b2|
+                if env2[:result]
+                  b2.use action_prepare_boot
+                  b2.use StartInstance # restart this instance
+                else
+                  b2.use MessageAlreadyCreated # TODO write a better message
+                end
+              end
+            else
+              b1.use action_prepare_boot
+              b1.use RunInstance # launch a new instance
+            end
+          end
+        end
+      end
+
+      def self.action_reload
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectVrealize
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use action_halt
+            b2.use Call, WaitForState, :stopped, 120 do |env2, b3|
+              if env2[:result]
+                b3.use action_up
+              else
+                # TODO we couldn't reach :stopped, what now?
+              end
+            end
+          end
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :ConnectVrealize, action_root.join("connect_vrealize")
+      autoload :IsCreated, action_root.join("is_created")
+      autoload :IsStopped, action_root.join("is_stopped")
+      autoload :MessageAlreadyCreated, action_root.join("message_already_created")
+      autoload :MessageNotCreated, action_root.join("message_not_created")
+      autoload :MessageWillNotDestroy, action_root.join("message_will_not_destroy")
+      autoload :PackageInstance, action_root.join("package_instance")
+      autoload :ReadSSHInfo, action_root.join("read_ssh_info")
+      autoload :ReadState, action_root.join("read_state")
+      autoload :RunInstance, action_root.join("run_instance")
+      autoload :StartInstance, action_root.join("start_instance")
+      autoload :StopInstance, action_root.join("stop_instance")
+      autoload :TerminateInstance, action_root.join("terminate_instance")
+      autoload :TimedProvision, action_root.join("timed_provision") # some plugins now expect this action to exist
+      autoload :WaitForState, action_root.join("wait_for_state")
+      autoload :WarnNetworks, action_root.join("warn_networks")
+    end
+  end
+end

data/lib/vagrant-vrealize/config.rb

@@ -0,0 +1,138 @@
+require "vagrant"
+require "vagrant-vrealize/extra-entries"
+
+module VagrantPlugins
+  module Vrealize
+    class Config < Vagrant.plugin("2", :config)
+
+      def initialize(*args, &blk)
+        @vra_username =
+          @vra_password =
+          @vra_tenant =
+          @vra_base_url =
+          @subtenant_id =
+          @catalog_item_id =
+          @requested_for =
+          UNSET_VALUE
+
+        @cpus = 1
+        @memory = 1024
+        @lease_days = 5
+
+        @__extra_entries = ExtraEntries.new
+        super
+      end
+
+      #
+      # The username for accessing the VRealize instance.
+      #
+      # @return [String]
+      attr_accessor :vra_username
+
+      #
+      # The password for accessing the VRealize instance.
+      #
+      # @return [String]
+      attr_accessor :vra_password
+
+
+      #
+      # The tenant to own the requested resource.
+      #
+      # @return [String]
+      attr_accessor :vra_tenant
+
+
+      #
+      # The VRealize endpoint URL.
+      #
+      # @return [String]
+      attr_accessor :vra_base_url
+
+
+      #
+      attr_accessor :subtenant_id
+      attr_accessor :catalog_item_id
+      attr_accessor :requested_for, :cpus, :memory, :lease_days
+
+      def add_entries
+        yield @__extra_entries
+      end
+
+      def extra_entries
+        @__extra_entries
+      end
+
+      def validate(machine)
+        errors = _detected_errors()
+        validation_failures =
+          [
+            validate_vra_username(),
+            validate_vra_password(),
+            validate_vra_username(),
+            validate_vra_password(),
+            validate_vra_tenant(),
+            validate_vra_base_url(),
+            validate_requested_for(),
+            validate_subtenant_id(),
+            validate_catalog_item_id(),
+            validate_memory()
+          ].compact
+
+        validation_failures.each do |msg|
+          errors << msg
+        end
+
+        {'Vrealize provider' => errors}
+      end
+
+      private
+      def validate_cpu(errors)
+        errors << "cpus required" if @cpus == UNSET_VALUE ||
+                                     @cpus.nil? ||
+                                     @cpus == 0
+      end
+
+      def unset?(str)
+        @vra_username == UNSET_VALUE ||
+          @vra_username.nil? ||
+          @vra_username.empty?
+      end
+
+      def validate_vra_username
+        "vra_username required" if unset?(@vra_username)
+      end
+
+      def validate_vra_password
+        "vra_password required" if unset?(@vra_password)
+      end
+
+      def validate_vra_tenant
+        "vra_tenant required" if unset?(@vra_tenant)
+      end
+
+      def validate_vra_base_url
+        "vra_base_url required" if unset?(@vra_base_url)
+      end
+
+      def validate_requested_for
+        "requested_for required" if unset?(@requested_for)
+      end
+
+      def validate_subtenant_id
+        "subtenant_id required" if unset?(@subtenant_id)
+      end
+
+      def validate_catalog_item_id
+        "catalog_item_id required" if unset?(@catalog_item_id)
+      end
+
+      def validate_memory
+        "memory required" if @memory == UNSET_VALUE ||
+                             @memory.nil? ||
+                             @memory == 0
+      end
+
+    end
+  end
+end

data/lib/vagrant-vrealize/errors.rb

@@ -0,0 +1,32 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Vrealize
+    module Errors
+      class VagrantVrealizeError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_vrealize.errors")
+      end
+
+      class InstanceReadyTimeout < VagrantVrealizeError
+        error_key(:instance_ready_timeout)
+      end
+
+      class InstancePackageError < VagrantVrealizeError
+        error_key(:instance_package_error)
+      end
+
+      class InstancePackageTimeout < VagrantVrealizeError
+        error_key(:instance_package_timeout)
+      end
+
+      class RsyncError < VagrantVrealizeError
+        error_key(:rsync_error)
+      end
+
+      class MkdirError < VagrantVrealizeError
+        error_key(:mkdir_error)
+      end
+
+    end
+  end
+end

data/lib/vagrant-vrealize/extra-entries.rb

@@ -0,0 +1,46 @@
+# This class provides a little DSL for setting extra config entries
+# in the Vagrantfile.
+# It's used like so:
+#
+#   config.vm.provider :vrealize do |vrealize|
+#     vrealize.add_entries do |extra_entries|
+#       extra_entries.string "provider-MyCustomSetting", "myCustomValue"
+#     end
+#   end
+#
+class ExtraEntries
+
+  LiteralTypes = %w{
+    boolean
+    decimal
+    integer
+    string
+  }
+
+  def initialize
+    @entries = Hash.new(){|h,k| h[k] = {}}
+  end
+
+  # This block defines a setter for each LiteralType.
+  # Use like this:
+  #
+  #   extra_entries.string "foo", "bar"
+  #
+  # then retrieve with
+  #
+  #   extra_entries.of_type("string") #=> [["foo", "bar"]]
+  #
+  LiteralTypes.each do |type|
+    define_method(type.to_sym) do |key,value|
+      @entries[type][key] = value
+    end
+  end
+
+  def of_type(type)
+    @entries[type] || []
+  end
+
+  def types
+    @entries.keys
+  end
+end

data/lib/vagrant-vrealize/plugin.rb

@@ -0,0 +1,73 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant VRealize plugin must be run within Vagrant."
+end
+
+# This is a sanity check to make sure no one is attempting to install
+# this into an early Vagrant version.
+if Vagrant::VERSION < "1.2.0"
+  raise "The Vagrant VRealize plugin is only compatible with Vagrant 1.2+"
+end
+
+module VagrantPlugins
+  module Vrealize
+    class Plugin < Vagrant.plugin("2")
+      name "VRealize"
+      description <<-DESC
+      This plugin installs a provider that allows Vagrant to manage
+      machines in VMWare VRealize.
+      DESC
+
+      config(:vrealize, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider(:vrealize, parallel: true) do
+        # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        # Return the provider
+        require_relative "provider"
+        Provider
+      end
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", Vrealize.source_root)
+        I18n.reload!
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.setup_logging
+        require "log4r"
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+        rescue NameError
+          # This means that the logging constant wasn't found,
+          # which is fine. We just keep `level` as `nil`. But
+          # we tell the user.
+          level = nil
+        end
+
+        # Some constants, such as "true" resolve to booleans, so the
+        # above error checking doesn't catch it. This will check to make
+        # sure that the log level is an integer, as Log4r requires.
+        level = nil if !level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+        if level
+          logger = Log4r::Logger.new("vagrant_vrealize")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vrealize/provider.rb

@@ -0,0 +1,52 @@
+require "log4r"
+require "vagrant"
+
+require_relative './action'
+
+module VagrantPlugins
+  module Vrealize
+    class Provider < Vagrant.plugin("2", :provider)
+      def initialize(machine)
+        @machine = machine
+      end
+
+      def action(name)
+        # Attempt to get the action method from the Action class if it
+        # exists, otherwise return nil to show that we don't support the
+        # given action.
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      def ssh_info
+        # Run a custom action called "read_ssh_info" which does what it
+        # says and puts the resulting SSH info into the `:machine_ssh_info`
+        # key in the environment.
+        env = @machine.action("read_ssh_info")
+        env[:machine_ssh_info]
+      end
+
+      def state
+        # Run a custom action we define called "read_state" which does
+        # what it says. It puts the state in the `:machine_state_id`
+        # key in the environment.
+        env = @machine.action("read_state")
+
+        state_id = env[:machine_state_id]
+
+        # Get the short and long description
+        short = I18n.t("vagrant_vrealize.states.short_#{state_id}")
+        long  = I18n.t("vagrant_vrealize.states.long_#{state_id}")
+
+        # Return the MachineState object
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      def to_s
+        id = @machine.id.nil? ? "new" : @machine.id
+        "Vrealize (#{id})"
+      end
+    end
+  end
+end

data/lib/vagrant-vrealize/util/timer.rb

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module Vrealize
+    module Util
+      class Timer
+        # A basic utility method that times the execution of the given
+        # block and returns it.
+        def self.time
+          start_time = Time.now.to_f
+          yield
+          end_time = Time.now.to_f
+
+          end_time - start_time
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vrealize/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module Vrealize
+    VERSION = '0.0.4'
+  end
+end