vagrant-hyperkit 0.4.3

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

@@ -0,0 +1,185 @@
+require "log4r"
+require 'json'
+require 'securerandom'
+
+require 'net/ssh'
+require 'vagrant/util/retryable'
+
+require 'vagrant-hyperkit/util/timer'
+require 'vagrant-hyperkit/util/vagrant-hyperkit'
+
+module VagrantPlugins
+  module HYPERKIT
+    module Action
+      # This runs the configured instance.
+      class Boot
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(" About to launch vm...")
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          machine_info_path = File.join(env[:machine].data_dir, "xhyve.json")
+          env[:ui].info("machine_info_path #{machine_info_path}")
+          if File.exist?(machine_info_path)
+            machine_json = File.read(machine_info_path)
+            machine_options = JSON.parse(machine_json, :symbolize_names => true)
+            log.debug "Machine Options: #{JSON.pretty_generate(machine_options)}"
+            machine_uuid = machine_options[:uuid]
+            pid = machine_options[:pid]
+            mac = machine_options[:mac]
+          else
+            machine_uuid = uuid(env)
+          end
+
+          guest_config = {
+            pid: pid,
+            mac: mac,
+            uuid: machine_uuid,
+            cmdline: kernel_command(env),
+            memory: memory(env),
+            processors: cpus(env),
+            binary: xhyve_binary(env),
+          }
+
+          xhyve_guest = start_guest(env, guest_config)
+          # Immediately save the ID since it is created at this point.
+          env[:machine].id = xhyve_guest.uuid
+
+          save_guest_status(env, xhyve_guest)
+          # Terminate the instance if we were interrupted
+          terminate(env) if env[:interrupted]
+
+          100.times do |i|
+            begin
+              ssh_try(xhyve_guest.ip, "accanto", "accanto")
+            rescue StandardError => e
+              env[:ui].error("SSL error: #{e.inspect}")
+              redo
+            end
+          end
+
+          @app.call(env)
+        end
+
+        def ssh_try(host, user, pass)
+          Net::SSH.start( host.to_s, user.to_s, :password => pass.to_s ) do |ssh|
+            ssh.exec!('date')
+            ssh.close
+          end
+        end
+
+        def recover(env)
+          return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)
+
+          if env[:machine].provider.state.id != :not_created
+            # Undo the import
+            terminate(env)
+          end
+        end
+
+        def terminate(env)
+          destroy_env = env.dup
+          destroy_env.delete(:interrupted)
+          destroy_env[:config_validate] = false
+          destroy_env[:force_confirm_destroy] = true
+          env[:action_runner].run(Action.action_destroy, destroy_env)
+        end
+
+        private
+
+        def block_device_paths(base_path)
+          block_paths = Dir.glob File.join(base_path, "block*.{raw,img,qcow,qcow2}")
+          block_paths.sort
+        end
+
+        def kernel_file_path(base_path)
+          File.join(base_path, "vmlinuz")
+        end
+
+        def initrd_file_path(base_path)
+          File.join(base_path, "initrd.gz")
+        end
+
+        def memory(env)
+          provider_config(env).memory
+        end
+
+        def uuid(env)
+          provider_config(env).uuid
+        end
+
+        def cpus(env)
+          provider_config(env).cpus
+        end
+
+        def xhyve_binary(env)
+          provider_config(env).xhyve_binary
+        end
+
+        def kernel_command(env)
+          provider_config(env).kernel_command
+        end
+
+        def provider_config(env)
+          @provider_config ||= env[:machine].provider_config
+        end
+
+        def start_guest(env, config = {})
+          image_dir = File.join(env[:machine].data_dir, "image")
+          default_config = {
+            kernel: kernel_file_path(image_dir),
+            initrd: initrd_file_path(image_dir),
+            blockdevs: block_device_paths(image_dir),
+            serial: 'com1',
+            networking: true,
+            acpi: true
+          }
+          config = default_config.merge(config)
+          xhyve_guest = Util::XhyveGuest.new(config)
+          xhyve_guest.start
+          xhyve_guest
+        end
+
+        def save_guest_status(env, guest)
+          wait_for_guest_ip(env, guest)
+          machine_info_path = File.join(env[:machine].data_dir, "xhyve.json")
+          log.debug "xhyve configuration: #{JSON.pretty_generate(guest.options)}"
+          File.write(machine_info_path, guest.options().to_json)
+          log.info(" Launched xhyve VM with PID #{guest.pid}, MAC: #{guest.mac}, and IP #{guest.ip}")
+        end
+
+        def wait_for_guest_ip(env, guest)
+          network_ready_retries = 0
+          network_ready_retries_max = 3
+          update_xhyve_status(env, guest.options)
+          while guest.ip.nil?
+            break if env[:interrupted]
+
+            if network_ready_retries < network_ready_retries_max then
+              network_ready_retries += 1
+              env[:ui].info("Waiting for IP to be ready. Try #{network_ready_retries}/#{network_ready_retries_max}...")
+            else
+              raise 'Waited too long for IP to be ready. Your VM probably did not boot.'
+            end
+            sleep 0.5
+          end
+          update_xhyve_status(env, guest.options)
+        end
+
+        def update_xhyve_status(env, status)
+          env[:xhyve_status] = status
+        end
+
+        def log
+          @logger ||= Log4r::Logger.new("vagrant_hyperkit::action::boot")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require "log4r"
+require "json"
+require "fileutils"
+
+module VagrantPlugins
+  module HYPERKIT
+    module Action
+      # This terminates the running instance.
+      class Import
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+
+          #TODO: Progress bar
+          env[:ui].info("Importing box...")
+
+          image_dir = File.join(env[:machine].data_dir, "image")
+          box_dir = env[:machine].box.directory
+
+          log.debug("Importing box from: #{box_dir}")
+
+          create_image_directory(image_dir)
+          copy_kernel_to(box_dir, image_dir)
+          copy_initrd_to(box_dir, image_dir)
+          copy_block_files_to(box_dir, image_dir)
+          env[:ui].info("Done importing box.")
+
+          @app.call(env)
+        end
+
+        private
+
+        def copy_kernel_to(from, to)
+          copy_file(from, to, "vmlinuz")
+        end
+
+        def copy_initrd_to(from, to)
+          copy_file(from, to, "initrd.gz")
+        end
+
+        def copy_block_files_to(from, to)
+          block_glob = Dir.glob(File.join(from, "block*.{img,raw,qcow,qcow2}"))
+          log.debug("Copying #{block_glob} to #{to} ")
+          FileUtils.cp_r block_glob, to
+        end
+
+        def copy_file(from, to, filename)
+          from_box_file_path = File.join(from, filename)
+          to_image_file_path = File.join(to, filename)
+
+          unless File.exist? to_image_file_path
+            log.debug("Copying #{from_box_file_path} to #{to} ")
+            FileUtils.cp(from_box_file_path, to)
+          end
+        end
+
+        def create_image_directory(path)
+          FileUtils.mkdir_p(path)
+        end
+
+        def log
+          @logger ||= Log4r::Logger.new("vagrant_hyperkit::action::import")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module HYPERKIT
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is created and branch in the middleware.
+      class IsCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].id != nil
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module HYPERKIT
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is stopped and branch in the middleware.
+      class IsStopped
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id == :stopped
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module HYPERKIT
+    module Action
+      class MessageAlreadyCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_hyperkit.already_status", :status => "created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module HYPERKIT
+    module Action
+      class MessageNotCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_hyperkit.not_created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module HYPERKIT
+    module Action
+      class MessageWillNotDestroy
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_hyperkit.will_not_destroy", name: env[:machine].name))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require "log4r"
+require 'vagrant-hyperkit/util/vagrant-hyperkit'
+
+module VagrantPlugins
+  module HYPERKIT
+    module Action
+      # This action reads the SSH info for the machine and puts it into the
+      # `:machine_ssh_info` key in the environment.
+      class ReadSSHInfo
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_hyperkit::action::read_ssh_info")
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env)
+          @app.call(env)
+        end
+
+        def read_ssh_info(env)
+          xhyve_status = env[:xhyve_status]
+          return { :host => xhyve_status[:ip], :port => 22 }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require "log4r"
+
+module VagrantPlugins
+  module HYPERKIT
+    module Action
+      # This action reads the state of the machine and puts it in the
+      # `:machine_state_id` key in the environment.
+      class ReadState
+        def initialize(app, env)
+          @app = app
+          @env = env
+          @logger = Log4r::Logger.new("vagrant_hyperkit::action::read_state")
+        end
+
+        def call(env)
+
+          env[:machine_state_id] = read_state(env)
+          @app.call(env)
+        end
+
+        private
+
+        def read_state(env)
+          xhyve_status = read_xhyve_status_file(env)
+          return :not_created if env[:machine].id.nil?
+          env[:xhyve_status] = xhyve_status
+          if process_alive(xhyve_status[:pid])
+            return :running
+          else
+            return :stopped
+          end
+        end
+
+        def read_xhyve_status_file(env)
+          xhyve_status_file_path = File.join(env[:machine].data_dir, "xhyve.json")
+          return {} unless File.exist?(xhyve_status_file_path)
+          machine_json = File.read(xhyve_status_file_path)
+          JSON.parse(machine_json, :symbolize_names => true)
+        end
+
+        def process_alive(pid)
+          return false if pid.nil?
+          begin
+            Process.getpgid(pid.to_i)
+            true
+          rescue Errno::ESRCH
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require "log4r"
+
+module VagrantPlugins
+  module HYPERKIT
+    module Action
+      # This stops the running instance.
+      class StopInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_hyperkit::action::stop_instance")
+        end
+
+        def call(env)
+          if is_process_alive? pid(env)
+            env[:ui].info(I18n.t("vagrant_hyperkit.stopping"))
+            kill_xhyve_process(env)
+          else
+            env[:ui].info(I18n.t("vagrant_hyperkit.already_status", status: env[:machine].state.id))
+          end
+          destroy_xhyve_status_file(env)
+          @app.call(env)
+        end
+
+        def is_process_alive?(pid)
+          return false if pid == 0
+          begin
+            Process.getpgid(pid)
+            true
+          rescue Errno::ESRCH
+            false
+          end
+        end
+
+        def kill_xhyve_process(env)
+          Process.kill(15, pid(env))
+        end
+
+        def destroy_xhyve_status_file(env)
+          xhyve_status_file_path = File.join(env[:machine].data_dir, "xhyve.json")
+          FileUtils.remove_file(xhyve_status_file_path, force: true)
+        end
+
+        def pid(env)
+          @pid ||= env[:xhyve_status][:pid].to_i
+        end
+      end
+    end
+  end
+end