ec2launcher 1.0.10 → 1.0.11

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 1.0.11
+
+* Support launching multiple instances with one command.
+
 ## 1.0.10
 
 * Support multiple "gem" definitions in applications.

data/lib/ec2launcher/block_device_builder.rb

@@ -7,7 +7,6 @@ module EC2Launcher
   # Helper class to build EC2 block device definitions.
   #
   class BlockDeviceBuilder
-    attr_reader :block_device_setup
     attr_reader :block_device_mappings
     attr_reader :block_device_tags
 
@@ -18,11 +17,63 @@ module EC2Launcher
       @ec2 = ec2
       @block_size = volume_size
       @volume_size ||= EC2Launcher::DEFAULT_VOLUME_SIZE
-    
-      @block_device_setup = {}
+
       @block_device_mappings = {}
       @block_device_tags = {}
     end
+
+    # Generates the mappings for ephemeral and ebs volumes.
+    #
+    # @param [String] instance_type type of instance. See EC2Launcher::Defaults::INSTANCE_TYPES.
+    # @param [EC2Launcher::Environment] environment current environment
+    # @param [EC2Launcher::Application] application current application
+    # @param [String, nil] clone_host FQDN of host to clone or nil to skip cloning.
+    #
+    # @return [Hash<String, Hash] returns a mapping of device names to device details
+    #
+    def generate_block_devices(instance_type, environment, application, clone_host = nil)
+      block_device_mappings = {}
+
+      build_ephemeral_drives(block_device_mappings, instance_type)
+      build_ebs_volumes(block_device_mappings, application.block_devices)
+      clone_volumes(block_device_mappings, application, clone_host)
+
+      block_device_mappings
+    end
+
+    # Generates a mapping of block device names to tags.
+    #
+    # @param [String] hostname FQDN for new host
+    # @param [String] short_hostname short name for host host, without domain name.
+    # @param [String] environment_name Name of current environment
+    # @param [EC2Launcher::DSL::BlockDevice] block devices for this application
+    #
+    # @return [Hash<String, Hash<String, String>] returns a mapping of device names to maps tag names and values.
+    def generate_device_tags(hostname, short_hostname, environment_name, block_devices)
+      block_device_tags = {}
+      unless block_devices.nil?
+        base_device_name = "sdf"
+        block_devices.each do |block_device|
+          build_block_devices(block_device.count, base_device_name) do |device_name, index|
+            block_device_tags["/dev/#{device_name}"] = {
+              "purpose" => block_device.name,
+              "host" => hostname,
+              "environment" => environment_name
+            }
+            
+            if block_device.raid_level.nil?
+              block_device_tags["/dev/#{device_name}"]["Name"] = "#{short_hostname} #{block_device.name}"
+            else
+              block_device_tags["/dev/#{device_name}"]["Name"] = "#{short_hostname} #{block_device.name} raid (#{(index + 1).to_s})"
+              block_device_tags["/dev/#{device_name}"]["raid_number"] = (index + 1).to_s
+            end
+          end
+        end
+      end
+      block_device_tags
+    end
+
+    private
   
     # Iterates over a number of block_devices, executing the specified Ruby block.
     #
@@ -41,12 +92,10 @@ module EC2Launcher
 
     # Creates the mappings for the appropriate EBS volumes.
     #
-    # @param [String] hostname FQDN for new host
-    # @param [String] short_hostname short name for host host, without domain name.
-    # @param [String] environment_name name of the environment
+    # @param [Hash<String, Hash>] block_device_mappings Mapping of device names to EBS block device details.
     # @param [Array<EC2Launcher::BlockDevice>] block_devices list of block devices to create.
     #
-    def build_ebs_volumes(hostname, short_hostname, environment_name, block_devices)
+    def build_ebs_volumes(block_device_mappings, block_devices)
       return if block_devices.nil?
       base_device_name = "sdf"
       block_devices.each do |block_device|
@@ -58,28 +107,16 @@ module EC2Launcher
             :volume_size => volume_size,
             :delete_on_termination => true
           }
-
-          block_device_tags["/dev/#{device_name}"] = {
-            "purpose" => block_device.name,
-            "host" => hostname,
-            "environment" => environment_name
-          }
-          
-          if block_device.raid_level.nil?
-            block_device_tags["/dev/#{device_name}"]["Name"] = "#{short_hostname} #{block_device.name}"
-          else
-            block_device_tags["/dev/#{device_name}"]["Name"] = "#{short_hostname} #{block_device.name} raid (#{(index + 1).to_s})"
-            block_device_tags["/dev/#{device_name}"]["raid_number"] = (index + 1).to_s
-          end
         end
       end
     end
 
     # Creates the mappings for the appropriate ephemeral drives.
     #
+    # @param [Hash<String, Hash>] block_devices Map of device names to EC2 block device details.
     # @param [String] instance_type type of instance. See EC2Launcher::Defaults::INSTANCE_TYPES.
     #
-    def build_ephemeral_drives(instance_type)
+    def build_ephemeral_drives(block_devices, instance_type)
       ephemeral_drive_count = case instance_type
         when "m1.small" then 1
         when "m1.medium" then 1
@@ -96,18 +133,18 @@ module EC2Launcher
         else 0
       end
       build_block_devices(ephemeral_drive_count, "sdb") do |device_name, index|
-        @block_device_mappings["/dev/#{device_name}"] = "ephemeral#{index}"
+        block_device_mappings["/dev/#{device_name}"] = "ephemeral#{index}"
       end
     end
 
     # Finds the EBS snapshots to clone for all appropriate block devices and
     # updates the block device mapping hash.
     #
-    # @param [EC2Launcher::Environment] environment current environment
+    # @param [Hash<String, Hash>] block_devices Map of device names to EC2 block device details.
     # @param [EC2Launcher::Application] application current application
     # @param [String] clone_host name of host to clone
     #
-    def clone_volumes(environment, application, clone_host)
+    def clone_volumes(block_device_mappings, application, clone_host = nil)
       return if clone_host.nil?
 
       puts "Retrieving snapshots..."
@@ -117,35 +154,20 @@ module EC2Launcher
         if block_device.raid_level.nil?
           latest_snapshot = get_latest_snapshot_by_purpose(clone_host, block_device.name)
           abort("Unable to find snapshot for #{clone_host} [#{block_device.name}]") if latest_snapshot.nil?
-          @block_device_mappings["/dev/#{base_device_name}"][:snapshot_id] = latest_snapshot.id
+          block_device_mappings["/dev/#{base_device_name}"][:snapshot_id] = latest_snapshot.id
           base_device_name.next!
         else
           snapshots = get_latest_raid_snapshot_mapping(clone_host, block_device.name, block_device.count)
           abort("Unable to find snapshot for #{clone_host} [#{block_device.name}]") if snapshots.nil? 
           abort("Incorrect snapshot count for #{clone_host} [#{block_device.name}]. Expected: #{block_device.count}, Found: #{snapshots.length}") if snapshots.length != block_device.count
           build_block_devices(block_device.count, base_device_name) do |device_name, index|
-            @block_device_mappings["/dev/#{device_name}"][:snapshot_id] = snapshots[(index + 1).to_s].id
+            block_device_mappings["/dev/#{device_name}"][:snapshot_id] = snapshots[(index + 1).to_s].id
           end
         end
       end
       AWS.stop_memoizing
     end
 
-    # Generates the mappings for ephemeral and ebs volumes.
-    #
-    # @param [String] hostname FQDN for new host
-    # @param [String] short_hostname short name for host host, without domain name.
-    # @param [String] instance_type type of instance. See EC2Launcher::Defaults::INSTANCE_TYPES.
-    # @param [EC2Launcher::Environment] environment current environment
-    # @param [EC2Launcher::Application] application current application
-    # @param [String, nil] clone_host FQDN of host to clone or nil to skip cloning.
-    #
-    def generate_block_devices(hostname, short_hostname, instance_type, environment, application, clone_host = nil)
-      build_ephemeral_drives(instance_type)
-      build_ebs_volumes(hostname, short_hostname, environment.name, application.block_devices)
-      clone_volumes(environment, application, clone_host)
-    end
-
     # Retrieves the latest set of completed snapshots for a RAID array of EBS volumes.
     #
     # Volumes must have the following tags:

data/lib/ec2launcher/dsl/application.rb

@@ -0,0 +1,297 @@
+#
+# Copyright (c) 2012 Sean Laurent
+#
+require 'ec2launcher/dsl/block_device'
+require 'ec2launcher/dsl/email_notification'
+require 'ec2launcher/security_group_handler'
+
+module EC2Launcher
+	module DSL
+		# Wrapper class to handle loading Application blocks.
+		class ApplicationDSL
+			attr_accessor :applications
+
+			def initialize
+				self.applications = []
+			end
+
+			def application(name, &block)
+				application = EC2Launcher::DSL::Application.new(name)
+				applications << application
+				application.instance_eval &block
+				application
+			end
+
+			def self.execute(dsl)
+				new.tap do |context|
+					context.instance_eval(dsl)
+				end
+			end
+		end
+
+		# Represents a single application stack.
+		class Application
+			include EC2Launcher::DSL::EmailNotifications
+			include EC2Launcher::SecurityGroupHandler
+
+			attr_reader :name
+
+			def initialize(name)
+				@name = name
+				@email_notifications = nil
+			end
+
+			def application(name)
+				@name = name
+				yield self
+				self
+			end
+
+			# Name of the AMI to use for new instances. Optional.
+			# Can be either a string or a regular expression.
+			#
+			# @param [Array, nil] Either an array of parameters or nil to return the AMI name.
+			def ami_name(*ami_name)
+				if ami_name.empty?
+					@ami_name
+				else
+					if ami_name[0].kind_of? String
+						@ami_name = /#{ami_name[0]}/
+					else
+						@ami_name = ami_name[0]
+					end
+					self
+				end
+			end
+
+			# Name of the availability zone to use for new instances. Optional.
+			# Must be one of EC2Launcher::AVAILABILITY_ZONES.
+			def availability_zone(*zone)
+				if zone.empty?
+					@availability_zone
+				else
+					@availability_zone = zone[0].to_s
+					self
+				end
+			end
+
+			# Defines a shorter name when building a host name for new instances. Optional.
+			# By default, new instances are named using the full application name. If you 
+			# specify basename, it will be used instead. Typically, this is used if you 
+			# want a shorter version of the full application name.
+			def basename(*name)
+				if name.empty?
+					@basename
+				else
+					@basename = name[0]
+					self
+				end
+			end
+
+			def block_devices(*block_device_data)
+				if block_device_data.empty?
+					@block_devices
+				else
+					self
+				end
+			end
+
+			def block_device(&block)
+				@block_devices = [] if @block_devices.nil?
+				device = EC2Launcher::DSL::BlockDevice.new
+				device.instance_exec(&block)
+				@block_devices << device
+			end
+
+			# Indicates the Amazon Elastic Load Balancer to which new instances should be
+			# attached after launch. Optional.
+			#
+			# The value can be either a String, indicating the name of the ELB, or a Hash
+			# that maps environment names to ELB names.
+			def elb(*elb)
+				if elb.empty?
+					@elb
+				else
+					@elb = Hash.new if @elb.nil?
+					if elb[0].kind_of? Hash
+						elb[0].keys.each {|key| @elb[key] = elb[0][key]}
+					else
+						@elb["default"] = elb[0].to_s
+					end
+					self
+				end
+			end
+
+			# Retrieves the ELB name for a given environment.
+			def elb_for_environment(environment)
+				elb_name = @elb[environment]
+				elb_name ||= @elb["default"]
+				elb_name
+			end
+
+			# Defines an Array of Chef roles that should be applied to new
+			# instances for a specific environment. Can be specified multiple times.
+			#
+			# Expects two parameters:
+			#   * Name of an environment
+			#   * Either the name of a single Chef role or an Array of Chef roles
+			def environment_roles(*data)
+				if data.empty?
+					@environment_roles
+				else
+					@environment_roles = Hash.new if @environment_roles.nil?
+					env_name = data[0]
+					env_roles = data[1]
+
+					environment_data = @environment_roles[env_name]
+					environment_data ||= []
+
+					if env_roles.kind_of? Array
+						environment_data += env_roles
+					else
+						environment_data << env_roles
+					end
+					@environment_roles[env_name] = environment_data
+
+					self
+				end
+			end
+
+			# Gems to install. Optional.
+			#
+			# Expects either a single String naming a gem to install or
+			# an Array of gems.
+			#
+			# Can be specified multiple times.
+			def gems(*gems)
+				if gems.empty?
+					@gems
+				else
+					@gems = [] if @gems.nil?
+					if gems[0].kind_of? Array
+						@gems += gems[0]
+					else
+						@gems << gems[0]
+					end
+					self
+				end
+			end
+
+			# Indicates that this application should inherit all of its settings from another named application.
+			# Optional.
+			def inherit(*inherit_type)
+				if inherit_type.empty?
+					@inherit_type
+				else
+					@inherit_type = inherit_type[0]
+				end
+			end
+
+			# The Amazon EC2 instance type that should be used for new instances.
+			# Must be one of EC2Launcher::INSTANCE_TYPES.
+			def instance_type(*type_name)
+				if type_name.empty?
+					@instance_type
+				else
+					@instance_type = type_name[0]
+					self
+				end
+			end
+
+			# Takes values from the other server type and merges them into this one
+			def merge(other_server)
+				@name = other_server.name
+				@ami_name = other_server.ami_name unless other_server.ami_name.nil?
+				@availability_zone = other_server.availability_zone unless other_server.availability_zone.nil?
+				@basename = other_server.basename unless other_server.basename.nil?
+				other_server.block_devices.each {|bd| @block_devices << bd } unless other_server.block_devices.nil?
+				other_server.elb.keys.each {|env_name| @elb[env_name] = other_server.elb[env_name] } unless other_server.elb.nil?
+				@instance_type = other_server.instance_type unless other_server.instance_type.nil?
+				@name_suffix = other_server.name_suffix unless other_server.name_suffix.nil?
+				other_server.roles.each {|role| @roles << role } unless other_server.roles.nil?
+				unless other_server.security_groups.nil?
+					other_server.security_groups.keys.each do |env_name|
+						unless @security_groups.has_key? env_name
+							@security_groups[env_name] = []
+						end
+						other_server.security_groups[env_name].each {|sg| @security_groups[env_name] << sg }
+					end
+				end
+			end
+
+			def name_suffix(*suffix)
+				if suffix.empty?
+					@name_suffix
+				else
+					@name_suffix = suffix[0]
+				end
+			end
+
+			def packages(*packages)
+				if packages.empty?
+					@packages
+				else
+					@packages = packages[0]
+					self
+				end
+			end
+
+			def roles(*roles)
+				if roles.empty?
+					@roles
+				else
+					@roles = [] if @roles.nil?
+					if roles[0].kind_of? Array
+						@roles += roles[0]
+					else
+						@roles = []
+						@roles << roles[0]
+					end
+					self
+				end
+			end
+
+			def roles_for_environment(environment)
+				roles = []
+				roles += @roles unless @roles.nil?
+
+				unless @environment_roles.nil? || @environment_roles[environment].nil?
+					roles += @environment_roles[environment]
+				end
+				roles
+			end
+
+			# Retrieves the list of Security Group names for the specified environment.
+			#
+			# @return [Array] Returns the list of security groups for the environment. Returns
+			#                 the security groups for the "defaukt" environment if the requested
+			#                 environment is undefined. Returns an empty Array if both the
+			#                 requested environment and "default" environment are undefined.
+			def security_groups_for_environment(environment)
+				groups = @security_groups[environment]
+				groups ||= @security_groups["default"]
+				groups ||= []
+				groups
+			end
+
+			def subnet(*subnet)
+				if subnet.empty?
+					@subnet
+				else
+					@subnet = subnet[0]
+					self
+				end
+			end
+
+			def load(dsl)
+				self.instance_eval(dsl)
+				self
+			end
+
+			def self.load(dsl)
+				env = Application.new.instance_eval(dsl)
+				env
+			end
+		end
+	end
+end

data/lib/ec2launcher/dsl/block_device.rb

@@ -0,0 +1,96 @@
+#
+# Copyright (c) 2012 Sean Laurent
+#
+
+module EC2Launcher
+	module DSL
+		class BlockDevice
+			attr_reader :mount_point
+			attr_reader :name
+
+			def initialize()
+				@count = 1
+				@group = "root"
+				@user = "root"
+			end
+
+			def is_raid?()
+				@raid_level.nil?
+			end
+
+			def count(*block_count)
+				if block_count.empty?
+					@count
+				else
+					@count = block_count[0]
+					self
+				end
+			end
+
+			def group(*group)
+				if group.empty?
+					@group
+				else
+					@group = group[0]
+					self
+				end
+			end
+
+			def mount(*mount)
+				if mount.empty?
+					@mount
+				else
+					@mount_point = mount[0]
+					self
+				end
+			end
+
+			def name(*name)
+				if name.empty?
+					@name
+				else
+					@name = name[0]
+					self
+				end
+			end
+
+			def owner(*owner)
+				if owner.empty?
+					@owner
+				else
+					@owner = owner[0]
+					self
+				end
+			end
+
+			def raid_level(*raid_level)
+				if raid_level.empty?
+					@raid_level
+				else
+					@raid_level = raid_level[0]
+					self
+				end
+			end
+
+			def size(*volume_size)
+				if volume_size.empty?
+					@size
+				else
+					@size = volume_size[0].to_i
+					self
+				end
+			end
+
+			def to_json(*a)
+				{
+					"name" => @name,
+					"count" => @count,
+					"raid_level" => @raid_level,
+					"mount_point" => @mount_point,
+					"owner" => @owner,
+					"group" => @group
+				}.to_json(*a)
+			end
+		end
+	end
+end

data/lib/ec2launcher/dsl/config.rb

@@ -0,0 +1,78 @@
+#
+# Copyright (c) 2012 Sean Laurent
+#
+module EC2Launcher
+  module DSL
+  class ConfigDSL
+      attr_reader :config
+
+      def config(&block)
+        return @config if block.nil?
+        
+        @config = Config.new
+        @config.instance_eval &block
+        @config
+      end
+
+      def self.execute(dsl)
+        new.tap do |context|
+          context.instance_eval(dsl)
+        end
+      end
+    end
+
+    class Config
+      DEFAULT_CONFIG_ERB = %q{
+config do
+  environments "environments"
+  applications "applications"
+
+  package_manager "apt"
+  config_manager "chef"
+end
+}.gsub(/^ /, '')
+      
+      def environments(*environments)
+        if environments.empty?
+          @environments
+        else
+          if environments[0].kind_of? Array
+            @environments = @environments[0]
+          else
+            @environments = [ environments[0] ]
+          end
+          self
+        end
+      end
+
+      def applications(*applications)
+        if applications.empty?
+          @applications
+        else
+          if applications[0].kind_of? Array
+            @applications = @applications[0]
+          else
+            @applications = [ applications[0] ]
+          end
+          self
+        end
+      end
+
+      def package_manager(*package_manager)
+        if package_manager.empty?
+          @package_manager
+        else
+          @package_manager = package_manager[0]
+        end
+      end
+
+      def config_manager(*config_manager)
+        if config_manager.empty?
+          @config_manager
+        else
+          @config_manager = config_manager[0]
+        end
+      end
+    end
+  end
+end