fog 1.0.0 → 1.1.0

data/lib/fog/slicehost/models/dns/zone.rb

@@ -39,7 +39,7 @@ module Fog
             Fog::DNS::Slicehost::Records.new(
               :zone       => self,
               :connection => connection
-            )
+            ).all
           end
         end
 

data/lib/fog/slicehost/parsers/dns/create_record.rb

@@ -11,9 +11,15 @@ module Fog
 
           def end_element(name)
             case name
-            when 'zone-id', 'ttl', 'id'
+            when 'zone_id'
+              @response["zone-id"] = value.to_i
+            when 'record_type'
+              @response["record-type"] = value
+            when 'ttl', 'id'
               @response[name] = value.to_i
-            when 'record-type', 'name', 'data', 'active', 'aux'
+            when 'value'
+              @response["data"] = value
+            when 'name', 'data', 'active', 'aux'
               @response[name] = value
             end
           end

data/lib/fog/slicehost/parsers/dns/get_record.rb

@@ -6,15 +6,27 @@ module Fog
         class GetRecord < Fog::Parsers::Base
 
           def reset
+            @record = {}
             @response = { }
           end
 
           def end_element(name)
             case name
-            when 'zone-id', 'ttl'
-              @response[name] = value.to_i
-            when 'record-type', 'name', 'data', 'active', 'aux'
-              @response[name] = value
+            when 'id'
+              @record["id"] = value.to_i
+            when 'zone-id'
+              @record["zone_id"] = value.to_i
+            when 'record-type'
+              @record["record_type"] = value
+            when 'ttl'
+              @record[name] = value.to_i
+            when 'data'
+              @record["value"] = value
+            when 'name', 'active', 'aux'
+              @record[name] = value
+            when 'record'
+              @response = @record
+              @record = {}
             end
           end
 
@@ -23,4 +35,4 @@ module Fog
       end
     end
   end
-end
+end

data/lib/fog/slicehost/parsers/dns/get_records.rb

@@ -12,9 +12,17 @@ module Fog
 
           def end_element(name)
             case name
-            when 'zone-id', 'ttl'
+            when 'id'
+              @record["id"] = value.to_i
+            when 'zone-id'
+              @record["zone_id"] = value.to_i
+            when 'record-type'
+              @record["record_type"] = value
+            when 'ttl'
               @record[name] = value.to_i
-            when 'record-type', 'name', 'data', 'active', 'aux'
+            when 'data'
+              @record["value"] = value
+            when 'name', 'active', 'aux'
               @record[name] = value
             when 'record'
               @response['records'] << @record

data/lib/fog/slicehost/requests/dns/get_record.rb

@@ -21,7 +21,7 @@ module Fog
           request(
             :expects  => 200,
             :method   => 'GET',
-            :parser   => Fog::Parsers::DNS::Slicehost::GetRecords.new,
+            :parser   => Fog::Parsers::DNS::Slicehost::GetRecord.new,
             :path     => "records/#{record_id}.xml"
           )
         end

data/lib/fog/slicehost/requests/dns/get_records.rb

@@ -10,14 +10,13 @@ module Fog
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Array>:
-        #     * 'addresses'<~Array> - Ip addresses for the slice
-        #     * 'backup-id'<~Integer> - Id of backup slice was booted from
-        #     * 'flavor_id'<~Integer> - Id of flavor slice was booted from
-        #     * 'id'<~Integer> - Id of the slice
-        #     * 'image-id'<~Integer> - Id of image slice was booted from
-        #     * 'name'<~String> - Name of the slice
-        #     * 'progress'<~Integer> - Progress of current action, in percentage
-        #     * 'status'<~String> - Current status of the slice
+        #     * 'name'<~String> - Record NAME field (e.g. "example.org." or "www")
+        #     * 'data'<~String> - Data contained by the record (e.g. an IP address, for A records)
+        #     * 'record_type'<~String> - Type of record (A, CNAME, TXT, etc)
+        #     * 'aux'<~String> - Aux data for the record, for those types which have it (e.g. TXT)
+        #     * 'zone_id'<~Integer> - zone ID to which this record belongs
+        #     * 'active'<~String> - whether this record is active in the Slicehost DNS (Y for yes, N for no)
+        #     * 'ttl'<~Integer> - TTL in seconds
         def get_records
           request(
             :expects  => 200,

data/lib/fog/slicehost/requests/dns/update_record.rb

@@ -0,0 +1,43 @@
+module Fog
+  module DNS
+    class Slicehost
+      class Real
+
+        #require 'fog/slicehost/parsers/dns/update_record'
+
+        # Get an individual DNS record from the specified zone
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'record_type'<~String> - type of DNS record to create (A, CNAME, etc)
+        #     * 'zone_id'<~Integer> - ID of the zone to update
+        #     * 'name'<~String> - host name this DNS record is for
+        #     * 'data'<~String> - data for the DNS record (ie for an A record, the IP address)
+        #     * 'ttl'<~Integer> - time to live in seconds
+        #     * 'active'<~String> - whether this record is active or not ('Y' or 'N')
+        #     * 'aux'<~String> - extra data required by the record
+        def update_record(record_id, record_type, zone_id, name, data, options = {})
+          optional_tags= ''
+          options.each { |option, value|
+            case option
+            when :ttl
+              optional_tags+= "<ttl type='integer'>#{value}</ttl>"
+            when :active
+              optional_tags+= "<active>#{value}</active>"
+            when :aux
+              optional_tags+= "<aux>#{value}</aux>"
+            end
+          }
+          request(
+            :body     => %Q{<?xml version="1.0" encoding="UTF-8"?><record><record_type>#{record_type}</record_type><zone_id type="integer">#{zone_id}</zone_id><name>#{name}</name><data>#{data}</data>#{optional_tags}</record>},
+            :expects  => 200,
+            :method   => 'PUT',
+            :path     => "records/#{record_id}.xml"
+          )
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/storm_on_demand/models/compute/balancers.rb

@@ -10,7 +10,7 @@ module Fog
         model Fog::Compute::StormOnDemand::Balancer
 
         def all
-          data = connection.list_balancers.body['loadbalancers']
+          data = connection.list_balancers.body['items']
           load(data)
         end
 

data/lib/fog/storm_on_demand/models/compute/configs.rb

@@ -10,7 +10,7 @@ module Fog
         model Fog::Compute::StormOnDemand::Config
 
         def all
-          data = connection.list_configs.body['configs']
+          data = connection.list_configs.body['items']
           load(data)
         end
 

data/lib/fog/storm_on_demand/models/compute/images.rb

@@ -10,7 +10,7 @@ module Fog
         model Fog::Compute::StormOnDemand::Image
 
         def all
-          data = connection.list_images.body['images']
+          data = connection.list_images.body['items']
           load(data)
         end
 

data/lib/fog/storm_on_demand/models/compute/servers.rb

@@ -10,7 +10,7 @@ module Fog
         model Fog::Compute::StormOnDemand::Server
 
         def all
-          data = connection.list_servers.body['servers']
+          data = connection.list_servers.body['items']
           load(data)
         end
 

data/lib/fog/storm_on_demand/models/compute/templates.rb

@@ -10,7 +10,7 @@ module Fog
         model Fog::Compute::StormOnDemand::Template
 
         def all
-          data = connection.list_templates.body['templates']
+          data = connection.list_templates.body['items']
           load(data)
         end
 

data/lib/fog/terremark/vcloud.rb

@@ -15,7 +15,7 @@ module Fog
      extend Fog::Terremark::Shared
 
      def self.new(options={})
-       Fog::Logger.warning("Fog::Terremark::Vcloud is deprecated, to be replaced with Vcloud 1.0 someday/maybe [light_black](#{caller.first})[/]")
+       Fog::Logger.deprecation("Fog::Terremark::Vcloud is deprecated, to be replaced with Vcloud 1.0 someday/maybe [light_black](#{caller.first})[/]")
 
        unless @required
          shared_requires

data/lib/fog/vsphere/compute.rb

@@ -29,36 +29,52 @@ module Fog
         attr_reader :vsphere_server
         attr_reader :vsphere_username
 
+        ATTR_TO_PROP = {
+          :id => 'config.instanceUuid',
+          :name => 'name',
+          :uuid => 'config.uuid',
+          :instance_uuid => 'config.instanceUuid',
+          :hostname => 'summary.guest.hostName',
+          :operatingsystem => 'summary.guest.guestFullName',
+          :ipaddress => 'guest.ipAddress',
+          :power_state => 'runtime.powerState',
+          :connection_state => 'runtime.connectionState',
+          :hypervisor => 'runtime.host',
+          :tools_state => 'guest.toolsStatus',
+          :tools_version => 'guest.toolsVersionStatus',
+          :is_a_template => 'config.template',
+        }
+
         # Utility method to convert a VMware managed object into an attribute hash.
         # This should only really be necessary for the real class.
         # This method is expected to be called by the request methods
         # in order to massage VMware Managed Object References into Attribute Hashes.
         def convert_vm_mob_ref_to_attr_hash(vm_mob_ref)
           return nil unless vm_mob_ref
-          # A cloning VM doesn't have a configuration yet.  Unfortuantely we just get
-          # a RunTime exception.
-          begin
-            is_ready = vm_mob_ref.config ? true : false
-          rescue RuntimeError
-            is_ready = nil
+
+          props = vm_mob_ref.collect! *ATTR_TO_PROP.values.uniq
+          # NOTE: Object.tap is in 1.8.7 and later.
+          # Here we create the hash object that this method returns, but first we need
+          # to add a few more attributes that require additional calls to the vSphere
+          # API. The hypervisor name and mac_addresses attributes may not be available
+          # so we need catch any exceptions thrown during lookup and set them to nil.
+          #
+          # The use of the "tap" method here is a convience, it allows us to update the
+          # hash object without expliclty returning the hash at the end of the method.
+          Hash[ATTR_TO_PROP.map { |k,v| [k.to_s, props[v]] }].tap do |attrs|
+            attrs['id'] ||= vm_mob_ref._ref
+            attrs['mo_ref'] = vm_mob_ref._ref
+            # The name method "magically" appears after a VM is ready and
+            # finished cloning.
+            if attrs['hypervisor'].kind_of?(RbVmomi::VIM::HostSystem) then
+              # If it's not ready, set the hypervisor to nil
+              attrs['hypervisor'] = attrs['hypervisor'].name rescue nil
+            end
+            # This inline rescue catches any standard error.  While a VM is
+            # cloning, a call to the macs method will throw and NoMethodError
+            attrs['mac_addresses'] = vm_mob_ref.macs rescue nil
+            attrs['path'] = get_folder_path(vm_mob_ref.parent)
           end
-          {
-            'id'               => is_ready ? vm_mob_ref.config.instanceUuid : vm_mob_ref._ref,
-            'mo_ref'           => vm_mob_ref._ref,
-            'name'             => vm_mob_ref.name,
-            'uuid'             => is_ready ? vm_mob_ref.config.uuid : nil,
-            'instance_uuid'    => is_ready ? vm_mob_ref.config.instanceUuid : nil,
-            'hostname'         => vm_mob_ref.summary.guest.hostName,
-            'operatingsystem'  => vm_mob_ref.summary.guest.guestFullName,
-            'ipaddress'        => vm_mob_ref.summary.guest.ipAddress,
-            'power_state'      => vm_mob_ref.runtime.powerState,
-            'connection_state' => vm_mob_ref.runtime.connectionState,
-            'hypervisor'       => vm_mob_ref.runtime.host ? vm_mob_ref.runtime.host.name : nil,
-            'tools_state'      => vm_mob_ref.summary.guest.toolsStatus,
-            'tools_version'    => vm_mob_ref.summary.guest.toolsVersionStatus,
-            'mac_addresses'    => is_ready ? vm_mob_ref.macs : nil,
-            'is_a_template'    => is_ready ? vm_mob_ref.config.template : nil
-          }
         end
 
       end
@@ -68,6 +84,7 @@ module Fog
         include Shared
 
         def initialize(options={})
+          require 'rbvmomi'
           @vsphere_username = options[:vsphere_username]
           @vsphere_password = 'REDACTED'
           @vsphere_server   = options[:vsphere_server]

data/lib/fog/vsphere/models/compute/server.rb

@@ -33,6 +33,7 @@ module Fog
         attribute :is_a_template
         attribute :connection_state
         attribute :mo_ref
+        attribute :path
 
         def start(options = {})
           requires :instance_uuid

data/lib/fog/vsphere/requests/compute/list_virtual_machines.rb

@@ -34,6 +34,7 @@ module Fog
           { 'virtual_machines' => virtual_machines }
         end
 
+
         # NOTE: This is a private instance method required by the vm_clone
         # request.  It's very hard to get the Managed Object Reference
         # of a Template because we can't search for it by instance_uuid
@@ -45,19 +46,50 @@ module Fog
           datacenters = @connection.rootFolder.children.find_all do |child|
             child.kind_of? RbVmomi::VIM::Datacenter
           end
-          # Next, look in the "vmFolder" of each data center:
+          # Next, search the "vmFolder" inventory of each data center:
           datacenters.each do |dc|
-            dc.vmFolder.children.each do |vm|
-              virtual_machines << vm
+            inventory = dc.vmFolder.inventory( 'VirtualMachine' => :all )
+            virtual_machines << find_all_in_inventory(inventory, :type => RbVmomi::VIM::VirtualMachine, :property => 'name' )
+          end
+
+          virtual_machines.flatten
+        end
+
+        def find_all_in_inventory(inventory, properties = { :type => RbVmomi::VIM::VirtualMachine, :property => nil } )
+          results = Array.new
+
+          inventory.each do |k,v|
+
+            # If we have a VMware folder we need to traverse the directory
+            # to ensure we pick VMs inside folders. So we do a bit of recursion
+            # here.
+            results << find_all_in_inventory(v) if k.is_a? RbVmomi::VIM::Folder
+
+            if v[0].is_a? properties[:type]
+              if properties[:property].nil?
+                results << v[0]
+              else
+                results << v[1][properties[:property]]
+              end
             end
           end
-          virtual_machines
+          results.flatten
         end
 
+        def get_folder_path(folder, root = nil)
+          if ( not folder.methods.include?('parent') ) or ( folder == root )
+            return
+          end
+          "#{get_folder_path(folder.parent)}/#{folder.name}"
+        end
       end
 
       class Mock
 
+        def get_folder_path(folder, root = nil)
+          nil
+        end
+
         def list_virtual_machines(options = {})
           case options['instance_uuid']
           when nil

data/lib/fog/zerigo/dns.rb

@@ -34,7 +34,7 @@ module Fog
 
         def self.data
           @data ||= Hash.new do |hash, key|
-            hash[key] = {}
+            hash[key] = key == :zones ? [] : {}
           end
         end
 
@@ -48,13 +48,24 @@ module Fog
         end
 
         def data
-          self.class.data[@zerigo_email]
+          self.class.data
         end
 
         def reset_data
-          self.class.data.delete(@zerigo_email)
+          self.class.reset
         end
 
+        def find_by_zone_id(zone_id)
+          self.data[:zones].find { |z| z['id'] == zone_id }
+        end
+
+        def find_by_domain(domain)
+          self.data[:zones].find { |z| z['domain'] == domain }
+        end
+
+        def find_host(host_id)
+          self.data[:zones].collect { |z| z['hosts'].find { |h| h['id'] == host_id } }.compact.first
+        end
       end
 
       class Real

data/lib/fog/zerigo/models/dns/record.rb

@@ -48,7 +48,7 @@ module Fog
             connection.create_host(@zone.id, type, value, options)
           else
             options[:host_type] = type
-            options[:data]      = data
+            options[:data]      = value
             connection.update_host(identity, options)
           end
           merge_attributes(data.body)

data/lib/fog/zerigo/models/dns/records.rb

@@ -34,6 +34,11 @@ module Fog
           super({ :zone => zone }.merge!(attributes))
         end
 
+        def find(fqdn)
+          hosts = connection.find_hosts(fqdn, zone.id).body['hosts']
+          hosts.collect { |host| new(host) }
+        end
+
       end
 
     end

data/lib/fog/zerigo/models/dns/zones.rb

@@ -14,8 +14,8 @@ module Fog
           load(data)
         end
 
-        def get(zone_id)
-          data = connection.get_zone(zone_id).body
+        def get(zone_id_or_domain)
+          data = connection.get_zone(zone_id_or_domain).body
           zone = new(data)
           zone.records.load(data['hosts'])
           zone