migrant-boxes 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+script/*

data/.rspec

@@ -0,0 +1 @@
+--colour

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in migrant.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,14 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/migrant/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+
+guard 'cucumber' do
+  watch(%r{^features/.+\.feature$})
+  watch(%r{^features/support/.+$})          { 'features' }
+  watch(%r{^features/step_definitions/(.+)_steps\.rb$}) { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'features' }
+end

data/README.markdown

@@ -0,0 +1,182 @@
+Migrant
+=======
+
+Migrant is a tool to take your Vagrant boxes to the 'cloud'.
+
+Migrant is designed to be a simple, focused tool to take boxes that are
+working locally with Vagrant and deploy them remotely. Migrant reads
+most configuration and provisioning information from Vagrant's 
+configuration files and then applies the same approach to remote 'cloud'
+servers.
+
+Installation
+------------
+
+```
+  $ gem install migrant-boxes
+```
+
+Or in a `Gemfile`:
+
+```ruby
+  gem 'migrant-boxes'
+```
+
+Examples
+========
+
+For single box configurations, the minimum that needs to be specified
+are provider access credentials and the location of the SSH keys to use
+to access the box.
+
+Minimal AWS Configuration
+-------------------------
+
+This sets up a 'micro' sized aws box.
+
+```ruby
+Configuration.for('migrant') {
+  provider {
+    name       'aws'
+    access_key ENV['AWS_ACCESS_KEY']
+    secret_key ENV['AWS_SECRET_KEY']
+  }
+  ssh {
+    public_key '~/.ssh/id_rsa.pub'
+    private_key '~/.ssh/id_rsa'
+  }
+}
+```
+
+Minimal Rackspace Configuration
+-------------------------------
+
+This sets up an instance with 256MB ram
+
+```ruby
+Configuration.for('migrant') {
+  provider {
+    name      'rackspace'
+    user_name ENV['RACKSPACE_ACCESS_KEY']
+    api_key   ENV['AWS_SECRET_KEY']
+  }
+  ssh {
+    public_key '~/.ssh/id_rsa.pub'
+    private_key '~/.ssh/id_rsa'
+  }
+}
+```
+
+This will create the smallest possible server instance and run the provisioners
+that are defined in the Vagrantfile.  It will use your ssh keys to
+access the box, and write some state information about instances to 
+`config/migrant.yml`
+
+Migrant is highly opinionated: it will use the latest LTS Ubuntu
+release. It will also download and install Ruby 1.9 from source in
+`/usr/local`.
+
+Customizing AWS instances
+-------------------------
+
+It's also possible to specify the size of the box and the AMI to use
+when provisioning. Keep in mind that as of right now all the
+bootstrapping and provisioning code is designed to work with recent
+flavors of Ubuntu.
+
+```ruby
+
+Configuration.for('migrant') {
+  provider {
+    name       'aws'
+    access_key ENV['AWS_ACCESS_KEY']
+    secret_key ENV['AWS_SECRET_KEY']
+    ip_address '1.2.3.4'             # <-- Elastic IP address
+    flavor     'c1.medium'           # <-- Any instance size
+    image_id   'ami-81b275e8'        # <-- AMI ID to use (Lucid 32-bit)
+  }
+  ssh {
+    public_key '~/.ssh/id_rsa.pub'
+    private_key '~/.ssh/id_rsa'
+  }
+}
+```
+Customizing Rackspace Instances
+-------------------------------
+
+It's also possible to customize the server size with Rackspace.
+
+```ruby
+Configuration.for('migrant') {
+  provider {
+    name      'rackspace'
+    user_name ENV['RACKSPACE_ACCESS_KEY']
+    api_key   ENV['AWS_SECRET_KEY']
+    flavor_id 3 # <-- 1GB Server
+  }
+  ssh {
+    public_key '~/.ssh/id_rsa.pub'
+    private_key '~/.ssh/id_rsa'
+  }
+}
+```
+
+Configuring Multiple Environments
+---------------------------------
+
+Most deployments have at least a staging and a production environment.
+Migrant supports an arbitrary number of named environments.
+
+```ruby
+Configuration.for('migrant') {
+  provider {
+    name      'rackspace'
+    user_name ENV['RACKSPACE_ACCESS_KEY']
+    api_key   ENV['AWS_SECRET_KEY']
+  }
+  ssh {
+    public_key '~/.ssh/id_rsa.pub'
+    private_key '~/.ssh/id_rsa'
+  }
+
+  # Production environment settings. Defaults are inherited from above
+  production {
+    provider {
+      flavor_id 3  # <-- 1GB Server
+    }
+  }
+
+  # Staging environment settings. Defaults are inherited from above
+  staging {
+    provider {
+      flavor_id 1  # <-- 256MB Server
+    }
+  }
+}
+```
+
+Usage
+=====
+```
+  $ gem install migrant
+  $ migrant init
+  $ migrant up
+```
+
+For a box in a particular 'environment':
+
+```
+  $ migrant production up
+  $ migrant staging up
+  $ migrant staging destroy
+```
+
+Gotchas
+=======
+
+* Bootstrapping and provisioning only tested on Ubuntu 'Lucid Lynx'
+* Chef-Solo provisioner the only one implemented
+* Currently does not support multi-vm configurations. Eventually would
+  be nice to support load-balanced configurations, and have some ability
+  to start or stop any instances necessary to implement that
+  configuration (like PoolParty).

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+require 'cucumber/rake/task'
+
+RSpec::Core::RakeTask.new(:spec)
+Cucumber::Rake::Task.new
+
+task :default => :spec
+

data/bin/.gitignore

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application '.gitignore' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('vagrant', '.gitignore')

data/bin/migrant

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+require 'migrant'
+require 'migrant/cli'
+
+# Start the command line interface and let it process the commands
+Migrant::CLI.start
+

data/features/basic_configuration.feature

@@ -0,0 +1,47 @@
+Feature: Basic Configuration
+  In order to use Migrant to provision boxes remotely
+  I need to configure some minimal information
+
+  Scenario: Basic AWS Configuration
+    Given a Migrantfile with the body
+      """
+      Configuration.for('migrant') {
+        provider {
+          name       'aws'
+          access_key 'my_access_key'
+          secret_key 'my_secret_key'
+        }
+        ssh {
+          public_key '~/.ssh/id_rsa.pub'
+          private_key '~/.ssh/id_rsa'
+        }
+      }
+      """
+    Then the cloud should be "aws"
+    And my AWS access key should be "my_access_key"
+    And my AWS secret key should be "my_secret_key"
+    And my ssh public key should reside at "~/.ssh/id_rsa.pub"
+    And my ssh private key should reside at "~/.ssh/id_rsa"
+    And my AWS instance ID should be "t1.micro"
+    And my AWS AMI should be "Ubuntu Lucid Lynx" for the architecture "AMD64"
+
+  Scenario: Basic Rackspace Configuration
+    Given a Migrantfile with the body
+      """
+      Configuration.for('migrant') {
+        provider {
+          name      'rackspace'
+          user_name 'my_user_name'
+          api_key   'my_api_key'
+        }
+        ssh {
+          public_key '~/.ssh/id_rsa.pub'
+          private_key '~/.ssh/id_rsa'
+        }
+      }
+      """
+    Then the cloud should be "rackspace"
+    And my rackspace username should be "my_user_name"
+    And my rackspace api key should be "my_api_key"
+    And my image should be "Ubuntu Lucid Lynx"
+    And my flavor should be "256 MB Server"

data/features/step_definitions/configuration_steps.rb

@@ -0,0 +1,60 @@
+require 'tempfile'
+require 'configuration'
+require 'pry'
+require 'migrant'
+
+Given /^a Migrantfile with the body$/ do |migrantfile_body|
+  tmpfile = Tempfile.open('migrant-config') do |f|
+    f.write migrantfile_body
+    f
+  end
+  Kernel.load(tmpfile.path)
+  @config = Configuration.for('migrant')
+  @environment = Migrant::Environment.new(nil,@config)
+end
+
+Then /^the cloud should be "([^"]*)"$/ do |cloud_provider_name|
+  # Make sure the environment is set up the right way
+  @environment.cloud.class.should == Migrant::Clouds::Base.registered(cloud_provider_name)
+end
+
+Then /^my AWS access key should be "([^"]*)"$/ do |arg1|
+  @config.provider.access_key.should == arg1
+end
+
+Then /^my AWS secret key should be "([^"]*)"$/ do |arg1|
+  @config.provider.secret_key.should == arg1
+end
+
+Then /^my ssh public key should reside at "([^"]*)"$/ do |arg1|
+  @config.ssh.public_key.should == arg1
+end
+
+Then /^my ssh private key should reside at "([^"]*)"$/ do |arg1|
+  @config.ssh.private_key.should == arg1
+end
+
+Then /^my AWS instance ID should be "([^"]*)"$/ do |arg1|
+  pending # express the regexp above with the code you wish you had
+end
+
+Then /^my AWS AMI should be "([^"]*)" for the architecture "([^"]*)"$/ do |arg1, arg2|
+  pending # express the regexp above with the code you wish you had
+end
+
+Then /^my rackspace username should be "([^"]*)"$/ do |arg1|
+  @config.provider.user_name.should == arg1
+end
+
+Then /^my rackspace api key should be "([^"]*)"$/ do |arg1|
+  @config.provider.api_key.should == arg1
+end
+
+Then /^my image should be "([^"]*)"$/ do |arg1|
+  pending # express the regexp above with the code you wish you had
+end
+
+Then /^my flavor should be "([^"]*)"$/ do |arg1|
+  pending # express the regexp above with the code you wish you had
+end
+

data/features/support/env.rb

@@ -0,0 +1,2 @@
+require 'fog'
+Fog.mock! # Make things run faster and try not to provision any real cloud resources

data/lib/migrant/bootstrappers/base.rb

@@ -0,0 +1,38 @@
+module Migrant
+  module Bootstrappers
+    # Base class for all boostrappers.
+    class Base
+
+      def self.register(shortcut)
+        @@bootstrappers ||= Hash.new
+        @@bootstrappers[shortcut] = self
+      end
+
+      def self.registered(shortcut)
+        @@bootstrappers[shortcut]
+      end
+      
+      def self.default_bootstrapper
+        @@default = self
+      end
+
+      def self.default
+        @@default
+      end
+      
+      def initialize(env)
+        @environment = env
+      end
+
+      # Run the bootstrapping process
+      def run
+        raise "Invalid Bootstrapper"
+      end
+
+      # Returns true if the box is already bootstrapped
+      def bootstrapped?
+        raise "Invalid Bootstrapper"
+      end
+    end
+  end
+end

data/lib/migrant/bootstrappers/ruby_local_192.rb

@@ -0,0 +1,33 @@
+module Migrant
+  module Bootstrappers
+    # Installs Ruby 1.9.2 into /usr/local
+    class RubyLocal192 < Base
+      register(:rbenv_192)
+      default_bootstrapper
+
+      def initialize(env)
+        super
+      end
+
+      def run
+        commands = [
+          'sudo apt-get update',
+          'sudo apt-get install -y build-essential wget build-essential bison openssl libreadline5 libreadline-dev ' +
+          'curl git-core zlib1g zlib1g-dev libssl-dev vim libsqlite3-0 libsqlite3-dev ' +
+          'sqlite3 libreadline-dev libxml2-dev autoconf',
+          'rm -rf /tmp/ruby-build',
+          'git clone git://github.com/theaboutbox/ruby-build.git /tmp/ruby-build',
+          'cd /tmp/ruby-build && sudo ./install.sh',
+          'sudo ruby-build 1.9.2-p290 /usr/local',
+          'sudo gem install bundler chef'
+        ]
+        @environment.cloud.execute commands
+      end
+
+      def bootstrapped?
+        result = @environment.server.ssh('/usr/local/bin/chef-solo --version')
+        result[0].status == 0
+      end
+    end
+  end
+end

data/lib/migrant/bootstrappers.rb

@@ -0,0 +1,2 @@
+require 'migrant/bootstrappers/base'
+require 'migrant/bootstrappers/ruby_local_192'

data/lib/migrant/boxes.rb

@@ -0,0 +1,55 @@
+module Migrant
+  # Represents a box managed by Migrant. We save this object in YAML format
+  # so that subsequent runs of Migrant can find them.
+  class Box
+    attr_accessor :provider
+    attr_accessor :id
+    attr_accessor :name
+
+    def initialize(box_provider=nil,box_id=nil,box_name=nil)
+      @id = box_id
+      @provider = box_provider
+      @name = box_name
+    end
+  end
+
+  # Loads and persists information about the boxes managed by this
+  # migrant configuration
+  class Boxes
+    # Returns an Boxes instance
+    def load
+      @boxes = YAML.load(File.read(@path)) if File.exists?(@path)
+      self
+    end
+
+    def initialize(path)
+      @path = path
+      @boxes = {}
+      @boxes['file_version'] = Migrant::VERSION
+      @boxes['boxes'] = Hash.new
+      load
+    end
+
+    def save()
+      File.open(@path,'w') do |f|
+        f.write(YAML.dump(@boxes))
+      end
+    end
+
+    def [](environment)
+      environment = 'default' if environment.nil?
+      @boxes['boxes'][environment]
+    end
+
+    def []=(environment,box)
+      environment = 'default' if environment.nil?
+      @boxes['boxes'][environment] = box
+    end
+
+    def add(environment,provider,id)
+      environment = 'default' if environment.nil?
+      box = Box.new(provider,id)
+      self[environment] = box
+    end
+  end
+end

data/lib/migrant/cli.rb

@@ -0,0 +1,39 @@
+require 'thor'
+require 'pp'
+module Migrant
+  class CLI < Thor
+    desc 'init', 'Creates a Migrantfile with basic information'
+    def init
+
+    end
+
+    desc 'up', 'Starts the environment based on the information in the Migrantfile'
+    method_option :environment, :aliases => '-e', :desc => 'Specify an environment to launch boxes'
+    def up
+      load_config(options.environment)
+      @environment.up
+    end
+
+    desc 'destroy','Shut down the servers based on the information in this Migrantfile'
+    method_option :environment, :aliases => '-e', :desc => 'Specify an environment to destroy boxes'
+    def destroy
+      load_config(options.environment)
+      @environment.destroy
+    end
+
+    desc 'info','Describe any currently running instances'
+    method_option :environment, :aliases => '-e', :desc => 'Specify an environment to destroy boxes'
+    def info
+      load_config(options.environment)
+      @environment.info
+    end
+
+    no_tasks do
+      def load_config(environment_name)
+        @environment = Environment.new(environment_name)
+      end
+
+    end
+  end
+end
+

data/lib/migrant/clouds/aws.rb

@@ -0,0 +1,28 @@
+module Migrant
+  module Clouds
+    class AWS < Base
+      register 'aws'
+
+      def initialize(env)
+        super
+        @server_def[:username] = 'ubuntu'
+        @server_def[:groups] = ['d2-server']
+        
+      end
+
+      def connect
+        @connection = Fog::Compute.new(:provider => 'AWS',
+                                       :aws_access_key_id => @environment.setting('provider.access_key'),
+                                       :aws_secret_access_key => @environment.setting('provider.secret_key'))
+      end
+
+      def log_server_info
+        super
+        @environment.ui.notice "  Flavor:     #{@environment.server.flavor.name}"
+        @environment.ui.notice "DNS Name:     #{@environment.server.dns_name}"
+        @environment.ui.notice "    Zone:     #{@environment.server.availability_zone}"
+      end
+
+    end
+  end
+end

data/lib/migrant/clouds/base.rb

@@ -0,0 +1,100 @@
+require 'fog'
+require 'pry'
+module Migrant
+  module Clouds
+    
+    # Base class for cloud service providers.
+    # All service providers use Fog to handle bootstrapping servers and running stuff
+    # Cloud service providers are responsible for starting up the server, setting up ssh
+    # access with the provided keypair, and (eventually) disabling the root user.
+    class Base
+      
+      # Register a provider
+      def self.register(shortcut)
+        @@clouds ||= {}
+        @@clouds[shortcut] = self
+      end
+
+      # Get a registered provider
+      def self.registered(shortcut)
+        @@clouds[shortcut]
+      end
+
+      def initialize(env)
+        @environment = env
+        @server_def = {:private_key_path => @environment.setting('ssh.private_key'),
+          :public_key_path => @environment.setting('ssh.public_key')}
+        flavor_id = @environment.setting('provider.flavor_id')
+        @server_def[:flavor_id] = flavor_id unless flavor_id.nil?
+        image_id = @environment.setting('provider.image_id')
+        @server_def[:image_id] = image_id unless image_id.nil?
+      end
+
+      attr_accessor :connection
+
+      def connect
+        raise "Invalid Action for Base Class"
+      end
+
+      def bootstrap_server
+        @environment.ui.info "Launching Server..."
+        @environment.server = @connection.servers.bootstrap(@server_def)
+        @environment.ui.notice "Server Launched!"
+        ip_address = @environment.setting('provider.ip_address')
+        unless ip_address.nil?
+          @connection.associate_address(@environment.server.id,ip_address)
+        end
+        log_server_info
+      end
+
+      def log_server_info
+        @environment.ui.notice "  ID:         #{@environment.server.id}"
+      end
+
+      # Set up connection information for a server and set up SSH keypair access
+      #
+      # box   -   Migrant::Box object with information about the server to connect to
+      #
+      # Does not return anything but sets up @environment.server
+      def connect_to_server(box)
+        @environment.ui.notice "Connecting to #{box.provider.to_s} server: #{box.id}"
+        @environment.server = @connection.servers.get(box.id)
+        if (@environment.server.nil?)
+          @environment.ui.error "Cannot connect to server!"
+          raise "Cannot find server"
+        end
+        @environment.server.merge_attributes(@server_def)
+      end
+
+      def execute(commands)
+        server = @environment.server
+        commands.each do |cmd|
+          @environment.ui.info("$ #{cmd}")
+          result = server.ssh cmd
+          if (result[0].status != 0)
+            @environment.ui.info(result[0].stdout)
+            @environment.ui.error "Error executing command: #{cmd}\n#{result.inspect}"
+            raise "Remote Script Error"
+          end
+          @environment.ui.info(result[0].stdout)
+          @environment.ui.warn(result[0].stderr) if result[0].stderr
+        end
+      end
+
+      # Asks the user if they want to shut down a box
+      # 
+      # box - A Migrant::Box with information about the box
+      #
+      # returns true if the user decided to shut down the box
+      def destroy(box)
+        if (@environment.ui.yes?("Are you sure you want to shut down box #{box.name}?",:red))
+          @environment.ui.notice "Shutting down box #{box.name} id: #{box.id}"
+          connect
+          @connection.servers.get(box.id).destroy
+          return true
+        end
+        return false
+      end
+    end
+  end
+end

data/lib/migrant/clouds/rackspace.rb

@@ -0,0 +1,25 @@
+module Migrant
+  module Clouds
+    class Rackspace < Base
+      register 'rackspace'
+
+      def initialize(env)
+        super
+      end
+
+      def connect
+        @connection = Fog::Compute.new(:provider => 'Rackspace', 
+                                      :rackspace_api_key => @environment.setting('provider.api_key'),
+                                      :rackspace_username => @environment.setting('provider.user_name'))
+      end
+
+      def log_server_info
+        super
+        @environment.ui.notice "  Name:       #{@environment.server.name}"
+        @environment.ui.notice "  IP Address: #{@environment.server.addresses['public']}"
+        @environment.ui.notice "  Image ID:   #{@environment.server.image.name}"
+        @environment.ui.notice "  Flavor:     #{@environment.server.flavor.name}"
+      end
+    end
+  end
+end