boucher 0.1

data/spec/boucher/compute_spec.rb

@@ -0,0 +1,75 @@
+require_relative "../spec_helper"
+require 'boucher/compute'
+require 'boucher/nagios'
+require 'ostruct'
+
+describe "Boucher Cloud" do
+
+  after do
+    Boucher::Config[:env] = "dev"
+  end
+
+  it "knows connections options" do
+    connection = Boucher.compute
+    connection.should_not == nil
+    Boucher::EC2_CONFIG[:aws_secret_access_key].should == "secret key"
+    Boucher::EC2_CONFIG[:aws_access_key_id].should == "public id"
+  end
+
+  it "ssh's a command" do
+    server = OpenStruct.new(:dns_name => "test_dns")
+
+    system "echo > /dev/null" # to populate $?
+    Kernel.should_receive(:system).with("ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -i #{Boucher::Config[:aws_key_filename]}.pem #{Boucher::Config[:username]}@test_dns \"some command\"")
+
+    Boucher.ssh(server, "some command")
+  end
+
+  it "downloads a file" do
+    server = stub(:dns_name => "test_dns")
+    Kernel.should_receive(:system).with("rsync", "-azb", "-e", Boucher.ssh_command, "--delete-after", "#{Boucher::Config[:username]}@test_dns:/usr/lib/a_file.txt", "/usr/local/local_file.txt")
+    Boucher.download(server, "/usr/lib/a_file.txt", "/usr/local/local_file.txt")
+  end
+
+  it "rsyncs files" do
+    server = stub(:dns_name => "test_dns")
+
+    system "echo > /dev/null" # to populate $?
+    Kernel.should_receive(:system).with("rsync", "-azb", "-e", Boucher.ssh_command,
+      "--delete-after", "foo", "#{Boucher::Config[:username]}@test_dns:bar")
+
+    Boucher.rsync(server, "foo", "bar")
+  end
+
+  it "opens an ssh shell" do
+    server = OpenStruct.new(:dns_name => "test_dns")
+
+    system "echo > /dev/null" # to populate $?
+    Kernel.should_receive(:system).with("ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -i #{Boucher::Config[:aws_key_filename]}.pem #{Boucher::Config[:username]}@test_dns ")
+
+    Boucher.ssh(server)
+  end
+
+  it "updates recipes and rsyncs local changes" do
+    server = OpenStruct.new(:id => "test_id")
+    Boucher.should_receive(:ssh).with(server, "cd infrastructure && git checkout . && git clean -d -f && git pull && bundle")
+    Boucher.should_receive(:rsync).with(server, "cookbooks/", "infrastructure/cookbooks/")
+    Boucher.should_receive(:rsync).with(server, "config/", "infrastructure/config/")
+    Boucher.should_receive(:rsync).with(server, "tasks/", "infrastructure/tasks/")
+
+    Boucher.update_recipes(server)
+  end
+
+  it "cooks a meal" do
+    server = OpenStruct.new(:id => "test_id")
+
+    Boucher.should_receive(:update_recipes).with(server)
+    Boucher.should_receive(:ssh).with(server, "cd infrastructure && sudo BUTCHER_ENV=env_name BRANCH=branch_name chef-solo -c config/solo.rb -j config/meal_name.json")
+    Boucher::Nagios.should_receive(:remove_host).with(server)
+    Boucher::Nagios.should_receive(:add_host).with(server)
+    Boucher::Config[:branch] = "branch_name"
+    Boucher::Config[:env] = "env_name"
+
+    Boucher.cook_meal(server, "meal_name")
+  end
+end

data/spec/boucher/env_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe "Environment" do
+  describe "env" do
+    before do
+      @old_env = ENV['BUTCHER_ENV']
+    end
+
+    after do
+      ENV['BUTCHER_ENV'] = @old_env
+    end
+
+    it "defaults to :dev" do
+      ENV.delete('BUTCHER_ENV')
+      #load File.expand_path(File.dirname(__FILE__) + "/../../lib/boucher/env.rb")
+      Boucher::env_name.should == :dev
+    end
+
+    it "can be set via an environment variable" do
+      ENV['BUTCHER_ENV'] = "ci"
+      load File.expand_path(File.dirname(__FILE__) + "/../../lib/boucher/env.rb")
+      Boucher::env_name.should == "ci"
+    end
+  end
+
+  describe "branch" do
+    before do
+      @old_branch = ENV['BRANCH']
+      ENV.delete('BRANCH')
+    end
+
+    after do
+      ENV['BRANCH'] = @old_branch
+    end
+
+    it "defaults to master" do
+      Boucher.force_env!(:dev)
+      Boucher::Config[:branch].should == "master"
+    end
+
+    it "can be set via an environment variable" do
+      ENV['BRANCH'] = "some_branch"
+      Boucher.force_env!(:dev)
+      Boucher::Config[:branch].should == "some_branch"
+    end
+  end
+end

data/spec/boucher/io_spec.rb

@@ -0,0 +1,68 @@
+require_relative "../spec_helper"
+require "boucher/io"
+require 'ostruct'
+
+describe "Boucher IO" do
+
+  before do
+    Boucher::IO.mock!
+  end
+
+  it "prints server table header" do
+    Boucher.print_server_table_header
+
+    output = $stdout.string
+    puts "output: #{output}"
+    %w{ID Env Class Creator State Public IP Private IP}.each do |header|
+      output.should include(header)
+    end
+  end
+
+  it "prints a server" do
+    server = OpenStruct.new(
+            :id => "test_id",
+            :tags => {"Env" => "test_env", "Class" => "test_class", "Creator" => "Joe"},
+            :state => "test_state",
+            :public_ip_address => "1.2.3.4")
+
+    Boucher.print_server server
+    output = $stdout.string
+
+    output.should include("test_id")
+    output.should include("test_")
+    output.should include("test_class")
+    output.should include("Joe")
+    output.should include("test_state")
+    output.should include("1.2.3.4")
+  end
+
+  it "prints servers ordered by Env, then Class" do
+    server_1 = OpenStruct.new(
+              :id => "test_id_1",
+              :tags => {"Env" => "test_env", "Class" => "test_class", "Creator" => "Joe"},
+              :state => "test_state",
+              :public_ip_address => "1.2.3.4")
+
+    server_2 = OpenStruct.new(
+              :id => "test_id_2",
+              :tags => {"Env" => "better_env", "Class" => "test_class_1", "Creator" => "Joe"},
+              :state => "test_state",
+              :public_ip_address => "1.2.3.5")
+
+    server_3 = OpenStruct.new(
+              :id => "test_id_3",
+              :tags => {"Env" => "better_env", "Class" => "test_class_2", "Creator" => "Joe"},
+              :state => "test_state",
+              :public_ip_address => "1.2.3.6")
+
+    Boucher.print_servers([server_1, server_2, server_3])
+    output = $stdout.string
+
+    lines = output.split("\n")
+    lines[0].should == ""
+    lines[2].should include("------")
+    lines[3].should include("test_id_2")
+    lines[4].should include("test_id_3")
+    lines[5].should include("test_id_1")
+  end
+end

data/spec/boucher/provision_spec.rb

@@ -0,0 +1,77 @@
+require_relative "../spec_helper"
+require 'boucher/provision'
+
+describe "Boucher Provisioning" do
+
+  before do
+    Boucher::Config[:elastic_ips] = nil
+  end
+
+  after do
+    Boucher::Config[:env] = "test"
+  end
+
+  describe "establish server" do
+    it "provisions a server if one does not exist" do
+      Boucher.stub(:server_classes).and_return({:class_of_server => "server details"})
+      Boucher.should_receive(:provision).with("class_of_server", "server details")
+
+      Boucher.establish_server nil, "class_of_server"
+    end
+
+    it "starts a server if it is stopped" do
+      server = mock(:id => "the id", :state => "stopped")
+      Boucher.stub(:server_classes).and_return({:class_of_server => "server details"})
+      Boucher.should_receive(:change_server_state).with("the id", :start, "running")
+      server.should_receive(:reload)
+      Boucher.should_receive(:cook_meals_on_server).with("class_of_server", "server details", server)
+
+      Boucher.establish_server server, "class_of_server"
+    end
+
+    it "attaches elastic IPs if the server was stopped" do
+      Boucher::Config[:elastic_ips] = { "class_of_server" => "1.2.3.4" }
+      server = mock(:id => "the id", :state => "stopped", :reload => nil)
+      Boucher.stub(:server_classes).and_return({:class_of_server => {:meals => []}})
+      Boucher.stub(:change_server_state)
+      Boucher.compute.should_receive(:associate_address).with(anything, "1.2.3.4")
+
+      Boucher.establish_server server, "class_of_server"
+    end
+
+    it "cooks meals on server if it is up and running" do
+      running_server = mock(:id => "the id", :state => "running")
+      Boucher.stub(:server_classes).and_return({:class_of_server => "server details"})
+      Boucher.should_receive(:cook_meals_on_server).with("class_of_server", "server details", running_server)
+
+      Boucher.establish_server running_server, "class_of_server"
+    end
+  end
+
+  describe "provision" do
+    it "provisions a server" do
+      Boucher.stub!(:ssh)
+      Boucher.should_receive(:classify)
+      Boucher.should_receive(:cook_meal).with(anything, "foo")
+
+      Boucher.provision "foo", {:meals => ["foo"]}
+    end
+
+    it "provisions a server with Procs as meals" do
+      Boucher.stub!(:ssh)
+      Boucher.should_receive(:classify)
+      Boucher.should_receive(:cook_meal).with(anything, "foo")
+
+      Boucher.provision "foo", {:meals => [lambda{"foo"}]}
+    end
+
+    it "provisions a server with elastic IP" do
+      Boucher.stub!(:ssh)
+      Boucher::Config[:elastic_ips] = { "foo" => "1.2.3.4" }
+      Boucher.should_receive(:classify)
+      Boucher.compute.should_receive(:associate_address).with(anything, "1.2.3.4")
+
+      Boucher.provision "foo", {:meals => []}
+    end
+  end
+end

data/spec/boucher/servers_spec.rb

@@ -0,0 +1,79 @@
+require_relative "../spec_helper"
+require 'boucher/servers'
+require 'ostruct'
+
+describe "Boucher::Servers" do
+
+  let(:remote_servers) {
+    [OpenStruct.new(:id => "s1", :tags => {"Env" => "test", "Class" => "foo"}, :state => "stopped"),
+     OpenStruct.new(:id => "s2", :tags => {"Env" => "test", "Class" => "bar"}, :state => "pending"),
+     OpenStruct.new(:id => "s3", :tags => {"Env" => "dev",  "Class" => "foo"}, :state => "terminated"),
+     OpenStruct.new(:id => "s4", :tags => {"Env" => "dev",  "Class" => "bar"}, :state => "running")]
+  }
+
+  before do
+    @env = Boucher::Config[:env]
+    Boucher.compute.stub(:servers).and_return(remote_servers)
+  end
+
+  after do
+    Boucher::Config[:env] = @env
+  end
+
+  it "finds all servers" do
+    Boucher::Servers.all.size.should == 4
+    Boucher::Servers.all.should == remote_servers
+  end
+
+  it "finds classed servers" do
+    Boucher::Servers.of_class("blah").should == []
+    Boucher::Servers.of_class(:foo).map(&:id).should == ["s1", "s3"]
+    Boucher::Servers.of_class("bar").map(&:id).should == ["s2", "s4"]
+  end
+
+  it "finds with env servers" do
+    Boucher::Servers.in_env("blah").should == []
+    Boucher::Servers.in_env("test").map(&:id).should == ["s1", "s2"]
+    Boucher::Servers.in_env("dev").map(&:id).should == ["s3", "s4"]
+  end
+
+  it "finds servers in a given state" do
+    Boucher::Servers.in_state("running").map(&:id).should == ["s4"]
+    Boucher::Servers.in_state("terminated").map(&:id).should == ["s3"]
+    Boucher::Servers.in_state("pending").map(&:id).should == ["s2"]
+    Boucher::Servers.in_state("stopped").map(&:id).should == ["s1"]
+  end
+
+  it "finds the first matching server" do
+    Boucher::Servers.find.id.should == "s1"
+    Boucher::Servers.find(:class => "foo").id.should == "s1"
+    Boucher::Servers.find(:class => "bar").id.should == "s2"
+    Boucher::Servers.find(:env => "test").id.should == "s1"
+    Boucher::Servers.find(:env => "dev").id.should == "s3"
+    Boucher::Servers.find(:class => "foo", :env => "test").id.should == "s1"
+    Boucher::Servers.find(:class => "foo", :env => "dev").id.should == "s3"
+    Boucher::Servers.find(:class => "bar", :env => "test").id.should == "s2"
+    Boucher::Servers.find(:class => "bar", :env => "dev").id.should == "s4"
+    expect { Boucher::Servers.find(:class => "blah", :env => "dev") }.to raise_error
+    expect { Boucher::Servers.find(:class => "foo", :env => "blah") }.to raise_error
+  end
+
+  it "raises an error if find returns no results" do
+    expect { Boucher::Servers.find(:class => "blah") }.to raise_error(Boucher::Servers::NotFound)
+  end
+
+  it "gets a server based on current env when all the servers are running" do
+    Boucher::Config[:env] = "test"
+    expect { Boucher::Servers["foo"] }.to raise_error
+    expect { Boucher::Servers["bar"] }.to raise_error
+
+    Boucher::Config[:env] = "dev"
+    expect { Boucher::Servers["foo"] }.to raise_error
+    Boucher::Servers["bar"].id.should == "s4"
+  end
+
+  it "stops a server" do
+    Boucher.should_receive(:change_server_state).with("the id", :stop, "stopped")
+    Boucher::Servers.stop("the id")
+  end
+end

data/spec/boucher/storage_spec.rb

@@ -0,0 +1,47 @@
+require_relative "../spec_helper"
+require 'boucher/storage'
+require 'ostruct'
+
+describe "Boucher Storage" do
+
+  it "knows connections options" do
+    connection = Boucher.storage
+    connection.should_not == nil
+    Boucher::S3_CONFIG[:aws_secret_access_key].should == Boucher::Config[:aws_secret_access_key]
+    Boucher::S3_CONFIG[:aws_access_key_id].should == Boucher::Config[:aws_access_key_id]
+  end
+
+  context "with dir" do
+    before do
+      Boucher.storage.directories.create(:key => "test_bucket")
+      File.open("test_file.txt", "w") { |f| f.write "wakka wakka" }
+    end
+
+    after do
+      File.delete("test_file.txt") if File.exists?("test_file.txt")
+      File.delete("test_file2.txt") if File.exists?("test_file2.txt")
+    end
+
+    it "puts a file" do
+      Boucher::Storage.put("test_bucket", "test_file", "test_file.txt")
+      dir = Boucher.storage.directories.get("test_bucket")
+      file = dir.files.get("test_file")
+      file.body.should == "wakka wakka"
+    end
+
+    it "gets a file" do
+      Boucher::Storage.put("test_bucket", "test_file", "test_file.txt")
+      time = Time.now
+      Time.stub!(:now).and_return(time)
+      Kernel.should_receive(:system) do |*args|
+        args[0].should == "curl"
+        args[1].should == Boucher.storage.directories.get("test_bucket").files.get_https_url("test_file", time + 3600)
+        args[2].should == "-o"
+        args[3].should == "test_file2.txt"
+      end
+
+      Boucher::Storage.get("test_bucket", "test_file", "test_file2.txt")
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+# MDM - Need to set config because it's never loaded in test
+module Boucher
+  NO_LOAD_CONFIG = true
+  Config = {
+          :aws_secret_access_key => "secret key",
+          :aws_access_key_id => "public id",
+          :aws_key_filename => "test_key"
+  }
+end
+
+require 'fog'
+require 'boucher/io'
+require 'boucher/env'
+
+Boucher.force_env!("dev")
+
+Fog.mock!
+Boucher::IO.mock!
+
+
+# MDM - Monkey patch wait_for methods so the tests are FASTER!
+module Fog
+  def self.wait_for(timeout=Fog.timeout, interval=1)
+    yield
+  end
+end
+
+require 'fog/core/model'
+
+module Fog
+  class Model
+    def wait_for(timeout=Fog.timeout, interval=1, &block)
+      yield
+    end
+  end
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: boucher
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- ! '''Micah Micah'''
+autorequire: boucher/tasks
+bindir: bin
+cert_chain: []
+date: 2012-09-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  name: retryable
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.10
+description: AWS system deployment and management
+email:
+- ! '''micah@8thlight.com'''
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .gitmodules
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- boucher.gemspec
+- lib/boucher/ci.rb
+- lib/boucher/classes.rb
+- lib/boucher/compute.rb
+- lib/boucher/env.rb
+- lib/boucher/io.rb
+- lib/boucher/nagios.rb
+- lib/boucher/provision.rb
+- lib/boucher/servers.rb
+- lib/boucher/storage.rb
+- lib/boucher/tasks.rb
+- lib/boucher/tasks/console.rake
+- lib/boucher/tasks/env.rake
+- lib/boucher/tasks/nagios.rake
+- lib/boucher/tasks/servers.rake
+- lib/boucher/tasks/storage.rake
+- lib/boucher/tasks/volumes.rake
+- lib/boucher/util.rb
+- lib/boucher/volumes.rb
+- spec/boucher/classes_spec.rb
+- spec/boucher/compute_spec.rb
+- spec/boucher/env_spec.rb
+- spec/boucher/io_spec.rb
+- spec/boucher/provision_spec.rb
+- spec/boucher/servers_spec.rb
+- spec/boucher/storage_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/8thlight/boucher
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: AWS system deployment and management
+test_files:
+- spec/boucher/classes_spec.rb
+- spec/boucher/compute_spec.rb
+- spec/boucher/env_spec.rb
+- spec/boucher/io_spec.rb
+- spec/boucher/provision_spec.rb
+- spec/boucher/servers_spec.rb
+- spec/boucher/storage_spec.rb
+- spec/spec_helper.rb