boucher 0.1 → 0.1.1

data/README.md

@@ -63,18 +63,16 @@ If you use github, you'll have to generate ssh keys and add them to the github r
     cd ..
     git clone git@github.com:<github account name>/<your infratructure project name>.git infrastructure
 
-10. Customize to your liking.
+11. Customize to your liking.
 
   * install your preferred vim dot files
   * etc...
 
-
-
-
-
 ## Usage
 
-...
+Run rake to see the list of tasks provided.
+
+    rake -T
 
 ## License
 

data/Rakefile

@@ -8,3 +8,10 @@ end
 
 desc "Default: run the specs."
 task :default => :spec
+
+desc "Push gem to rubygems.org"
+task :push do
+  system "rm boucher-*.gem"
+  system "gem build boucher.gemspec"
+  system "gem push boucher-*.gem"
+end

data/boucher.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = "boucher"
-  s.version     = "0.1"
+  s.version     = "0.1.1"
   s.authors     = ["'Micah Micah'"]
   s.email       = ["'micah@8thlight.com'"]
   s.homepage    = "http://github.com/8thlight/boucher"

data/lib/boucher/compute.rb

@@ -1,5 +1,5 @@
 require 'boucher/env'
-require 'boucher/classes'
+require 'boucher/meals'
 require 'boucher/io'
 require 'fog'
 require 'retryable'
@@ -38,35 +38,14 @@ module Boucher
     "ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -i #{Boucher::Config[:aws_key_filename]}.pem"
   end
 
-  def self.download(server, remote_filepath, local_filepath)
-    command = ["rsync", "-azb", "-e", ssh_command, "--delete-after", "#{Boucher::Config[:username]}@#{server.dns_name}:#{remote_filepath}", local_filepath]
-    Kernel.system(*command)
-    raise "command failed with code #{$?.exitstatus}: #{command.inspect}" unless $?.success?
-  end
-
-  def self.rsync(server, from, to)
-    command = ["rsync", "-azb", "-e", ssh_command, "--delete-after",
-      from, "#{Boucher::Config[:username]}@#{server.dns_name}:#{to}"]
-    Kernel.system(*command)
-    raise "command failed with code #{$?.exitstatus}: #{command.inspect}" unless $?.success?
-  end
-
   def self.update_recipes(server)
     puts "Updating recipes on #{server.id}"
     ssh server, "cd infrastructure && git checkout . && git clean -d -f && git pull && bundle"
-
-    %w[cookbooks config tasks].each do |folder|
-      rsync server, "#{folder}/", "infrastructure/#{folder}/"
-    end
   end
 
-  def self.cook_meal(server, meal)
-    Boucher::Nagios.remove_host(server)
-
+  def self.cook_meal(server, meal_name)
     update_recipes(server)
-    ssh server, "cd infrastructure && sudo BUTCHER_ENV=#{Boucher::Config[:env]} BRANCH=#{Boucher::Config[:branch]} chef-solo -c config/solo.rb -j config/#{meal}.json"
-
-    Boucher::Nagios.add_host(server)
+    ssh server, "cd infrastructure && sudo BUTCHER_ENV=#{Boucher::Config[:env]} BRANCH=#{Boucher::Config[:branch]} chef-solo -c config/solo.rb -j config/#{meal_name}.json"
   end
 
   def self.ssh_open?(server)

data/lib/boucher/env.rb

@@ -38,9 +38,5 @@ module Boucher
     unless ENV['BUTCHER_ENV']
       raise 'BUTCHER_ENV must be set before running this command'
     end
-
-    unless ENV['BRANCH']
-      raise 'BRANCH must be set before running this command'
-    end
   end
 end

data/lib/boucher/io.rb

@@ -17,7 +17,7 @@ module Boucher
   end
 
   def self.verbose(*args)
-    if ENV["VERBOSE"] != "false"
+    if ENV["VERBOSE"]
       puts *args
     end
   end
@@ -26,7 +26,7 @@ module Boucher
 
   def self.print_server_table_header
     puts
-    printf SERVER_TABLE_FORMAT, "ID", "Environment", "Class", "Creator", "State", "Public IP", "Private IP", "Inst. Size"
+    printf SERVER_TABLE_FORMAT, "ID", "Environment", "Meal", "Creator", "State", "Public IP", "Private IP", "Inst. Size"
     puts ("-" * 120)
   end
 
@@ -34,7 +34,7 @@ module Boucher
     printf SERVER_TABLE_FORMAT,
            server.id,
            (server.tags["Env"] || "???")[0...12],
-           (server.tags["Class"] || "???")[0...10],
+           (server.tags["Meal"] || "???")[0...10],
            (server.tags["Creator"] || "???")[0...10],
            server.state,
            server.public_ip_address,
@@ -45,7 +45,7 @@ module Boucher
   def self.print_servers(servers)
     print_server_table_header
     sorted_servers = servers.sort_by{|s| [s.tags["Env"] || "?",
-                                          s.tags["Class"] || "?"]}
+                                          s.tags["Meal"] || "?"]}
     sorted_servers.each do |server|
       print_server(server) if server
     end

data/lib/boucher/meals.rb

@@ -0,0 +1,45 @@
+require 'boucher/env'
+require 'boucher/util'
+require 'json'
+
+module Boucher
+
+  def self.json_to_meal(json)
+    parser = JSON.parser.new(json, :symbolize_names => true)
+    config = parser.parse
+    config[:boucher] || {}
+  end
+
+  def self.meals
+    if @meals.nil?
+      @meals = {}
+      Dir.glob(File.join("config", "*.json")).each do |file|
+        spec = json_to_meal(::IO.read(file))
+        meal_name = File.basename(file)[0...-5].to_sym
+        @meals[meal_name] = spec.merge(:name => meal_name)
+      end
+    end
+    @meals
+  end
+
+  def self.meal(meal_name)
+    the_meal = meals[meal_name.to_sym]
+    raise "Missing meal: #{mean_name}" unless the_meal
+    return the_meal
+  end
+
+  def self.setup_meal(server, meal)
+    server.image_id = meal[:base_image_id] || Boucher::Config[:base_image_id]
+    server.flavor_id = meal[:flavor_id] || Boucher::Config[:default_instance_flavor_id]
+    server.groups = meal[:groups] || Boucher::Config[:default_instance_groups]
+    server.key_name = meal[:key_name] || Boucher::Config[:aws_key_filename]
+    server.tags = {}
+    server.tags["Name"] = "#{meal[:meal_name] || "base"} #{Time.new.strftime("%Y%m%d%H%M%S")}"
+    server.tags["Meal"] = meal[:meal_name] || "base"
+    server.tags["CreatedAt"] = Time.new.strftime("%Y%m%d%H%M%S")
+    server.tags["Creator"] = current_user
+    server.tags["Env"] = Boucher::Config[:env]
+    server.tags["Volumes"] = meal[:volumes]
+  end
+
+end

data/lib/boucher/provision.rb

@@ -2,82 +2,61 @@ require 'boucher/compute'
 require 'boucher/io'
 require 'boucher/servers'
 require 'boucher/volumes'
-require 'boucher/nagios'
 require 'retryable'
 
 module Boucher
-  def self.each_required_server(&block)
-    Boucher::Config[:servers].each do |server_class|
-      server = find_server(server_class, Boucher::Config[:env])
-      block.yield(server, server_class)
-    end
-  end
 
-  def self.get_server(server_class, environment, state)
+  def self.get_server(meal, environment, state)
     begin
-      Boucher::Servers.find(:env => environment.to_s, :class => server_class, :state => state)
+      Boucher::Servers.find(:env => environment.to_s, :meal => meal, :state => state)
     rescue Boucher::Servers::NotFound
       nil
     end
   end
 
-  def self.find_server(server_class, environment)
-    get_server(server_class, environment, "stopped") || get_server(server_class, environment, "running")
-  end
-
-  def self.establish_all_servers
-    Boucher.each_required_server do |server, server_class|
-      # Retries after 2, 4, 8, 16, 32, and 64 seconds
-      retryable(:tries => 6, :sleep => lambda { |n| 2**n }) do
-        # A RuntimeError will sometimes be thrown here, with a message of:
-        # "command failed with code 255"
-        Boucher.establish_server(server, server_class)
-      end
-    end
+  def self.find_server(meal, environment)
+    get_server(meal, environment, "stopped") || get_server(meal, environment, "running")
   end
 
-  def self.establish_server(server, server_class)
+  def self.establish_server(server, meal_name)
+    meal = Boucher.meal(meal_name)
     if server.nil?
-      Boucher.provision(server_class, Boucher.server_classes[server_class.to_sym])
+      Boucher.provision(meal)
     elsif server.state == "stopped"
       Boucher::Servers.start(server.id)
       server.reload
-      Boucher.cook_meals_on_server(server_class, Boucher.server_classes[server_class.to_sym], server)
+      Boucher.cook_meal_on_server(meal, server)
     else
-      Boucher.cook_meals_on_server(server_class, Boucher.server_classes[server_class.to_sym], server)
+      Boucher.cook_meal_on_server(meal, server)
     end
   end
 
-  def self.provision(class_name, class_map)
-    puts "Provisioning new #{class_name} server..."
-    server = create_classified_server(class_map)
+  def self.provision(meal)
+    puts "Provisioning new #{meal[:name]} server..."
+    server = create_meal_server(meal)
     wait_for_server_to_boot(server)
     wait_for_server_to_accept_ssh(server)
-    volumes = create_volumes(class_map, server)
+    volumes = create_volumes(meal, server)
     attach_volumes(volumes, server)
-    cook_meals_on_server(class_name, class_map, server)
-    puts "\nThe new #{class_name} server has been provisioned! id: #{server.id}"
+    cook_meal_on_server(meal, server)
+    puts "\nThe new #{meal[:name]} server has been provisioned! id: #{server.id}"
   end
 
-  def self.attach_elastic_ips(class_name, server)
+  def self.attach_elastic_ips(meal, server)
     puts "Attaching elastic IPs..."
-    return unless Boucher::Config[:elastic_ips] && Boucher::Config[:elastic_ips][class_name]
+    ips = meal[:elastic_ips] || []
 
-    puts "Associating #{server.id} with #{Boucher::Config[:elastic_ips][class_name]}"
-    compute.associate_address(server.id, Boucher::Config[:elastic_ips][class_name])
+    ips.each do |ip|
+      puts "Associating #{server.id} with #{ip}"
+      compute.associate_address(server.id, ip)
+    end
   end
 
   private
 
-  def self.cook_meals_on_server(class_name, class_map, server)
-    return unless class_map[:meals]
-
-    class_map[:meals].each do |meal|
-      meal = meal.call if meal.is_a?(Proc)
-      Boucher.cook_meal(server, meal)
-    end
-
-    attach_elastic_ips(class_name, server)
+  def self.cook_meal_on_server(meal, server)
+    Boucher.cook_meal(server, meal[:name])
+    attach_elastic_ips(meal, server)
   end
 
   def self.wait_for_server_to_accept_ssh(server)
@@ -93,16 +72,16 @@ module Boucher
     Boucher.print_servers([server])
   end
 
-  def self.create_classified_server(class_map)
+  def self.create_meal_server(meal)
     server = compute.servers.new(:tags => {})
-    Boucher.classify(server, class_map)
+    Boucher.setup_meal(server, meal)
     server.save
     Boucher.print_servers([server])
     server
   end
 
-  def self.create_volumes(class_map, server)
-    Array(class_map[:volumes]).map do |volume_name|
+  def self.create_volumes(meal, server)
+    Array(meal[:volumes]).map do |volume_name|
       attributes = Boucher.volume_configs[volume_name]
       snapshot = snapshots.get(attributes[:snapshot])
       puts "Creating volume from snapshot #{snapshot.id}..."

data/lib/boucher/servers.rb

@@ -16,7 +16,7 @@ module Boucher
         cultivate(@instance)
       end
 
-      %w{all of_class in_env in_state search find [] with_id}.each do |m|
+      %w{all of_meal in_env in_state search find [] with_id}.each do |m|
         module_eval "def #{m}(*args); instance.#{m}(*args); end"
       end
 
@@ -32,7 +32,7 @@ module Boucher
 
     def search(options={})
       servers = self
-      servers = servers.of_class(options[:class]) if options[:class]
+      servers = servers.of_meal(options[:meal]) if options[:meal]
       servers = servers.in_env(options[:env]) if options[:env]
       servers = servers.in_state(options[:state]) if options[:state]
       servers
@@ -55,8 +55,8 @@ module Boucher
       Servers.cultivate(self.find_all {|s| s.state == state.to_s })
     end
 
-    def of_class(klass)
-      Servers.cultivate(self.find_all {|s| s.tags["Class"] == klass.to_s })
+    def of_meal(meal)
+      Servers.cultivate(self.find_all {|s| s.tags["Meal"] == meal.to_s })
     end
 
     def self.start(server_id)
@@ -68,7 +68,6 @@ module Boucher
     end
 
     def self.terminate(server)
-      Boucher::Nagios.remove_host(server)
       volumes = server.volumes
       volumes_to_destroy = volumes.select {|v| !v.delete_on_termination}
 
@@ -85,8 +84,8 @@ module Boucher
       Servers.cultivate(self.find_all {|s| s.id == server_id}).first
     end
 
-    def [](klass)
-      find(:env => Boucher::Config[:env], :class => klass, :state => "running")
+    def [](meal)
+      find(:env => Boucher::Config[:env], :meal => meal, :state => "running")
     end
   end
 end

data/lib/boucher/storage.rb

@@ -1,5 +1,5 @@
 require 'boucher/env'
-require 'boucher/classes'
+require 'boucher/meals'
 require 'fog'
 
 module Boucher

data/lib/boucher/tasks/console.rake

@@ -1,11 +1,10 @@
 require 'boucher/compute'
 require 'boucher/env'
 require 'boucher/io'
-require 'boucher/classes'
+require 'boucher/meals'
 require 'boucher/provision'
 require 'boucher/servers'
 require 'boucher/volumes'
-require 'boucher/nagios'
 
 desc "Starts a console with the Boucher modules loaded"
 task :console do

data/lib/boucher/tasks/servers.rake

@@ -1,11 +1,10 @@
 require 'boucher/compute'
 require 'boucher/env'
 require 'boucher/io'
-require 'boucher/classes'
+require 'boucher/meals'
 require 'boucher/provision'
 require 'boucher/servers'
 require 'boucher/volumes'
-require 'boucher/nagios'
 require 'retryable'
 
 def meals
@@ -40,9 +39,9 @@ namespace :servers do
     server_listing("in the '#{args.env}' environment", Boucher::Servers.in_env(args.env))
   end
 
-  desc "List AWS servers in specified class"
-  task :of_class, [:klass] do |t, args|
-    server_listing("of class '#{args.klass}'", Boucher::Servers.of_class(args.klass))
+  desc "List AWS servers of the specified meal"
+  task :of_meal, [:meal] do |t, args|
+    server_listing("of meal '#{args.meal}'", Boucher::Servers.of_meal(args.meal))
   end
 
   desc "Terminates the specified server"
@@ -67,7 +66,6 @@ web console and click Instance Actions -> Change Termination Protection -> Yes."
   desc "Stops the specified server"
   task :stop, [:server_id] do |t, args|
     server = Boucher.compute.servers.get(args.server_id)
-    Boucher::Nagios.remove_host(server)
     Boucher::Servers.stop(args.server_id)
   end
 
@@ -75,7 +73,6 @@ web console and click Instance Actions -> Change Termination Protection -> Yes."
   task :start, [:server_id] do |t, args|
     Boucher::Servers.start(args.server_id)
     server = Boucher.compute.servers.get(args.server_id)
-    Boucher::Nagios.add_host(server)
   end
 
   desc "Open an SSH session with the specified server"
@@ -87,11 +84,9 @@ web console and click Instance Actions -> Change Termination Protection -> Yes."
 
   desc "Download a file from the server"
   task :download, [:server_id, :filepath] do |t, args|
-    puts "Downloading #{args.filepath}"
-
-    server      = Boucher.compute.servers.get(args.server_id)
+    server = Boucher.compute.servers.get(args.server_id)
     remote_path = args.filepath
-    local_path  = File.expand_path(File.join("..", "..", File.basename(args.filepath)), __FILE__)
+    local_path = File.expand_path(File.join("..", "..", File.basename(args.filepath)), __FILE__)
 
     Boucher.download(server, remote_path, local_path)
   end
@@ -101,27 +96,22 @@ web console and click Instance Actions -> Change Termination Protection -> Yes."
     system "chmod 0600 *.pem"
   end
 
-  desc "Provision new server [#{Boucher.server_classes.keys.sort.join(', ')}]"
-  task :provision, [:klass] do |t, args|
-    class_map = Boucher.server_classes[args.klass.to_sym]
-    Boucher.provision(args.klass, class_map)
+  desc "Provision new server [#{Boucher.meals.keys.sort.join(', ')}]"
+  task :provision, [:meal] do |t, args|
+    meal = Boucher.meal(args.meal)
+    Boucher.provision(meal)
   end
 
-  desc "Provision new, or chef existing server of the specified class"
-  task :establish, [:klass] do |t, args|
-    Boucher.assert_env!
-    server = Boucher.find_server(args.klass, ENV['BUTCHER_ENV'])
-    Boucher.establish_server(server, args.klass)
+  desc "Provision new, or chef existing server of the specified meal"
+  task :establish, [:meal] do |t, args|
+    server = Boucher.find_server(args.meal, ENV['BUTCHER_ENV'])
+    Boucher.establish_server(server, args.meal)
   end
 
-  namespace :chef do
-    meals.each do |s_class|
-      desc "Cook #{s_class} meal"
-      task s_class, [:server_id] do |t, args|
-        Boucher.assert_env!
-        server = Boucher.compute.servers.get(args.server_id)
-        Boucher.cook_meal(server, s_class)
-      end
-    end
+  desc "Cook the given meal on the given server"
+  task :chef, [:meal, :server_id] do |t, args|
+    server = Boucher.compute.servers.get(args.server_id)
+    Boucher.cook_meal(server, args.meal)
   end
 end
+

data/spec/boucher/compute_spec.rb

@@ -1,6 +1,5 @@
 require_relative "../spec_helper"
 require 'boucher/compute'
-require 'boucher/nagios'
 require 'ostruct'
 
 describe "Boucher Cloud" do
@@ -25,22 +24,6 @@ describe "Boucher Cloud" do
     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")
 
@@ -50,12 +33,9 @@ describe "Boucher Cloud" do
     Boucher.ssh(server)
   end
 
-  it "updates recipes and rsyncs local changes" do
+  it "updates recipes" 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
@@ -65,8 +45,6 @@ describe "Boucher Cloud" do
 
     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"
 

data/spec/boucher/io_spec.rb

@@ -13,7 +13,7 @@ describe "Boucher IO" do
 
     output = $stdout.string
     puts "output: #{output}"
-    %w{ID Env Class Creator State Public IP Private IP}.each do |header|
+    %w{ID Env Meal Creator State Public IP Private IP}.each do |header|
       output.should include(header)
     end
   end
@@ -21,7 +21,7 @@ describe "Boucher IO" do
   it "prints a server" do
     server = OpenStruct.new(
             :id => "test_id",
-            :tags => {"Env" => "test_env", "Class" => "test_class", "Creator" => "Joe"},
+            :tags => {"Env" => "test_env", "Meal" => "test_class", "Creator" => "Joe"},
             :state => "test_state",
             :public_ip_address => "1.2.3.4")
 
@@ -36,22 +36,22 @@ describe "Boucher IO" do
     output.should include("1.2.3.4")
   end
 
-  it "prints servers ordered by Env, then Class" do
+  it "prints servers ordered by Env, then Meal" do
     server_1 = OpenStruct.new(
               :id => "test_id_1",
-              :tags => {"Env" => "test_env", "Class" => "test_class", "Creator" => "Joe"},
+              :tags => {"Env" => "test_env", "Meal" => "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"},
+              :tags => {"Env" => "better_env", "Meal" => "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"},
+              :tags => {"Env" => "better_env", "Meal" => "test_class_2", "Creator" => "Joe"},
               :state => "test_state",
               :public_ip_address => "1.2.3.6")
 

data/spec/boucher/{classes_spec.rb → meals_spec.rb}

@@ -1,8 +1,8 @@
 require_relative "../spec_helper"
-require 'boucher/classes'
+require 'boucher/meals'
 require 'ostruct'
 
-describe "Boucher Server Classes" do
+describe "Boucher Server Meals" do
 
   before do
     Boucher.stub(:current_user).and_return("joe")
@@ -11,21 +11,24 @@ describe "Boucher Server Classes" do
 
   it "pull classification from json" do
     json = "{\"boucher\": {\"foo\": 1,\n \"bar\": 2}}"
-    Boucher.json_to_class(json).should == {:foo => 1, :bar => 2}
+    Boucher.json_to_meal(json).should == {:foo => 1, :bar => 2}
+
+    json = "{}"
+    Boucher.json_to_meal(json).should == {}
   end
 
   it "can classify base server" do
-    some_class = {:class_name => "base",
+    some_class = {:meal_name => "base",
                   :meals => ["base"]}
     Boucher::Config[:default_instance_flavor_id] = 'm1.small'
     Boucher::Config[:default_instance_groups] = ["SSH"]
-    Boucher.classify(@server, some_class)
+    Boucher.setup_meal(@server, some_class)
 
     @server.image_id.should == Boucher::Config[:base_image_id]
     @server.flavor_id.should == 'm1.small'
     @server.groups.should == ["SSH"]
     @server.key_name.should == "test_key"
-    @server.tags["Class"].should == "base"
+    @server.tags["Meal"].should == "base"
     @server.tags["Name"].should_not == nil
     @server.tags["Creator"].should == "joe"
     @server.tags["Env"].should == Boucher::Config[:env]

data/spec/boucher/provision_spec.rb

@@ -13,65 +13,59 @@ describe "Boucher Provisioning" do
 
   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.should_receive(:meal).with("some_meal").and_return(:meal)
+      Boucher.should_receive(:provision).with(:meal)
 
-      Boucher.establish_server nil, "class_of_server"
+      Boucher.establish_server nil, "some_meal"
     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"})
+      meal = {:name => "some_meal"}
+      Boucher.stub(:meal).and_return(meal)
       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.should_receive(:cook_meal_on_server).with(meal, server)
 
-      Boucher.establish_server server, "class_of_server"
+      Boucher.establish_server server, "some_meal"
     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(:meal).and_return({:name => "some_meal", :elastic_ips => %w(1.2.3.4)})
       Boucher.stub(:change_server_state)
+      Boucher.stub(:cook_meal)
       Boucher.compute.should_receive(:associate_address).with(anything, "1.2.3.4")
 
-      Boucher.establish_server server, "class_of_server"
+      Boucher.establish_server server, "meal_name"
     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)
+      meal = {:name => "some_meal"}
+      Boucher.stub(:meal).and_return(meal)
+      Boucher.should_receive(:cook_meal_on_server).with(meal, running_server)
 
-      Boucher.establish_server running_server, "class_of_server"
+      Boucher.establish_server running_server, "some_meal"
     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.should_receive(:setup_meal)
+      Boucher.should_receive(:cook_meal).with(anything, "some_meal")
 
-      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"}]}
+      Boucher.provision :name => "some_meal"
     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.should_receive(:setup_meal)
+      Boucher.stub(:cook_meal)
       Boucher.compute.should_receive(:associate_address).with(anything, "1.2.3.4")
 
-      Boucher.provision "foo", {:meals => []}
+      Boucher.provision :name => "some_meal", :elastic_ips => %w(1.2.3.4)
     end
   end
 end

data/spec/boucher/servers_spec.rb

@@ -5,10 +5,10 @@ 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")]
+    [OpenStruct.new(:id => "s1", :tags => {"Env" => "test", "Meal" => "foo"}, :state => "stopped"),
+     OpenStruct.new(:id => "s2", :tags => {"Env" => "test", "Meal" => "bar"}, :state => "pending"),
+     OpenStruct.new(:id => "s3", :tags => {"Env" => "dev",  "Meal" => "foo"}, :state => "terminated"),
+     OpenStruct.new(:id => "s4", :tags => {"Env" => "dev",  "Meal" => "bar"}, :state => "running")]
   }
 
   before do
@@ -25,10 +25,10 @@ describe "Boucher::Servers" do
     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"]
+  it "finds mealed servers" do
+    Boucher::Servers.of_meal("blah").should == []
+    Boucher::Servers.of_meal(:foo).map(&:id).should == ["s1", "s3"]
+    Boucher::Servers.of_meal("bar").map(&:id).should == ["s2", "s4"]
   end
 
   it "finds with env servers" do
@@ -46,20 +46,20 @@ describe "Boucher::Servers" do
 
   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(:meal => "foo").id.should == "s1"
+    Boucher::Servers.find(:meal => "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
+    Boucher::Servers.find(:meal => "foo", :env => "test").id.should == "s1"
+    Boucher::Servers.find(:meal => "foo", :env => "dev").id.should == "s3"
+    Boucher::Servers.find(:meal => "bar", :env => "test").id.should == "s2"
+    Boucher::Servers.find(:meal => "bar", :env => "dev").id.should == "s4"
+    expect { Boucher::Servers.find(:meal => "blah", :env => "dev") }.to raise_error
+    expect { Boucher::Servers.find(:meal => "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)
+    expect { Boucher::Servers.find(:meal => "blah") }.to raise_error(Boucher::Servers::NotFound)
   end
 
   it "gets a server based on current env when all the servers are running" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: boucher
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: boucher/tasks
 bindir: bin
 cert_chain: []
-date: 2012-09-25 00:00:00.000000000 Z
+date: 2012-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -91,28 +91,24 @@ files:
 - 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/meals.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/meals_spec.rb
 - spec/boucher/provision_spec.rb
 - spec/boucher/servers_spec.rb
 - spec/boucher/storage_spec.rb
@@ -129,6 +125,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3836006143599038364
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -142,10 +141,10 @@ 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/meals_spec.rb
 - spec/boucher/provision_spec.rb
 - spec/boucher/servers_spec.rb
 - spec/boucher/storage_spec.rb

data/lib/boucher/ci.rb

@@ -1,18 +0,0 @@
-module Boucher
-  module CI
-    def self.each_server(&block)
-      threads = []
-      Boucher.each_required_server do |server, server_class|
-        thread = Thread.new { block.yield(server, server_class) }
-        threads << thread
-      end
-      threads.each { |t| t.join }
-    end
-
-    def self.terminate_server(server_class)
-      server = Boucher.get_server(server_class, "ci", "running")
-      Boucher.change_server_state server.id, :destroy, "terminated" if server
-    end
-  end
-end
-

data/lib/boucher/classes.rb

@@ -1,39 +0,0 @@
-require 'boucher/env'
-require 'boucher/util'
-require 'json'
-
-module Boucher
-
-  def self.json_to_class(json)
-    parser = JSON.parser.new(json, :symbolize_names => true)
-    config = parser.parse
-    config[:boucher]
-  end
-
-  def self.server_classes
-    if @server_classes.nil?
-      @server_classes = {}
-      Dir.glob(File.join("config", "*.json")).each do |file|
-        spec = json_to_class(IO.read(file))
-        class_name = File.basename(file).to_sym
-        @server_classes[class_name] = spec
-      end
-    end
-    @server_classes
-  end
-
-  def self.classify(server, class_spec)
-    server.image_id = class_spec[:base_image_id] || Boucher::Config[:base_image_id]
-    server.flavor_id = class_spec[:flavor_id] || Boucher::Config[:default_instance_flavor_id]
-    server.groups = class_spec[:groups] || Boucher::Config[:default_instance_groups]
-    server.key_name = class_spec[:key_name] || Boucher::Config[:aws_key_filename]
-    server.tags = {}
-    server.tags["Name"] = "#{class_spec[:class_name] || "base"} #{Time.new.strftime("%Y%m%d%H%M%S")}"
-    server.tags["Class"] = class_spec[:class_name] || "base"
-    server.tags["CreatedAt"] = Time.new.strftime("%Y%m%d%H%M%S")
-    server.tags["Creator"] = current_user
-    server.tags["Env"] = Boucher::Config[:env]
-    server.tags["Volumes"] = class_spec[:volumes]
-  end
-
-end

data/lib/boucher/nagios.rb

@@ -1,50 +0,0 @@
-require 'boucher/servers'
-require 'boucher/compute'
-
-module Boucher
-  module Nagios
-    def self.remove_host(host)
-      return if host.tags["Class"] == "nagios_server"
-
-      monitors_for(host.tags["Env"]).each do |monitor|
-        commands = [
-          "cd /home/#{Boucher::Config[:username]}/infrastructure",
-          "sudo rake nagios:remove_host[#{host.id}]",
-          "sudo /etc/init.d/nagios3 restart"
-        ]
-        Boucher.ssh(monitor, commands.join(" && "))
-      end
-    end
-
-    def self.add_host(host)
-      return if checks_for(host.tags["Class"]).empty?
-
-      monitors_for(host.tags["Env"]).each do |monitor|
-        commands = [
-          "cd /home/#{Boucher::Config[:username]}/infrastructure",
-          "sudo rake nagios:add_host[#{host.id},#{host.public_ip_address},#{host.tags["Class"]}]",
-          "sudo /etc/init.d/nagios3 restart"
-        ]
-
-        Boucher.ssh(monitor, commands.join(" && "))
-      end
-    end
-
-    def self.checks_for(server_class)
-      config_path = File.expand_path("../../../config/#{server_class}.json", __FILE__)
-      return [] unless File.exists? config_path
-      server_configuration = JSON.parse(File.read config_path)
-      server_configuration["nagios"] || []
-    end
-
-    private
-
-    def self.monitors_for(env)
-      Boucher::Servers.all.select do |monitor|
-        monitor.tags["Class"] == "nagios_server" &&
-        monitor.tags["Env"] == env &&
-        monitor.dns_name
-      end
-    end
-  end
-end

data/lib/boucher/tasks/env.rake

@@ -1,42 +0,0 @@
-require 'boucher/env'
-require 'boucher/provision'
-require 'retryable'
-
-namespace :env do
-
-  desc "Attaches elastic IPs"
-  task :elastic_ips, [:env] do |t, args|
-    Boucher.force_env!(args.env)
-    Boucher.each_required_server do |server, server_class|
-      Boucher.attach_elastic_ips(server_class, server)
-    end
-  end
-
-  desc "Starts and deploys all the servers for the specified environment"
-  task :start, [:env] do |t, args|
-    Boucher.force_env!(args.env)
-    Boucher.assert_env!
-    Boucher.establish_all_servers
-  end
-
-  desc "Stops all the servers for the specified environment"
-  task :stop, [:env] do |t, args|
-    Boucher.force_env!(args.env)
-
-    Boucher.each_required_server do |server, server_class|
-      if server
-        Boucher::Servers.stop(server.id)
-      else
-        puts "No #{server_class} server found for #{Boucher::Config[:env]} environment."
-      end
-    end
-  end
-
-  desc "Terminates all servers for the specified environment"
-  task :terminate, [:env] do |t, args|
-    Boucher.force_env!(args.env)
-    Boucher.each_required_server do |server, server_class|
-      Boucher::Servers.terminate(server) if server
-    end
-  end
-end

data/lib/boucher/tasks/nagios.rake

@@ -1,74 +0,0 @@
-require 'json'
-require 'fileutils'
-
-def make_config_path(host_name)
-  "/etc/nagios3/conf.d/#{host_name}.cfg"
-end
-
-def host_entry(host_name, ip)
-<<-HOST
-define host {
-  host_name             #{host_name}
-  alias                 #{host_name}
-  address               #{ip}
-  check_command         check_ssh
-  notification_interval 0
-  notification_period   24x7
-  max_check_attempts    10
-  notification_options  d,u,r
-  notifications_enabled 1
-}
-HOST
-end
-
-def service_entry(host_name, ip, plugin)
-<<-SERVICE
-define command {
-  command_name #{host_name}-#{plugin}
-  command_line /usr/lib/nagios/plugins/check_nrpe -H #{ip} -c "#{plugin}"
-}
-
-define service {
-  use                   generic-service
-  host_name             #{host_name}
-  check_command         #{host_name}-#{plugin}
-  service_description   #{plugin}
-  normal_check_interval 5
-  check_period          24x7
-  notifications_enabled 1
-}
-SERVICE
-end
-
-namespace :nagios do
-  desc "Remove a nagios host from this machine"
-  task :remove_host, [:name] do |t, args|
-    FileUtils.rm_f make_config_path(args.name)
-  end
-
-  desc "Adds a nagios host to be monitored by this machine"
-  task :add_host, [:name, :ip, :klass] do |t, args|
-    checks = Boucher::Nagios.checks_for(args.klass)
-    return if checks.empty?
-
-    File.open(make_config_path(args.name), "w") do |file|
-      host_name = "#{args.klass}-#{args.name}"
-
-      file.puts host_entry(host_name, args.ip)
-
-      checks.each do |plugin, command|
-        file.puts
-        file.puts service_entry(host_name, args.ip, plugin)
-      end
-    end
-  end
-
-  desc "Opens the nagios web console"
-  task :open do
-    server = Boucher::Servers["nagios_server"]
-    url = "http://#{server.public_ip_address}/nagios3"
-    puts "Nagios lives at #{url}"
-    puts "Login using nagiosadmin / 'we are many lonely souls'"
-    `open #{url}`
-  end
-end