capify-ec2 1.1.16.pre.2 → 1.2.0.pre.3

data/capify-ec2.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
-#  s.add_dependency('activesupport', '=3.1.1')
-  s.add_dependency('fog', '=1.0.0')
+  s.add_dependency('fog', '=1.1.1')
   s.add_dependency('colored', '=1.2')
+  s.add_dependency('capistrano')
 end

data/lib/capify-ec2.rb

@@ -1,100 +1,74 @@
 require 'rubygems'
 require 'fog'
 require 'colored'
+require File.expand_path(File.dirname(__FILE__) + '/capify-ec2/server')
+
 
 class CapifyEc2
 
-  attr_accessor :load_balancer
+  attr_accessor :load_balancer, :instances
   SLEEP_COUNT = 5
-
-  def self.ec2_config
-    YAML.load(File.new("config/ec2.yml"))
-  end  
   
-  def self.determine_regions(region = nil)
-    region.nil? ? (ec2_config[:aws_params][:regions] || [ec2_config[:aws_params][:region]]) : [region]
-  end
-  
-  def self.running_instances(region = nil)
-    regions = determine_regions(region)
-    instances = []
+  def initialize()
+    @ec2_config = YAML.load(File.new("config/ec2.yml"))
+    regions = determine_regions()
+    
+    @instances = []
     regions.each do |region|
-      ec2 = Fog::Compute.new(:provider => 'AWS', :aws_access_key_id => ec2_config[:aws_access_key_id], :aws_secret_access_key => ec2_config[:aws_secret_access_key], :region => region)
-      project_tag = ec2_config[:project_tag]
-      running_instances = ec2.servers.select {|instance| instance.state == "running" && (project_tag.nil? || instance.tags["Project"] == project_tag) }
-      running_instances.each do |instance|
-        instance.instance_eval do
-          def case_insensitive_tag(key)
-            tags[key] || tags[key.downcase]
-          end
-        
-          def name
-            case_insensitive_tag("Name").split('-').reject {|portion| portion.include?(".")}.join("-")
-          end
-        
-          def roles
-            role = case_insensitive_tag("Role")
-            roles = role.nil? ? [] : [role]
-            if (roles_tag = case_insensitive_tag("Roles"))
-              roles += case_insensitive_tag("Roles").split(/\s*,\s*/)
-            end
-            roles
-          end
-          def options
-            option = case_insensitive_tag("Option")
-            options = option.nil? ? [] : [option]
-            if (options_tag = case_insensitive_tag("Options"))
-              options += case_insensitive_tag("Options").split(/\s*,\s*/)
-            end
-            options
-          end
-        end
-        instances << instance
+      servers = Fog::Compute.new(:provider => 'AWS', :aws_access_key_id => @ec2_config[:aws_access_key_id], 
+        :aws_secret_access_key => @ec2_config[:aws_secret_access_key], :region => region).servers
+      servers.each do |server|
+        @instances << server if server.ready?
       end
     end
-    instances
+  end 
+  
+  def determine_regions()
+    @ec2_config[:aws_params][:regions] || [@ec2_config[:aws_params][:region]]
   end
   
-  def self.instance_health(load_balancer, instance)
-    elb.describe_instance_health(load_balancer.id, instance.id).body['DescribeInstanceHealthResult']['InstanceStates'][0]['State']
+  def display_instances
+    @instances.each_with_index do |instance, i|
+      puts sprintf "%-11s:   %-40s %-20s %-20s %-62s %-20s (%s)",
+        i.to_s.magenta, instance.name, instance.id.red, instance.flavor_id.cyan,
+        instance.dns_name.blue, instance.availability_zone.green, (instance.role rescue "").yellow
+    end
+  end
+    
+  def project_instances(project_tag)
+    @instances.select {|instance| instance.tags["Project"] == project_tag}
   end
   
-  def self.get_instances_by_role(role)
-    filter_instances_by_role(running_instances, role)
+  def running_instances(region = nil)
+    instances = @ec2_config[:project_tag].nil? ? @instances : project_instances(@ec2_config[:project_tag])
   end
   
-  def self.get_instances_by_region(role, region)
-    return unless region
-    region_instances = running_instances(region)
-    filter_instances_by_role(region_instances,role)
-  end 
+  def get_instances_by_role(role)
+    @instances.select {|instance| instance.role == role.to_s rescue false}
+  end
   
-  def self.filter_instances_by_role(instances, role)
-    selected_instances = instances.select do |instance|
-      server_roles = [instance.case_insensitive_tag("Role")] || []
-      if (roles_tag = instance.case_insensitive_tag("Roles"))        
-        server_roles += roles_tag.split(/\s*,\s*/)
-      end
-      server_roles.member?(role.to_s)
-    end
+  def get_instances_by_region(role, region)
+    return unless region
+    @instances.select {|instance| instance.availability_zone.match(region) && instance.role == role.to_s rescue false}
   end 
   
-  def self.get_instance_by_name(name)
-    selected_instances = running_instances.select do |instance|
-      value = instance.case_insensitive_tag("Name")
-      value == name.to_s
-    end.first
+  def get_instance_by_name(name)
+    @instances.select {|instance| instance.name == name}.first
+  end
+    
+  def instance_health(load_balancer, instance)
+    elb.describe_instance_health(load_balancer.id, instance.id).body['DescribeInstanceHealthResult']['InstanceStates'][0]['State']
   end
   
-  def self.server_names
-    running_instances.map {|instance| instance.case_insensitive_tag("Name")}
+  def server_names
+    @instances.map {|instance| instance.name}
   end
   
-  def self.elb
-    Fog::AWS::ELB.new(:aws_access_key_id => ec2_config[:aws_access_key_id], :aws_secret_access_key => ec2_config[:aws_secret_access_key], :region => ec2_config[:aws_params][:region])
+  def elb
+    Fog::AWS::ELB.new(:aws_access_key_id => @ec2_config[:aws_access_key_id], :aws_secret_access_key => @ec2_config[:aws_secret_access_key], :region => @ec2_config[:aws_params][:region])
   end 
   
-  def self.get_load_balancer_by_instance(instance_id)
+  def get_load_balancer_by_instance(instance_id)
     hash = elb.load_balancers.inject({}) do |collect, load_balancer|
       load_balancer.instances.each {|load_balancer_instance_id| collect[load_balancer_instance_id] = load_balancer}
       collect
@@ -102,7 +76,7 @@ class CapifyEc2
     hash[instance_id]
   end
   
-  def self.get_load_balancer_by_name(load_balancer_name)
+  def get_load_balancer_by_name(load_balancer_name)
     lbs = {}
     elb.load_balancers.each do |load_balancer|
       lbs[load_balancer.id] = load_balancer
@@ -111,8 +85,8 @@ class CapifyEc2
 
   end
      
-  def self.deregister_instance_from_elb(instance_name)
-    return unless ec2_config[:load_balanced]
+  def deregister_instance_from_elb(instance_name)
+    return unless @ec2_config[:load_balanced]
     instance = get_instance_by_name(instance_name)
     return if instance.nil?
     @@load_balancer = get_load_balancer_by_instance(instance.id)
@@ -121,8 +95,8 @@ class CapifyEc2
     elb.deregister_instances_from_load_balancer(instance.id, @@load_balancer.id)
   end
   
-  def self.register_instance_in_elb(instance_name, load_balancer_name = '')
-    return if !ec2_config[:load_balanced]
+  def register_instance_in_elb(instance_name, load_balancer_name = '')
+    return if !@ec2_config[:load_balanced]
     instance = get_instance_by_name(instance_name)
     return if instance.nil?
     load_balancer =  get_load_balancer_by_name(load_balancer_name) || @@load_balancer
@@ -130,7 +104,7 @@ class CapifyEc2
 
     elb.register_instances_with_load_balancer(instance.id, load_balancer.id)
 
-    fail_after = ec2_config[:fail_after] || 30
+    fail_after = @ec2_config[:fail_after] || 30
     state = instance_health(load_balancer, instance)
     time_elapsed = 0
     

data/lib/capify-ec2/capistrano.rb

@@ -1,27 +1,25 @@
 require File.join(File.dirname(__FILE__), '../capify-ec2')
 require 'colored'
 
-Capistrano::Configuration.instance(:must_exist).load do
+Capistrano::Configuration.instance(:must_exist).load do  
   namespace :ec2 do
+    
     desc "Prints out all ec2 instances. index, name, instance_id, size, dns_name, region, tags"
     task :status do
-      CapifyEc2.running_instances.each_with_index do |instance, i|
-        puts sprintf "%-11s:   %-40s %-20s %-20s %-62s %-20s (%s)",
-          i.to_s.magenta, instance.case_insensitive_tag("Name"), instance.id.red, instance.flavor_id.cyan,
-          instance.dns_name.blue, instance.availability_zone.green, instance.roles.join(", ").yellow
-      end
+      CapifyEc2.new.display_instances
     end
+
     desc "Deregisters instance from its ELB"
     task :deregister_instance do
       instance_name = variables[:logger].instance_variable_get("@options")[:actions].first
-      CapifyEc2.deregister_instance_from_elb(instance_name)
+      CapifyEc2.new.deregister_instance_from_elb(instance_name)
     end
 
     desc "Registers an instance with an ELB."
     task :register_instance do
       instance_name = variables[:logger].instance_variable_get("@options")[:actions].first
       load_balancer_name = variables[:logger].instance_variable_get("@options")[:vars][:loadbalancer]
-      CapifyEc2.register_instance_in_elb(instance_name, load_balancer_name)
+      CapifyEc2.new.register_instance_in_elb(instance_name, load_balancer_name)
     end
 
     task :date do
@@ -30,19 +28,18 @@ Capistrano::Configuration.instance(:must_exist).load do
 
     desc "Prints list of ec2 server names"
     task :server_names do
-      puts CapifyEc2.server_names.sort
+      puts CapifyEc2.new.server_names.sort
     end
     
     desc "Allows ssh to instance by id. cap ssh <INSTANCE NAME>"
     task :ssh do
       server = variables[:logger].instance_variable_get("@options")[:actions][1]
-      instance = numeric?(server) ? CapifyEc2.running_instances[server.to_i] : CapifyEc2.get_instance_by_name(server)
+      instance = numeric?(server) ? CapifyEc2.new.instances[server.to_i] : CapifyEc2.new.get_instance_by_name(server)
       port = ssh_options[:port] || 22 
       command = "ssh -p #{port} #{user}@#{instance.dns_name}"
       puts "Running `#{command}`"
       exec(command)
     end
-
   end
   
   namespace :deploy do
@@ -50,42 +47,49 @@ Capistrano::Configuration.instance(:must_exist).load do
     after "deploy", "ec2:register_instance"
     after "deploy:rollback", "ec2:register_instance"
   end
-  
+    
   def ec2_roles(*roles)
+    @capify_ec2 = CapifyEc2.new
     server_name = variables[:logger].instance_variable_get("@options")[:actions].first unless variables[:logger].instance_variable_get("@options")[:actions][1].nil?
-    named_instance = CapifyEc2.get_instance_by_name(server_name)
+    named_instance = @capify_ec2.get_instance_by_name(server_name)
+    
     task named_instance.name.to_sym do
       remove_default_roles
       server_address = named_instance.dns_name
-      named_instance.roles.each do |role|
-        define_role({:name => role, :options => {}}, named_instance)
+      named_instance.role.each do |role|
+        define_role({:name => role, :options => {:on_no_matching_servers => :continue}}, named_instance)
       end
     end unless named_instance.nil?
+    
     roles.each {|role| ec2_role(role)}
   end
   
   def ec2_role(role_name_or_hash)
     role = role_name_or_hash.is_a?(Hash) ? role_name_or_hash : {:name => role_name_or_hash,:options => {}}
+    @roles[role[:name]]
     
-    instances = CapifyEc2.get_instances_by_role(role[:name])
+    instances = @capify_ec2.get_instances_by_role(role[:name])
     if role[:options].delete(:default)
       instances.each do |instance|
         define_role(role, instance)
       end
-    end
-        
-    regions = CapifyEc2.ec2_config[:aws_params][:regions] || [CapifyEc2.ec2_config[:aws_params][:region]]
+    end    
+    regions = @capify_ec2.determine_regions
     regions.each do |region|
       define_regions(region, role)
     end unless regions.nil?
-    
+
     define_role_roles(role, instances)
     define_instance_roles(role, instances)    
 
   end  
 
   def define_regions(region, role)
-    instances = CapifyEc2.get_instances_by_region(role[:name], region)
+    instances = []
+    @roles.each do |role_name, junk|
+      region_instances = @capify_ec2.get_instances_by_region(role_name, region)
+      region_instances.each {|instance| instances << instance} unless region_instances.nil?
+    end
     task region.to_sym do
       remove_default_roles
       instances.each do |instance|
@@ -116,7 +120,7 @@ Capistrano::Configuration.instance(:must_exist).load do
     options = role[:options]
     new_options = {}
     options.each {|key, value| new_options[key] = true if value.to_s == instance.name}
-    instance.options.each {|option| new_options[option.to_sym] = true}
+    instance.option.each { |option| new_options[option.to_sym] = true } rescue false
 
     if new_options
       role role[:name].to_sym, instance.dns_name, new_options 

data/lib/capify-ec2/server.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'fog/aws/models/compute/server'
+
+module Fog
+  module Compute
+    class AWS
+      class Server
+        def method_missing(method_sym, *arguments, &block)
+          tags.each do |key, value|
+            tag = key.downcase.gsub(/\W/, '').chomp('s')
+            return value if method_sym.to_s == tag
+          end if tags
+          super
+        end
+        
+        def respond_to?(method_sym, include_private = false)
+          tags.each do |key, value|
+            tag = key.downcase.gsub(/\W/, '').chomp('s')
+            return true if method_sym.to_s == tag
+          end if tags
+          super
+        end
+      end
+    end
+  end
+end

data/lib/capify-ec2/version.rb

@@ -1,5 +1,5 @@
 module Capify
   module Ec2
-    VERSION = "1.1.16.pre.2"
+    VERSION = "1.2.0.pre.3"
   end
 end

data/readme.md

@@ -166,8 +166,8 @@ The yml file needs to look something like this:
 :load_balanced: true
 :project_tag: "YOUR APP NAME"
 ```
+aws_access_key_id, aws_secret_access_key, and region are required. Other settings are optional.
 
-The :aws_params are optional.
 If :load_balanced is set to true, the gem uses pre and post-deploy
 hooks to deregister the instance, reregister it, and validate its
 health.

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: capify-ec2
 version: !ruby/object:Gem::Version 
-  hash: 1923831837
+  hash: 1923831983
   prerelease: true
   segments: 
   - 1
-  - 1
-  - 16
-  - pre
   - 2
-  version: 1.1.16.pre.2
+  - 0
+  - pre
+  - 3
+  version: 1.2.0.pre.3
 platform: ruby
 authors: 
 - Noah Cantor
@@ -18,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-11 00:00:00 +01:00
+date: 2011-12-02 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -29,12 +29,12 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        hash: 23
+        hash: 17
         segments: 
         - 1
-        - 0
-        - 0
-        version: 1.0.0
+        - 1
+        - 1
+        version: 1.1.1
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -52,6 +52,20 @@ dependencies:
         version: "1.2"
   type: :runtime
   version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: capistrano
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
 description: Grabs roles from ec2's tags and autogenerates capistrano tasks
 email: 
 - noah.cantor@forward.co.uk
@@ -71,6 +85,7 @@ files:
 - capify-ec2.gemspec
 - lib/capify-ec2.rb
 - lib/capify-ec2/capistrano.rb
+- lib/capify-ec2/server.rb
 - lib/capify-ec2/version.rb
 - readme.md
 has_rdoc: true