vagrant-xhyve 0.1.0.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e86cc52b4ca725cdda0aef517879001aa4e3840e
+  data.tar.gz: d61ffc7960f9d079c37ffef1f0f90200f45f922b
+SHA512:
+  metadata.gz: 160141682ee37beed607aef94bf476e31d8af4c42742090b3755e381ecb14ecb840bd3646455327a53af6ceca7c7da42e5757a07501e97b464757172250496ec
+  data.tar.gz: b026f9a63b2483c747c4413ddf051f81ca32029d9edf9fe60959923fb6c1b2beeb9a51f889831d93467ee0cd1549fbcbee4927e4884659d8f717847a338a5279

data/.gitignore

@@ -0,0 +1,22 @@
+# OS-specific
+.DS_Store
+
+# editors
+*.swp
+
+# Bundler/Rubygems
+*.gem
+.bundle
+pkg/*
+tags
+Gemfile.lock
+
+# Vagrant
+.vagrant
+Vagrantfile
+example_box
+example.box
+
+# RVM files for gemset/ruby setting
+.ruby-*
+.rvmrc

data/.rspec

@@ -0,0 +1 @@
+--format doc --order random --color --fail-fast

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 0.1.0 (April xx, 2016)
+
+* Initial release.

data/Gemfile

@@ -0,0 +1,13 @@
+source "https://rubygems.org"
+
+group :plugins do
+  gemspec
+end
+
+group :development do
+  # We depend on Vagrant for development, but we don't add it as a
+  # gem dependency because we expect to be installed within the
+  # Vagrant environment itself using `vagrant plugin`.
+  gem "vagrant", :git => "https://github.com/mitchellh/vagrant.git"
+end
+

data/LICENSE

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+Copyright (c) 2016 Patrick Armstrong
+Copyright (c) 2014 Mitchell Hashimoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,140 @@
+# Vagrant xhyve Provider
+
+This is a [Vagrant](http://www.vagrantup.com) plugin that adds an [xhyve](http://aws.amazon.com)
+provider to Vagrant.
+
+## Features
+
+* Sorta works
+
+## Limitations
+
+You need to use sudo for most vagrant actions with the xhyve driver,
+due to the entitlements needed for xhyve to run without sudo. More details
+in the [xhyve github issue](https://github.com/mist64/xhyve/issues/60).
+
+Also, sometimes launching a VM just fails. But I'm not quite sure why.
+
+## Usage
+
+Install using standard Vagrant plugin installation methods. After
+installing, `vagrant up` and specify the `xhyve` provider. An example is
+shown below.
+
+```
+$ vagrant plugin install vagrant-xhyve
+...
+$ sudo vagrant up --provider=xhyve
+...
+```
+
+Of course prior to doing this, you'll need to obtain an XHYVE-compatible
+box file for Vagrant.
+
+## Quick Start
+
+After installing the plugin (instructions above), the quickest way to get
+started is to actually use a dummy AWS box and specify all the details
+manually within a `config.vm.provider` block. So first, add the dummy
+box using any name you want:
+
+```
+$ vagrant box add oldpatricka/tinycorelinux
+...
+```
+
+And then make a Vagrantfile that looks like the following, filling in
+your information where necessary.
+
+```
+Vagrant.configure("2") do |config|
+  config.vm.box = "oldpatricka/tinycorelinux"
+
+  config.vm.provider :xhyve do |xhyve|
+    xhyve.cpus = 1
+    xhyve.memory = 1G
+  end
+end
+```
+
+And then run `sudo vagrant up --provider=xhyve`.
+
+This will start a Tiny Core Linux instance.
+
+## Box Format
+
+The vagrant-xhyve box format is pretty straightforward. See
+the [example_box/ directory](https://github.com/oldpatricka/vagrant-xhyve/tree/master/example_box).
+That directory also contains instructions on how to build a box.
+
+## Configuration
+
+This provider exposes quite a few provider-specific configuration options:
+
+* `memory` - 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
+* `cpus` - The number of CPUs to give the VM
+
+These can be set like typical provider-specific configuration:
+
+```ruby
+Vagrant.configure("2") do |config|
+  # ... other stuff
+
+  config.vm.provider :xhyve do |xhyve|
+    xhyve.cpus = 2
+    xhyve.memory = 1G
+  end
+end
+```
+## Synced Folders
+
+There is minimal support for synced folders. Upon `vagrant up`,
+`vagrant reload`, and `vagrant provision`, the XHYVE provider will use
+`rsync` (if available) to uni-directionally sync the folder to
+the remote machine over SSH.
+
+## Questions
+
+Q. Should I use this for my work?
+
+A. Do you want to keep your job? I'm not even sure you should use this for toy
+projects.
+
+Q. Why?
+
+A. This project is powered by ignorance and good intentions.
+
+Q. Will I even not have to use sudo?
+
+A. There's a theory in that issue linked above that wrapping xhyve in an
+app store app would help. If that were the case, you could probably use the
+embedded binary with vagrant-xhyve.
+
+## Development
+
+To work on the `vagrant-xhyve` plugin, clone this repository out, and use
+[Bundler](http://gembundler.com) to get the dependencies:
+
+```
+$ bundle
+```
+
+Once you have the dependencies, verify the unit tests pass with `rake`:
+
+```
+$ bundle exec rake
+```
+
+If those pass, you're ready to start developing the plugin. You can test
+the plugin without installing it into your Vagrant environment by just
+creating a `Vagrantfile` in the top level of this directory (it is gitignored)
+and add the following line to your `Vagrantfile` 
+```ruby
+Vagrant.require_plugin "vagrant-xhyve"
+```
+Use bundler to execute Vagrant:
+```
+$ bundle exec vagrant up --provider=xhyve
+```

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec/core/rake_task'
+
+# Immediately sync all stdout so that tools like buildbot can
+# immediately load in the output.
+$stdout.sync = true
+$stderr.sync = true
+
+# Change to the directory of this file.
+Dir.chdir(File.expand_path("../", __FILE__))
+
+# This installs the tasks that help with gem creation and
+# publishing.
+Bundler::GemHelper.install_tasks
+
+# Install the `spec` task so that we can run tests.
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = "--order defined"
+end
+# Default task is to run the unit tests
+task :default => :spec

data/example_box/README.md

@@ -0,0 +1,31 @@
+# vagrant-xhyve Box Format
+
+A vagrant-xhyve box, like all vagrant boxes is an archive of a directory of
+files with a metadata file, a kernel, ramdisk, and optionally some raw disk
+images.
+
+Here's an example:
+
+```
+.
+|-- block0.img
+|-- initrd.gz
+|-- metadata.json
+`-- vmlinuz
+```
+
+The metadata.json just contains the defaults from the vagrant box documentation,
+that is it looks like:
+
+```
+{
+    "provider": "xhyve"
+}
+```
+
+initrd.gz and vmlinuz are extracted from a raw disk image using the technique
+described in Michael Steil's nice blog post 
+[introducing xhyve](http://www.pagetable.com/?p=831).
+
+You can have up to ten block devices to attach to your vm, named from block0.img
+upto block9.img. You can also have zero. That's ok.

data/example_box/metadata.json

@@ -0,0 +1,3 @@
+{
+    "provider": "xhyve"
+}

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

@@ -0,0 +1,142 @@
+require "log4r"
+require 'json'
+require 'securerandom'
+
+require 'vagrant/util/retryable'
+
+require 'vagrant-xhyve/util/timer'
+require 'vagrant-xhyve/util/vagrant-xhyve'
+
+module VagrantPlugins
+  module XHYVE
+    module Action
+      # This runs the configured instance.
+      class Boot
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_xhyve::action::run_instance")
+        end
+
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          env[:ui].info(" About to launch vm")
+          
+          memory = env[:machine].provider_config.memory
+          cpus = env[:machine].provider_config.cpus
+
+          # Launch!
+          env[:ui].info(" -- CPUs: #{cpus}") if cpus
+          env[:ui].info(" -- Memory: #{memory}")
+
+          machine_info_path = File.join(env[:machine].data_dir, "xhyve.json")
+          if File.exist?(machine_info_path) then
+            machine_json = File.read(machine_info_path)
+            machine_options = JSON.parse(machine_json, :symbolize_names => true)
+            machine_uuid = machine_options[:uuid]
+            @logger.debug("Found existing UUID: #{machine_uuid}")
+          else
+            machine_uuid = SecureRandom.uuid
+            @logger.debug("Created new UUID: #{machine_uuid}")
+          end
+
+          image_dir = File.join(env[:machine].data_dir, "image")
+          vmlinuz_file = File.join(image_dir, "vmlinuz")
+          initrd_file = File.join(image_dir, "initrd.gz")
+          block_devices = []
+
+          0.upto(10).each do |blockidx|
+            block_file = File.join(image_dir, "block#{blockidx}.img")
+            if (File.exist? block_file) then
+              @logger.debug("Found block device #{block_file}")
+              block_devices.push(block_file)
+            else
+              break
+            end
+          end
+
+          if block_devices.any? then
+              disk_kernel_parameters = "root=/dev/vda1 ro"
+          else
+              disk_kernel_parameters = ""
+          end
+
+          kernel_parameters = "\"earlyprintk=serial console=ttyS0 #{disk_kernel_parameters}\""
+
+          firmware = "kexec,#{vmlinuz_file},#{initrd_file},#{kernel_parameters}"
+
+          @logger.debug("Machine data_dir: #{env[:machine].data_dir}")
+          @logger.debug("Kernel Options: #{kernel_parameters}")
+          @logger.debug("Block Devices: #{block_devices}")
+
+          xhyve_guest = Util::XhyveGuest.new(
+              kernel: vmlinuz_file,
+              initrd: initrd_file,
+              cmdline: kernel_parameters,
+              blockdevs: block_devices,
+              serial: 'com1',
+              memory: memory,
+              processors: cpus,
+              networking: true,
+              acpi: true
+          )
+
+
+          xhyve_pid = xhyve_guest.start
+          env[:ui].info(xhyve_guest.options().to_json)
+        
+          # Immediately save the ID since it is created at this point.
+          env[:machine].id = xhyve_pid
+
+          # wait for ip
+          network_ready_retries = 0
+          network_ready_retries_max = 5
+          while true
+            break if env[:interrupted]
+
+            if xhyve_guest.ip
+                break
+            end
+            if network_ready_retries < network_ready_retries_max then
+                network_ready_retries += 1
+                env[:ui].info("Waiting for IP to be ready...")
+            else
+                raise 'Waited too long for IP to be ready. Your VM probably did not boot.'
+            end
+            sleep 2
+          end
+
+          machine_info_path = File.join(env[:machine].data_dir, "xhyve.json")
+          File.write(machine_info_path, xhyve_guest.options().to_json)
+          
+          @logger.info(" Launched xhyve VM with PID #{xhyve_pid}, MAC: #{xhyve_guest.mac}, and IP #{xhyve_guest.ip}")
+
+          # Terminate the instance if we were interrupted
+          terminate(env) if env[:interrupted]
+
+          @app.call(env)
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require "log4r"
+require "json"
+require "fileutils"
+
+module VagrantPlugins
+  module XHYVE
+    module Action
+      # This terminates the running instance.
+      class Import
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_xhyve::action::import")
+        end
+
+        def call(env)
+
+          #TODO: Progress bar
+          env[:ui].info("Importing box...")
+          # something like:
+          # # tempfile is a File instance
+          # File.open( new_file, 'wb' ) do |f|
+          #   # Read in small 65k chunks to limit memory usage
+          #     f.write(tempfile.read(2**16)) until tempfile.eof?
+          #     end
+
+          image_dir = File.join(env[:machine].data_dir, "image")
+          box_dir = env[:machine].box.directory
+
+          box_files = [File.join(box_dir, "vmlinuz"), File.join(box_dir, "initrd.gz")]
+
+          0.upto(10).each do |blockidx|
+            block_file = File.join(box_dir, "block#{blockidx}.img")
+            if (File.exist? block_file) then
+              box_files.push(block_file)
+            else
+              break
+            end
+          end
+
+          FileUtils.mkdir_p(image_dir)
+          FileUtils.cp(box_files, image_dir)
+
+          env[:ui].info("Done importing box.")
+
+          @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/is_created.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module XHYVE
+    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-xhyve/action/is_stopped.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module XHYVE
+    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-xhyve/action/message_already_created.rb

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

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

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

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

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

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

@@ -0,0 +1,33 @@
+require "log4r"
+require 'vagrant-xhyve/util/vagrant-xhyve'
+
+module VagrantPlugins
+  module XHYVE
+    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_xhyve::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)
+          return nil if env[:machine].id.nil?
+
+          machine_info_path = File.join(env[:machine].data_dir, "xhyve.json")
+          machine_json = File.read(machine_info_path)
+          machine_options = JSON.parse(machine_json, :symbolize_names => true)
+
+          return { :host => machine_options[:ip], :port => 22 }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require "log4r"
+
+module VagrantPlugins
+  module XHYVE
+    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
+          @logger = Log4r::Logger.new("vagrant_xhyve::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_state(machine)
+          return :not_created if machine.id.nil?
+
+          xhyve_pid = Integer(machine.id)
+
+          if process_alive(xhyve_pid) then
+              return :running
+          else
+              return :stopped
+          end
+        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/stop_instance.rb

@@ -0,0 +1,45 @@
+require "log4r"
+
+module VagrantPlugins
+  module XHYVE
+    module Action
+      # This stops the running instance.
+      class StopInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_xhyve::action::stop_instance")
+        end
+
+        def call(env)
+          if env[:machine].state.id == :stopped
+            env[:ui].info(I18n.t("vagrant_xhyve.already_status", :status => env[:machine].state.id))
+          else
+              env[:ui].info(I18n.t("vagrant_xhyve.stopping"))
+
+              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
+          end
+
+          @app.call(env)
+        end
+
+        def process_alive(pid)
+          begin
+            Process.getpgid(pid)
+            true
+          rescue Errno::ESRCH
+            false
+          end
+        end
+      end
+    end
+  end
+end