poolparty 1.3.15 → 1.4.0

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

@@ -0,0 +1,98 @@
+module CloudProviders
+  class SecurityGroup < Ec2Helper
+    
+    def run
+      if should_create_security_group?
+        create_security_group!
+      end
+      current_security_groups = security_groups.map {|a| 
+        a[:ip_permissions].map do |perm|
+          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
+            {
+              :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...
+              :ip_protocol => perm[:protocol]
+            }
+          end
+        end.flatten
+      }.flatten
+      
+      authorizers = []
+      authorizes.each do |a|
+        unless current_security_groups.include?(a.to_hash)
+          authorizers << a
+        end
+      end
+      
+      defined_security_group_hashes = authorizes.map {|a| a.to_hash}
+      
+      current_security_groups.each do |hsh|
+        unless defined_security_group_hashes.include?(hsh)
+          revoke(hsh.merge(:protocol => hsh[:ip_protocol]))
+        end
+      end
+      
+      revokes.each {|r| r.run }
+      authorizers.each {|a| a.run}
+    end
+    def authorize(o={}, &block)
+      authorizes << Authorize.new("#{name}", o.merge(:parent => parent, :cloud => cloud), &block)
+    end
+    def revoke(o={}, &block)
+      revokes << Revoke.new("#{name}", o.merge(:parent => parent, :cloud => cloud), &block)
+    end
+    def create_security_group!
+      ec2.create_security_group(:group_name => name, :group_description => "PoolParty generated security group: #{name}")
+    end
+    def should_create_security_group?
+      security_groups.empty?
+    end
+    def security_groups
+      @security_groups ||= all_security_groups.select {|sg| sg[:name] == name }
+    end
+    def all_security_groups
+      @all_security_groups ||= ec2.describe_security_groups.securityGroupInfo.item.map do |sg|
+        perms = sg["ipPermissions"] || {"item" => []} rescue [{"item" => []}]
+        {
+          :name => sg["groupName"],
+          :description => sg["groupDescription"],
+          :ip_permissions => perms["item"].map do |i|
+            ip_ranges = i["ipRanges"] || {"item" => []} rescue {"item" => []}
+            {
+              :protocol => i["ipProtocol"],
+              :from_port => i["fromPort"],
+              :to_port => i["toPort"],
+              :ip_ranges => ip_ranges["item"].map do |ip|
+                {
+                  :cidrIp => ip["cidrIp"]
+                }
+              end
+            }
+          end
+        }
+      end
+    end
+    def to_s
+      name
+    end
+    def authorizes
+      @authorizes ||= []
+    end
+    def revokes
+      @revokes ||= []
+    end
+  end
+
+end

data/lib/cloud_providers/remote_instance.rb

@@ -0,0 +1,139 @@
+=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?
+      @chef_bootstrapped ||= !ssh(["gem list | grep chef"]).empty?
+    end
+    
+    def bootstrap_chef!
+      unless chef_bootstrapped?
+        ssh([
+          'apt-get update',
+          'apt-get autoremove -y',
+          'apt-get install -y ruby ruby-dev rubygems git-core',
+          'gem sources -a http://gems.opscode.com',
+          'gem install chef ohai --no-rdoc --no-ri'
+        ])
+      end
+    end
+    
+    def run_chef!
+      ssh([
+        "/var/lib/gems/1.8/bin/chef-solo -j /etc/chef/dna.json -c /etc/chef/solo.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  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/cloud_providers.rb

@@ -10,10 +10,10 @@ module CloudProviders
 
 end
 
-require File.dirname(__FILE__)+"/cloud_providers/connections"
-require File.dirname(__FILE__)+"/cloud_providers/cloud_provider"
-require File.dirname(__FILE__)+"/cloud_providers/cloud_provider_instance"
+%w(connections remote_instance cloud_provider).each do |lib|
+  require File.dirname(__FILE__)+"/cloud_providers/#{lib}"
+end
 
-%w(ec2 vmware ssh).each do |lib|
+%w(ec2).each do |lib|
   require "cloud_providers/#{lib}/#{lib}"
 end

data/lib/core/array.rb

@@ -2,11 +2,7 @@
   Array extensions
 =end
 
-require "enumerator"
 class Array
-  def collect_with_index &block
-    self.enum_for(:each_with_index).collect &block
-  end
 
   # Example  nodes.select_with_hash(:status=>'running')
   def select_with_hash(conditions={})
@@ -17,38 +13,5 @@ class Array
       end
     end
   end
-  
-  def wrapping_next(id)
-    raise "Element #{id} not in array" unless index(id)
-    index(id) >= size-1 ? at(0) : at(index(id)+1)
-  end
-  
-  # Swap elements of an array
-  def swap!(a,b)
-    self[a], self[b] = self[b], self[a]
-    self
-  end
-  
-  # Rotate an array
-  # Example:
-  #   arr = %w(a b c d e f)
-  #   arr2 = arr.clone.rotate
-  # 
-  #   arr.zip(arr2) => 
-  #   [["a", "b"], ["b", "c"], ["c", "d"], ["d", "e"], ["e", "f"], ["f", "a"]]  
-  def rotate
-    push shift
-  end
-  
-  def zip_offset(offset=0)
-    arr2 = self.dup
-    
-    out = []
-    self.each_with_index do |ele,i|
-      break if i == (self.size - offset)
-      out[i] = [ele, arr2[i+1]]
-    end
-    out
-  end
     
 end

data/lib/core/hash.rb

@@ -7,49 +7,23 @@ class Hash
   def choose(&block)
     Hash[*self.select(&block).inject([]){|res,(k,v)| res << k << v}]
   end
-
-  def to_instance_variables(inst=nil)
-    each do |k,v|
-      inst.instance_variable_set "@#{k}", v
-      inst.class.send :attr_reader, k if inst
-    end
-  end
-  
-  # extracted from activesupport
-  # Returns an array of the values at the specified indices:
-  #
-  #   hash = HashWithIndifferentAccess.new
-  #   hash[:a] = "x"
-  #   hash[:b] = "y"
-  #   hash.values_at("a", "b") # => ["x", "y"]
-  def values_at(*indices)
-    indices.collect {|key| self[key]}.compact
-  end
   
-  def next_sorted_key(from)
-    idx = (size - keys.sort.index(from))
-    keys.sort[idx - 1]
-  end
-  
-  def stringify_keys
-    dup.stringify_keys!
+  # Computes the difference between two hashes
+  def diff(other, *hsh)
+    o = {}
+    keys.map do |k|
+      if hsh.include?(k) || hsh.empty?
+        other[k] == self[k] ? nil : o.merge!({k => other[k]})
+      end
+    end.reject {|b| b.nil? }
+    o
   end
   
-  # Converts all of the keys to strings
-  def stringify_keys!
-    keys.each{|k| 
-      v = delete(k)
-      self[k.to_s] = v
-      v.stringify_keys! if v.is_a?(Hash)
-      v.each{|p| p.stringify_keys! if p.is_a?(Hash)} if v.is_a?(Array)
-    }
+  def merge_if!(k, v)
+    self[k] = v if v
     self
   end
   
-  def symbolize_keys(key_modifier=nil)
-    dup.symbolize_keys!(key_modifier)
-  end
-  
   # Converts all of the keys to strings
   # can pass in a :key_modifier that will be sent to each key, before being symbolized.
   # This can be usefull if you want to downcase, or snake_case each key.

data/lib/core/object.rb

@@ -1,92 +1,11 @@
 class Object
     
-  # The pool method creates a pool and
-  # inserts it into the pool hash
-  def pool(name, &block)
-    if block
-      pools[name.to_s] ||= PoolParty::Pool.new(name, &block)
-    else
-      raise PoolParty::PoolPartyError.create("PoolError", "You must pass a block when defining a pool")
-    end
+  def pool(name=nil, &block)
+    @@pool ||= PoolParty::Pool.new(name, &block)
   end
   
-  # The global hash of pools
-  def pools
-    $pools ||= {}
+  def reset!
+    @@pool = nil
   end
-  
-  # The clouds hash is a global hash
-  # that all objects can retrieve clouds from
-  # and they are stored by name
-  def clouds
-    $clouds ||= {}
-  end
-  
-  # Alias method
-  def alias_method(new_id, original_id)
-    original = self.method(original_id).to_proc
-    define_method(new_id){|*args| original.call(*args)}
-  end
-  
-  # Benchmark a block
-  def bm(msg, &block)
-    t = Time.now
-    block.call
-    puts "#{msg}: #{Time.now-t}"
-  end
-
-  # Do once.
-  # Takes a block. IF this block has already been run (from the run_procs array),
-  # then run it and store the block unique id in the run_procs array so
-  # it never gets run again
-  def do_once(&block)
-    unless run_procs.include?(block.to_s)      
-      instance_eval &block if block
-      run_procs << block.to_s
-    end    
-  end
-  
-  # Procs that have been run already in the run_once blocks
-  # This is just a container array of procs
-  def run_procs
-    @run_procs ||= []
-  end
-  
-  # Taken from http://www.ruby-forum.com/topic/54096
-  # Instance eval a block with arguments
-  def instance_exec(*args, &block)
-    mname = "__instance_exec_#{Thread.current.object_id.abs}"
-    class << self; self end.class_eval{ define_method(mname, &block) }
-    begin
-      ret = send(mname, *args)
-    ensure
-      class << self; self end.class_eval{ undef_method(mname) } rescue nil
-    end
-    ret
-  end
-  
-  # MESSAGES
-  # Debugging output helpers
-  def vputs(m="")
-    puts "[INFO] -- #{m}" if verbose?
-  end
-  def dputs(m="")
-    puts "[DEBUG] -- #{m.is_a?(String) ? m : m.inspect}" if debugging?
-  end
-  def ddputs(m="")
-    puts "[VERY DEBUG] -- #{m.is_a?(String) ? m : m.inspect}" if very_debugging?
-  end
-  def verbose?
-    $TESTING ||= false
-  end
-  def very_verbose?
-    ($VERY_VERBOSE ||= false)
-  end
-  def debugging?
-    ($DEBUGGING ||= false)
-  end
-  def very_debugging?
-    ($VERY_DEBUGGING ||= false)
-  end
-  
+    
 end

data/lib/core/string.rb

@@ -1,44 +1,4 @@
 class String
-  # Quick replacement of variables in a string with the
-  # hash equivalent
-  # Usage:
-  #   ":god bless :country" ^ {:god => "Budda", :country => "India"} #=> "Budda bless India"
-  # 
-  def ^(h={})
-    self.gsub(/:([\w]+)/) {h[$1.to_sym] if h.include?($1.to_sym)}
-  end
-  
-  # Get the top level class
-  # such as:
-  #   Dr::Pepper #=> pepper
-  def top_level_class
-    self.classify.split("::").last.snake_case
-  end
-  
-  # Strip ugly characters out of a string
-  def sanitize
-    self.gsub(/[ \.\/\-]*/, '')
-  end
-  
-  # Generate a unique integer key for this string
-  def keyerize
-    signed_short = 0x7FFFFFFF
-    len = self.sanitize.length
-    hash = 0 
-    len.times{ |i|  hash = self[i] + ( hash << 6 ) + ( hash << 16 ) - hash }
-    hash & signed_short
-  end
-  
-  # Strip quotes from the string and replaced them with backslashed quotes
-  def safe_quote
-    self.gsub(/['"]/, '\\\"')
-  end
-  
-  # Substitute spaces in a path for '\ ' spaces
-  def path_quote
-    self.safe_quote.gsub(/[ ]/, '\ ')
-  end
-  
   # Turn a downcased string and capitalize it
   # so that it can be a class
   # doc_river #=> DocRiver
@@ -50,7 +10,7 @@ class String
   def snake_case
    gsub(/\B[A-Z]+/, '_\&').downcase
   end
-
+ 
   # "FooBar".dasherize #=> "foo-bar"
   def dasherize
     gsub(/\B[A-Z]+/, '-\&').downcase
@@ -65,14 +25,6 @@ class String
   def classify
     self.sub(/.*\./, '').split("::").map {|ele| ele.camelcase }.join("::")
   end
-  
-  #TODO: implement here to drop activesupport
-  # # Form can be either :utc (default) or :local.
-  # def to_time(form = :utc)
-  #   ::Time.send("#{form}_time", *::Date._parse(self, false)(:year, :mon, :mday, :hour, :min, :sec).map { |arg| arg || 0 })
-  # end
-  
-    
   # Constantize tries to find a declared constant with the name specified
   # in the string. It raises a NameError when the name is not in CamelCase
   # or is not initialized.
@@ -89,62 +41,8 @@ class String
     end
   end
   
-  # Collect every line in the the array of the string split by newlines
-  # and assign an index with the line on the enumeration
-  def collect_each_line_with_index(&block)
-    returning [] do |arr|
-      arr << self.split(/\n/).collect_with_index(&block)
-    end.flatten
-  end
-  
-  # Read a new-line separated string and turn 
-  # the string from the form 
-  #   a = "b"
-  #   b = "c"
-  # into a hash
-  #  {:a => "b", :b => "c"}
-  def to_hash
-    split("\n").inject({}) do |sum,line| 
-      if line.include?("=")
-        l = line.split("=").map {|a| a.strip }
-        key = l[0].to_sym
-        value = l[1].gsub(/\"/, '')
-        sum.merge(key => value)
-      else
-        sum
-      end
-    end
-  end
-  
-  # Take a mac address and split it to map to the arp -a response
-  # Just rip off the first 0 if the first char is 0
-  def macify
-    split(":").map {|a| a[0].chr == "0" ? a[1].chr : a}.join(":")
-  end
-
-  ##
-  # @param o<String> The path component to join with the string.
-  #
-  # @return <String> The original path concatenated with o.
-  #
-  # @example
-  #   "merb"/"core_ext" #=> "merb/core_ext"
   def /(o)
     File.join(self, o.to_s)
   end
   
-  # Parse json string to a ruby object
-  def json_parse
-    return nil if self == "null" || self.empty?
-    result = JSON.parse self
-    if result.respond_to? :keys
-      result.symbolize_keys!
-    end
-  end
-
-  # dumb and ugly pluralize
-  def pluralize(count=2)
-    count > 1 ? self + "s" : self 
-  end
-  
 end

data/lib/keypair.rb

@@ -7,11 +7,13 @@ class Keypair
   has_searchable_paths(:prepend_paths => [Dir.pwd, '/etc/poolparty/keys', "#{ENV["HOME"]}/.ssh/", "#{ENV["HOME"]}/.ec2/", ENV['EC2_CONFIG_DIR']])
   
   attr_accessor :filepath
+  attr_reader :extra_paths, :opts
   
   # Create a new key that defaults to id_rsa as the name. 
-  def initialize(fpath)
+  def initialize(fpath, extra_paths=[], opts={})
     @filepath = fpath
-    valid?
+    @opts = opts
+    @extra_paths = extra_paths.map {|a| File.expand_path(a) }
   end
   
   # If the full_filepath is nil, then the key doesn't exist
@@ -27,13 +29,18 @@ class Keypair
   # 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 ||= if File.file?(::File.expand_path(filepath))
+    return @full_filepath if @full_filepath
+    @full_filepath = if File.file?(File.expand_path(filepath))
       ::File.expand_path(filepath)
       else
-        search_in_known_locations(filepath)
+        search_in_known_locations(filepath, extra_paths)
       end
+    @full_filepath ? @full_filepath : false
+  end
+  
+  def to_s
+    basename
   end
-  alias :to_s :full_filepath
   
   #TODO: gracefully handle the case when a passpharase is needed
   # Generate a public key from the private key
@@ -65,16 +72,16 @@ class Keypair
   def each
     yield full_filepath
   end
-      
+
   # Validation checks
   # if all of the validations pass, the object is considered valid
   # the validations are responsible for raising a PoolPartyError (StandardError)
   def valid?
     validations.each {|validation| self.send(validation.to_sym) }
   end
-
+ 
   private
-
+ 
   # Validations
   def validations
     [:keypair_found?, :has_proper_permissions?]
@@ -84,10 +91,14 @@ class Keypair
   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?
-    raise StandardError.new("#{filepath} key file cannot be found") unless exists?
+    if exists?
+      true
+    else
+      raise StandardError.new("#{filepath} key file cannot be found") unless filepath.nil?
+    end
   end
   
+  
 end