vagrant-brightbox 0.1.0

data/.gitignore

@@ -0,0 +1,15 @@
+# OS-specific
+.DS_Store
+
+# Bundler/Rubygems
+*.gem
+.bundle
+pkg/*
+tags
+Gemfile.lock
+
+# Vagrant
+.vagrant
+Vagrantfile
+manifests/*
+!example_box/Vagrantfile

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+# 0.1.0 (unreleased)
+
+* Exclude the ".vagrant" directory from rsync.
+* Initial release.

data/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+gemspec
+
+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 => "git://github.com/mitchellh/vagrant.git"
+end

data/LICENSE

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright (c) 2013 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,217 @@
+# Vagrant Brightbox Provider
+
+This is a [Vagrant](http://www.vagrantup.com) 1.1+ plugin that adds a [Brightbox](http://brightbox.com/)
+provider to Vagrant, allowing Vagrant to control and provision servers in
+the Brightbox Cloud
+
+**Note:** This plugin requires Vagrant 1.1+,
+
+## Features
+
+* Boot Brightbox Cloud servers.
+* SSH into the servers.
+* Provision the servers with any built-in Vagrant provisioner.
+* Minimal synced folder support via `rsync`.
+* Define region-specific configurations so Vagrant can manage servers
+  in multiple regions.
+
+## Usage
+
+Install using standard Vagrant 1.1+ plugin installation methods. After
+installing, `vagrant up` and specify the `brightbox` provider. An example is
+shown below.
+
+```
+$ vagrant plugin install vagrant-brightbox
+...
+$ vagrant up --provider=brightbox
+...
+```
+
+Of course prior to doing this, you'll need to obtain an Brightbox-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 Brightbox 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 dummy https://github.com/NeilW/vagrant-brightbox/raw/master/dummy.box
+...
+```
+
+And then make a Vagrantfile that looks like the following, filling in
+your information where necessary.
+
+```ruby
+Vagrant.configure("2") do |config|
+  config.vm.box = "dummy"
+
+  config.vm.provider :brightbox do |brightbox|
+    brightbox.client_id = "YOUR API CLIENT ID"
+    brightbox.secret = "YOUR API SECRET"
+    brightbox.ssh_private_key_path = "PATH TO YOUR PRIVATE KEY"
+
+    brightbox.image_id = "img-q6gc8"
+    brightbox.ssh_username = "ubuntu"
+  end
+end
+```
+
+And then run `vagrant up --provider=brightbox`.
+
+This will start an Ubuntu 12.04 server in the gb1 region within
+your account. And assuming your SSH information was filled in properly
+within your Vagrantfile, SSH and provisioning will work as well.
+
+Note that normally a lot of this boilerplate is encoded within the box
+file, but the box file used for the quick start, the "dummy" box, has
+no preconfigured defaults.
+
+Instead of having to add our client credentials to each Vagrantfile
+we can put them in the Fog configuration file. Create a new
+file at `~/.fog` and add the following:
+
+```
+:default:
+  :brightbox_client_id: "your_api_client_id"
+  :brightbox_secret: "your_secret"
+```
+
+## Box Format
+
+Every provider in Vagrant must introduce a custom box format. This
+provider introduces `brightbox` boxes. You can view an example box in
+the [example_box/ directory](https://github.com/NeilW/vagrant-brightbox/tree/master/example_box).
+That directory also contains instructions on how to build a box.
+
+The box format is basically just the required `metadata.json` file
+along with a `Vagrantfile` that does default settings for the
+provider-specific configuration for this provider.
+
+## Configuration
+
+This provider exposes quite a few provider-specific configuration options:
+
+* `client_id` - The api access key for accessing Brightbox in the form 'cli-xxxxx'
+* `secret` - The api secret access code for accessing Brightbox
+* `image_id` - The image id to boot, in the form 'img-xxxxx'
+* `zone` - The zone within the region to launch
+  the server. If nil, it will use the default for this account. 
+* `server_type` - The type of server, such as "nano"
+* `region` - The region to start the server in, such as "gb1"
+* `ssh_private_key_path` - The path to the SSH private key. This overrides
+  `config.ssh.private_key_path`.
+* `ssh_username` - The SSH username, which overrides `config.ssh.username`.
+* `security_groups` - An array of security groups for the server.
+
+If you are the collaborator on a number of accounts you can specify which one you want by setting the following options:
+
+* `username` - User id in the form 'usr-xxxxx'
+* `password` - The password for the user id
+* `account` - Create servers in the context of this account - in the form 'acc-xxxxx'
+
+These can be set like typical provider-specific configuration:
+
+```ruby
+Vagrant.configure("2") do |config|
+  # ... other stuff
+
+  config.vm.provider :brightbox do |brightbox|
+    brightbox.client_id = "cli-fooxx"
+    brightbox.secret = "barfoobarfoobar"
+  end
+end
+```
+
+In addition to the above top-level configs, you can use the `region_config`
+method to specify region-specific overrides within your Vagrantfile. Note
+that the top-level `region` config must always be specified to choose which
+region you want to actually use, however. This looks like this:
+
+```ruby
+Vagrant.configure("2") do |config|
+  # ... other stuff
+
+  config.vm.provider :brightbox do |brightbox|
+    brightbox.client_id = "foo"
+    brightbox.secret = "bar"
+    brightbox.region = "gb1"
+
+    # Simply region config
+    brightbox.region_config "gb1", :image_id => "img-mvunm"
+
+    # More comprehensive region config
+    brightbox.region_config "gb1" do |region|
+      region.image_id = "img-mvunm"
+    end
+  end
+end
+```
+
+The region-specific configurations will override the top-level
+configurations when that region is used. They otherwise inherit
+the top-level configurations, as you would probably expect.
+
+## Networks
+
+By default each brightbox is created and mapped to a cloud ip so that
+you can access it over the public network.
+
+However this can exhaust your allocation of cloud ips if you have several servers. Therefore a couple of networking options are supported.
+
+```ruby
+  # Switch off cloud ip mapping and access servers over the IPv4 private
+  # network - useful if you are running Vagrant from another cloud server.
+  config.vm.network :private_network
+
+  # Switch off cloud ip mapping and access servers over IPv6.
+  config.vm.network :public_network, ipv6: true
+```
+
+## Synced Folders
+
+There is minimal support for synced folders. Upon `vagrant up`,
+`vagrant reload`, and `vagrant provision`, the Brightbox provider will use
+`rsync` (if available) to uni-directionally sync the folder to
+the remote machine over SSH.
+
+This is good enough for all built-in Vagrant provisioners (shell,
+chef, and puppet) to work!
+
+## Development
+
+To work on the `vagrant-brightbox` 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)
+that uses it:
+
+```ruby
+Vagrant.require_plugin "vagrant-brightbox"
+
+Vagrant.configure("2") do |config|
+  #Config here
+end
+```
+
+and then use bundler to execute Vagrant:
+
+```
+$ bundle exec vagrant up --provider=brightbox
+```

data/Rakefile

@@ -0,0 +1,21 @@
+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
+
+# Default task is to run the unit tests
+task :default => "spec"

data/Vagrantfile.example

@@ -0,0 +1,105 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant.require_plugin "vagrant-brightbox"
+
+Vagrant.configure("2") do |config|
+  config.vm.box = "dummy"
+
+  config.vm.provider "brightbox" do |brightbox|
+    brightbox.client_id = "cli-xxxxx"
+    brightbox.secret = "abc123"
+    brightbox.ssh_username = "ubuntu"
+    brightbox.ssh_private_key_path = "/home/here/.ssh/id_rsa"
+    brightbox.image_id = "img-77j4h"
+    #brightbox.auth_url = "https://api.gb1.brightbox.com"
+    #brightbox.api_url = brightbox.auth_url
+    #brightbox.region = "gb1"
+  end
+
+  # By default the Brightbox provider maps a cloud ip to each server
+  # created and accesses the server over the public IPv4 network. This
+  # may cause your allocation to be exhausted. Therefore there are a couple
+  # of options.
+  #
+  # Switch off cloud ip allocation and access over the private IPv4
+  # network. Useful if Vagrant is running on another cloud server in the
+  # same region.
+  #
+  # config.vm.network :private_network
+  #
+  # Switch off cloud ip allocation and access over the public IPv6 network
+  #
+  # config.vm.network :public_network, ipv6: true
+
+  config.vm.provision :shell do |s|
+    s.inline=<<-END
+    apt-get install -y -V puppet
+    END
+  end
+  
+
+  # Enable provisioning with Puppet stand alone.  Puppet manifests
+  # are contained in a directory path relative to this Vagrantfile.
+  # You will need to create the manifests directory and a manifest in
+  # the file base.pp in the manifests_path directory.
+  #
+  # An example Puppet manifest to provision the message of the day:
+  #
+  # # group { "puppet":
+  # #   ensure => "present",
+  # # }
+  # #
+  # # File { owner => 0, group => 0, mode => 0644 }
+  # #
+  # # file { '/etc/motd':
+  # #   content => "Welcome to your Vagrant-built virtual machine!
+  # #               Managed by Puppet.\n"
+  # # }
+  #
+  # config.vm.provision :puppet do |puppet|
+  #   puppet.manifests_path = "manifests"
+  #   puppet.manifest_file  = "base.pp"
+  # end
+
+  # Won't work without puppet installed on the image.
+  config.vm.provision :puppet
+
+  # Enable provisioning with chef solo, specifying a cookbooks path, roles
+  # path, and data_bags path (all relative to this Vagrantfile), and adding
+  # some recipes and/or roles.
+  #
+  # config.vm.provision :chef_solo do |chef|
+  #   chef.cookbooks_path = "../my-recipes/cookbooks"
+  #   chef.roles_path = "../my-recipes/roles"
+  #   chef.data_bags_path = "../my-recipes/data_bags"
+  #   chef.add_recipe "mysql"
+  #   chef.add_role "web"
+  #
+  #   # You may also specify custom JSON attributes:
+  #   chef.json = { :mysql_password => "foo" }
+  # end
+
+  # Enable provisioning with chef server, specifying the chef server URL,
+  # and the path to the validation key (relative to this Vagrantfile).
+  #
+  # The Opscode Platform uses HTTPS. Substitute your organization for
+  # ORGNAME in the URL and validation key.
+  #
+  # If you have your own Chef Server, use the appropriate URL, which may be
+  # HTTP instead of HTTPS depending on your configuration. Also change the
+  # validation key to validation.pem.
+  #
+  # config.vm.provision :chef_client do |chef|
+  #   chef.chef_server_url = "https://api.opscode.com/organizations/ORGNAME"
+  #   chef.validation_key_path = "ORGNAME-validator.pem"
+  # end
+  #
+  # If you're using the Opscode platform, your validator client is
+  # ORGNAME-validator, replacing ORGNAME with your organization name.
+  #
+  # If you have your own Chef Server, the default validation client name is
+  # chef-validator, unless you changed the configuration.
+  #
+  #   chef.validation_client_name = "ORGNAME-validator"
+end

data/example_box/README.md

@@ -0,0 +1,9 @@
+# Vagrant Brightbox Cloud Example Box
+
+Vagrant providers each require a custom provider-specific box format.
+This folder shows the example contents of a box for the `brightbox` provider.
+To turn this into a box:
+
+```
+$ tar cvzf bright.box ./metadata.json
+```

data/example_box/metadata.json

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

data/lib/vagrant-brightbox/action/connect_brightbox.rb

@@ -0,0 +1,53 @@
+require "fog"
+require "log4r"
+
+module VagrantPlugins
+  module Brightbox
+    module Action
+      # This action connects to Brightbox, verifies credentials work, and
+      # puts the Brightbox connection object into the `:brightbox_compute` key
+      # in the environment.
+      class ConnectBrightbox
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_brightbox::action::connect_brightbox")
+        end
+
+        def call(env)
+          # Get the region we're going to booting up in
+          region = env[:machine].provider_config.region
+
+          # Get the configs
+          region_config     = env[:machine].provider_config.get_region_config(region)
+          client_id     = region_config.client_id
+	  client_secret = region_config.secret
+	  username      = region_config.username
+	  password      = region_config.password
+	  account       = region_config.account
+	  auth_url      = region_config.auth_url
+	  api_url       = region_config.api_url
+
+          @logger.info("Connecting to Brightbox...")
+	  @logger.info("Fog credentials are: #{Fog.credentials.inspect}")
+	  fog_options={
+            :provider => :brightbox,
+	    :brightbox_auth_url => auth_url,
+	    :brightbox_api_url => api_url,
+	    :brightbox_client_id => client_id,
+	    :brightbox_secret => client_secret,
+	    :brightbox_username => username,
+	    :brightbox_password => password,
+	    :brightbox_account => account,
+          }
+	  fog_options.delete_if {|k, v| v.nil? }
+	  @logger.info("Fog compute options are: #{fog_options.inspect}")
+          env[:brightbox_compute] = Fog::Compute.new(fog_options)
+
+          @app.call(env)
+	rescue ArgumentError => e
+	  raise Errors::FogError, :message => e.message
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-brightbox/action/create_server.rb

@@ -0,0 +1,137 @@
+require "log4r"
+
+require 'vagrant/util/retryable'
+
+require 'vagrant-brightbox/util/timer'
+
+module VagrantPlugins
+  module Brightbox
+    module Action
+      # This creates the Brightbox Server
+      class CreateServer
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_brightbox::action::create_server")
+        end
+
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          # Get the region we're going to booting up in
+          region = env[:machine].provider_config.region
+
+          # Get the configs
+          region_config      = env[:machine].provider_config.get_region_config(region)
+          image_id         = region_config.image_id
+          zone             = region_config.zone
+          server_name      = region_config.server_name
+          server_type      = region_config.server_type
+          server_groups    = region_config.server_groups
+
+          # Launch!
+          env[:ui].info(I18n.t("vagrant_brightbox.launching_server"))
+          env[:ui].info(" -- Type: #{server_type}") if server_type
+          env[:ui].info(" -- Image: #{image_id}") if image_id
+          env[:ui].info(" -- Region: #{region}")
+	  env[:ui].info(" -- Name: #{server_name}") if server_name
+          env[:ui].info(" -- Zone: #{zone}") if zone
+          env[:ui].info(" -- Server Groups: #{server_groups.inspect}") if !server_groups.empty?
+
+          begin
+            options = {
+              :image_id           => image_id,
+	      :name		  => server_name,
+              :flavor_id          => server_type,
+              :zone_id 		  => zone
+            }
+
+            if !server_groups.empty?
+              options[:server_groups] = server_groups
+            end
+
+            server = env[:brightbox_compute].servers.create(options)
+          rescue Excon::Errors::HTTPStatusError => e
+            raise Errors::FogError, :message => e.response
+          end
+
+          # Immediately save the ID since it is created at this point.
+          env[:machine].id = server.id
+
+          # Wait for the server to build
+          env[:metrics]["server_build_time"] = Util::Timer.time do
+            env[:ui].info(I18n.t("vagrant_brightbox.waiting_for_build"))
+            retryable(:on => Fog::Errors::TimeoutError, :tries => 30) do
+              # If we're interrupted don't worry about waiting
+              next if env[:interrupted]
+
+              # Wait for the server to be ready
+              server.wait_for(2) { ready? }
+            end
+          end
+
+          @logger.info("Time for server to build: #{env[:metrics]["server_build_time"]}")
+
+          if !env[:interrupted]
+	    @app.call(env)
+            env[:metrics]["instance_ssh_time"] = Util::Timer.time do
+              # Wait for SSH to be ready.
+              env[:ui].info(I18n.t("vagrant_brightbox.waiting_for_ssh"))
+              while true
+                # If we're interrupted then just back out
+                break if env[:interrupted]
+                break if ready?(env[:machine])
+                sleep 2
+              end
+            end
+
+            @logger.info("Time for SSH ready: #{env[:metrics]["instance_ssh_time"]}")
+
+            # Ready and booted!
+            env[:ui].info(I18n.t("vagrant_brightbox.ready"))
+          end
+
+          # Terminate the instance if we were interrupted
+          terminate(env) if env[:interrupted]
+
+        end
+
+	# Check if machine is ready, trapping only non-fatal errors
+	def ready?(machine)
+	  @logger.info("Checking if SSH is ready or is permanently broken...")
+	  @logger.info("Connecting as '#{machine.ssh_info[:username]}'") if machine.ssh_info[:username]
+	  # Yes this is cheating.
+	  machine.communicate.send(:connect)
+	  @logger.info("SSH is ready")
+	  true
+	# Fatal errors
+	rescue Vagrant::Errors::SSHAuthenticationFailed
+	  raise
+	# Transient errors
+	rescue Vagrant::Errors::VagrantError => e
+	  @logger.info("SSH not up: #{e.inspect}")
+	  return false
+	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-brightbox/action/delete_server.rb

@@ -0,0 +1,26 @@
+require "log4r"
+
+module VagrantPlugins
+  module Brightbox
+    module Action
+      # This terminates the running server
+      class DeleteServer
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_brightbox::action::delete_server")
+        end
+
+        def call(env)
+          server = env[:brightbox_compute].servers.get(env[:machine].id)
+
+          # Destroy the server and remove the tracking ID
+          env[:ui].info(I18n.t("vagrant_brightbox.deleting_server"))
+          server.destroy
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-brightbox/action/forced_halt.rb

@@ -0,0 +1,27 @@
+require "log4r"
+
+module VagrantPlugins
+  module Brightbox
+    module Action
+      # This halts the running server via the api
+      class ForcedHalt
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_brightbox::action::forced_halt")
+        end
+
+        def call(env)
+          server = env[:brightbox_compute].servers.get(env[:machine].id)
+
+	  if server.ready?
+	    # Stop the server.
+	    env[:ui].info(I18n.t("vagrant_brightbox.stopping_server"))
+	    server.stop
+	  end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module Brightbox
+    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].state.id != :not_created
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-brightbox/action/is_running.rb

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