auser-poolparty 1.2.10 → 1.2.11

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

@@ -25,7 +25,7 @@ end
   
 class String
   def convert_from_ec2_to_ip
-    self.gsub(/.compute-1.amazonaws.com*/, '').gsub(/ec2-/, '').gsub(/-/, '.')
+    self.match(/-(\d+-\d+-\d+-\d+)\./) ? $1.gsub(/-/, '.') : self
   end
   def parse_datetime
     DateTime.parse( self.chomp ) rescue self
@@ -74,16 +74,18 @@ module PoolParty
         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) )
+        o.merge!( dsl_options.merge(:key_name=>keypair_name, :group_id => security_group) )
         instance = ec2(o).run_instances(o)
+        
         begin
-          h = EC2ResponseObject.get_hash_from_response(instance.instancesSet.item.first)
+          h = EC2ResponseObject.describe_instance(instance)
           #h = instance.instancesSet.item.first
         rescue Exception => e
-          h = EC2ResponseObject.get_hash_from_response(instance) rescue instance
+          vputs "There was an error:\n\t#{e.inspect}"
+          h = EC2ResponseObject.describe_instance(instance) rescue instance
           # h = instance
         end
-        h
+        Ec2RemoteInstance.new(h)
       end
       
       # Terminate an instance by id
@@ -200,21 +202,23 @@ module PoolParty
       # 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
-        # [{"instanceId"=>nil, "publicIp"=>"174.129.212.93"}, {"instanceId"=>nil, "publicIp"=>"174.129.212.94"}]
-        if addressesSet = ec2(dsl_options).describe_addresses["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
-            else
-              ips.first
+        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
-          rescue Exception => e
-            puts "Error: #{e}"
-            nil
-          end          
+          end
         end
       end
 

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

@@ -28,53 +28,35 @@ module PoolParty
       # 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)
-        @keypair ||= Key.new(key_name)
+        dsl_options[:keypair] ||= Key.new(key_name)
       end
       
-      ## hash like methods
-      # TODO: move these into a module, or into dslify
-      # include Enumerable
-      def each
-        dsl_options.each{ |k,v| yield k,v }
-      end
-      def [](k)
-        dsl_options[k]
+      # 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
       
-      def []=(k,v)
-        dsl_options[k] = v
+      # 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 keys
-        dsl_options.keys
-      end
-         
-      def values
-        dsl_options.values
+      def self.to_s(hsh)
+        new(hsh).to_s
       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?
+      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

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

@@ -8,19 +8,19 @@ class EC2ResponseObject
     # puts rs.methods.sort - rs.ancestors.methods
     out = begin
       if rs.respond_to?(:instancesSet)
-        [EC2ResponseObject.get_hash_from_response(rs.instancesSet.item, group)]
+        [EC2ResponseObject.describe_instances(rs)]
       else
         rs.collect {|r| 
           if r.instancesSet.item.class == Array
-            r.instancesSet.item.map {|t| EC2ResponseObject.get_hash_from_response(t, group)}
+            r.instancesSet.item.map {|t| EC2ResponseObject.describe_instances(t)}
           else
-            [EC2ResponseObject.get_hash_from_response(r.instancesSet.item, group)]
+            [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.get_hash_from_response(r)}.reject {|a| a.nil? } rescue []
+      rs.collect {|r| EC2ResponseObject.describe_instances(r)}.reject {|a| a.nil? } rescue []
     end
 
     out
@@ -67,25 +67,33 @@ class EC2ResponseObject
   #####
   
   # 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"}
+  # {: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=response['reservationSet']['item'].first['instancesSet']['item'][index]
-    Ec2RemoteInstance.new(symbolize_and_snakecase(inst))
+    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)

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

@@ -0,0 +1,73 @@
+=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

@@ -0,0 +1,64 @@
+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

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

@@ -11,21 +11,23 @@ module PoolParty
       include ::PoolParty::CloudResourcer
       
       default_options(
-        # :machine_image => 'ubuntu-kvm',
-        # :key       => lambda {Key.new},
-        # :keypair_name  => lambda {key.basename},
-        # :keypair_path  => lambda {key.full_filepath},
-        # :public_key    => lambda { key.public_key.to_s },
-        :keypair_name    => nil,
-        :keypair_path    => nil,
         :authorized_keys => nil,
-        :remoter_base    => :vmrun,
+        :remoter_base    => :libvirt,
         :server_config   => {}
         )
       
       def initialize(o={}, &block)
         using o[:remoter_base], o.delete(:remote_base) if o.has_key?(:remoter_base)
         super
+        set_vars_from_options remote_base.dsl_options
+      end
+      
+      def method_missing(m, args, &blk)
+        remote_base.respond_to?(m) ? remote_base.send(m, args, &blk) : super
+      end
+      
+      def authorized_keys
+        keypair.public_key
       end
       
       def remote_base(n=nil)
@@ -35,15 +37,21 @@ module PoolParty
           @remote_base = n
         end
       end
-        
+      
+      def image_id
+        dsl_options[:remote_base].image_id
+      end
+      
+      #Setup server instance that will talk to metavirt webservice
       def server
         if @server
           @server
         else
-          opts = {:content_type =>'application/json', 
-           :accept      => 'application/json',
-           :host        => 'http://localhost',
-           :port        => '3000'}.merge(server_config)
+          opts = { :content_type  =>'application/json', 
+                   :accept        => 'application/json',
+                   :host          => 'http://localhost',
+                   :port          => '3000'
+                  }.merge(server_config)
           @uri = "#{opts.delete(:host)}:#{opts.delete(:port)}"
           @server = RestClient::Resource.new( @uri, opts)
         end
@@ -56,8 +64,9 @@ module PoolParty
         opts = to_hash.merge(o)
         result = JSON.parse(server['/run-instance'].put(opts.to_json)).symbolize_keys!
         @id = result[:instance_id]
-        result
+        MetavirtInstance.new result
       end
+      
       # Terminate an instance by id
       def self.terminate_instance!(o={})
         new(nil, o).terminate_instance!
@@ -65,7 +74,7 @@ module PoolParty
       def terminate_instance!(o={})
         opts = to_hash.merge(o)
         raise "id or instance_id must be set before calling describe_instace" if !id(o)
-        server["/instance/#{id(o)}"].delete
+        MetavirtInstance.new server["/instances/#{id(o)}"].delete.json_parse
       end
 
       # Describe an instance's status, must pass :vmx_file in the options
@@ -75,7 +84,7 @@ module PoolParty
       def describe_instance(o={})
         opts = to_hash.merge(o)
         raise "id or instance_id must be set before calling describe_instace" if !id(o)
-        server["/instance/#{id(o)}"].get.json_parse
+        MetavirtInstance.new server["/instances/#{id(o)}"].get.json_parse
       end
 
       def self.describe_instances(o={})
@@ -83,7 +92,8 @@ module PoolParty
       end
       def describe_instances(o={})
         opts = to_hash.merge(o)
-        JSON.parse( server["/instances/"].get ).collect{|i| i.symbolize_keys!}
+        list = JSON.parse( server["/instances/"].get ).collect{|i| i.symbolize_keys!}
+        list.collect{|l| MetavirtInstance.new l}
       end
       
       def to_hash