boucher 0.1.8 → 0.2.0

data/README.md

@@ -119,11 +119,13 @@ allows you too add extra configuration information under the "Boucher": key.  Fo
         "groups": ["SSH"], // overides :default_groups config
         "key_name": ["some_key"], // overides :aws_key_filename config
         "elastic_ips": ["1.2.3.4"], // a list of elastic IPs that'll be attached to the server.  Elastic IP's acquired via AWS management console.
-        "volumes": ["some_volume"] // a list of volume names that'll be attached to the server.  Volumes acquired via AWS management console.
+        "volumes": {"/dev/sda2": <volume spec>} // See Volume Specs below
       }
     }
 
-ERB: The "boucher": content can contain ERB.  So you can use config params like so:
+### ERB in config
+
+Meal .json files may contain ERB in the "boucher" section.  However, the file get's parsed by chef-solo so it has to remain a valid JSON file.  But you can do things like this:
 
          {
            "run_list": ...
@@ -133,6 +135,28 @@ ERB: The "boucher": content can contain ERB.  So you can use config params like
            }
          }
 
+Also keep in mind that you can use ERB in recipes' template files.
+
+### Volume Specs
+
+Volumes may be specified in the config for a given meal. The "volumes": entry must be a hash where keys are the device name (mount point) and the values
+are a hash describing the volume.  There are really three variations:
+
+1) Mounting an existing volume by using the volume_id:
+
+    "volumes": {"/dev/sda3" => {"volume_id": "volume-abc123"}}
+
+2) Mount a new volume based on an existing snapshot:
+
+    "volumes": {"/dev/sda4" => {"snapshot_id": "snapshot-abc123"}}
+
+3) Mount a new volume of a given size:
+
+    "volumes": {"/dev/sda5" => {"size": 16}}
+
+If volumes are not specified, AWS will apply the default volume setup in the management console.
+
+
 ### Environments
 
 Enviroments are configured in config/env/<env_name>.rb. The project template we checked out earlier only provides one: dev.

data/TODO.md

@@ -0,0 +1,2 @@
+* security groups:  More thought required
+* EBS snapshots: More thought required

data/boucher.gemspec

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

data/lib/boucher/addresses.rb

@@ -0,0 +1,90 @@
+require 'boucher/compute'
+require 'boucher/servers'
+
+module Boucher
+
+  ADDRESS_TABLE_FORMAT = "%-15s  %-12s\n"
+
+  def self.print_addresses(addresses)
+    puts
+    printf ADDRESS_TABLE_FORMAT, "Public IP", "Server ID"
+    puts ("-" * 29)
+
+    addresses.each do |address|
+      printf ADDRESS_TABLE_FORMAT,
+             address.public_ip,
+             address.server_id
+    end
+  end
+
+  ADDRESS_OVERVIEW_TABLE_FORMAT = "%12s  %-15s  %-12s\n"
+
+  def self.print_address_overview(addresses)
+    puts
+    printf ADDRESS_OVERVIEW_TABLE_FORMAT, "Meal", "Public IP", "Server ID"
+    puts ("-" * 43)
+
+    addresses.values.each do |address|
+      printf ADDRESS_OVERVIEW_TABLE_FORMAT,
+             address[:meal],
+             address[:ip],
+             address[:server_id]
+    end
+  end
+
+  def self.address_overview
+    ips = {}
+    Boucher.compute.addresses.each do |ip|
+      ips[ip.public_ip] = {ip: ip.public_ip, server_id: ip.server_id}
+    end
+    Boucher.meals.each do |name, meal|
+      (meal[:elastic_ips] || []).each do |ip|
+        if ip.nil? || ip.size == 0
+          # skip
+        elsif ips[ip]
+          ips[ip][:meal] = name
+        else
+          ips[ip] = {meal: name, ip: ip}
+        end
+      end
+    end
+    ips
+  end
+
+  def self.associate_addresses_for(meal, server)
+    ips = meal[:elastic_ips]
+    if ips.nil? || ips.empty?
+      puts "No Elastic IPs to associate for meal #{meal[:name]}."
+      return
+    end
+    ips.each do |ip|
+      address = Boucher.compute.addresses.get(ip)
+      if address
+        if address.server_id == server.id
+          puts "#{ip} already associated with #{meal[:name]}:#{server.id}"
+        else
+          puts "Associating #{ip} with #{meal[:name]}:#{server.id}"
+          address.server = server
+        end
+      else
+        puts "Elastic IP (#{ip}) not found. Skipping."
+      end
+    end
+  end
+
+  def self.associate_all_addresses
+    meals = Boucher.meals
+    meals.each do |name, meal|
+      ips = meal[:elastic_ips]
+      if ips && ips.size > 0
+        begin
+          server = Boucher::Servers.find(meal: name, env: Boucher::Config[:env])
+          associate_addresses_for(meal, server)
+        rescue Boucher::Servers::NotFound => e
+          puts "Can't associate address to '#{name}' server because it can't be found."
+        end
+      end
+    end
+  end
+
+end

data/lib/boucher/compute.rb

@@ -54,19 +54,4 @@ module Boucher
   rescue Exception => e
     false
   end
-
-  def self.change_server_state(server_id, command, new_state)
-    print "#{command}-ing server #{server_id}..."
-    server = compute.servers.get(server_id)
-    server.send(command.to_sym)
-    server.wait_for { print "."; state == new_state }
-    puts
-    Boucher.print_servers [server]
-    puts
-    puts "The server has been #{command}-ed."
-  end
-
-  def self.find_servers
-    compute.servers
-  end
 end

data/lib/boucher/env.rb

@@ -5,7 +5,7 @@ module Boucher
   } unless defined?(Boucher::Config)
 
   def self.env_name
-    ENV["BENV"] ? ENV["BENV"] : :dev
+    Boucher::Config[:env] || ENV["BENV"] || :dev
   end
 
   env_dir = File.expand_path("config/env")

data/lib/boucher/io.rb

@@ -22,87 +22,4 @@ module Boucher
     end
   end
 
-  SERVER_TABLE_FORMAT = "%-12s  %-12s  %-10s  %-10s  %-10s  %-15s  %-15s %-10s\n"
-
-  def self.print_server_table_header
-    puts
-    printf SERVER_TABLE_FORMAT, "ID", "Environment", "Meal", "Creator", "State", "Public IP", "Private IP", "Inst. Size"
-    puts ("-" * 120)
-  end
-
-  def self.print_server(server)
-    printf SERVER_TABLE_FORMAT,
-           server.id,
-           (server.tags["Env"] || "???")[0...12],
-           (server.tags["Meal"] || "???")[0...10],
-           (server.tags["Creator"] || "???")[0...10],
-           server.state,
-           server.public_ip_address,
-           server.private_ip_address,
-           server.flavor_id
-  end
-
-  def self.print_servers(servers)
-    print_server_table_header
-    sorted_servers = servers.sort_by{|s| [s.tags["Env"] || "?",
-                                          s.tags["Meal"] || "?"]}
-    sorted_servers.each do |server|
-      print_server(server) if server
-    end
-    puts
-  end
-
-  def self.print_volumes(volumes)
-    id_sizes = []
-    size_sizes = []
-    state_sizes = []
-    zone_sizes = []
-    snapshot_sizes = []
-
-    Array(volumes).each do |volume|
-      id_sizes << volume.id.length
-      size_sizes << volume.size.to_s.length
-      state_sizes << volume.state.length
-      zone_sizes << volume.availability_zone.length
-      snapshot_sizes << volume.snapshot_id.to_s.length
-    end
-
-    id_length = id_sizes.max + 5
-    size_length = size_sizes.max + 5
-    state_length = state_sizes.max + 5
-    zone_length = zone_sizes.max + 5
-    snapshot_length = snapshot_sizes.max
-
-    puts "ID#{" "*(id_length - 2)}Size#{" "*(size_length - 4)}State#{" "*(state_length - 5)}Zone#{" "*(zone_length - 4)}Snapshot"
-    puts "-"*(id_length + size_length + state_length + zone_length + snapshot_length)
-
-    Array(volumes).each do |volume|
-      puts "#{volume.id}#{" "*(id_length - volume.id.length)}#{volume.size}GB#{" "*(size_length - volume.size.to_s.length - 2)}#{volume.state}#{" "*(state_length - volume.state.length)}#{volume.availability_zone}#{" "*(zone_length - volume.availability_zone.length)}#{volume.snapshot_id}#{" "*(snapshot_length - volume.snapshot_id.to_s.length)}"
-    end
-  end
-
-  FILE_TABLE_FORMAT = "%-60s  %-10s  %-25s  %-32s\n"
-
-  def self.print_file_table_header
-    puts
-    printf FILE_TABLE_FORMAT, "Key", "Size", "Last Modified", "etag"
-    puts ("-" * 150)
-  end
-
-  def self.print_file(file)
-    printf FILE_TABLE_FORMAT,
-           file.key,
-           file.content_length,
-           file.last_modified,
-           file.etag
-  end
-
-  def self.print_files(files)
-    print_file_table_header
-    files.each do |file|
-      print_file(file) if file
-    end
-    puts
-  end
-
 end

data/lib/boucher/provision.rb

@@ -2,6 +2,7 @@ require 'boucher/compute'
 require 'boucher/io'
 require 'boucher/servers'
 require 'boucher/volumes'
+require 'boucher/addresses'
 require 'retryable'
 
 module Boucher
@@ -23,7 +24,7 @@ module Boucher
     if server.nil?
       Boucher.provision(meal)
     elsif server.state == "stopped"
-      Boucher::Servers.start(server.id)
+      Boucher::Servers.start([server])
       server.reload
       Boucher.cook_meal_on_server(meal, server)
     else
@@ -36,28 +37,17 @@ module Boucher
     server = create_meal_server(meal)
     wait_for_server_to_boot(server)
     wait_for_server_to_accept_ssh(server)
-    volumes = create_volumes(meal, server)
-    attach_volumes(volumes, server)
+    attach_volumes(meal, server)
     cook_meal_on_server(meal, server)
     puts "\nThe new #{meal[:name]} server has been provisioned! id: #{server.id}"
   end
 
-  def self.attach_elastic_ips(meal, server)
-    puts "Attaching elastic IPs..."
-    ips = meal[:elastic_ips] || []
-
-    ips.each do |ip|
-      puts "Associating #{server.id} with #{ip}"
-      compute.associate_address(server.id, ip)
-    end
-  end
-
   private
 
   def self.cook_meal_on_server(meal, server)
     puts "Cooking meal '#{meal[:name]}' on server: #{server}"
     Boucher.cook_meal(server, meal[:name])
-    attach_elastic_ips(meal, server)
+    associate_addresses_for(meal, server)
   end
 
   def self.wait_for_server_to_accept_ssh(server)
@@ -81,21 +71,28 @@ module Boucher
     server
   end
 
-  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}..."
-      Boucher::Volumes.create(server.availability_zone, snapshot, attributes[:device])
+  def self.attach_volumes(meal, server)
+    volumes = meal[:volumes]
+    return unless volumes && volumes.size > 0
+    puts "Attaching volumes..."
+    volumes.each do |device, spec|
+      volume = acquire_volume(spec, server)
+      print "Attaching volume #{volume.id} to #{server.id}..."
+      Boucher.compute.attach_volume(server.id, volume.id, device)
+      volume.wait_for { print "."; volume.state == "in-use" }
+      puts
     end
   end
 
-  def self.attach_volumes(volumes, server)
-    volumes.each do |volume|
-      print "Attaching volume #{volume.id} to #{server.id}..."
-      Boucher::Volumes.attach(volume, server)
-      volume.wait_for { print "."; state == "in-use" }
-      puts
+  def self.acquire_volume(spec, server)
+    if spec[:volume_id]
+      Boucher.compute.volumes.get(spec[:volume_id])
+    elsif spec[:snapshot_id]
+      puts "Creating volume based on snapshot: #{spec[:snapshot_id]}"
+      Boucher::Volumes.create(:snapshot_id => spec[:snapshot_id], :availability_zone => server.availability_zone)
+    else
+      puts "Creating new volume of size: #{spec[:size]}GB"
+      Boucher::Volumes.create(:size => spec[:size].to_i, :availability_zone => server.availability_zone)
     end
   end
 end

data/lib/boucher/servers.rb

@@ -1,10 +1,45 @@
 require 'boucher/compute'
 
 module Boucher
+
+  SERVER_TABLE_FORMAT = "%-12s  %-12s  %-10s  %-10s  %-10s  %-15s  %-15s %-10s\n"
+
+  def self.print_server_table_header
+    puts
+    printf SERVER_TABLE_FORMAT, "ID", "Environment", "Meal", "Creator", "State", "Public IP", "Private IP", "Inst. Size"
+    puts ("-" * 107)
+  end
+
+  def self.print_server(server)
+    printf SERVER_TABLE_FORMAT,
+           server.id,
+           (server.tags["Env"] || "???")[0...12],
+           (server.tags["Meal"] || "???")[0...10],
+           (server.tags["Creator"] || "???")[0...10],
+           server.state,
+           server.public_ip_address,
+           server.private_ip_address,
+           server.flavor_id
+  end
+
+  def self.print_servers(servers)
+    print_server_table_header
+    sorted_servers = servers.sort_by { |s| [s.tags["Env"] || "?",
+                                            s.tags["Meal"] || "?"] }
+    sorted_servers.each do |server|
+      print_server(server) if server
+    end
+    puts
+  end
+
   module Servers
     NotFound = Class.new(StandardError)
 
     class << self
+      def clear
+        @instance = nil
+      end
+
       def instance
         reload if !@instance
         @instance
@@ -48,44 +83,67 @@ module Boucher
     end
 
     def in_env(env)
-      Servers.cultivate(self.find_all {|s| s.tags["Env"] == env.to_s })
+      Servers.cultivate(self.find_all { |s| s.tags["Env"] == env.to_s })
     end
 
     def in_state(state)
-      Servers.cultivate(self.find_all {|s| s.state == state.to_s })
+      if state[0] == "!"
+        state = state[1..-1]
+        Servers.cultivate(self.find_all { |s| s.state != state.to_s })
+      else
+        Servers.cultivate(self.find_all { |s| s.state == state.to_s })
+      end
     end
 
     def of_meal(meal)
-      Servers.cultivate(self.find_all {|s| s.tags["Meal"] == meal.to_s })
+      Servers.cultivate(self.find_all { |s| s.tags["Meal"] == meal.to_s })
     end
 
-    def self.start(server_id)
-      Boucher.change_server_state(server_id, :start, "running")
+    def self.start(servers)
+      Boucher.change_servers_state(servers, :start, "running")
     end
 
-    def self.stop(server_id)
-      Boucher.change_server_state(server_id, :stop, "stopped")
+    def self.stop(servers)
+      Boucher.change_servers_state(servers, :stop, "stopped")
     end
 
-    def self.terminate(server)
-      volumes = server.volumes
-      volumes_to_destroy = volumes.select {|v| !v.delete_on_termination}
-
-      Boucher.change_server_state server.id, :destroy, "terminated"
+    def self.restart(servers)
+      Boucher.change_servers_state(servers, :stop, "stopped")
+      Boucher.change_servers_state(servers, :start, "running")
+    end
 
-      volumes_to_destroy.each do |volume|
-        volume.wait_for { volume.state == 'available' }
-        puts "Destroying volume #{volume.id}..."
-        Boucher::Volumes.destroy(volume)
-      end
+    def self.terminate(servers)
+      Boucher.change_servers_state(servers, :destroy, "terminated")
     end
 
     def with_id(server_id)
-      Servers.cultivate(self.find_all {|s| s.id == server_id}).first
+      Servers.cultivate(self.find_all { |s| s.id == server_id }).first
     end
 
     def [](meal)
       find(:env => Boucher::Config[:env], :meal => meal, :state => "running")
     end
   end
+
+  def self.change_servers_state(servers, command, new_state)
+    print "#{command}-ing servers #{servers.map(&:id).join(", ")}..."
+    servers.each { |s| s.send(command.to_sym) }
+    servers.each { |s| s.wait_for { print "."; s.state == new_state }}
+    puts
+    Boucher.print_servers servers
+    puts
+    puts "The servers have been #{command}-ed."
+  end
+
+  def self.resolve_servers(id_or_meal)
+    if id_or_meal[0..1] == "i-"
+      puts "Retrieving server with id #{id_or_meal}..."
+      [Boucher::Servers.with_id(id_or_meal)]
+    else
+      puts "Searching for running #{id_or_meal} servers in #{Boucher.env_name} environment..."
+      servers = Boucher::Servers.search(:meal => id_or_meal, :env => Boucher.env_name, :state => "!terminated")
+      Boucher::print_servers(servers)
+      servers
+    end
+  end
 end

data/lib/boucher/storage.rb

@@ -15,11 +15,35 @@ module Boucher
     @store
   end
 
+  FILE_TABLE_FORMAT = "%-60s  %-10s  %-25s  %-32s\n"
+
+  def self.print_file_table_header
+    puts
+    printf FILE_TABLE_FORMAT, "Key", "Size", "Last Modified", "etag"
+    puts ("-" * 150)
+  end
+
+  def self.print_file(file)
+    printf FILE_TABLE_FORMAT,
+           file.key,
+           file.content_length,
+           file.last_modified,
+           file.etag
+  end
+
+  def self.print_files(files)
+    print_file_table_header
+    files.each do |file|
+      print_file(file) if file
+    end
+    puts
+  end
+
   module Storage
 
     def self.list(dir_name)
       dir = Boucher.storage.directories.get(dir_name)
-      result = dir.files.select {|f| f.key[-1] != "/" }.to_a
+      result = dir.files.select { |f| f.key[-1] != "/" }.to_a
       result
     end
 
@@ -36,7 +60,7 @@ module Boucher
       dir = Boucher.storage.directories.get(dir_name)
       url = dir.files.get_https_url(key, Time.now + 3600)
       Kernel.system("curl", url, "-o", filename)
-      dir.files.detect{|f| f.key == key}
+      dir.files.detect { |f| f.key == key }
     end
 
   end

data/lib/boucher/tasks/addresses.rake

@@ -0,0 +1,42 @@
+require 'boucher/addresses'
+
+namespace :addresses do
+
+  desc "Prints a list of allocated Elastic IP addresses"
+  task :list do
+    Boucher.print_address_overview(Boucher.address_overview)
+  end
+
+  desc "Allocates a new Elastic IP address"
+  task :allocate do
+    puts "Allocation a new Elastic IP address..."
+    address = Boucher.compute.addresses.create
+    Boucher.print_addresses([address])
+  end
+
+  desc "Releases an Elastic IP address"
+  task :deallocate, [:ip] do |t, args|
+    puts "Deallocating Elastic IP address: #{args.ip} ..."
+    address = Boucher.compute.addresses.get(args.ip)
+    raise "Elastic IP address not found: #{args.ip}" unless address
+    address.destroy
+    puts "Done."
+  end
+
+  desc "Associates an Elastic IP with a specific server"
+  task :associate, [:ip, :server_id] do |t, args|
+    server = Boucher.compute.servers.get(args.server_id)
+    raise "Server not found!" unless server
+    address = Boucher.compute.addresses.get(args.ip)
+    raise "Elastic IP not found!" unless address
+    address.server = server
+    Boucher.print_addresses [address]
+  end
+
+  desc "Associates all unbound Elastic IP addresses configured for all meals"
+  task :push do
+    Boucher.associate_all_addresses
+  end
+
+
+end

data/lib/boucher/tasks/servers.rake

@@ -44,17 +44,12 @@ namespace :servers do
     server_listing("of meal '#{args.meal}'", Boucher::Servers.of_meal(args.meal))
   end
 
-  desc "Terminates the specified server"
-  task :terminate, [:server_id] do |t, args|
-    server = Boucher::Servers.with_id(args.server_id)
-
-    if !server
-      puts "Server #{args.server_id} does not exist"
-      exit 1
-    end
+  desc "Terminates the specified server(s)"
+  task :terminate, [:id_or_meal] do |t, args|
+    servers = Boucher.resolve_servers(args.id_or_meal)
 
     begin
-      Boucher::Servers.terminate(server)
+      Boucher::Servers.terminate(servers) if !servers.empty?
     rescue => e
       puts "\nTermination failed. This may be due to termination protection. If
 you're sure you wish to disable this protection, select the instance in the AWS
@@ -63,16 +58,22 @@ web console and click Instance Actions -> Change Termination Protection -> Yes."
     end
   end
 
-  desc "Stops the specified server"
-  task :stop, [:server_id] do |t, args|
-    server = Boucher.compute.servers.get(args.server_id)
-    Boucher::Servers.stop(args.server_id)
+  desc "Stops the specified server(s)"
+  task :stop, [:id_or_meal] do |t, args|
+    servers = Boucher.resolve_servers(args.id_or_meal)
+    Boucher::Servers.stop(servers) if !servers.empty?
   end
 
-  desc "Starts the specified server"
-  task :start, [:server_id] do |t, args|
-    Boucher::Servers.start(args.server_id)
-    server = Boucher.compute.servers.get(args.server_id)
+  desc "Starts the specified server(s)"
+  task :start, [:id_or_meal] do |t, args|
+    servers = Boucher.resolve_servers(args.id_or_meal)
+    Boucher::Servers.start(servers) if !servers.empty?
+  end
+
+  desc "Restarts the specified server(s)"
+  task :restart, [:id_or_meal] do |t, args|
+    servers = Boucher.resolve_servers(args.id_or_meal)
+    Boucher::Servers.restart(servers) if !servers.empty?
   end
 
   desc "Open an SSH session with the specified server"
@@ -110,17 +111,10 @@ web console and click Instance Actions -> Change Termination Protection -> Yes."
     Boucher.establish_server(server, args.meal)
   end
 
-  desc "Cook the specified meal on the instance specified, or deployed instances of that meal"
+  desc "Cook the specified meal on the instance(s) specified by the given id or meal"
   task :chef, [:meal, :server_id] do |t, args|
     Boucher.assert_env!
-    servers = []
-    if(args.server_id)
-      servers = [Boucher.compute.servers.get(args.server_id)]
-    else
-      puts "Searching for running #{args.meal} servers in #{Boucher.env_name} environment..."
-      servers = Boucher::Servers.search(:meal => args.meal, :env => Boucher.env_name, :state => "running")
-      puts "Found #{servers.size}."
-    end
+    servers = resolve_servers(args.server_id || args.meal)
     servers.each do |server|
       Boucher.cook_meal(server, args.meal)
     end

data/lib/boucher/tasks/volumes.rake

@@ -9,6 +9,12 @@ namespace :volumes do
 
   desc "Destroy the specified volume"
   task :destroy, [:volume_id] do |t, args|
-    Boucher.destroy_volume(args.volume_id)
+    volume = Boucher::Volumes.with_id(args.volume_id)
+    if volume
+      puts "Destroying volume:"
+      print_volumes [volume]
+    else
+      raise "Volume not found: #{args.volume_id}"
+    end
   end
 end

data/lib/boucher/volumes.rb

@@ -1,9 +1,23 @@
 require 'boucher/compute'
 
 module Boucher
-  def self.destroy_volume(volume_id)
-    volume = Boucher::Volumes.with_id(volume_id)
-    Volumes.destroy(volume)
+
+  VOLUME_TABLE_FORMAT = "%-12s  %-15s  %-6s  %-10s  %-10s  %-13s\n"
+
+  def self.print_volumes(volumes)
+    puts
+    printf VOLUME_TABLE_FORMAT, "ID", "Name", "Size", "Server", "State", "Snapshot"
+    puts ("-" * 76)
+
+    volumes.each do |volume|
+      printf VOLUME_TABLE_FORMAT,
+             volume.id,
+             (volume.tags["Name"] || "")[0...15],
+             volume.size.to_s + "GB",
+             volume.server_id,
+             volume.state,
+             volume.snapshot_id
+    end
   end
 
   module Volumes
@@ -19,23 +33,25 @@ module Boucher
     end
 
     def self.with_id(volume_id)
-      all.find {|volume| volume.id == volume_id}
+      all.find { |volume| volume.id == volume_id }
     end
 
-    def self.create(zone, snapshot, device)
-      response  = Boucher.compute.create_volume(zone, snapshot.volume_size.to_i, snapshot.id)
+    def self.create(options)
+      zone = options[:availability_zone]
+      raise ":availability_zone is required to create a volume." unless zone
+      size = options[:size]
+      snapshot_id = options[:snapshot_id]
+      response = if snapshot_id
+        snapshot = Boucher::compute.snapshots.get(snapshot_id)
+        size = snapshot.volume_size.to_i
+        Boucher.compute.create_volume(zone, size, "SnapshotId" => snapshot_id)
+      else
+        Boucher.compute.create_volume(zone, size)
+      end
       volume_id = response.body["volumeId"]
-      volume    = Boucher.compute.volumes.get(volume_id)
-
-      volume.wait_for { ready? }
-      volume.device = device
+      volume = Boucher.compute.volumes.get(volume_id)
+      volume.wait_for { volume.ready? }
       volume
     end
-
-    def self.attach(volumes, server)
-      Array(volumes).each do |volume|
-        Boucher.compute.attach_volume(server.id, volume.id, volume.device)
-      end
-    end
   end
 end

data/spec/boucher/addresses_spec.rb

@@ -0,0 +1,73 @@
+require_relative "../spec_helper"
+require 'boucher/addresses'
+require 'ostruct'
+
+describe "Boucher Addresses" do
+
+  before do
+    Boucher::Servers.clear
+  end
+
+  after do
+    Boucher::Servers.all.each { |s| s.destroy }
+    Boucher::Config[:env] = "test"
+  end
+
+  it "does nothing for meal with no elastic ips" do
+    server = Boucher.compute.servers.create(tags: {"Meal" => "some_meal"})
+
+    Boucher.associate_addresses_for({name: "some_meal"}, server)
+
+    server.reload
+    server.addresses.should == []
+  end
+
+  it "associates ips for server" do
+    server = Boucher.compute.servers.create(tags: {"Meal" => "some_meal"})
+    ip = Boucher.compute.addresses.create
+
+    meal = {name: "some_meal", elastic_ips: [ip.public_ip]}
+    Boucher.associate_addresses_for(meal, server)
+
+    server.reload
+    server.addresses.count.should == 1
+    server.addresses.first.public_ip.should == ip.public_ip
+  end
+
+  it "associating ips skips missing ips" do
+    server = Boucher.compute.servers.create(tags: {"Meal" => "some_meal"})
+
+    meal = {name: "some_meal", elastic_ips: ["1.2.3.4"]}
+
+    lambda { Boucher.associate_addresses_for(meal, server) }.should_not raise_error
+  end
+
+  it "associates all ips for all meals" do
+    server1 = Boucher.compute.servers.create(tags: {"Meal" => "meal1", "Env" => "test"})
+    server2 = Boucher.compute.servers.create(tags: {"Meal" => "meal2", "Env" => "test"})
+    ip1 = Boucher.compute.addresses.create
+    ip2 = Boucher.compute.addresses.create
+
+    meals = {meal1: {name: "meal1", elastic_ips: [ip1.public_ip]},
+             meal2: {name: "meal2", elastic_ips: [ip2.public_ip]}}
+    Boucher.stub(:meals).and_return meals
+
+    Boucher.associate_all_addresses
+
+    server1.reload
+    server1.addresses.size.should == 1
+    server1.addresses.first.public_ip.should == ip1.public_ip
+    server2.reload
+    server2.addresses.first.public_ip.should == ip2.public_ip
+  end
+
+  it "associate all with missing server doesn't crash" do
+    ip = Boucher.compute.addresses.create
+
+    Boucher.meals[:some_meal] = {name: "some_meal", elastic_ips: [ip.public_ip]}
+
+    lambda { Boucher.associate_all_addresses }.should_not raise_error
+  end
+
+
+end

data/spec/boucher/provision_spec.rb

@@ -4,7 +4,7 @@ require 'boucher/provision'
 describe "Boucher Provisioning" do
 
   before do
-    Boucher::Config[:elastic_ips] = nil
+    Boucher::Servers.clear
   end
 
   after do
@@ -23,23 +23,13 @@ describe "Boucher Provisioning" do
       server = mock(:id => "the id", :state => "stopped")
       meal = {:name => "some_meal"}
       Boucher.stub(:meal).and_return(meal)
-      Boucher.should_receive(:change_server_state).with("the id", :start, "running")
+      Boucher.should_receive(:change_servers_state).with([server], :start, "running")
       server.should_receive(:reload)
       Boucher.should_receive(:cook_meal_on_server).with(meal, server)
 
       Boucher.establish_server server, "some_meal"
     end
 
-    it "attaches elastic IPs if the server was stopped" do
-      server = mock(:id => "the id", :state => "stopped", :reload => nil)
-      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, "meal_name"
-    end
-
     it "cooks meals on server if it is up and running" do
       running_server = mock(:id => "the id", :state => "running")
       meal = {:name => "some_meal"}
@@ -60,12 +50,73 @@ describe "Boucher Provisioning" do
     end
 
     it "provisions a server with elastic IP" do
+      Boucher.compute.key_pairs.create(name: "test_key")
+      ip = Boucher.compute.addresses.create
+      Boucher.stub!(:ssh)
+      Boucher.stub!(:cook_meal)
+
+      Boucher.provision :name => "some_meal", :elastic_ips => [ip.public_ip]
+
+      server = Boucher::Servers["some_meal"]
+      server.reload
+      server.addresses.size.should == 1
+      server.addresses.first.public_ip.should == ip.public_ip
+    end
+
+    it "attaches volumes" do
       Boucher.stub!(:ssh)
       Boucher.should_receive(:setup_meal)
-      Boucher.stub(:cook_meal)
-      Boucher.compute.should_receive(:associate_address).with(anything, "1.2.3.4")
+      Boucher.stub(:cook_meals_on_server)
+
+      Boucher.should_receive(:attach_volumes)
+
+      Boucher.provision :name => "some_meal", :volumes => {}
+    end
+  end
 
-      Boucher.provision :name => "some_meal", :elastic_ips => %w(1.2.3.4)
+  context "Volumes" do
+
+    let(:server) { server = Boucher.compute.servers.new; server.save; server }
+
+    it "attaches an existing volume" do
+      volume = Boucher::Volumes.create(:size => 12, :availability_zone => "us-east-1c")
+
+      meal_spec = {:volumes => {"/dev/sda2" => {:volume_id => volume.id}}}
+      Boucher.attach_volumes(meal_spec, server)
+
+      server.reload
+      server.volumes.size.should == 1
+      server.volumes.first.device.should == "/dev/sda2"
+      server.volumes.first.availability_zone.should == "us-east-1c"
+      server.volumes.first.size.should == 12
+    end
+
+    it "attaches a new volume based on a snapshot" do
+      old_volume = Boucher::Volumes.create(:size => 12, :availability_zone => "us-east-1c")
+      response = old_volume.snapshot("test")
+      snapshot_id = response.body["snapshotId"]
+
+      meal_spec = {:volumes => {"/dev/sda3" => {:snapshot_id => snapshot_id}}}
+      Boucher.attach_volumes(meal_spec, server)
+
+      server.reload
+      server.volumes.size.should == 1
+      volume = server.volumes.first
+      volume.snapshot_id.should == snapshot_id
+      volume.size.should == 12
+      volume.device.should == "/dev/sda3"
+    end
+
+    it "attaches a new volume with specified size" do
+      meal_spec = {:volumes => {"/dev/sda4" => {:size => 42}}}
+      Boucher.attach_volumes(meal_spec, server)
+
+      server.reload
+      server.volumes.size.should == 1
+      volume = server.volumes.first
+      volume.size.should == 42
+      volume.device.should == "/dev/sda4"
     end
+
   end
 end

data/spec/boucher/servers_spec.rb

@@ -44,6 +44,13 @@ describe "Boucher::Servers" do
     Boucher::Servers.in_state("stopped").map(&:id).should == ["s1"]
   end
 
+  it "finds servers NOT in a given state" do
+    Boucher::Servers.in_state("!running").map(&:id).should == %w(s1 s2 s3)
+    Boucher::Servers.in_state("!terminated").map(&:id).should == %w(s1 s2 s4)
+    Boucher::Servers.in_state("!pending").map(&:id).should == %w(s1 s3 s4)
+    Boucher::Servers.in_state("!stopped").map(&:id).should == %w(s2 s3 s4)
+  end
+
   it "finds the first matching server" do
     Boucher::Servers.find.id.should == "s1"
     Boucher::Servers.find(:meal => "foo").id.should == "s1"
@@ -73,7 +80,8 @@ describe "Boucher::Servers" do
   end
 
   it "stops a server" do
-    Boucher.should_receive(:change_server_state).with("the id", :stop, "stopped")
-    Boucher::Servers.stop("the id")
+    server = OpenStruct.new(:id => "the id")
+    Boucher.should_receive(:change_servers_state).with([server], :stop, "stopped")
+    Boucher::Servers.stop([server])
   end
 end

data/spec/boucher/util_spec.rb

@@ -0,0 +1,6 @@
+require_relative "../spec_helper"
+require 'boucher/util'
+
+describe "Boucher Util" do
+
+end

data/spec/boucher/volumes_spec.rb

@@ -0,0 +1,50 @@
+require_relative "../spec_helper"
+require 'boucher/volumes'
+require 'ostruct'
+
+describe "Boucher::Volumes" do
+
+  context "with mocked volumes" do
+    let(:remote_volumes) {
+      [OpenStruct.new(:id => "v1", :tags => {"Name" => "1", "Meal" => "foo"}, :size => 8),
+       OpenStruct.new(:id => "v2", :tags => {"Name" => "2", "Meal" => "bar"}, :size => 16),
+       OpenStruct.new(:id => "v3", :tags => {"Name" => "3", "Meal" => "foo"}, :size => 32)]
+    }
+
+    before do
+      Boucher.compute.stub(:volumes).and_return(remote_volumes)
+    end
+
+    after do
+      Boucher::Config[:env] = "test"
+    end
+
+    it "finds all volumes" do
+      Boucher::Volumes.all.size.should == 3
+      Boucher::Volumes.all.should == remote_volumes
+    end
+
+    it "finds volumes by id" do
+      Boucher::Volumes.with_id("v1").should == remote_volumes[0]
+      Boucher::Volumes.with_id("v2").should == remote_volumes[1]
+      Boucher::Volumes.with_id("v3").should == remote_volumes[2]
+    end
+  end
+
+  it "creates a volume" do
+    volume = Boucher::Volumes.create(:size => 12, :availability_zone => "us-east-1c")
+
+    volume.availability_zone.should == "us-east-1c"
+    volume.size.should == 12
+  end
+
+  it "creates a volume with snapshot" do
+    volume = Boucher::Volumes.create(:size => 12, :availability_zone => "us-east-1c")
+    response = volume.snapshot("test")
+
+    new_volume = Boucher::Volumes.create(:snapshot_id => response.body["snapshotId"], :availability_zone => "us-east-1c")
+
+    new_volume.size.should == 12
+    new_volume.availability_zone.should == "us-east-1c"
+  end
+end

data/spec/spec_helper.rb

@@ -19,18 +19,19 @@ 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'
+# Unfortunately, Fog mocks depends on real time delays :.-(
+#module Fog
+#  def self.wait_for(timeout=Fog.timeout, interval=1)
+#    yield
+#  end
+#end
 
-module Fog
-  class Model
-    def wait_for(timeout=Fog.timeout, interval=1, &block)
-      yield
-    end
-  end
-end
+#require 'fog/core/model'
+#
+#module Fog
+#  class Model
+#    def wait_for(timeout=Fog.timeout, interval=1, &block)
+#      yield
+#    end
+#  end
+#end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: boucher
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-27 00:00:00.000000000 Z
+date: 2012-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -90,7 +90,9 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- TODO.md
 - boucher.gemspec
+- lib/boucher/addresses.rb
 - lib/boucher/compute.rb
 - lib/boucher/env.rb
 - lib/boucher/io.rb
@@ -99,12 +101,14 @@ files:
 - lib/boucher/servers.rb
 - lib/boucher/storage.rb
 - lib/boucher/tasks.rb
+- lib/boucher/tasks/addresses.rake
 - lib/boucher/tasks/console.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/addresses_spec.rb
 - spec/boucher/compute_spec.rb
 - spec/boucher/env_spec.rb
 - spec/boucher/io_spec.rb
@@ -112,6 +116,8 @@ files:
 - spec/boucher/provision_spec.rb
 - spec/boucher/servers_spec.rb
 - spec/boucher/storage_spec.rb
+- spec/boucher/util_spec.rb
+- spec/boucher/volumes_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/8thlight/boucher
 licenses: []
@@ -125,9 +131,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -3841890267981667096
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -141,6 +144,7 @@ signing_key:
 specification_version: 3
 summary: AWS system deployment and management
 test_files:
+- spec/boucher/addresses_spec.rb
 - spec/boucher/compute_spec.rb
 - spec/boucher/env_spec.rb
 - spec/boucher/io_spec.rb
@@ -148,4 +152,6 @@ test_files:
 - spec/boucher/provision_spec.rb
 - spec/boucher/servers_spec.rb
 - spec/boucher/storage_spec.rb
+- spec/boucher/util_spec.rb
+- spec/boucher/volumes_spec.rb
 - spec/spec_helper.rb