remy 0.0.1

data/lib/remy/remy.rb

@@ -0,0 +1,140 @@
+#--
+# Copyright (c) 2011 Gregory S. Woodward
+#
+# 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.
+#++
+
+module Remy
+  class Configuration
+    attr_accessor :yml_files, :cookbook_path, :spec_path, :remote_chef_dir, :node_attributes, :roles_path
+
+    def initialize
+      @yml_files = []
+      @node_attributes = {}
+    end
+  end
+
+  class << self
+    include ::Remy::Shell
+    include FileUtils
+
+    def configure
+      @config_instance = Configuration.new
+      yield @config_instance
+      @configuration = Hashie::Mash.new({:yml_files => [@config_instance.yml_files].compact.flatten,
+                                 :remote_chef_dir => (@config_instance.remote_chef_dir || '/var/chef'),
+                                 :roles_path => [@config_instance.roles_path].compact.flatten,
+                                 :spec_path => [@config_instance.spec_path].compact.flatten,
+                                 :cookbook_path => [@config_instance.cookbook_path].compact.flatten}.merge!(@config_instance.node_attributes))
+
+      @config_instance.yml_files.each do |filename|
+        begin
+          configuration.deep_merge!(YAML.load(ERB.new(File.read(filename)).result) || {})
+        rescue SystemCallError, IOError
+          warn "WARN: #{filename} could not be found!"
+        end
+      end
+    end
+
+    def configuration
+      @configuration ? @configuration : Hashie::Mash.new
+    end
+
+    def to_json
+      configuration.to_json
+    end
+
+    def servers
+      configuration.servers
+    end
+
+    def find_servers(options = {})
+      return nil unless configuration.servers
+      Hashie::Mash.new(configuration.servers.inject({}) do |hash, (server_name, server_config)|
+        found = options.all? { |(key, value)| server_config[key] == value }
+        hash[server_name] = server_config if found
+        hash
+      end)
+    end
+
+    def find_server(options = {})
+      return nil unless configuration.servers
+      server_name, server_config = configuration.servers.detect do |(server_name, server_config)|
+        options.all? { |(key, value)| server_config[key] == value }
+      end
+      {server_name => server_config.nil? ? nil : server_config.dup}
+    end
+
+    def find_server_config(options = {})
+      find_server(options).try(:values).try(:first)
+    end
+
+    def find_server_config_by_name(name)
+      return nil unless configuration.servers
+      configuration.servers.find {|(server_name, _)| server_name == name}.try(:last)
+    end
+
+    def cloud_configuration
+      configuration && configuration.cloud_configuration
+    end
+
+    def bootstrap
+      configuration && configuration.bootstrap
+    end
+
+    def determine_ip_addresses_for_remy_run(rake_args)
+      ip_addresses = []
+      if options_hash = convert_properties_to_hash(rake_args)
+        servers = find_servers(options_hash)
+        if !servers.empty?
+          ip_addresses = servers.collect {|server_name, chef_option| chef_option.ip_address }
+        else
+          ip_addresses = [options_hash[:ip_address]]
+        end
+      else
+        names_or_ip_addresses = rake_args.split(' ').collect {|name| name.strip }
+        names_or_ip_addresses.each do |name_or_ip_address|
+          # From: http://www.regular-expressions.info/examples.html
+          ip_address_regex = '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b'
+          if name_or_ip_address.match(ip_address_regex)
+            ip_addresses << name_or_ip_address
+          elsif server_config = find_server_config_by_name(name_or_ip_address)
+            ip_addresses << server_config.ip_address
+          end
+        end
+        ip_addresses << configuration.ip_address
+      end
+      ip_addresses.compact
+    end
+
+    # Converts "foo:bar baz:blech" to {:foo => 'bar', :baz => 'blech'}
+    def convert_properties_to_hash(properties)
+      if properties =~ /:/
+        properties.split(' ').inject({}) do |result, pair|
+          key, value = pair.split(':')
+          result[key] = value
+          result
+        end.symbolize_keys
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/remy/server.rb

@@ -0,0 +1,71 @@
+class Remy::Server
+  attr_reader :server_name, :cloud_api_key, :cloud_username, :cloud_provider, :flavor_id, :image_id, :server
+
+  def initialize(options = {})
+    options = {
+      :flavor_id => 4, # 2GB
+      :image_id => 49, # Ubuntu 10.04 LTS (lucid)
+      :quiet => false
+    }.merge(Remy.cloud_configuration || {}).merge(options || {}).symbolize_keys
+
+    @server_name = options[:server_name]
+    @cloud_api_key = options[:cloud_api_key]
+    @cloud_username = options[:cloud_username]
+    @cloud_provider = options[:cloud_provider]
+    @flavor_id = options[:flavor_id]
+    @image_id = options[:image_id]
+    @quiet = options[:quiet]
+    @raise_exception = options[:raise_exception]
+    @server = nil
+  end
+
+  def create
+    compute = Fog::Compute.new(
+      :provider => cloud_provider,
+      :rackspace_api_key => cloud_api_key,
+      :rackspace_username => cloud_username
+    )
+
+    @server = compute.servers.create(:flavor_id => flavor_id.to_i, :image_id => image_id.to_i, :name => server_name)
+    server.wait_for do
+      print '.'
+      STDOUT.flush
+      ready?
+    end
+    print server_info
+    {:ip_address => server.public_ip_address, :password => server.password}
+  rescue Exception => e
+    puts 'Failed!'
+    p e
+    raise e if raise_exception?
+    {}
+  end
+
+  private
+  def server_info
+    <<-SERVER_INFO
+
+
+Server name:        #{server.name}
+root password:      #{server.password}
+RAM:                #{server.flavor.ram} MB
+Image:              #{server.image.name}
+IP address:         #{server.public_ip_address}
+Private IP address: #{server.addresses['private'][0]}
+
+SERVER_INFO
+
+  end
+
+  def print *args
+    Kernel.print(*args) unless quiet?
+  end
+
+  def quiet?
+    @quiet
+  end
+
+  def raise_exception?
+    @raise_exception
+  end
+end

data/lib/remy/shell.rb

@@ -0,0 +1,26 @@
+module Remy
+  module Shell
+    def execute(command)
+      if quiet?
+        `#{command} 2>&1`
+        $?.success?
+      else
+        puts "Running command: #{command}"
+        system command
+      end
+    end
+
+    def remote_execute(cmd)
+      raise ArgumentError.new unless ip_address
+      execute "ssh -T #{user}@#{ip_address} '#{cmd.strip}'"
+    end
+
+    def user
+      'root'
+    end
+
+    def quiet?
+      false
+    end
+  end
+end

data/lib/remy/version.rb

@@ -0,0 +1,3 @@
+module Remy
+  VERSION = "0.0.1"
+end

data/lib/remy.rb

@@ -0,0 +1,56 @@
+#--
+# Copyright (c) 2011 Gregory S. Woodward
+#
+# 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.
+#++
+
+begin
+  require 'active_support/core_ext/object/to_json'
+rescue LoadError
+  require 'active_support/json/encoders/object'
+end
+
+begin
+  require 'active_support/core_ext/object/try'
+rescue LoadError
+  require 'active_support/core_ext/try'
+end
+
+require 'active_support/core_ext/hash'
+require 'fog'
+require 'erb'
+require 'json'
+require 'hashie'
+require 'tmpdir'
+require 'remy/shell'
+require 'yaml'
+dir = File.dirname(__FILE__)
+Dir[File.join(File.dirname(__FILE__), 'remy', '**', '*.rb')].each {|f| require f.gsub(dir, '')[1, f.length] }
+
+module Remy
+  begin
+    class Railtie < ::Rails::Railtie
+      rake_tasks do
+        load 'tasks/remy.rake'
+      end
+    end
+  rescue LoadError, NameError
+  end
+end

data/lib/tasks/remy.rake

@@ -0,0 +1,51 @@
+require 'remy'
+
+namespace :remy do
+  task :environment do
+    begin
+      Rake::Task[:environment].invoke
+    rescue RuntimeError
+    end
+  end
+
+  desc 'ssh to a named box'
+  task :ssh, :rake_args do |task, options|
+    Rake::Task[:'remy:environment'].invoke
+    user = Remy.configuration.user || 'root'
+    if ip_address = Remy.determine_ip_addresses_for_remy_run(options[:rake_args]).try(:first)
+      exec "ssh #{user}@#{ip_address}"
+    end
+  end
+
+  namespace :chef do
+    desc 'run chef solo'
+    task :run, :rake_args do |task, options|
+      Rake::Task[:'remy:environment'].invoke
+      Remy::Chef.rake_run(options[:rake_args])
+    end
+  end
+
+  namespace :server do
+    desc 'create a server'
+    task :create, :server_name, :flavor_id, :cloud_api_key, :cloud_username, :cloud_provider, :image_id do |task, options|
+      Rake::Task[:'remy:environment'].invoke
+      Remy::Server.new(options).create
+    end
+
+    desc 'bootstrap chef'
+    task :bootstrap, :ip_address, :password do |task, options|
+      Rake::Task[:'remy:environment'].invoke
+      Remy::Bootstrap.new(options).run
+    end
+
+    desc 'create a server and bootstrap chef'
+    task :create_and_bootstrap, :server_name, :flavor_id, :cloud_api_key, :cloud_username, :cloud_provider, :image_id do |task, options|
+      Rake::Task[:'remy:environment'].invoke
+      begin
+        result = Remy::Server.new({:raise_exception => true}.merge(options)).create
+        Rake::Task[:'remy:server:bootstrap'].invoke(result[:ip_address], result[:password])
+      rescue Exception => e
+      end
+    end
+  end
+end

data/remy.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'remy/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'remy'
+  s.version     = Remy::VERSION
+  s.authors     = ['Greg Woodward & Ryan Dy']
+  s.email       = ['pair+gwoodward+rdy@pivotallabs.com']
+  s.homepage    = 'http://sharespost.com'
+  s.summary     = %q{Remy gem}
+  s.description = %q{Easy chef deployment}
+
+  s.rubyforge_project = 'remy'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency 'bourne'
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'i18n'
+  s.add_development_dependency 'json'
+  s.add_development_dependency 'rspec', '~> 2.7.0'
+  s.add_runtime_dependency 'activesupport', '>= 2'
+  s.add_runtime_dependency 'chef'
+  s.add_runtime_dependency 'fog'
+  s.add_runtime_dependency 'hashie'
+end

data/spec/fixtures/bar.yml

@@ -0,0 +1,7 @@
+baz:
+  baz
+another_node_attribute:
+  hot
+colors:
+  blue: 'blue'
+  green: 'green'

data/spec/fixtures/chef.yml

@@ -0,0 +1,44 @@
+app_server: &APP
+  recipes:
+    - recipe[hello_world]
+database_server: &DB
+  adapter: mysql2
+  encoding: utf8
+
+rails_env: bogus_and_should_be_overridden_by_value_in_servers_section
+
+servers:
+  web.sharespost.com:
+    <<: *APP
+    ip_address: <%= IP_ADDRESS %>
+    rails_env: demo
+    color: blue
+
+  db.sharespost.com:
+    <<: *DB
+    ip_address: 51.51.51.51
+    rails_env: production
+    color: yellow
+
+  demo.sharespost.com:
+    <<: *DB
+    <<: *APP
+    ip_address: 52.52.52.52
+    rails_env: demo
+    color: green
+
+cloud_configuration:
+  cloud_provider: Rackspace
+  cloud_username: sharespost
+  cloud_api_key: abcdefg12345
+  flavor_id: 4
+  image_id: 49
+  server_name: new-server.somedomain.com
+
+bootstrap:
+  ruby_version: 1.9.2
+  gems:
+    bundler: 1.0.21
+    chef: 0.10.4
+    rspec: 2.7.0
+

data/spec/fixtures/foo.yml

@@ -0,0 +1,5 @@
+blah:
+  bar
+colors:
+  red: 'red'
+  green: 'green'

data/spec/fixtures/hello_world_chef.yml

@@ -0,0 +1,8 @@
+ip_address: <%= IP_ADDRESS %>
+color: blue
+recipes:
+  - recipe[hello_world]
+other_data:
+  - red
+  - yellow
+  - blue

data/spec/remy/bootstrap_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Remy::Bootstrap do
+  def ruby_version(bootstrap)
+    bootstrap.instance_variable_get(:@ruby_version)
+  end
+
+  def gem(bootstrap)
+    bootstrap.instance_variable_get(:@gems)
+  end
+
+  def ip_address(bootstrap)
+    bootstrap.instance_variable_get(:@ip_address)
+  end
+
+  describe "ruby_version" do
+    it 'should default to 1.8.7 if there is no Ruby version specified in the yml files' do
+      Remy.configure { |config| config.yml_files = File.join(File.dirname(__FILE__), '../fixtures/hello_world_chef.yml') }
+      bootstrap = Remy::Bootstrap.new
+      ruby_version(bootstrap).should == '1.8.7'
+    end
+
+    it 'should get the Ruby version if specified in the yml files' do
+      Remy.configure { |config| config.yml_files = File.join(File.dirname(__FILE__), '../fixtures/chef.yml') }
+      bootstrap = Remy::Bootstrap.new
+      ruby_version(bootstrap).should == '1.9.2'
+    end
+
+    it 'should use the version passed in as an option, even if it exists in the yml files' do
+      Remy.configure { |config| config.yml_files = File.join(File.dirname(__FILE__), '../fixtures/chef.yml') }
+      bootstrap = Remy::Bootstrap.new(:ruby_version => '1.9.1')
+      ruby_version(bootstrap).should == '1.9.1'
+    end
+  end
+
+  describe "gems" do
+    it 'should default to nil if not specified in the yml files' do
+      Remy.configure { |config| config.yml_files = File.join(File.dirname(__FILE__), '../fixtures/hello_world_chef.yml') }
+      bootstrap = Remy::Bootstrap.new
+      gem(bootstrap)[:chef].should be_nil
+      gem(bootstrap)[:bundler].should be_nil
+      gem(bootstrap)[:rspec].should be_nil
+    end
+
+    it 'should get gem version if it has been specified in the yml files' do
+      Remy.configure { |config| config.yml_files = File.join(File.dirname(__FILE__), '../fixtures/chef.yml') }
+      bootstrap = Remy::Bootstrap.new
+      gem(bootstrap)[:chef].should == '0.10.4'
+      gem(bootstrap)[:bundler].should == '1.0.21'
+      gem(bootstrap)[:rspec].should == '2.7.0'
+    end
+  end
+
+  describe "ip_address" do
+    it 'should use the value from the options' do
+      Remy.configure { |config| config.yml_files = File.join(File.dirname(__FILE__), '../fixtures/hello_world_chef.yml') }
+      bootstrap = Remy::Bootstrap.new(:ip_address => '1.2.3.4', :password => 'abcdef')
+      ip_address(bootstrap).should == '1.2.3.4'
+    end
+  end
+end

data/spec/remy/chef_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Remy::Chef do
+  def node_configuration(chef)
+    chef.instance_variable_get(:@node_configuration)
+  end
+
+  describe "#initialize and the node configuration" do
+    it 'should use the top-level IP address in the yml files, if one is present, and an ip address is not passed in as an argument' do
+      Remy.configure { |config| config.yml_files = File.join(File.dirname(__FILE__), '../fixtures/hello_world_chef.yml') }
+      chef = Remy::Chef.new
+      node_configuration(chef).ip_address.should == IP_ADDRESS
+      node_configuration(chef).color.should == 'blue'
+      node_configuration(chef).recipes.should == ['recipe[hello_world]']
+    end
+
+    it 'should allow the top-level values in the yml files (including the ip address) to be overridden' do
+      Remy.configure { |config| config.yml_files = File.join(File.dirname(__FILE__), '../fixtures/hello_world_chef.yml') }
+      chef = Remy::Chef.new(:ip_address => '1.2.3.4', :color => 'green')
+      node_configuration(chef).ip_address.should == '1.2.3.4'
+      node_configuration(chef).color.should == 'green'
+      node_configuration(chef).recipes.should == ['recipe[hello_world]']
+    end
+
+    it 'should return properties from the :servers section of the yml file if the ip address is found in there' do
+      Remy.configure { |config| config.yml_files = File.join(File.dirname(__FILE__), '../fixtures/chef.yml') }
+      chef = Remy::Chef.new(:ip_address => '51.51.51.51')
+      node_configuration(chef).ip_address.should == '51.51.51.51'
+      node_configuration(chef).rails_env.should == 'production'
+      node_configuration(chef).color.should == 'yellow'
+      node_configuration(chef).adapter.should == 'mysql2'
+      node_configuration(chef).encoding.should == 'utf8'
+    end
+
+    it 'should allow properties from the servers section of the yml file to be overridden plus additional options added' do
+      Remy.configure { |config| config.yml_files = File.join(File.dirname(__FILE__), '../fixtures/chef.yml') }
+      chef = Remy::Chef.new(:ip_address => '51.51.51.51', :color => 'purple', :temperature => 'warm')
+      node_configuration(chef).color.should == 'purple'      # Overrides 'yellow' from the yml files
+      node_configuration(chef).temperature.should == 'warm'  # A new node attribute which is not present in the yml files
+    end
+
+    it 'should allow the chef args to be specified (and not merge this chef_args value into the node configuration)' do
+      Remy.configure { |config| config.yml_files = File.join(File.dirname(__FILE__), '../fixtures/chef.yml') }
+      chef = Remy::Chef.new(:chef_args => '-l debug')
+      node_configuration(chef).chef_args.should be_nil
+      chef.instance_variable_get(:@chef_args).should == '-l debug'
+    end
+
+    it 'should allow the quiet option to be specified (and not merge this option into the node configuration)' do
+      Remy.configure { |config| config.yml_files = File.join(File.dirname(__FILE__), '../fixtures/chef.yml') }
+      chef = Remy::Chef.new(:quiet => true)
+      node_configuration(chef).quiet.should be_nil
+      chef.instance_variable_get(:@quiet).should be_true
+    end
+
+    it 'should not modify the global Remy configuration, but rather only the node configuration for this particular Chef node' do
+      Remy.configure { |config| config.yml_files = File.join(File.dirname(__FILE__), '../fixtures/bar.yml') }
+      Remy.configuration.another_node_attribute.should == 'hot'
+      chef = Remy::Chef.new(:another_node_attribute => 'cold')
+      node_configuration(chef).another_node_attribute.should == 'cold'
+      Remy.configuration.another_node_attribute.should == 'hot' # Unchanged from its original value                                                                                                  # do some checks
+    end
+  end
+
+  describe '#run' do
+    before do
+      Remy.configure { |config| config.yml_files = File.join(File.dirname(__FILE__), '../fixtures/chef.yml') }
+    end
+
+    it 'should work with a hash as its argument' do
+      chef = Remy::Chef.new(:ip_address => IP_ADDRESS)
+      node_configuration(chef).ip_address.should == IP_ADDRESS
+      node_configuration(chef).recipes.should == ['recipe[hello_world]']
+    end
+
+    it 'should work with JSON as its argument' do
+      chef = Remy::Chef.new("{\"ip_address\":\"#{IP_ADDRESS}\"}")
+      node_configuration(chef).ip_address.should == IP_ADDRESS
+      node_configuration(chef).recipes.should == ['recipe[hello_world]']
+    end
+  end
+end

data/spec/remy/integration/chef_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Remy::Chef do
+  before do
+    Remy.configure do |config|
+      config.yml_files = ['../../fixtures/foo.yml', '../../fixtures/bar.yml', '../../fixtures/chef.yml'].map { |f| File.join(File.dirname(__FILE__), f) }
+      config.cookbook_path = ["../../../chef/cookbooks"].map { |f| File.join(File.dirname(__FILE__), f) }
+      config.spec_path = ["../../../chef/spec"].map { |f| File.join(File.dirname(__FILE__), f) }
+    end
+  end
+
+  describe '#run' do
+    def clean_up_remote_chef_test_files(chef)
+      chef.remote_execute "rm -rf /tmp/hello_world.txt #{Remy.configuration.remote_chef_dir}" if Remy.configuration.remote_chef_dir && Remy.configuration.remote_chef_dir.size > 2
+    end
+
+    def verify_contents_of_hello_world(chef)
+      chef.remote_execute(%Q{cat /tmp/hello_world.txt | grep "I am feeling blue"}).should be_true
+    end
+
+    def run_chef(options = {})
+      chef = Remy::Chef.new(options)
+      clean_up_remote_chef_test_files(chef)
+      chef.run
+      yield chef
+      clean_up_remote_chef_test_files(chef)
+    end
+
+    it 'should work with a hash as its argument' do
+      run_chef(:ip_address => IP_ADDRESS) do |chef|
+        verify_contents_of_hello_world(chef)
+      end
+    end
+
+    it 'should work with JSON as its argument' do
+      run_chef("{\"ip_address\":\"#{IP_ADDRESS}\"}") do |chef|
+        verify_contents_of_hello_world(chef)
+      end
+    end
+  end
+end