vagabund 0.0.20

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1a48a7598698d3423b75512abc153f25e8ef0d54
+  data.tar.gz: 4915f37d0d22ced7d22afba5907c0b96477a8f33
+SHA512:
+  metadata.gz: aaa07779e973b03fd0f1ee8b78c1952c68700089a6d84574649c0c2a944d8a24e299b2a927af30a2eea9c27e1f5028173c44ea3e19ba092bbbec0446a2352466
+  data.tar.gz: a949234531ac4aea039f48c0c3e4ed0579ef2d89e1409310a3c4a18d700ff6b168fd212ce56777c082d50bf100e2bc5e6a7984ed6ff0a1b64140ca7670e243d2

data/.gitignore

@@ -0,0 +1,32 @@
+*.gem
+*.rbc
+Gemfile.lock
+.bundle
+.config
+.env
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# Vagrant
+.vagrant
+*/.vagrant
+*.box
+*/*.box
+
+# VIM swap files
+*.swp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+# Test Packages
+packages/

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem "vagrant", :git => "https://github.com/mitchellh/vagrant.git", :tag => "v1.7.2"
+end
+
+group :plugins do
+  gem "vagabund", path: "."
+  gem "vagrant-aws"
+  gem "vagrant-awsinfo"
+end

data/README.md

@@ -0,0 +1,301 @@
+Vagabund
+========
+
+Vagrant plugin providing automatic config management, git operations and the ability to checkout projects and manage services. Adds custom provisioners for "squatting" a machine by temporarily copying config files like your vim and git configs and provisioning a user account, and "settling" a machine by easily installing packages of all types and automatically checking out any projects you plan to work on. There is also the "boxer" component, which makes it easier to package and release custom boxes for different providers.
+
+## Usage
+
+### Squatter
+
+Squatter is a provisioner that copies all your personal config files over to the VM automatically to make it feel more like home.
+
+You can configure the host and guest home directories and override or add to the list of config files to be copied. Any relative paths provided will be relative to the home directories, while absolute paths will be preserved.
+
+Really, this can be used to copy any files/directories from the host to the guest, not just "config files". Wildcard operators are not currently supported, but directories will be copied recursively. You can also provide a remote source in the form of a URL or S3 resource (the AWS CLI will be used to copy the file when using S3), or a `proc`.
+
+The default list of config files includes `~/.vimrc`, `~/.viminfo`, `~/.gitconfig` and `~/.ssh/known_hosts`.
+
+```ruby
+config.vm.provision :squat do |squatter|
+  squatter.host_home = '/Users/markrebec' # the host directory used for relative file paths
+  squatter.guest_home = '/home/vagrant'   # the guest directory used for relatvie file paths
+  
+  squatter.files = ['.vimrc', '.gitconfig', ['file.env', '.env']] # override the default list of files
+  squatter.file = '.filename'                                     # home-relative path
+  squatter.file = '/path/to/.testfile'                            # absolute path
+  squatter.file = ['/host/path/.somefile', '.somefile']           # absolute host path, home-relative guest path
+  squatter.file = ['.somefile', '/guest/path/.somefile']          # home-relative host path, absolute guest path
+  squatter.file = 'http://example.com/source/file'                # remote source file, home-relative guest path based of remote file basename
+  squatter.file = 's3://example-bucket/source/file'               # remote source file, home-relative guest path based of remote file basename
+  squatter.file = ['http://example.com/source/file', '.other']    # remote source file, home-relative guest path
+  squatter.file = proc { ['.source_file', '.target_file'] }       # must return a string or array, result will be interpreted like the above examples
+  squatter.file = [proc { '.source' }, proc { '.target' }]        # must each return a string, results will be interpreted like the above examples
+end
+```
+
+You can also use squatter to provision a new user account on the guest OS. This is particularly useful if you're creating a custom base box and want a user account other than the default `vagrant` user.
+
+It's important to note that the files copied over by squatter are copied by the **current** user, not the user being created here. You can specify the guest home path to match your new user's home directory, but any files copied will be owned by the **current** ssh user.
+
+```ruby
+config.vm.provision :squat do |squatter|
+  # Create a user with the given username
+  squatter.user.username = 'example'                # required
+
+  # Set the home directory for the user
+  squatter.user.home = '/home/example'              # optional
+  
+  # Set the primary group
+  squatter.user.group = 'example'                   # optional
+
+  # Set additional groups
+  squatter.user.groups = ['rvm', 'admins']          # optional
+
+  # Set the public key that should be added to .ssh/authorized_keys
+  # If not specified, the CURRENT user's authorized_keys file is copied over to the new user
+  # Add multiple keys by using an array
+  squatter.user.public_key = '/path/to/key.pub'     # optional. a filepath, string or array of filepaths/strings
+
+  # Add an ssh config file for the user
+  squatter.user.ssh_config = '/path/to/.ssh/config' # optional. a filepath or string
+end
+```
+
+### Settler
+
+Settler is a provisioner that allows you to easily install software packages and checkout projects you'll be working on.
+
+You can invoke the provisioner with the following in your `Vagrantfile`:
+
+```ruby
+config.vm.provision :settle do |settler|
+  # add software packages with settler.package and projects with settler.project
+end
+```
+
+#### Packages
+
+To build and install a software package on the guest OS you add them to your provisioner config:
+
+```ruby
+config.vm.provision :settle do |settler|
+  settler.packages do |packages|
+    # Download, extract and build the package using the built-in procs
+    package 'epubcheck', '3.0.1', url: 'https://github.com/IDPF/epubcheck/releases/download/v3.0.1/epubcheck-3.0.1.zip'
+  
+    # Upload the local package, extract and build it using the built-in procs
+    package 'my_dependency', '0.3.0', local: '/local/path/to/mydependency-0.3.0.tar.gz'
+  end
+  
+  # You can also add a package outside a packages config block
+  settler.package 'my_dependency', '0.3.0', local: '/local/path/to/mydependency-0.3.0.tar.gz'
+end
+```
+
+The supported sources for pulling the package are: `git: GIT_URL`, `local: LOCAL_PATH`, `url: URL`.
+
+You can override the paths where the work is done with a few configuration options, and you can use a block for an advanced configuration DSL:
+
+```ruby
+config.vm.provision :settle do |settler|
+  settler.packages do |packages|
+    package 'my_dependency', '0.3.0', local: '/local/path/to/mydependency-0.3.0.tar.gz' do |package|
+      package.build_root = '/some/local/path'               # the path to which the source package will be pulled (default /tmp)
+      package.build_path = '/another/local/path/my_package' # the path where the package will be built (default build_root/name-version)
+      package.local_package = '/some/local/package.tar.gz'  # the path to the local package file (default based on source filename)
+    end
+  end
+end
+```
+
+There is a built-in extractor that will work for most common file types and a builder and installer that perform simple `./configure && make` and `make install` commands, but you can override these as well as some other key hooks and actions with your own blocks/procs.
+
+```ruby
+config.vm.provision :settle do |settler|
+  settler.packages do |package|
+    package 'mydependency', '0.3.0', local: '/local/path/to/mydependency-0.3.0.tar.gz' do |pkg|
+      # Perform a custom action before provisioning the package
+      before do
+        installed = true # Maybe check something like `which some_binary`
+        
+        # Allows skipping this package if it's already installed
+        skip true if installed
+      end
+      
+      # Custom extractor to extract the pulled package into the build_path
+      extractor do |package, machine, channel|
+        execute "tar xzf #{local_package} /mydependency/src -C #{build_path}"
+      end
+
+      # Perform a custom build and install for the package
+      pkg.builder = proc do |package, machine, channel|
+        execute "cd #{build_path}; make"
+      end
+
+      install_proc = Proc.new do |package, machine, channel|
+        sudo "cp #{build_path}/my_custom_binary /usr/bin"
+      end
+      installer install_proc
+
+      # Or for simple commands, you can pass the command as a string (they will automatically be executed within the build_path)
+      builder "make"
+      installer "cp my_custom_binary /usr/bin", sudo: true
+    end
+  end
+end
+```
+There are a number of DSL methods that allow you to pass additional blocks/procs as package actions or before and after hooks, which will be executed within the context of the package instance:
+
+* `before` - Executed before provisioning the package. Also aliased to `before_package`.
+* `before_pull` - Executed before pulling the package from it's source.
+* `puller` - Override the default behavior for pulling the remote source.
+* `after_pull` - Executed after pulling the package.
+* `before_extract` - Executed before extracting the package.
+* `extractor` - Override the default extractor with your own.
+* `after_extract` - Executed after extracting the package.
+* `before_build` - Executed before building the package.
+* `builder` - Override the default builder with your own.
+* `after_build` - Executed after building the package.
+* `before_install` - Executed before installing the package.
+* `installer` - Override the default installer with your own.
+* `after_install` - Executed after installing the package.
+* `before_clean` - Executed before cleaning up.
+* `cleaner` - Override the default cleaner with your own.
+* `after_clean` - Executed after cleaning up.
+* `after` - Executed after provisioning the package. Also aliased to `after_package`.
+
+These each provide three arguments to the block, which are the package itself, the machine, and the channel (which is a shortcut for `machine.communicate`). However there are additionally a few helper methods available within these blocks to facilitate communication with the machine and input/output:
+
+* Package: `build_root`, `build_path`, `local_package`
+* Communication: `execute`, `sudo`, `test`
+* I/O: `ask`, `detail`, `error`, `info`, `output`, `warn`
+
+#### Projects
+
+To automatically check out and prepare (i.e. run bundler for ruby projects) a project you can add a it to your provisioner config:
+
+```ruby
+config.vm.provision :settle do |settler|
+  settler.projects do |projects|
+    # A simple project, it will only be cloned into a local path
+    project 'my_project', git: 'git@github.com:example/example.git'
+
+    # A ruby or rails project will be bundled after it is cloned
+    project :ruby, 'ruby_project', git: 'git@github.com:example/example.git'
+    project :rails, 'my_app', git: 'git@github.com:example/example.git'
+  end
+  
+  # You can also add a project outside a projects config block
+  settler.project 'my_project', git: 'git@github.com:example/example.git'
+end
+```
+
+For ruby/rails projects your gem dependencies will be automatically installed for you with `bundle install`.
+
+You can configure project paths for all or individual projects.
+
+```ruby
+config.vm.provision :settle do |settler|
+  settler.projects do |projects|
+    # All projects that do not override the path will be cloned into /some/local/path/PROJECT_NAME
+    projects.path = '/some/local/path'
+
+    # Project ends up in /some/local/path/my_project
+    project 'my_project', git: 'git@github.com:example/example.git'
+
+    # Project ends up in /another/path/other_project
+    project 'other_project', git: 'git@github.com:example/example.git', path: '/another/path/other_project'
+
+    # Project ends up in /another/path/third_project
+    project 'third_project', git: 'git@github.com:example/example.git', projects_path: '/another/path'
+  end
+end
+```
+
+All config options (and some additional features) can also be called through the config DSL when passing a block.
+
+```ruby
+config.vm.provision :settle do |settler|
+  settler.projects do |projects|
+    
+    project :ruby, 'my_project', git: 'git@github.com:example/example.git' do |project_config|
+      # Project configuration DSL is available within an optional block
+
+      project_config.path = '/path/to/my_project'
+      
+      # Do something before provisioning the project
+      before do |project, machine, channel|
+        info "Executing some command on the server..."
+        execute "cd #{path}; execute some command on the server"
+      end
+
+      # Do something before pulling the project
+      before_pull(Proc.new { sudo "execute something as root" })
+
+      # Do something after bundling the project
+      after_bundle "execute inline server command"
+    end
+  
+  end
+end
+```
+
+There are a number of DSL methods that allow you to pass additional blocks/procs as before and after hooks, which will be executed within the context of the project instance:
+
+* `before` - Executed before provisioning the project. Also aliased to `before_project`.
+* `before_pull` - Executed before pulling the project from it's source.
+* `puller` - Override the default puller with your own.
+* `after_pull` - Executed after pulling the project.
+* `before_bundle` - Executed before running bundler (ruby/rails projects only).
+* `bundler` - Override the default bundler with your own (ruby/rails projects only).
+* `after_bundle` - Executed after running bundler (ruby/rails projects only).
+* `after` - Executed after provisioning the project. Also aliased to `after_project`.
+
+These each provide three arguments to the block, which are the project itself, the machine, and the channel (which is a shortcut for `machine.communicate`). However there are additionally a few helper methods available within these blocks to facilitate communication with the machine and input/output:
+
+* Project: `path`
+* Communication: `execute`, `sudo`, `test`
+* I/O: `ask`, `detail`, `error`, `info`, `output`, `warn`
+
+### Boxer
+
+#### Requirements
+
+If you plan on using boxer with aws, you'll need the [AWS Command Line Interface](http://aws.amazon.com/cli/) as well as the [vagrant-aws](https://github.com/mitchellh/vagrant-aws) and [vagrant-awsinfo](https://github.com/johntdyer/vagrant-awsinfo) vagrant plugins, which you can install with:
+
+    $ vagrant plugin install vagrant-aws
+    $ vagrant plugin install vagrant-awsinfo
+
+#### Usage
+
+Boxer is a new command for vagrant that wraps up the creation of boxes for VirtualBox and AWS. It uses the built in `vagrant package` to package VirtualBox VMs, and packages AWS instances by creating an AMI and a box that points to that AMI.
+
+You can run boxer on a stopped VM with `vagrant boxer machine --name some-box-name`. Passing in a `machine` is optional, and without one all loaded machines will be boxed. The `--name` flag is also optional, and if not passed the name of the current machine (`default` by default) will be used.
+
+**VirtualBox**
+
+    $ vagrant up --provider virtualbox
+    $ vagrant halt
+    $ vagrant boxer --name mybox-precise64-0.1.0
+    $ vagrant destroy -f
+
+This will leave you with a vagrant box file backed by VirtualBox called `mybox-precise64-0.1.0-virtualbox.box` in the current directory.
+
+**AWS**
+
+    $ vagrant up --provider aws
+    $ vagrant halt
+    $ vagrant boxer --name mybox-precise64-0.1.0
+    $ vagrant destroy -f
+
+This will create an EC2 AMI named `mybox-precise64-0.1.0-aws` and leave you with a vagrant box file backed by AWS and pointing to the new AMI called `mybox-precise64-0.1.0-aws.box` in the current directory.
+
+## Development
+
+Make sure you read the documentation at [http://docs.vagrantup.com/v2/plugins/index.html](http://docs.vagrantup.com/v2/plugins/index.html) to familiarize yourself with basic usage and development practices for vagrant plugins.
+
+**Note:** If you `bundle install` without specifying a `--path` the rubygems version of the `vagrant` binary might override your installed version, even outside of this project's directory.  It is suggested you `bundle install --path ./.bundle` so you can use `bundle exec vagrant` while working on this plugin, but it won't interfere with your installed vagrant.
+
+### Test Box
+
+The default `Vagrantfile` points to the default `hashicorp/precise64` box and uses the VirtualBox provider. You can use any base box you'd like for development and testing, just edit the `Vagrantfile` to point to an available base box (**but do not commit your changes**).

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/Vagrantfile

@@ -0,0 +1,50 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+require 'dotenv'
+Dotenv.load
+
+# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
+VAGRANTFILE_API_VERSION = "2"
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  
+  # Example config for Squatter provisioner
+  config.vm.provision :squat do |squatter|
+    squatter.files = []
+  end
+
+  # Example config for Settler provisioner
+  config.vm.provision :settle do |settler|
+    settler.packages do
+    end
+    settler.projects do
+    end
+  end
+
+  config.ssh.forward_agent = true
+
+  config.vm.define "vagabund-testing", primary: true do |machine|
+    machine.vm.provider "virtualbox" do |vb, override|
+      override.vm.box = "hashicorp/precise64"
+
+      vb.name = "vagabund-testing"
+      vb.memory = 2048
+      vb.cpus = 2
+    end
+
+    #machine.vm.provider :aws do |aws, override|
+    #  override.vm.box = "aws/precise64"
+    #  override.ssh.username = "ubuntu"
+    #  override.ssh.private_key_path = "~/.ssh/id_rsa"
+    #  override.vm.synced_folder "./", "/vagrant", disabled: true
+
+    #  aws.access_key_id = ENV['AWS_ACCESS_KEY_ID']
+    #  aws.secret_access_key = ENV['AWS_SECRET_ACCESS_KEY']
+    #  aws.keypair_name = ENV['AWS_KEYPAIR_NAME']
+
+    #  aws.instance_type = "m1.large"
+    #  aws.tags = {'Name' => 'vagabund-testing'}
+    #end
+  end
+end

data/lib/monkey_patches.rb

@@ -0,0 +1,16 @@
+# Ports over some useful stuff from ActiveSupport for method args
+class Hash
+  def extractable_options?
+    true
+  end
+end
+
+class Array
+  def extract_options!
+    if last.is_a?(Hash) && last.extractable_options?
+      pop
+    else
+      {}
+    end
+  end
+end

data/lib/vagabund/boxer/command.rb

@@ -0,0 +1,202 @@
+require 'tmpdir'
+require 'json'
+
+module Vagabund
+  module Boxer
+    class Command < Vagrant.plugin(2, :command)
+      def self.synopsis
+        "starts, provisions and packages a new vagrant box"
+      end
+
+      def initialize(argv, env)
+        super
+      end
+
+      def execute
+        options = Struct.new(:name)
+        
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant boxer [options] [name]"
+          o.separator ""
+          o.separator "Options:"
+          o.separator ""
+
+          o.on("--box-name NAME", "Name the box (and associated AMI for the aws provider)") do |value|
+            options.name = value
+          end
+        end
+
+        argv = parse_options(opts)
+        return if !argv
+        #raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp if argv.empty?
+
+        with_target_vms(argv) do |machine|
+          box_name = "#{options.name || machine.name}-#{machine.provider_name}"
+          box_file = File.expand_path("./#{box_name}.box")
+          
+          @env.ui.info "==> #{machine.name}: Packaging box for provider #{machine.provider_name}", bold: true
+
+          if box_exists?(box_file)
+            @env.ui.error "The file #{box_file} already exists. Please remove this file or specify a different box name."
+            next
+          end
+          
+          if !created?(machine)
+            @env.ui.warn "==> #{machine.name}: Can't package VM that hasn't been created. Please create it with `vagrant up` and try again.", bold: true
+            next
+          end
+          
+          send "package_#{machine.provider_name.to_s}", machine, box_name
+        end
+
+        0
+      end
+
+      def status(machine)
+        machine.state
+      end
+
+      def created?(machine)
+        status(machine).id != :not_created
+      end
+
+      def stopped?(machine)
+        [:poweroff, :stopped].include?(status(machine).id)
+      end
+      
+      def stopping?(machine)
+        status(machine).id == :stopping
+      end
+
+      def running?(machine)
+        status(machine).id == :running
+      end
+
+      def package_virtualbox(machine, box_name, box_file=nil)
+        box_file ||= File.expand_path("./#{box_name}.box")
+        vm_name = machine.config.vm.get_provider_config(:virtualbox).name
+        
+        if !stopped?(machine)
+          @env.ui.warn "==> #{machine.name}: Can't package running VM. Please stop it with `vagrant halt` and try again.", bold: true
+          exit
+        end
+
+        @env.ui.info "==> #{vm_name}: Packaging VirtualBox VM '#{vm_name}' into #{File.basename(box_file)}", bold: true
+        system "vagrant package --base #{vm_name} --output #{box_file}"
+      end
+
+      def package_aws(machine, box_name, box_file=nil)
+        box_file ||= File.expand_path("./#{box_name}.box")
+          
+        if !stopped?(machine)
+          if stopping?(machine)
+            @env.ui.info "==> #{machine.name}: Waiting for VM to halt...", bold: true
+            instance_id = `vagrant awsinfo -m #{machine.name} -k instance_id`.chomp.split($/).last
+            wait_for_instance_state(instance_id)
+          else
+            @env.ui.warn "==> #{machine.name}: Can't package running VM. Please stop it with `vagrant halt` and try again.", bold: true
+            exit
+          end
+        end
+
+        if aws_image_exists?(box_name)
+          image_id = existing_image_id(box_name)
+          @env.ui.warn "==> #{image_id}: An AMI with the name #{box_name} already exists", bold: true
+          @env.ui.warn "    #{image_id}: Using existing AMI to package the box"
+        else
+          instance_id = `vagrant awsinfo -m #{machine.name} -k instance_id`.chomp.split($/).last
+          @env.ui.info "==> #{instance_id}: Packaging AWS instance into AMI #{box_name}...", bold: true
+          
+          wait_for_instance_state instance_id, 'stopped'
+          image_id = `aws ec2 create-image --instance-id=#{instance_id} --name=#{box_name} --output=text`.chomp
+        end
+
+        @env.ui.info "==> #{image_id}: Creating AMI #{box_name}...", bold: true
+        wait_for_image_state image_id, 'available'
+        @env.ui.info "==> #{image_id}: Packaging AMI '#{box_name}' into #{File.basename(box_file)}", bold: true
+
+        Dir.mktmpdir do |dir|
+          Dir.chdir(dir) do
+            File.write 'Vagrantfile', aws_vagrantfile(image_id, box_name)
+            File.write 'metadata.json', aws_metafile
+            system "tar cf #{box_file} Vagrantfile metadata.json"
+          end
+        end
+      end
+
+      def box_exists?(box_file)
+        File.exists?(box_file)
+      end
+
+      def aws_image_exists?(box_name)
+        !existing_image_id(box_name).nil?
+      end
+
+      def existing_image_id(box_name)
+        ami_json = JSON.parse(`aws ec2 describe-images --filters Name=name,Values=#{box_name}`.chomp)
+        ami_json['Images'].first['ImageId']
+      rescue
+        nil
+      end
+      
+      def wait_for_image_state(image_id, state='available')
+        @env.ui.info "    #{image_id}: Waiting for image to enter state '#{state}'..."
+
+        last_state = nil 
+        while true do
+          ami_json = JSON.parse(`aws ec2 describe-images --owners=self --output=json`.chomp)
+          image = ami_json['Images'].select { |img| img['ImageId'] == image_id }.first
+
+          @env.ui.info "    #{image_id}: Image is in state '#{image['State']}'" if image['State'] != last_state
+
+          last_state = image['State']
+          if image['State'] == 'failed'
+            @env.ui.error "==> #{image_id}: Image Creation Failed!", bold: true
+            @env.ui.error "    #{image_id}: #{image['StateReason']['Message']}"
+            break;
+          elsif image['State'] == state
+            break;
+          end 
+          
+          sleep 5
+        end 
+      end 
+      
+      def wait_for_instance_state(instance_id, state='stopped')
+        # TODO use the machine to check/wait for state instead of `aws`?
+        @env.ui.info "    #{instance_id}: Waiting for instance to enter state '#{state}'..."
+        
+        last_state = nil 
+        while true do
+          instance_state = JSON.parse(`aws ec2 describe-instances --instance-id=#{instance_id} --output=json --query="Reservations[0].Instances[0].State"`.chomp)
+      
+          @env.ui.info "    #{instance_id}: Instance is in state '#{instance_state['Name']}'" if instance_state['Name'] != last_state
+      
+          last_state = instance_state['Name']
+          break if instance_state['Name'] == state
+          
+          sleep 1
+        end 
+      end
+
+      def aws_vagrantfile(image_id, box_name)
+        return <<VAGRANTFILE
+Vagrant.configure("2") do |config|
+  config.vm.provider :aws do |aws, override|
+    aws.ami = "#{image_id}" # #{box_name}
+  end
+end
+VAGRANTFILE
+      end
+
+      def aws_metafile
+        return <<METAFILE
+{
+  "provider": "aws"
+}
+METAFILE
+      end
+
+    end
+  end
+end

data/lib/vagabund/boxer.rb

@@ -0,0 +1,4 @@
+module Vagabund
+  module Boxer
+  end
+end

data/lib/vagabund/settler/config.rb

@@ -0,0 +1,49 @@
+require_relative 'packages/config'
+require_relative 'projects/config'
+
+module Vagabund
+  module Settler
+    class Config < Vagrant.plugin(2, :config)
+      def packages(*args, &block)
+        @packages ||= Packages::Config.new(self, *args)
+        @packages.instance_eval &block if block_given?
+        @packages
+      end
+
+      def packages=(pkgs)
+        raise Vagrant::Errors::VagrantError, :invalid_packages_config unless pkgs.is_a?(Array)
+        @packages = Packages::Config.new(self, pkgs)
+      end
+
+      def add_package(*args, &block)
+        packages.add_package *args, &block
+      end
+      alias_method :package, :add_package
+      alias_method :package=, :add_package
+      
+      def projects(*args, &block)
+        @projects ||= Projects::Config.new(self, *args)
+        @projects.instance_eval &block if block_given?
+        @projects
+      end
+
+      def projects=(prjs)
+        raise Vagrant::Errors::VagrantError, :invalid_projects_config unless prjs.is_a?(Array)
+        @projects = Projects::Config.new(self, prjs)
+      end
+
+      def add_project(*args, &block)
+        projects.add_project *args, &block
+      end
+      alias_method :project, :add_project
+      alias_method :project=, :add_project
+
+      def initialize
+        super
+        Dir['packages/**/*.rb'].each { |package| eval(IO.read(package)) }
+        Dir['projects/**/*.rb'].each { |project| eval(IO.read(project)) }
+      end
+
+    end
+  end
+end