vagrant-xhyve 0.1.0.pre

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

@@ -0,0 +1,47 @@
+require "log4r"
+require "json"
+require "fileutils"
+
+module VagrantPlugins
+  module XHYVE
+    module Action
+      # This terminates the running instance.
+      class TerminateInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_xhyve::action::terminate_instance")
+        end
+
+        def call(env)
+          xhyve_pid = env[:machine].id
+
+          if xhyve_pid == nil then
+            @logger.debug("xhyve already gone")
+          elsif process_alive(Integer(xhyve_pid)) then
+            env[:ui].info(" Terminating xhyve instance with PID #{xhyve_pid}")
+            Process.kill(3, Integer(xhyve_pid))
+          else
+            @logger.debug("xhyve PID already gone #{xhyve_pid}")
+          end
+
+          # Destroy the server and remove the tracking ID
+          env[:ui].info(I18n.t("vagrant_xhyve.terminating"))
+          env[:machine].id = nil
+
+          FileUtils.rm_rf(env[:machine].data_dir)
+
+          @app.call(env)
+        end
+
+        def process_alive(pid)
+          begin
+            Process.getpgid(pid)
+            true
+          rescue Errno::ESRCH
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require "vagrant-xhyve/util/timer"
+
+module VagrantPlugins
+  module XHYVE
+    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-xhyve/action/wait_for_state.rb

@@ -0,0 +1,41 @@
+require "log4r"
+require "timeout"
+
+module VagrantPlugins
+  module XHYVE
+    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_xhyve::action::wait_for_state")
+          @state   = state
+          @timeout = timeout
+        end
+
+        def call(env)
+          env[:result] = true
+          if env[:machine].state.id == @state
+            @logger.info(I18n.t("vagrant_xhyve.already_status", :status => @state))
+          else
+            @logger.info("Waiting for machine to reach state #{@state}")
+            begin
+              Timeout.timeout(@timeout) do
+                until env[:machine].state.id == @state
+                  sleep 2
+                end
+              end
+            rescue Timeout::Error
+              env[:result] = false # couldn't reach state in time
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xhyve/action.rb

@@ -0,0 +1,193 @@
+require "pathname"
+
+require "vagrant/action/builder"
+
+module VagrantPlugins
+  module XHYVE
+    module Action
+      # Include the built-in modules so we can use them as top-level things.
+      include Vagrant::Action::Builtin
+
+      def self.action_package
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            # Connect to AWS and then Create a package from the server instance
+            #b2.use ConnectAWS
+            b2.use PackageInstance
+          end
+        end
+      end
+
+      # 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 Call, GracefulHalt, :stopped, :running do |env2, b3|
+                if !env2[:result]
+                  b3.use StopInstance
+                end
+              end
+            else
+              b2.use MessageNotCreated
+            end
+          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 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 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 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 Import
+          b.use Provision
+          b.use SyncedFolders
+        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 Call, IsCreated do |env1, b1|
+            if not env1[:result]
+              b1.use action_prepare_boot
+            end
+
+            b1.use Boot # launch a new instance
+          end
+        end
+      end
+
+      def self.action_reload
+        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 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 :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 :Import, action_root.join("import")
+      autoload :Boot, action_root.join("boot")
+      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")
+    end
+  end
+end

data/lib/vagrant-xhyve/config.rb

@@ -0,0 +1,66 @@
+require "vagrant"
+require "iniparse"
+
+module VagrantPlugins
+  module XHYVE
+    class Config < Vagrant.plugin("2", :config)
+
+
+      # The number of CPUs to give the VM
+      #
+      # @return [Fixnum]
+      attr_accessor :cpus
+
+      # The amount of memory to give the VM
+      #
+      # This can just be a simple integer for memory in MB
+      # or you can use the suffixed style, eg. 2G for two
+      # Gigabytes
+      #
+      # @return [String]
+      attr_accessor :memory
+      
+      # The mac address of the VM
+      #
+      # @return [String]
+      attr_accessor :mac
+      
+      # The uuid of the VM
+      #
+      # @return [String]
+      attr_accessor :uuid
+
+      def initialize(region_specific=false)
+        @cpus   = UNSET_VALUE
+        @memory = UNSET_VALUE
+        @mac    = UNSET_VALUE
+        @uuid   = UNSET_VALUE
+
+        # Internal state (prefix with __ so they aren't automatically
+        # merged)
+        @__compiled_region_configs = {}
+        @__finalized = false
+        @__region_config = {}
+        @__region_specific = region_specific
+      end
+
+      #-------------------------------------------------------------------
+      # Internal methods.
+      #-------------------------------------------------------------------
+
+      def finalize!
+
+        @cpus = 1 if @cpus == UNSET_VALUE
+        @memory = 1024 if @cpus == UNSET_VALUE
+ 
+        # Mark that we finalized
+        @__finalized = true
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+        { "XHYVE Provider" => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-xhyve/errors.rb

@@ -0,0 +1,19 @@
+require "vagrant"
+
+module VagrantPlugins
+  module XHYVE
+    module Errors
+      class VagrantXHYVEError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_xhyve.errors")
+      end
+
+      class RsyncError < VagrantXYHVEError
+        error_key(:rsync_error)
+      end
+
+      class MkdirError < VagrantXHYVEError
+        error_key(:mkdir_error)
+      end
+    end
+  end
+end

data/lib/vagrant-xhyve/plugin.rb

@@ -0,0 +1,73 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant XHYVE 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 XHYVE plugin is only compatible with Vagrant 1.2+"
+end
+
+module VagrantPlugins
+  module XHYVE
+    class Plugin < Vagrant.plugin("2")
+      name "XHYVE"
+      description <<-DESC
+      This plugin installs a provider that allows Vagrant to manage
+      machines in XHYVE.
+      DESC
+
+      config(:xhyve, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider(:xhyve) 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", XHYVE.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_xhyve")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xhyve/provider.rb

@@ -0,0 +1,50 @@
+require "log4r"
+require "vagrant"
+
+module VagrantPlugins
+  module XHYVE
+    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_xhyve.states.short_#{state_id}")
+        long  = I18n.t("vagrant_xhyve.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
+        "XHYVE (#{id})"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module XHYVE
+    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-xhyve/util/vagrant-xhyve.rb

@@ -0,0 +1,50 @@
+require 'xhyve'
+
+module VagrantPlugins
+  module XHYVE
+    module Util
+      class XhyveGuest < Xhyve::Guest
+
+        def initialize(**opts)
+          if opts.has_key? "pid"
+            @pid = pid
+          else
+            @kernel = opts.fetch(:kernel)
+            @initrd = opts.fetch(:initrd)
+            @cmdline = opts.fetch(:cmdline)
+            @blockdevs = [opts[:blockdevs] || []].flatten
+            @memory = opts[:memory] || '500M'
+            @processors = opts[:processors] || '1'
+            @uuid = opts[:uuid] || SecureRandom.uuid
+            @serial = opts[:serial] || 'com1'
+            @acpi = opts[:acpi] || true
+            @networking = opts[:networking] || true
+            @foreground = opts[:foreground] || false
+            @command = build_command
+            @mac = find_mac
+          end
+        end
+
+        def options
+          {
+            :pid => @pid,
+            :kernel => @kernel,
+            :initrd => @initrd,
+            :cmdline => @cmdline,
+            :blockdevs => @blockdevs,
+            :memory => @memory,
+            :processors => @processors,
+            :uuid => @uuid,
+            :serial => @serial,
+            :acpi => @acpi,
+            :networking => @networking,
+            :foreground => @foreground,
+            :command => @command,
+            :mac => @mac,
+            :ip => ip
+          }
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xhyve/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module XHYVE
+    VERSION = '0.1.0.pre'
+  end
+end

data/lib/vagrant-xhyve.rb

@@ -0,0 +1,18 @@
+require "pathname"
+
+require "vagrant-xhyve/plugin"
+
+module VagrantPlugins
+  module XHYVE
+    lib_path = Pathname.new(File.expand_path("../vagrant-xhyve", __FILE__))
+    autoload :Action, lib_path.join("action")
+    autoload :Errors, lib_path.join("errors")
+
+    # This returns the path to the source of this plugin.
+    #
+    # @return [Pathname]
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path("../../", __FILE__))
+    end
+  end
+end

data/locales/en.yml

@@ -0,0 +1,83 @@
+en:
+  vagrant_xhyve:
+    already_status: |-
+      The machine is already %{status}.
+    launching_instance: |-
+      Launching an instance with the following settings...
+    not_created: |-
+      Instance is not created. Please run `vagrant up` first.
+    ready: |-
+      Machine is booted and ready for use!
+    rsync_not_found_warning: |-
+      Warning! Folder sync disabled because the rsync binary is missing in the %{side}.
+      Make sure rsync is installed and the binary can be found in the PATH.
+    rsync_folder: |-
+      Rsyncing folder: %{hostpath} => %{guestpath}
+    source_dest_checks_no_vpc: |-
+      Warning! Ignoring source_dest_checks flag as it can only be configured on
+      a VPC instance.
+    starting: |-
+      Starting the instance...
+    stopping: |-
+      Stopping the instance...
+    terminating: |-
+      Terminating the instance...
+    waiting_for_ready: |-
+      Waiting for instance to become "ready"...
+    waiting_for_ssh: |-
+      Waiting for SSH to become available...
+    warn_ssh_access: |-
+      Warning! Vagrant might not be able to SSH into the instance.
+      Please check your security groups settings.
+    will_not_destroy: |-
+      The instance '%{name}' will not be destroyed, since the confirmation
+      was declined.
+
+    errors:
+      rsync_error: |-
+        There was an error when attempting to rsync a shared folder.
+        Please inspect the error message below for more info.
+
+        Host path: %{hostpath}
+        Guest path: %{guestpath}
+        Error: %{stderr}
+      mkdir_error: |-
+        There was an error when attempting to create a shared host folder.
+        Please inspect the error message below for more info.
+
+        Host path: %{hostpath}
+        Error: %{err}
+
+    states:
+      short_not_created: |-
+        not created
+      long_not_created: |-
+        The xhyve VM is not created. Run `vagrant up` to create it.
+
+      short_stopped: |-
+        stopped
+      long_stopped: |-
+        The xhyve VM is stopped. Run `vagrant up` to start it.
+
+      short_stopping: |-
+        stopping
+      long_stopping: |-
+        The xhyve VM is stopping. Wait until is completely stopped to
+        run `vagrant up` and start it.
+
+      short_pending: |-
+        pending
+      long_pending: |-
+        The xhyve VM is pending a start (i.e. this is a transition state).
+
+      short_running: |-
+        running
+      long_running: |-
+        The xhyve VM is running. To stop this machine, you can run
+        `vagrant halt`. To destroy the machine, you can run `vagrant destroy`.
+
+      short_pending: |-
+        pending
+      long_pending: |-
+        The xhyve VM is still being initialized. To destroy this machine,
+        you can run `vagrant destroy`.

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+