auser-poolparty 1.2.12 → 1.3.0

data/lib/poolparty/net/remoter_bases/ec2/ec2.rb

@@ -1,300 +0,0 @@
-=begin rdoc
-  EC2 Remoter Base
-  
-  This serves as the basis for running PoolParty on Amazon's ec2 cloud.
-=end
-require "date"
-require "#{::File.dirname(__FILE__)}/ec2_response_object"
-
-begin
-  require 'EC2'
-rescue LoadError
-  puts <<-EOM
-Error: In order to use ec2, you need to install the amazon-ec2 gem
-
-Ec2 is the default remoter base for PoolParty. If you intend on using
-a different remoter base, specify it with:
-
-using :remoter_name
-
-in your config file, otherwise, to continue install grempe-amazon-ec2 with
-
-sudo gem install grempe-amazon-ec2 --source http://gems.github.com
-EOM
-end
-  
-class String
-  def convert_from_ec2_to_ip
-    self.match(/-(\d+-\d+-\d+-\d+)\./) ? $1.gsub(/-/, '.') : self
-  end
-  def parse_datetime
-    DateTime.parse( self.chomp ) rescue self
-  end
-end
-  
-module PoolParty    
-  module Remote
-    class Ec2 < Remote::RemoterBase
-      require "#{::File.dirname(__FILE__)}/ec2_remote_instance"
-      
-      dsl_methods :elastic_ips,           # An array of the elastic ips
-                  :ebs_volume_id         # The volume id of an ebs volume
-      
-      default_options({
-        :image_id           => 'ami-bf5eb9d6',
-        :ami                => 'ami-bf5eb9d6',  #Deprecated, but here for backwards compatability
-        # :key_name => ::File.basename(keypair.is_a?(String) ? keypair : keypair.full_filepath),
-        :instance_type      => 'm1.small', # or 'm1.large', 'm1.xlarge', 'c1.medium', or 'c1.xlarge'
-        :addressing_type    => "public",
-        :availability_zone  => "us-east-1a",
-        :access_key         => ENV['AWS_ACCESS_KEY'],
-        :secret_access_key  => ENV['AWS_SECRET_ACCESS_KEY'],
-        :security_group     => ["default"],
-        :keypair_name       => nil,
-        :key_name           => nil
-        })
-        
-      # alias to image_id
-      # def ami(n=nil)
-      #   if n.nil?
-      #     image_id
-      #   else
-      #     image_id n
-      #   end
-      # end
-      
-      # Requires a hash of options
-      def self.launch_new_instance!(o)
-        new(o).launch_new_instance!
-      end
-      
-      # TODO: Fix the key_name issue
-      # Start a new instance with the given options
-      def launch_new_instance!(o={})
-        set_vars_from_options o
-        keypair_name ||= o[:keypair_name] || keypair || (clouds[o[:cloud_name]].keypair.basename if o[:cloud_name])
-        raise "You must pass a keypair to launch an instance, or else you will not be able to login. options = #{o.inspect}" if !keypair_name 
-        o.merge!( dsl_options.merge(:key_name=>keypair_name, :group_id => security_group) )
-        instance = ec2(o).run_instances(o)
-        
-        begin
-          h = EC2ResponseObject.describe_instance(instance)
-          #h = instance.instancesSet.item.first
-        rescue Exception => e
-          vputs "There was an error:\n\t#{e.inspect}"
-          h = EC2ResponseObject.describe_instance(instance) rescue instance
-          # h = instance
-        end
-        Ec2RemoteInstance.new(h)
-      end
-      
-      # Terminate an instance by id
-      def terminate_instance!(o={})
-        ec2(o).terminate_instances(:instance_id => o[:instance_id])
-      end
-      
-      # Describe an instance's status
-      def describe_instance(o={})
-        return describe_instances.first if o.empty? || o[:instance_id].nil?
-        describe_instances.detect {|a| a[:name] == o[:instance_id] || a[:ip] == o[:instance_id] || a[:instance_id] == o[:instance_id] }
-      end
-      
-      def describe_instances(o={})
-        ec2_instants = EC2ResponseObject.describe_instances(ec2.describe_instances)
-        insts = ec2_instants.select_with_hash(o) if !o.empty?
-        ec2_remote_instances = ec2_instants.collect{|i| Ec2RemoteInstance.new(i)}
-        ec2_remote_instances.sort {|a,b| a[:ami_launch_index] <=> b[:ami_launch_index] }
-      end
-      
-      # TODO: Clean up this method and remove hostnames
-      # def describe_instances(o={})
-      #   id = 0
-      #   set_vars_from_options(dsl_options.merge(o))
-      #   get_instances_description(dsl_options).each_with_index do |h,i|
-      #     if h[:status] == "running"
-      #       inst_name = id == 0 ? "master" : "node#{id}"
-      #       id += 1
-      #     else
-      #       inst_name = "#{h[:status]}_node#{i}"
-      #     end
-      #     h.merge!({
-      #       :name           => inst_name,
-      #       :hostname       => h[:ip],
-      #       :ip             => h[:ip].convert_from_ec2_to_ip,
-      #       # :internal_ip    => h.ip
-      #       :index          => i,  #TODO get the instance id from the aws result instead
-      #       :launching_time => (h[:launching_time])
-      #     })
-      #   end.compact.sort {|a,b| a[:index] <=> b[:index] }
-      # end
-      
-      # ===================================
-      # = Ec2 Specific methods below here =
-      # ===================================
-      
-      # return or create a new base EC2 connection object that will actually connect to ec2
-      def ec2(o={})
-        @ec2 ||= EC2::Base.new( :access_key_id => o[:access_key] || get_access_key, 
-                                :secret_access_key => o[:secret_access_key] || get_secret_access_key
-                              )
-      end
-      def self.ec2(o)
-        @ec2 ||= EC2::Base.new( :access_key_id => o[:access_key], 
-                                :secret_access_key => o[:secret_access_key]
-                              )
-      end
-      
-      # Get the ec2 description for the response in a hash format
-      def get_instances_description(o={})
-        #TODO: only use keypair.full_filepath
-        set_vars_from_options dsl_options.merge(o)
-        key_hash = {:keypair => self.keypair_name}
-        out = EC2ResponseObject.get_descriptions(ec2(dsl_options).describe_instances)
-        out = keypair_name ? out.select_with_hash(key_hash) : out
-      end
-      def get_descriptions(o={})
-        self.class.get_descriptions(o)
-      end
-            
-      # Class method helpers
-      def aws_keys
-        unless @access_key && @secret_access_key
-          aws_keys = {}
-          aws_keys = YAML::load( File.open('/etc/poolparty/aws_keys.yml') ) rescue 'No aws_keys.yml file.   Will try to use enviornment variables'
-          @access_key ||= aws_keys[:access_key] || ENV['AMAZON_ACCESS_KEY_ID'] || ENV['AWS_ACCESS_KEY']
-          @secret_access_key ||= aws_keys[:secret_access_key] || ENV['AMAZON_SECRET_ACCESS_KEY'] || ENV['AWS_SECRET_ACCESS_KEY']
-        end
-        [@access_key, @secret_access_key]
-      end
-      
-      def after_launch_instance(inst)
-        if inst
-          associate_address(inst)
-        end
-      end
-      
-      # Associate an address with the instance using ec2
-      # Get the next_unused_elastic_ip
-      # and if there is one, associate the instance to the 
-      # public ip
-      def associate_address(instance=nil)
-        if ip = next_unused_elastic_ip
-          vputs "Associating #{instance.instance_id} with #{ip}"
-          ec2.associate_address(:instance_id => instance.instance_id, :public_ip => ip)
-          
-          # Try for 10 minutes to pint port 22 
-          500.times do |i|
-            dprint "."
-            if ping_port(ip, 22)
-              instance[:ip] = ip
-              return true
-            end
-            sleep(2)
-          end 
-        end
-      end
-      
-      # Get the next usable elastic ip
-      # First, get the list of addresses from ec2 that the client
-      # has access to, then select only the ones that are not associated
-      # with an instance.
-      # If the cloud has set elastic_ips to use, then, using the 
-      # intersection of the unused ips and those, find the first one available
-      # and return that, otherwise, return the first elastic ip available
-      def next_unused_elastic_ip
-        if elastic_ips.empty?
-          nil
-        else
-          # [{"instanceId"=>nil, "publicIp"=>"174.129.212.93"}, {"instanceId"=>nil, "publicIp"=>"174.129.212.94"}]
-          if addressesSet = ec2(dsl_options).describe_addresses(:public_ip => elastic_ips)["addressesSet"]
-            begin
-              empty_addresses = addressesSet["item"].select {|i| i["instanceId"].nil? }
-              ips = empty_addresses.map {|addr| addr["publicIp"]}
-              if elastic_ips
-                ips_to_use = elastic_ips & ips
-                ips_to_use.first
-              end
-            rescue Exception => e
-              puts "Error: #{e}"
-              nil
-            end
-          end
-        end
-      end
-
-      # Help create a keypair for the cloud
-      # This is a helper to create the keypair and add them to the cloud for you
-      def create_keypair
-        return false unless keypair
-        unless ::File.exists?( new_keypair_path )
-          FileUtils.mkdir_p ::File.dirname( new_keypair_path )
-          vputs "Creating keypair: #{keypair} in #{new_keypair_path}"
-          Kernel.system "ec2-add-keypair #{keypair} > #{new_keypair_path} && chmod 600 #{new_keypair_path}"
-        end
-      end
-    
-      # wrapper for remote base to perform a snapshot backup for the ebs volume
-      def create_snapshot
-        return nil if ebs_volume_id.nil?
-        ec2.create_snapshot(:volume_id => ebs_volume_id)
-      end
-    
-      def has_cert_and_key?
-        pub_key && private_key
-      end
-      # The keys are used only for puppet certificates
-      # and are only used for EC2.
-      # Public key 
-      def pub_key
-        @pub_key ||= ENV["EC2_CERT"] ? ENV["EC2_CERT"] : nil
-      end
-      # Private key
-      def private_key
-        @private_key ||= ENV["EC2_PRIVATE_KEY"] ? ENV["EC2_PRIVATE_KEY"] : nil
-      end
-    
-      def custom_minimum_runnable_options
-        [:ami, :availability_zone, :security_group]
-      end
-
-      # Hook
-      #TODO#: Change this so they match with the cap tasks
-      def custom_install_tasks_for(o)        
-        [
-          # "if [ -z $(grep -v '#' /etc/hosts | grep '#{o.name}') ]; then echo \"$(curl http://169.254.169.254/latest/meta-data/public-ipv4) #{o.name}\" >> /etc/hosts; fi",
-          "if [ -z \"$(grep -v '#' /etc/hosts | grep '#{o.name}')\" ]; then echo '127.0.0.1 #{o.name}' >> /etc/hosts; fi",
-          "hostname #{o.name}",
-          "echo #{o.name} > /etc/hostname"
-        ]
-      end
-    
-      def after_install_tasks_for(o)
-        [
-          # "cd /var/poolparty && wget http://rubyforge.org/frs/download.php/43666/amazon-ec2-0.3.1.gem -O amazon-ec2.gem 2>&1",
-          # "/usr/bin/gem install --no-ri --no-rdoc amazon-ec2.gem 2>&1"
-        ]
-      end
-      
-      def get_access_key(n=nil)
-        if n.nil?
-          dsl_options[:access_key] ||= Default.access_key
-        else
-          self.access_key = n
-        end
-      end
-      
-      def get_secret_access_key(n=nil)
-        if n.nil?
-          dsl_options[:secret_access_key] ||= Default.secret_access_key
-        else
-          self.secret_access_key = n
-        end
-      end
-
-      def reset_base!
-        @describe_instances = @cached_descriptions = nil
-      end      
-    end
-        
-  end
-end

data/lib/poolparty/net/remoter_bases/ec2/ec2_remote_instance.rb

@@ -1,64 +0,0 @@
-require "#{::File.dirname(__FILE__)}/ec2"
-module PoolParty  
-  module Remote
-    class Ec2RemoteInstance < RemoteInstance
-      include Dslify
-      include Remote
-      
-      default_options({
-        # :launching_time   => Time.now,
-        :dns_name         => nil,
-        :private_dns_name => nil,
-        :key_name         => nil,
-        :kernel_id        => nil,
-        :ramdisk_id       => nil,
-        :launch_time      => nil,
-        :instance_id      => nil,
-        :ami_launch_index => nil,
-        :ip               => nil,
-        :public_ip        => nil,
-        :internal_ip      => nil
-        }.merge(Remote::Ec2.default_options) )
-      
-      @uniquely_identifiable_by = [:ip, :name, :dns_name, :instance_id]
-      
-      # A new instance will be created from the passed in hash.  
-      # This hash of passed in values will be converted to methods on this instance.
-      # The parent clouds describe_instances list will be searched for the first one matching any of this instance's provided unique identifiers.
-      # If an instance is found, this instance's properties will be set to the properties provided
-      # If the found instance has properties of the same key as the provided options, the found instance's values will override the passed in options
-      def initialize(opts={})
-        opts.delete(:id)  # metavirt passes an id that we do not want to set
-        set_vars_from_options(opts) if opts.is_a?(Hash)
-        @target_host = public_ip || internal_ip || ip  #set this for the netssh commands
-        # super(opts)
-      end
-      
-      def keypair(*n)
-        dsl_options[:keypair] ||= Key.new(key_name)
-      end
-      
-      # Printing. This is how we extract the instances into the listing on the 
-      # local side into the local listing file
-      def to_s
-        "#{name}\t#{ip}\t#{instance_id rescue ""}"
-      end
-      
-      # Class method to disect a neighborhood line
-      def self.hash_from_s(s)
-        arr = s.split("\t")
-        {:name => arr[0], :ip => arr[1]}
-      end
-      
-      def self.to_s(hsh)
-        new(hsh).to_s
-      end
-      
-      def hosts_file_listing_for(cl)
-        string = (cl.name == cloud.name) ? "#{name}.#{my_cloud.name}\t#{name}" : "#{name}.#{my_cloud.name}"
-        "#{internal_ip}\t#{string}"
-      end
-      
-    end
-  end
-end

data/lib/poolparty/net/remoter_bases/ec2/ec2_response_object.rb

@@ -1,129 +0,0 @@
-# Convenience class to convert standard amazon-ec2 responses from their camel cased style to a hash using underscore style.
-# For example: instanceId to instance_id
-class EC2ResponseObject
-  def self.get_descriptions(resp)          
-    rs = get_instance_from_response(resp)
-    group = get_group_from_response(resp)
-    
-    # puts rs.methods.sort - rs.ancestors.methods
-    out = begin
-      if rs.respond_to?(:instancesSet)
-        [EC2ResponseObject.describe_instances(rs)]
-      else
-        rs.collect {|r| 
-          if r.instancesSet.item.class == Array
-            r.instancesSet.item.map {|t| EC2ResponseObject.describe_instances(t)}
-          else
-            [EC2ResponseObject.describe_instances(r)]
-          end            
-        }.flatten.reject {|a| a.nil? }
-      end
-    rescue Exception => e
-      # Really weird bug with amazon's ec2 gem
-      rs.collect {|r| EC2ResponseObject.describe_instances(r)}.reject {|a| a.nil? } rescue []
-    end
-
-    out
-  end
-  def self.get_instance_from_response(resp)
-    begin
-      rs = resp.reservationSet.item unless resp.reservationSet.nil?
-      rs ||= resp.DescribeInstancesResponse.reservationSet.item
-      rs ||= rs.respond_to?(:instancesSet) ? rs.instancesSet : rs
-      rs.reject! {|a| a.nil? || a.empty? }
-    rescue Exception => e
-      resp
-    end
-    rs
-  end
-  def self.get_group_from_response(resp)
-    begin
-      resp = resp.reservationSet.item.first if resp.reservationSet.item.is_a?(Array)
-      group = resp.reservationSet.item.groupSet.item.groupId unless resp.reservationSet.nil?
-      group ||= resp.groupSet.item[0].groupId rescue nil
-      group ||= resp.DescribeInstancesResponse.reservationSet.item.groupSet.item.groupId
-      #rs ||= rs.respond_to?(:instancesSet) ? rs.instancesSet : rs
-      #rs.reject! {|a| a.nil? || a.empty? }
-    rescue Exception => e
-      resp
-    end
-    group
-  end
-  def self.get_hash_from_response(resp, group = 'default')
-      symbolize_and_snakecase
-      {
-        :instance_id => resp.instanceId,
-        :name => resp.instanceId,
-        :status => resp.instanceState.name,
-        :public_ip => resp.dnsName || "not-assigned",
-        :ip => resp.dnsName || "not-assigned",
-        :internal_ip => resp.privateDnsName,
-        :launching_time => resp.launchTime.parse_datetime,
-        :keypair => (resp.keyName rescue ""),
-        :security_group => group
-      }
-  end
-  
-  #####
-  
-  # Convert the standard reponse into output similar to this example
-  # {:dns_name          =>"ec2-75-101-175-49.compute-1.amazonaws.com",
-  #  :private_dns_name  =>"domU-11-31-39-00-DC-78.compute-1.internal",
-  #  :reason            =>nil,
-  #  :instance_state    =>{"name"=>"running", "code"=>"16"},
-  #  :kernel_id         =>"aki-a71cf9ce",
-  #  :ramdisk_id        =>"ari-a51cf9cc",
-  #  :placement         =>{"availabilityZone"=>"us-east-1a"},
-  #  :product_codes     =>nil,
-  #  :image_id          =>"ami-bf5eb9d6",
-  #  :launch_time       =>"2009-05-29T05:07:09.000Z",
-  #  :key_name          =>"poolname_cloudname",
-  #  :instance_id       =>"i-1b7b2942",
-  #  :ami_launch_index  =>"0",
-  #  :instance_type     =>"m1.small"}
-  #
-  # Selects the first instance if an index is not given.
-  def self.describe_instance(response, index=0)
-    inst = if response.has_key?("reservationSet")
-      response['reservationSet']['item'].first['instancesSet']['item'][index]
-    elsif response.has_key?("instancesSet")
-      response['instancesSet']['item'][index]
-    else
-      raise StandardError.new("EC2ResponseObject was given a response it doesn't know about\n\t#{response.inspect}")
-    end
-    
-    # Ec2RemoteInstance.new(
-    symbolize_and_snakecase(inst)
-  end
-  
-  def self.describe_instances(response)
-    return [] if response['reservationSet'].nil?
-    ec2_insts = response['reservationSet']['item'].collect do |ri|
-      ri['instancesSet']['item'].collect{|i| i}
-    end
-    ec2_insts.flatten.collect {|i| symbolize_and_snakecase(i) }
-  end
-  
-  # Convert the standard response hash to format used throughout the rest of PoolParty code.
-  # And add in some more values we rely on
-  def self.symbolize_and_snakecase(inst)
-    n = inst.symbolize_keys(:snake_case)
-    n[:internal_ip] = convert_from_ec2_dns_to_ip(n[:private_dns_name])
-    n[:public_ip]   = convert_from_ec2_dns_to_ip(n[:dns_name])
-    n[:ip]          = n[:public_ip]
-    n[:launch_time] = parse_datetime(n[:launch_time])
-    n[:status]      = n[:instance_state][:name]
-    n[:availability_zone] = n[:placement][:availability_zone]
-    n
-  end
-  
-  def self.convert_from_ec2_dns_to_ip(str)
-    return nil if str.nil?
-    str.scan(/-(\d{1,3})-(\d{1,3})-(\d{1,3})-(\d{1,3})/).flatten.join('.')
-  end
-  
-  def self.parse_datetime(str)
-    DateTime.parse( str.chomp ) rescue self
-  end
-  
-end

data/lib/poolparty/net/remoter_bases/libvirt/libvirt.rb

@@ -1,73 +0,0 @@
-=begin rdoc
-
-=end
-require 'xmlsimple'
-
-module PoolParty
-  module Remote
-    class Libvirt < Remote::RemoterBase
-      include Dslify
-      
-      default_options :image_id => nil 
-      
-      def initialize(opts={}, &block)
-        set_vars_from_options opts
-        super
-      end
-      
-      def self.launch_new_instance!(o={})
-        new(o).launch_new_instance!
-      end
-      def launch_new_instance!(o={})
-        `virsh start #{image_id}`
-        describe_instance :image_id=>image_id
-      end
-      # Terminate an instance by id
-      def self.terminate_instance!(o={})
-        new(o).terminate_instance!
-      end
-      def terminate_instance!(o={})
-        `virsh shutdown #{image_id}`
-      end
-      
-      def self.describe_instance(o={})
-        new(o).describe_instance
-      end
-      def describe_instance(o={})
-        LibvirtInstance.new(o).description
-      end
-      
-      # Returns an array of instance name => state
-      # For example:
-      #   [{"i-3687065A" =>"shut off"},
-      #     {"jaunty19"  =>"shut off"},
-      #     {"jauntykvm" =>"running"}]
-      def self.describe_instances(o={})
-        new(o).describe_instances
-      end
-      def describe_instances(o={})
-        output = `virsh list`.split("\n")
-        return [] if output.empty? || output.size < 3
-        output[2..-1].collect do |i|
-          d=i.split(' ')
-          LibvirtInstance.new(:name => d[1], :status  => d[2..-1].join(' '))
-        end
-      end
-      
-      # After launch callback
-      # This is called after a new instance is launched
-      def after_launched(force=false)
-        puts "new instance was launched"
-      end
-      
-      # Before shutdown callback
-      # This is called before the cloud is contracted
-      def before_shutdown
-      end
-      def self.virsh
-        new({}).path_to_binary
-      end
-      
-    end
-  end
-end

data/lib/poolparty/net/remoter_bases/libvirt/libvirt_instance.rb

@@ -1,64 +0,0 @@
-require 'xmlsimple'
-
-module PoolParty
-  module Remote
-    
-    class LibvirtInstance < RemoteInstance
-      include Dslify
-      
-      dsl_methods :name,
-                  :instance_id, # Libvirt UUID
-                  :image_id,
-                  :ip,          # Ip of the remote instance, by default, the public_ip
-                  :internal_ip, # Internal ip of the remote instance
-                  :public_ip,
-                  :status,      # Status of the remote instance
-                  :mac_address,
-                  :keypair_name,
-                  :cloud
-      
-      def initialize(o={})
-        set_vars_from_options o
-        # super
-      end
-      
-      def to_hash
-        dsl_options
-      end
-      
-      def keypair(*n)
-        dsl_options[:keypair] ||= Key.new(keypair_name)
-      end
-      
-      # TODO: this needs to be extended for selecting between multiple interfaces
-      def mac_address(hsh=nil)
-        mac_addresses.first(hsh)
-      end
-      
-      def mac_addresses(hsh=nil)
-        data = hsh || description
-        data[:devices].select{|el| 
-          el.has_key? :interface 
-          }.collect{|eth|
-            eth.interface.collect{|n| n.mac}
-          }.flatten.collect{|c| c.values}.flatten
-      end
-      
-      def description
-        p command = "virsh dumpxml #{instance_id || image_id || name}"
-        xml = `#{command}`
-        hsh = XmlSimple.xml_in(xml, 'KeyToSymbol'=>true)
-        hsh[:state] = `virsh domstate #{instance_id || image_id || name}`
-        hsh[:mac_address] = mac_addresses( hsh ).first
-        dsl_options.merge! hsh
-        self
-      end
-      
-      def mac_address
-        
-      end
-      
-    end
-    
-  end
-end