fragrant 0.0.1

data/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2012 Matt Whiteley
+
+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,6 @@
+* Top notes
+  - Wrap Vagrant actions in HTTP so we can execute from VMs
+* Middle notes
+  - Quick
+* Base notes
+  - Dirty

data/bin/fragrant

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+lib_dir = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
+require 'fragrant'
+require 'rack/handler/puma'
+require 'vegas'
+
+app = Fragrant::Frontend.new
+def app.server
+  "puma"
+end
+Vegas::Runner.new(app, 'fragrant', {:skip_launch => true, :app_dir => Fragrant.env_dir})

data/lib/fragrant/address_manager.rb

@@ -0,0 +1,80 @@
+require 'ipaddr'
+require 'json'
+
+module Fragrant
+  AddressRangeExhausted = Class.new(StandardError)
+
+  class AddressManager
+    attr_accessor :data_location, :allocated_addresses
+    attr_accessor :address_range, :address_map
+
+    def initialize(data_location, address_range)
+      self.data_location = data_location
+      self.address_range = address_range
+      self.address_map = {}
+      self.allocated_addresses = []
+      load_address_data
+    end
+
+    def load_address_data
+      return unless File.exist?(data_location)
+      unless File.writable?(data_location)
+        raise "Unable to access IP address config file at #{data_location}"
+      end
+      File.open(data_location, 'rb') do |f|
+        data = JSON.parse(f.read)
+        self.address_range = data['address_range']
+        self.address_map = data['address_map']
+        self.allocated_addresses = data['allocated_addresses']
+      end
+    end
+
+    def address_data
+      {:address_range => address_range,
+       :allocated_addresses => allocated_addresses,
+       :address_map => address_map}
+    end
+
+    def first_available_address
+      ip = IPAddr.new(address_range).to_range.detect do |ip|
+        !allocated_addresses.include?(ip.to_s)
+      end
+      return ip.to_s if ip
+      raise AddressRangeExhausted, "No more addresses available in range #{address_range}"
+    end
+
+    def persist
+      dir = File.dirname(data_location)
+      FileUtils.mkdir_p(dir) unless File.directory?(dir)
+      File.open(data_location, 'wb') do |f|
+        f.write(address_data.to_json)
+      end
+    end
+
+    def claim_address(environment_id)
+      if address_map.key?(environment_id)
+        raise "#{environment_id} already has an address"
+      end
+      address = first_available_address
+      address_map[environment_id] = address
+      allocated_addresses << address
+      persist
+      address
+    end
+
+    def release_address(environment_id, ip)
+      unless address_map.key?(environment_id)
+        raise "No addresses registered to environment #{environment_id}"
+      end
+
+      address = address_map[environment_id]
+      unless address == ip
+        raise "IP #{ip} is not currently assigned to environment #{environment_id} (#{address} is)"
+      end
+
+      address_map.delete environment_id
+      allocated_addresses.delete ip
+      persist
+    end
+  end
+end

data/lib/fragrant/vagrantfile_generator.rb

@@ -0,0 +1,64 @@
+require 'fileutils'
+require 'erb'
+
+module Fragrant
+  class VagrantfileGenerator
+
+    attr_accessor :addresses
+
+    def self.template_path
+      File.expand_path('../../templates/Vagrantfile', __FILE__)
+    end
+
+    def initialize(target_directory, opts={})
+      @target_directory = target_directory
+      @scripts          = opts[:scripts] || []
+      @addresses        = opts[:addresses] || []
+      @box_name         = opts[:box_name]
+      @box_url          = opts[:box_url]
+      @contents         = opts[:contents]
+    end
+
+    def box_name
+      @box_name || "precise32"
+    end
+
+    def box_url
+      @box_url || "http://files.vagrantup.com/precise32.box"
+    end
+
+    def add_script(contents)
+      raise "body set, adding a script not supported" if @contents
+      @scripts << contents
+      true
+    end
+
+    def writeable_scripts
+      retval = {}
+      @scripts.each_with_index do |contents, i|
+        retval[sprintf("script%03d", i + 1)] = contents
+      end
+      retval
+    end
+
+    def write
+      FileUtils.mkdir_p(@target_directory)
+
+      writeable_scripts.each do |filename, script_body|
+        File.open(File.join(@target_directory, filename), 'w') do |f|
+          f.print script_body
+          f.chmod 0755
+        end
+      end
+
+      @contents ||= Vagrant::Util::TemplateRenderer.render(self.class.template_path,
+                                                           :box_name => box_name,
+                                                           :box_url => box_url,
+                                                           :provision_script_paths => writeable_scripts.keys.sort,
+                                                           :addresses => addresses)
+      File.open(File.join(@target_directory, 'Vagrantfile'), 'w') { |f| f.print @contents }
+
+      true
+    end
+  end
+end

data/lib/fragrant.rb

@@ -0,0 +1,323 @@
+vendor_dir = File.expand_path('../../vendor', __FILE__)
+$LOAD_PATH.unshift File.join(vendor_dir, 'grape', 'lib')
+require 'grape'
+require 'thread'
+require 'fileutils'
+require 'uuid'
+require 'vagrant'
+require 'fragrant/vagrantfile_generator'
+require 'fragrant/address_manager'
+
+module Fragrant
+  def self.env_dir
+    @env_dir ||= begin
+                   dir = ENV["FRAGRANT_ENV_DIR"] || File.expand_path("~/.fragrant")
+                   FileUtils.mkdir_p(dir)
+                   dir
+                 end
+  end
+
+  def self.address_manager
+    data_location = File.join(Fragrant.env_dir, "addresses.json")
+    range = ENV["FRAGRANT_IP_RANGE"] || "172.24.24.128/25"
+    @address_manager ||= AddressManager.new(data_location, range)
+  end
+
+  def self.add_task(task)
+    background_worker
+    tasks.push(task)
+  end
+
+  # Tasks are two-element Arrays of a machine id and a set of vagrant args
+  def self.tasks
+    @tasks ||= Queue.new
+  end
+
+  def self.create_worker_thread
+    thread = Thread.new do
+      Thread.current.abort_on_exception = true
+      until Thread.current[:shutdown] do
+        unless Fragrant.tasks.empty?
+          task = Fragrant.tasks.pop
+          env = Vagrant::Environment.new({ :cwd => File.join(env_dir, task[:id]) })
+          env.cli(task[:args])
+        end
+      end
+    end
+
+    at_exit do
+      $stderr.puts "Waiting for any running Vagrant tasks to complete."
+      thread[:shutdown] = true
+      thread.join
+    end
+    thread
+  end
+
+  def self.background_worker
+    @background_worker ||= create_worker_thread
+  end
+
+  class Frontend < Grape::API
+    version 'v1', :using => :header, :vendor => 'fragrant'
+    format :json
+
+    ENV_REGEX = /[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/
+
+    rescue_from :all do |e|
+      rack_response({ :message => "Encountered exception: #{e}", :backtrace => e.backtrace }, 500, {"Content-Type" => "application/json"})
+    end
+
+    helpers do
+      def add_task(task)
+        Fragrant.add_task(task)
+      end
+
+      def box_name
+        params[:box_name] || 'precise32'
+      end
+
+      def box_url
+        params[:box_url] || "http://files.vagrantup.com/precise32.box"
+      end
+
+      def user_script
+        params[:user_data_script]
+      end
+
+      def env_dir
+        Fragrant.env_dir
+      end
+
+      def env_glob
+        Dir.entries(env_dir).select do |d|
+          next if d.start_with?('.')
+          File.exists?(File.join(env_dir, d, 'Vagrantfile'))
+        end
+      end
+
+      def env_rand
+        UUID.generate
+      end
+
+      def v_action
+        route.route_path.split(/[\/\(]/)[2]
+      end
+
+      def v_env(id = params[:id])
+        Vagrant::Environment.new({ :cwd => File.join(env_dir, id) })
+      end
+
+      def allocate_address(env_id)
+        Fragrant.address_manager.claim_address(env_id)
+      end
+
+      def v_file(env_id, directory, contents = nil)
+        addresses = [allocate_address(env_id)] unless contents
+        VagrantfileGenerator.new(directory, :box_name => box_name,
+                                            :box_url => box_url,
+                                            :scripts => Array(user_script),
+                                            :addresses => addresses,
+                                            :contents => contents).write
+        Array(addresses)
+      end
+
+      def make_machine_dir(machine_id)
+        machine_dir = File.join(env_dir, machine_id)
+        begin
+          Dir.mkdir(machine_dir, 0755)
+        rescue Errno::EEXIST
+          error!({ "error" => "#{machine_dir} already exists!" }, 409)
+        end
+        machine_dir
+      end
+    end
+
+    get do
+      {}
+    end
+
+    resource :environments do
+
+      desc "Destroys a Vagrant environment"
+      params do
+        requires :id, :desc => "Vagrant environment id", :type => String, regexp: ENV_REGEX
+        optional :vm_name, :desc => 'single vm to act on'
+      end
+      delete '/destroy/:id' do
+        args = [v_action, params[:vm_name], '--force']
+        v_env.cli(args.compact)
+        {:id => params[:id]}
+      end
+
+      desc "Lists Vagrant environments"
+      get :list do
+        env_glob
+      end
+
+      desc "Halts a Vagrant environment"
+      params do
+        requires :id, :desc => "Vagrant environment id", :type => String, regexp: ENV_REGEX
+        optional :force, :desc => 'Force shut down (equivalent of pulling power)'
+        optional :vm_name, :desc => 'single vm to act on'
+      end
+      post '/halt/:id' do
+        force = params[:force] == true ? '--force' : nil
+        args = [v_action, params[:vm_name], force]
+        v_env.cli(args.compact)
+        {:id => params[:id]}
+      end
+
+      desc "Initializes a Vagrant environment"
+      params do
+        optional :vagrantfile, :desc => "Vagrant environment configuration", :type => String
+      end
+      post :init do
+        machine = env_rand
+        machine_dir = File.join(env_dir, machine)
+        begin
+          Dir.mkdir(machine_dir, 0755)
+        rescue Errno::EEXIST
+          error!({ "error" => "#{machine_dir} already exists!" }, 409)
+        end
+        if params[:vagrantfile].nil?
+          v_env(machine).cli(v_action, box_name, box_url)
+        else
+          File.open(File.join(machine_dir, 'Vagrantfile'), 'w') {|f| f.write(params[:vagrantfile])}
+        end
+        {:id => machine}
+      end
+
+      desc "Provisions a Vagrant environment"
+      params do
+        requires :id, :desc => "Vagrant environment id", :type => String, regexp: ENV_REGEX
+        optional :vm_name, :desc => 'single vm to act on'
+      end
+      post '/provision/:id' do
+        args = [v_action, params[:vm_name]]
+        v_env.cli(args.compact)
+        {:id => params[:id]}
+      end
+
+      desc "Initialize and provision an environment, returns the environment id"
+      params do
+        requires :box_name, :desc => 'Name for box, used to lookup already loaded box', :type => String, :regexp => /^[\w_-]+$/
+        optional :box_url, :desc => 'URL for box location, optional iff \'box_name\' exists', :type => String
+        optional :user_data_script, :desc => 'Script to invoke upon provisioning'
+      end
+      post :create do
+        machine_id = env_rand
+        machine_dir = make_machine_dir(machine_id)
+        addresses = v_file machine_id, machine_dir
+        args = 'up', '--provision'
+        add_task(:id => machine_id, :args => args)
+        {:id => machine_id, :ips => addresses}
+      end
+
+      desc "Initializes a Vagrant environment"
+      params do
+        optional :vagrantfile, :desc => "Vagrant environment configuration", :type => String
+      end
+      post :init do
+        machine_id = env_rand
+        machine_dir = make_machine_dir(machine_id)
+        if params[:vagrantfile].nil?
+          v_env(machine_id).cli(v_action, box_name, box_url)
+        else
+          v_file(machine_id, machine_dir, params[:vagrantfile])
+        end
+        {:id => machine_id}
+      end
+
+      desc "Purges a Vagrant environment"
+      params do
+        requires :id, :desc => "Vagrant environment id", :type => String, regexp: ENV_REGEX
+      end
+      post '/purge/:id' do
+        if v_env.vms.all? {|vm| vm.last.state == 'not_created'}
+          machine_dir = File.join(env_dir, params[:id])
+          FileUtils.remove_entry_secure(machine_dir)
+        else
+          error!({ "error" => "Environment contains undestroyed machines!" }, 409)
+        end
+        {:id => params[:id]}
+      end
+
+      desc "Reloads a Vagrant environment"
+      params do
+        requires :id, :desc => "Vagrant environment id", :type => String, regexp: ENV_REGEX
+        optional :no_provision, :desc => 'disable provisioning'
+        optional :vm_name, :desc => 'single vm to act on'
+      end
+      post '/reload/:id' do
+        provision = params[:no_provision] == true ? '--no-provision' : '--provision'
+        args = [v_action, params[:vm_name], provision]
+        v_env.cli(args.compact)
+        {:id => params[:id]}
+      end
+
+      desc "Resumes a Vagrant environment"
+      params do
+        requires :id, :desc => "Vagrant environment id", :type => String, regexp: ENV_REGEX
+        optional :vm_name, :desc => 'single vm to act on'
+      end
+      post '/resume/:id' do
+        args = [v_action, params[:vm_name]]
+        v_env.cli(args.compact)
+        {:id => params[:id]}
+      end
+
+      desc "Prints the status of a Vagrant environment"
+      params do
+        requires :id, :desc => "Vagrant environment id", :type => String, regexp: ENV_REGEX
+      end
+      get '/status/:id' do
+        state = {}
+        v_env.vms.each do |vm|
+          state[vm.first] = vm.last.state
+        end
+        {:status => state}
+      end
+
+      desc "Suspends a Vagrant environment"
+      params do
+        requires :id, :desc => "Vagrant environment id", :type => String, regexp: ENV_REGEX
+        optional :vm_name, :desc => 'single vm to act on'
+      end
+      post '/suspend/:id' do
+        args = [v_action, params[:vm_name]]
+        v_env.cli(args.compact)
+        {:id => params[:id]}
+      end
+
+      desc "Boots a Vagrant environment"
+      params do
+        requires :id, :desc => "Vagrant environment id", :type => String, regexp: ENV_REGEX
+        optional :no_provision, :desc => 'disable provisioning'
+        optional :vm_name, :desc => 'single vm to act on'
+      end
+      post '/up/:id' do
+        provision = params[:no_provision] == true ? '--no-provision' : '--provision'
+        args = [v_action, params[:vm_name], provision]
+        v_env.cli(args.compact)
+        {:id => params[:id]}
+      end
+
+    end
+
+    resource :vms do
+
+      desc "Lists registered virtual machines"
+      get :registered do
+        out = %x{VBoxManage list vms}
+        {:vms => out.split('\n')}
+      end
+
+      desc "Lists running virtual machines"
+      get :running do
+        out = %x{VBoxManage list runningvms}
+        {:vms => out.split('\n')}
+      end
+
+    end
+  end
+end

data/spec/fragrant/environments_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Fragrant do
+  include Rack::Test::Methods
+
+  def app
+    Fragrant::Frontend
+  end
+
+  describe "GET /environments/list" do
+    it "returns an array of Vagrant environments" do
+      get "/environments/list"
+      last_response.status.should == 200
+      JSON.parse(last_response.body).should be_kind_of(Array)
+    end
+  end
+
+end

data/spec/fragrant/vagrantfile_generator_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'fileutils'
+require 'tempfile'
+
+describe Fragrant::VagrantfileGenerator do
+  before do
+    @original_pwd = Dir.pwd
+    @working_directory = Dir.mktmpdir('fragrant-')
+    Dir.chdir @working_directory
+  end
+
+  after do
+    Dir.chdir @original_pwd
+    FileUtils.rm_rf @working_directory
+  end
+
+  it 'should create a Vagrantfile' do
+    v = Fragrant::VagrantfileGenerator.new(Dir.pwd)
+    v.write
+    File.exist?(File.join(Dir.pwd, 'Vagrantfile')).should be_true
+  end
+
+  describe 'with a provisioning script passed as an option' do
+    before do
+      v = Fragrant::VagrantfileGenerator.new(Dir.pwd)
+      @custom_script = "#!/not/really/bin/bash\nDo this thing!"
+      v.add_script @custom_script
+      v.write
+    end
+
+    it 'should write the provisioning script as a separate file' do
+      File.read(File.join(Dir.pwd, 'script001')).should == @custom_script
+    end
+
+    it 'should refer to the provisioning script in the Vagrantfile' do
+      vagrantfile = File.read(File.join(Dir.pwd, 'Vagrantfile'))
+      vagrantfile.split("\n").grep(/provision.*script001/).should_not be_empty
+    end
+  end
+end

data/spec/fragrant/vms_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Fragrant do
+  include Rack::Test::Methods
+
+  def app
+    Fragrant::Frontend
+  end
+
+  describe "GET /vms/registered" do
+    it "returns an array of registered vms" do
+      get "/vms/registered"
+      last_response.status.should == 200
+      JSON.parse(last_response.body).should be_kind_of(Array)
+    end
+  end
+
+  describe "GET /vms/running" do
+    it "returns an array of running vms" do
+      get "/vms/running"
+      last_response.status.should == 200
+      JSON.parse(last_response.body).should be_kind_of(Array)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
+
+require 'rubygems'
+require 'bundler'
+Bundler.setup :default, :test
+require 'fragrant'
+require 'rack/test'
+require 'fileutils'
+
+RSpec.configure do |config|
+  config.include Rack::Test::Methods
+  config.before do
+    FileUtils.mkdir_p(Fragrant.env_dir)
+  end
+end

data/vendor/grape/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Michael Bleigh and Intridea, Inc.
+
+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.