vagrant-hyperkit 0.4.3

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

@@ -0,0 +1,31 @@
+require "log4r"
+require "json"
+require "fileutils"
+
+module VagrantPlugins
+  module HYPERKIT
+    module Action
+      # This terminates the running instance.
+      class TerminateInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_hyperkit::action::terminate_instance")
+        end
+
+        def call(env)
+          stop_instance(env)
+          # Remove the tracking ID
+          env[:ui].info(I18n.t("vagrant_hyperkit.terminating"))
+          FileUtils.rm_rf(env[:machine].data_dir)
+
+          @app.call(env)
+        end
+
+        def stop_instance(env)
+          halt_env = env.dup
+          env[:action_runner].run(Action.action_halt, halt_env)
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,41 @@
+require "log4r"
+require "timeout"
+
+module VagrantPlugins
+  module HYPERKIT
+    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_hyperkit::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_hyperkit.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-hyperkit/config.rb

@@ -0,0 +1,83 @@
+require "vagrant"
+require "iniparse"
+
+module VagrantPlugins
+  module HYPERKIT
+    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 path to the xhyve binary if you don't want to
+      # use the one bundled with xhyve-ruby
+      #
+      # @return [String]
+      attr_accessor :xhyve_binary
+
+      # The mac address of the VM
+      #
+      # @return [String]
+      attr_accessor :mac
+
+      # The uuid of the VM
+      #
+      # @return [String]
+      attr_accessor :uuid
+
+      # The kernel command to initialize the machine
+      # The default command assumes that the instalation is done directly on the
+      # disk and not using a lvm. For example, by default, Centos intallation uses
+      # LVM. Moreover, it might be interesting to add new kernel options.
+      # @return [String]
+      attr_accessor :kernel_command
+
+      def initialize(region_specific=false)
+        @cpus           = UNSET_VALUE
+        @memory         = UNSET_VALUE
+        @xhyve_binary   = UNSET_VALUE
+        @mac            = UNSET_VALUE
+        @uuid           = UNSET_VALUE
+        @kernel_command = 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 @memory == UNSET_VALUE
+        @xhyve_binary = nil if @xhyve_binary == UNSET_VALUE
+        @kernel_command = %Q{"earlyprintk=serial console=ttyS0 root=/dev/vda1 ro"} if @kernel_command == 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-hyperkit/errors.rb

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

data/lib/vagrant-hyperkit/plugin.rb

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

data/lib/vagrant-hyperkit/provider.rb

@@ -0,0 +1,67 @@
+require "log4r"
+require "vagrant"
+
+module VagrantPlugins
+  module HYPERKIT
+    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
+      #   droplet = Provider.droplet(@machine)
+
+      #   return nil if droplet['status'].to_sym != :active
+
+      #   public_network = droplet['networks']['v4'].find { |network| network['type'] == 'public' }
+
+      #   return {
+      #     :host => public_network['ip_address'],
+      #     :port => '22',
+      #     :username => 'root',
+      #     :private_key_path => 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_hyperkit.states.short_#{state_id}")
+        long  = I18n.t("vagrant_hyperkit.states.long_#{state_id}")
+
+        # Return the MachineState object
+        Vagrant::MachineState.new(state_id, short, long)
+      rescue
+        Vagrant::MachineState.new(:not_running, "", "")
+      end
+
+      def to_s
+        id = @machine.id.nil? ? "new" : @machine.id
+        "XHYVE (#{id})"
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,79 @@
+require 'xhyve'
+
+module VagrantPlugins
+  module HYPERKIT
+    module Util
+      # TODO: send all this upstream
+      class XhyveGuest < Xhyve::Guest
+
+        def initialize(**opts)
+          super.tap do |s|
+            @pid = opts.fetch(:pid, nil)
+            @mac = opts[:mac] unless opts[:mac].nil?
+          end
+        end
+
+        def start
+          return @pid if running?
+          super
+        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,
+            :binary => @binary
+          }
+        end
+
+        def build_command
+          cmd = [
+            "sudo",
+            "#{@binary}",
+            "#{'-A' if @acpi}",
+            '-U', @uuid,
+            '-m', @memory,
+            '-c', @processors,
+            '-s', '0:0,hostbridge',
+            "#{"-s #{PCI_BASE - 2}:0,virtio-net,en0" if @networking }" ,
+            "#{build_block_device_parameter}",
+            '-s', '31,lpc',
+            '-l', "#{@serial},stdio",
+            '-f', "kexec,#{@kernel},#{@initrd},'#{@cmdline}'"
+          ].join(' ')
+
+          cmd
+        end
+
+        def log
+          @logger ||= Log4r::Logger.new("vagrant_hyperkit::vagrant_hyperkit")
+        end
+
+        def build_block_device_parameter
+          block_device_parameter = ""
+          @blockdevs.each_with_index.map do |p, i|
+            if p.include? "qcow"
+              block_device_parameter << "-s #{PCI_BASE + i},virtio-blk,file://#{p},format\=qcow "
+            else
+              block_device_parameter << "-s #{PCI_BASE + i},virtio-blk,#{p} "
+            end
+          end
+          block_device_parameter
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-hyperkit/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module HYPERKIT
+    VERSION = '0.4.3'
+  end
+end