poolparty 1.6.8 → 1.6.9

data/lib/cloud_providers/ec2/helpers/authorize.rb

@@ -12,12 +12,17 @@ module CloudProviders
       options = 
       if group_name
         puts "Authorizing #{name} for group named: #{group_name} of owner id: #{owner_id}"
-        {:authorize_security_group_ingress => group_name, :source_security_group_owner_id => owner_id}
+        {:group_name => name, :source_security_group_name=> group_name, :source_security_group_owner_id => owner_id}
       else
         puts "Authorizing: #{name} for #{protocol} to #{from_port}:#{to_port} #{network}"
         to_hash
       end
-      ec2.authorize_security_group_ingress(options) rescue nil
+      begin
+        ec2.authorize_security_group_ingress(options) 
+      rescue AWS::InvalidPermissionDuplicate => e
+        nil
+      end
+        
     end
     
     def to_hash
@@ -35,4 +40,4 @@ module CloudProviders
     end
     
   end
-end
+end

data/lib/cloud_providers/ec2/helpers/elastic_auto_scaler.rb

@@ -321,13 +321,14 @@ module CloudProviders
       :measure => :cpu,
       :period => 60,
       :statistic => :average,
-      :unit => "Seconds",
+      :unit => "Percent",
       :lower_threshold => 20,
       :upper_threshold => 60,
       :trigger_name => "CpuTrigger",
       :lower_breach_scale_increment => -1,
       :upper_breach_scale_increment => 1,
-      :breach_duration => 120
+      :breach_duration => 120,
+      :namespace => 'AWS/EC2'
     )
     
     def measure_names
@@ -392,7 +393,8 @@ module CloudProviders
             :breach_duration => trigger["BreachDuration"],
             :dimensions => trigger["Dimensions"],
             :unit => trigger["Unit"],
-            :autoscaling_group_name => trigger["AutoScalingGroupName"]
+            :autoscaling_group_name => trigger["AutoScalingGroupName"],
+            :namespace => trigger['Namespace']
           }
         end
       rescue Exception => e
@@ -412,7 +414,8 @@ module CloudProviders
         :lower_threshold => "#{lower_threshold}",
         :lower_breach_scale_increment => "#{lower_breach_scale_increment}",
         :upper_threshold => "#{upper_threshold}",
-        :upper_breach_scale_increment => "#{upper_breach_scale_increment}"
+        :upper_breach_scale_increment => "#{upper_breach_scale_increment}",
+        :namespace => namespace
       )
     end
     

data/lib/cloud_providers/ec2/helpers/revoke.rb

@@ -7,8 +7,8 @@ module CloudProviders
                 :to_port => "22",
                 :cidr_ip => "0.0.0.0/0"})
     def run
-      puts "Revoking: #{cloud.proper_name} for #{protocol} to #{from_port}:#{to_port} #{network}"
-      options = { :group_name => cloud.proper_name,
+      puts "Revoking: #{name} for #{protocol} to #{from_port}:#{to_port} #{network}"
+      options = { :group_name => name,
                   :ip_protocol => protocol,
                   :from_port => from_port,
                   :to_port => to_port,
@@ -16,9 +16,9 @@ module CloudProviders
 
       ec2.revoke_security_group_ingress(options) rescue nil
     end
-    
+
     alias :network :cidr_ip
-    
+
   end
 
-end
+end

data/lib/cloud_providers/ec2/helpers/security_group.rb

@@ -1,57 +1,54 @@
 module CloudProviders
   class SecurityGroup < Ec2Helper
-    
+
     def run
       if should_create_security_group?
         create_security_group!
       end
-      current_security_groups = security_groups.map {|a| 
+      current_security_groups = security_groups.map {|a|
+        # Example:
+        #    [{ :ip_permissions=>[
+        #       {:ip_ranges=>[{:cidr_ip=>"0.0.0.0/0"}], :from_port=>"22", :protocol=>"tcp", :to_port=>"22"},
+        #       {:ip_ranges=>[{:cidr_ip=>"0.0.0.0/0"}], :from_port=>"80", :protocol=>"tcp", :to_port=>"80"} ],
+        #     :description=>"PoolParty generated security group: clyde-chefclient", :name=>"clyde-chefclient"}]
+        #
         a[:ip_permissions].map do |perm|
           if perm[:group_name]
             {
               :group_name => perm[:group_name]
             }
           else
-            if perm[:ip_ranges].size > 1
-              perm[:ip_ranges].map do |range|
-                {
-                  :group_name => a[:name],
-                  :from_port => perm[:from_port],
-                  :to_port => perm[:to_port],
-                  :cidr_ip => range,
-                  :ip_protocol => perm[:protocol]
-                }.flatten
-              end.flatten
-            else
+            (perm[:ip_ranges] || ["0.0.0.0/0"]).map do |range|
+              range = range[:cidr_ip] if range.is_a?(Hash)
               {
-                :group_name => a[:name],
-                :from_port => perm[:from_port], 
-                :to_port => perm[:to_port],
-                :cidr_ip => perm[:ip_ranges].map {|c| c[:cidrIp] }.first, # first for simplicity for now...
+                :group_name  => a[:name],
+                :from_port   => perm[:from_port].to_i,
+                :to_port     => perm[:to_port].to_i,
+                :cidr_ip     => range,
                 :ip_protocol => perm[:protocol]
               }
-            end
+            end.flatten
           end
         end.flatten
       }.flatten
-      
-      authorizers = []
-      authorizes.each do |a|
-        unless current_security_groups.include?(a.to_hash)
-          authorizers << a
-        end
+
+      authorizes_requested        = authorizes.select{|a| a.name == name }
+      authorizes_requested_hashes = authorizes_requested.map{|a| a.to_hash}
+      authorizes_needed = []
+
+      # take each requested authorization. If it doesn't exist in the current_security_groups, we need to add it.
+      authorizes_requested.each do |a|
+        authorizes_needed << a unless current_security_groups.include?(a.to_hash)
       end
-      
-      defined_security_group_hashes = authorizes.map {|a| a.to_hash}
-      
+      # conversely, every current_security_groups authorization that isn't in the authorizes_requested list must be revoked
       current_security_groups.each do |hsh|
-        unless defined_security_group_hashes.include?(hsh)
+        unless authorizes_requested_hashes.include?(hsh)
           revoke(hsh.merge(:protocol => hsh[:ip_protocol]))
         end
       end
-      
+
       revokes.each {|r| r.run }
-      authorizers.each {|a| a.run}
+      authorizes_needed.each {|a| a.run}
     end
     def authorize(o={}, &block)
       authorizes << Authorize.new("#{name}", o.merge(:parent => parent, :cloud => cloud), &block)
@@ -82,7 +79,7 @@ module CloudProviders
               :to_port => i["toPort"],
               :ip_ranges => ip_ranges["item"].map do |ip|
                 {
-                  :cidrIp => ip["cidrIp"]
+                  :cidr_ip => ip["cidrIp"]
                 }
               end
             }
@@ -101,4 +98,4 @@ module CloudProviders
     end
   end
 
-end
+end

data/lib/cloud_providers/remote_instance.rb.orig

@@ -0,0 +1,162 @@
+=begin rdoc
+  Remote instances
+=end
+module CloudProviders
+  class RemoteInstance
+    include Dslify, Connections
+    
+    attr_reader :name, :init_opts, :raw_response
+    attr_accessor :cloud_provider
+    
+    default_options(
+      :instance_id => nil,
+      :image_id => nil,
+      :status => nil
+    )
+    
+    def initialize(init_opts={}, &block)
+      @init_opts = init_opts
+      set_vars_from_options(init_opts)
+      instance_eval &block if block
+      after_initialized
+    end
+    
+    def keypair(n=nil)
+      @keypair ||= n.nil? ? nil : Keypair.new(n)
+    end
+    
+    def after_initialized
+    end
+    
+    def accessible?
+      ping_port(public_ip, 22, 40)
+    end
+    
+    def rsync_dir(dir)
+      rsync :source => dir/"*", :destination => "/"
+    end
+    
+    def chef_bootstrapped?
+      # do_sudo is false cause we want to capture the return code of the call
+      @chef_bootstrapped ||= cloud.chef.node_bootsrapped?(self)
+    end
+    
+    def bootstrap_chef!
+<<<<<<< HEAD:lib/cloud_providers/remote_instance.rb
+      unless chef_bootstrapped?
+        ssh([
+          'apt-get update',
+          'apt-get autoremove -y',
+          'apt-get install -y ruby ruby-dev rubygems git-core libopenssl-ruby',
+          'gem sources -a http://gems.opscode.com',
+          'gem install chef ohai --no-rdoc --no-ri' ])
+      end
+      if bootstrap_gems.size > 0
+        ssh(bootstrap_gems.collect { |gem| "gem install #{gem} --no-rdoc --no-ri" } )
+      end
+    end
+    
+    def run_chef!
+      if ENV["CHEF_DEBUG"] 
+        debug = "-l debug"
+      else
+        debug = ""
+      end
+      chef_solo_cmd = <<-CMD
+        $GEM_BIN/chef-solo -j /etc/chef/dna.json -c /etc/chef/solo.rb #{debug}
+      CMD
+      envhash = {
+        :GEM_BIN => %q%$(gem env | grep "EXECUTABLE DIRECTORY" | awk "{print \\$4}")%
+      }
+      ssh([chef_solo_cmd.strip.squeeze(' ')], :env => envhash )
+=======
+      cloud.chef.node_bootstrap(self) unless chef_bootstrapped?
+    end
+    
+    def run_chef!
+      cloud.chef.node_run!(self)
+>>>>>>> 81a7e0df2d02545ff9b22572194a4f115f73906a:lib/cloud_providers/remote_instance.rb
+    end
+        
+    def run
+      warn "#{self.class} does not implement run. Something is wrong"
+    end
+    
+    def default_keypair_path
+      self.class.default_keypair_path
+    end
+    
+    ## provide hash like methods to access and iterate over node attributes
+    def each
+      dsl_options.each{ |k,v| yield k,v }
+    end
+    
+    def [](k)
+      if dsl_options.has_key? k
+        dsl_options[k]
+      else
+        nil
+      end
+    end
+    
+    def []=(k,v)
+      dsl_options[k] = v
+    end
+    
+    def has_key?(key)
+      dsl_options.has_key?(key)
+    end
+    
+    def keys
+      dsl_options.keys
+    end
+       
+    def values
+      dsl_options.values
+    end
+    
+    def to_hash
+      dsl_options
+    end
+    ##end of hash like methods
+    
+    # Is this instance running?
+    def running?
+      !(status =~ /running/).nil?
+    end
+    # Is this instance pending?
+    def pending?
+      !(status =~ /pending/).nil?
+    end
+    # Is this instance terminating?
+    def terminating?
+      !(status =~ /shutting/).nil?
+    end
+    # Has this instance been terminated?
+    def terminated?
+      !(status =~ /terminated/).nil?
+    end
+    
+    # elapsed seconds since node launch time
+    def elapsed_runtime
+      Time.now - Time.parse(launch_time)
+    end
+    
+    def ssh_available?
+      warn "Implemented in cloudprovider instance class. something is wrong"
+    end
+    # def  to_s
+    #  (cloud ? to_hash.merge(:cloud=>cloud.name) : to_hash)
+    # end
+    
+    private
+    def cloud
+      init_opts.has_key?(:cloud) ? init_opts[:cloud] : nil
+    end
+    
+    def cloud_provider
+      cloud.cloud_provider
+    end
+    
+  end
+end

data/lib/core/object.rb

@@ -13,6 +13,21 @@ class Object
       puts line
     end
   end
+
+  # === Description
+  #
+  # Change +attr+ to +val+ within the scope of block
+  # and then sets it back again
+  #
+  def change_attr attr, val, &block
+    old_val = instance_variable_get attr
+    begin
+      instance_variable_set attr, val
+      yield
+    ensure
+      instance_variable_set attr, old_val
+    end
+  end
   
   def progress_bar_until(msg=nil, &block)
     print "#{msg}" if msg
@@ -30,4 +45,4 @@ class Object
   end
   
   
-end
+end

data/lib/keypair.rb

@@ -2,7 +2,7 @@
   ssh key used to login to remote instances\
 =end
 class Keypair
-  
+
   include SearchablePaths
   has_searchable_paths(:prepend_paths => [Dir.pwd, '/etc/poolparty/keys', "#{ENV["HOME"]}/.ssh/", "#{ENV["HOME"]}/.ec2/", ENV['EC2_CONFIG_DIR']])
 
@@ -12,37 +12,37 @@ class Keypair
   attr_accessor :filepath
   attr_reader :extra_paths, :opts
   attr_reader :search_suffixes
-  
-  # Create a new key that defaults to id_rsa as the name. 
+
+  # Create a new key that defaults to id_rsa as the name.
   def initialize(fpath, extra_paths=[], opts={})
     @filepath = fpath
     @opts = opts
     @extra_paths = extra_paths.map {|a| File.expand_path(a) }
     @search_suffixes = SEARCH_SUFFIXES
   end
-  
+
   # If the full_filepath is nil or false, then the key doesn't exist
   def exists?
     !! full_filepath
   end
-  
+
   # Read the content of the key
   def content
     @content ||= exists? ? open(full_filepath).read : nil
   end
-      
+
   # Returns the full_filepath of the key. If a full filepath is passed, we just return the expanded filepath
   # for the keypair, otherwise query where it is against known locations
   def full_filepath
-    @full_filepath ||= 
-      find_file_in_path_with_suffix(filepath, extra_paths, 
+    @full_filepath ||=
+      find_file_in_path_with_suffix(filepath, extra_paths,
                                     search_suffixes) || false
   end
-  
+
   def to_s
     basename
   end
-  
+
   #TODO: gracefully handle the case when a passpharase is needed
   # Generate a public key from the private key
   # net/ssh already has this built-in from our extension.
@@ -54,21 +54,21 @@ class Keypair
       @public_key_string
     end
   end
-  
+
   def public_key=(str)
      @public_key_string = str
   end
-  
+
   # Basename of the keypair
   def basename
     @basename ||= ::File.basename(filepath, ::File.extname(filepath))
   end
-  
+
   # Just the filename of the keypair
   def filename
     @filename ||= ::File.basename(full_filepath) rescue filepath
   end
-  
+
   # Support to add the enumerable each to keys
   def each
     yield full_filepath
@@ -80,19 +80,19 @@ class Keypair
   def valid?
     validations.each {|validation| self.send(validation.to_sym) }
   end
- 
+
   private
- 
+
   # Validations
   def validations
     [:keypair_found?, :has_proper_permissions?]
   end
-  
+
   # Check the proper permissions
   def has_proper_permissions?
     perm_truth = [:readable?, :writable?, :executable?].map {|meth| File.send(meth, full_filepath)} == [true, true, false]
     raise StandardError.new("Your keypair #{full_filepath} has improper file permissions. Keypairs must be 0600 permission. Please chmod your keypair file and try again") unless perm_truth
-  end  
+  end
   def keypair_found?
     if exists?
       true
@@ -103,10 +103,10 @@ class Keypair
 
   # try filename with suffix and without suffixes.
   # Checks all paths without suffix first, then try all paths for all suffixes.
-  def find_file_in_path_with_suffix(file, extra_paths, suffixes=[], 
+  def find_file_in_path_with_suffix(file, extra_paths, suffixes=[],
                                     try_wo_suffix=true)
     suffixes_to_try = suffixes.dup
-    suffixes_to_try.unshift '' if try_wo_suffix
+    suffixes_to_try.push '' if try_wo_suffix
 
     suffixes_to_try.map {|s| file + s }.each do |suffixed|
       fullpath = if File.file?(File.expand_path(suffixed))
@@ -119,5 +119,5 @@ class Keypair
 
     nil
   end
-  
+
 end