fairchild-poolparty 1.1.5 → 1.2.12

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

@@ -1,51 +1,62 @@
+require "#{::File.dirname(__FILE__)}/ec2"
 module PoolParty  
   module Remote
     class Ec2RemoteInstance < RemoteInstance
       include Dslify
+      include Remote
       
-      attr_reader :my_cloud, :uniquely_identifiable_by, :found_at
-
+      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={}, prnt=Ec2.new)
-        @uniquely_identifiable_by = [:ip, :name, :dns_name, :instance_id]
-        @original_options = opts
-        @my_cloud = prnt
-        super(opts, prnt)
-        find_myself(@uniquely_identifiable_by && opts.keys) if prnt.respond_to?(:describe_instances)
+      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
-   
-      # Search the clouds describe_instances list for the first match on one of this nodes unique identifiers
-      def find_myself(unique_identifiers = @original_options.keys)
-        description_hash = @my_cloud.describe_instances.detect do|node|
-          unique_identifiers.detect{|identifier_key| node[identifier_key] == options[identifier_key]
-            }
-        end
-        return nil if description_hash.blank?
-        @found_at = Time.now
-        self.set_vars_from_options(description_hash)
-        self
+      
+      def keypair(*n)
+        dsl_options[:keypair] ||= Key.new(key_name)
       end
       
-      # Is this instance running?
-      def running?
-        !(status =~ /running/).nil?
+      # 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
-      # Is this instance pending?
-      def pending?
-        !(status =~ /pending/).nil?
+      
+      # Class method to disect a neighborhood line
+      def self.hash_from_s(s)
+        arr = s.split("\t")
+        {:name => arr[0], :ip => arr[1]}
       end
-      # Is this instance terminating?
-      def terminating?
-        !(status =~ /shutting/).nil?
+      
+      def self.to_s(hsh)
+        new(hsh).to_s
       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

@@ -1,26 +1,26 @@
 # 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)      
+  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.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
@@ -50,15 +50,80 @@ class EC2ResponseObject
     group
   end
   def self.get_hash_from_response(resp, group = 'default')
+      symbolize_and_snakecase
       {
         :instance_id => resp.instanceId,
-        :name => resp.instanceId, 
-        :ip => resp.dnsName || "not-assigned",
+        :name => resp.instanceId,
         :status => resp.instanceState.name,
-        :launching_time => resp.launchTime.parse_datetime,
+        :public_ip => resp.dnsName || "not-assigned",
+        :ip => resp.dnsName || "not-assigned",
         :internal_ip => resp.privateDnsName,
-        :keypair => resp.keyName,
+        :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

@@ -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

@@ -0,0 +1,110 @@
+=begin rdoc
+ The metavirt remoter base send all commands to a RESTful HTTP server that implements the commands
+  
+=end
+require 'restclient'
+
+module PoolParty
+  module Remote
+    class Metavirt < Remote::RemoterBase
+      include Dslify
+      include ::PoolParty::CloudResourcer
+      
+      default_options(
+        :authorized_keys => nil,
+        :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)
+        if n.nil?
+          @remote_base
+        else
+          @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)
+          @uri = "#{opts.delete(:host)}:#{opts.delete(:port)}"
+          @server = RestClient::Resource.new( @uri, opts)
+        end
+      end
+      
+      def self.launch_new_instance!(o={})
+        new_instance(o).launch_new_instance!
+      end
+      def launch_new_instance!(o={})
+        opts = to_hash.merge(o)
+        result = JSON.parse(server['/run-instance'].put(opts.to_json)).symbolize_keys!
+        @id = result[:instance_id]
+        MetavirtInstance.new result
+      end
+      
+      # Terminate an instance by id
+      def self.terminate_instance!(o={})
+        new(nil, o).terminate_instance!
+      end
+      def terminate_instance!(o={})
+        opts = to_hash.merge(o)
+        raise "id or instance_id must be set before calling describe_instace" if !id(o)
+        MetavirtInstance.new server["/instances/#{id(o)}"].delete.json_parse
+      end
+
+      # Describe an instance's status, must pass :vmx_file in the options
+      def self.describe_instance(o={})
+        new(o).describe_instance
+      end
+      def describe_instance(o={})
+        opts = to_hash.merge(o)
+        raise "id or instance_id must be set before calling describe_instace" if !id(o)
+        MetavirtInstance.new server["/instances/#{id(o)}"].get.json_parse
+      end
+
+      def self.describe_instances(o={})
+        new(o).describe_instances
+      end
+      def describe_instances(o={})
+        opts = to_hash.merge(o)
+        list = JSON.parse( server["/instances/"].get ).collect{|i| i.symbolize_keys!}
+        list.collect{|l| MetavirtInstance.new l}
+      end
+      
+      def to_hash
+        dsl_options.merge(:remote_base => remote_base.to_hash)
+      end
+      
+      private
+      def id(o={})
+       @id = ( o[:id] || o[:instance_id] || @id || dsl_options[:id] || dsl_options[:instance_id] )
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module PoolParty
+  module Remote
+    
+    class MetavirtInstance < RemoteInstance
+      dsl_methods :mac_address, 
+                  :vmx_file
+      
+      def to_hash
+        {
+          :status         => status,
+          :mac_addresses  => mac_address,
+          :ip             => ip,
+          :instance_id    => instance_id,
+          :internal_ip    => internal_ip,
+          :keypair_name   => keypair.basename
+        }
+      end
+      
+      def keypair(n=nil)
+        if n.nil?
+          @keypair ||= Key.new(keypair_name)
+        else
+          @keypair = Key.new(n)
+        end
+      end
+      
+      def launch!
+      end
+      
+      def terminate!
+        `virsh destroy #{instance_id}`
+      end
+      
+    end
+    
+  end
+end

data/lib/poolparty/net/remoter_bases/vmrun/utilities/vm_disk.rb

@@ -6,7 +6,7 @@ class VmxDisk
   end
   
   def compile
-    %x[qemu-img create -f vmdk #{base_directory}/#{name}/#{name}.vmdk #{options[:vmx_disk][:image_size]} ]
+    %x[qemu-img create -f vmdk #{base_directory}/#{name}/#{name}.vmdk #{dsl_options[:vmx_disk][:image_size]} ]
     "#{base_directory}/#{name}/#{name}.vmdk"
   end
 end

data/lib/poolparty/net/remoter_bases/vmrun/utilities/vmx.rb

@@ -25,7 +25,7 @@ class Vmx
   end
   
   def compile
-    ::FileUtils.mkdir_p "#{base_directory}/#{options[:name]}"
+    ::FileUtils.mkdir_p "#{base_directory}/#{dsl_options[:name]}"
     vmdk = @vmx_disk.compile
     @vmx_file.set("ide0:0.fileName", vmdk)
     @vmx_file.compile