fog 1.7.0 → 1.8.0

data/lib/fog/rackspace/models/compute_v2/server.rb

@@ -33,6 +33,7 @@ module Fog
         attribute :tenant_id
         attribute :links
         attribute :metadata
+        attribute :personality
         attribute :ipv4_address, :aliases => 'accessIPv4'
         attribute :ipv6_address, :aliases => 'accessIPv6'
         attribute :disk_config, :aliases => 'OS-DCF:diskConfig'
@@ -54,8 +55,12 @@ module Fog
 
         def create
           requires :name, :image_id, :flavor_id
+
           options = {}
           options[:disk_config] = disk_config unless disk_config.nil?
+          options[:metadata] = metadata unless metadata.nil?
+          options[:personality] = personality unless personality.nil?
+
           data = connection.create_server(name, image_id, flavor_id, 1, 1, options)
           merge_attributes(data.body['server'])
           true
@@ -92,6 +97,14 @@ module Fog
             })
           end
         end
+        
+        def private_ip_address
+          addresses['private'].select{|a| a["version"] == 4}[0]["addr"]
+        end
+
+        def public_ip_address
+          ipv4_address
+        end
 
         def ready?
           state == ACTIVE
@@ -137,6 +150,20 @@ module Fog
           @password = password
           true
         end
+        
+        def setup(credentials = {})
+          requires :public_ip_address, :identity, :public_key, :username
+          Fog::SSH.new(public_ip_address, username, credentials).run([
+            %{mkdir .ssh},
+            %{echo "#{public_key}" >> ~/.ssh/authorized_keys},
+            %{passwd -l #{username}},
+            %{echo "#{Fog::JSON.encode(attributes)}" >> ~/attributes.json},
+            %{echo "#{Fog::JSON.encode(metadata)}" >> ~/metadata.json}
+          ])
+        rescue Errno::ECONNREFUSED
+          sleep(1)
+          retry
+        end
 
         private
 

data/lib/fog/rackspace/models/compute_v2/servers.rb

@@ -4,6 +4,7 @@ require 'fog/rackspace/models/compute_v2/server'
 module Fog
   module Compute
     class RackspaceV2
+
       class Servers < Fog::Collection
 
         model Fog::Compute::RackspaceV2::Server
@@ -13,6 +14,13 @@ module Fog
           load(data)
         end
 
+        def bootstrap(new_attributes = {})
+          server = create(new_attributes)
+          server.wait_for { ready? }
+          server.setup(:password => server.password)
+          server
+        end
+
         def get(server_id)
           data = connection.get_server(server_id).body['server']
           new(data)

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

@@ -1,5 +1,6 @@
 require 'fog/core/model'
 require 'fog/rackspace/models/dns/callback'
+require 'ipaddr'
 
 module Fog
   module DNS
@@ -55,7 +56,19 @@ module Fog
           end
 
           response = wait_for_job connection.add_records(@zone.identity, [options]).body['jobId']
-          merge_attributes(response.body['response']['records'].select {|record| record['name'] == self.name && record['type'] == self.type && record['data'] == self.value}.first)
+
+          matching_record = response.body['response']['records'].find do |record| 
+            if ['A', 'AAAA'].include?(self.type.upcase)
+              # If this is an A or AAAA record, match by normalized IP address value.
+              (record['name'] == self.name) && (record['type'] == self.type) && (IPAddr.new(record['data']) == IPAddr.new(self.value))
+            else
+              # Other record types are matched by the raw value.
+              (record['name'] == self.name) && (record['type'] == self.type) && (record['data'] == self.value)
+            end 
+          end
+          
+          merge_attributes(matching_record)
+          
           true
         end
 

data/lib/fog/rackspace/models/storage/file.rb

@@ -12,6 +12,8 @@ module Fog
         attribute :content_type,    :aliases => ['content_type', 'Content-Type']
         attribute :etag,            :aliases => ['hash', 'Etag']
         attribute :last_modified,   :aliases => ['last_modified', 'Last-Modified'], :type => :time
+        attribute :access_control_allow_origin, :aliases => ['Access-Control-Allow-Origin']
+        attribute :origin,          :aliases => ['Origin']
 
         def body
           attributes[:body] ||= if last_modified
@@ -32,6 +34,8 @@ module Fog
         def copy(target_directory_key, target_file_key, options={})
           requires :directory, :key
           options['Content-Type'] ||= content_type if content_type
+          options['Access-Control-Allow-Origin'] ||= access_control_allow_origin if access_control_allow_origin
+          options['Origin'] ||= origin if origin
           connection.copy_object(directory.key, key, target_directory_key, target_file_key, options)
           target_directory = connection.directories.new(:key => target_directory_key)
           target_directory.files.get(target_file_key)
@@ -43,6 +47,10 @@ module Fog
           true
         end
 
+        def metadata
+          @metadata ||= headers_to_metadata
+        end
+
         def owner=(new_owner)
           if new_owner
             attributes[:owner] = {
@@ -64,8 +72,14 @@ module Fog
         def save(options = {})
           requires :body, :directory, :key
           options['Content-Type'] = content_type if content_type
-          data = connection.put_object(directory.key, key, body, options)
-          merge_attributes(data.headers.reject {|key, value| ['Content-Length', 'Content-Type'].include?(key)})
+          options['Access-Control-Allow-Origin'] = access_control_allow_origin if access_control_allow_origin
+          options['Origin'] = origin if origin
+          options.merge!(metadata_to_headers)
+
+          data = connection.put_object(directory.key, key, body, options)          
+          update_attributes_from(data)
+          refresh_metadata
+
           self.content_length = Fog::Storage.get_body_size(body)
           self.content_type ||= Fog::Storage.get_content_type(body)
           true
@@ -77,6 +91,58 @@ module Fog
           @directory = new_directory
         end
 
+        def refresh_metadata
+          metadata.reject! {|k, v| v.nil? }
+        end
+
+        def headers_to_metadata
+          key_map = key_mapping
+          Hash[metadata_attributes.map {|k, v| [key_map[k], v] }]
+        end
+
+        def key_mapping
+          key_map = metadata_attributes
+          key_map.each_pair {|k, v| key_map[k] = header_to_key(k)}
+        end
+
+        def header_to_key(opt)
+          opt.gsub(metadata_prefix, '').split('-').map {|k| k[0, 1].downcase + k[1..-1]}.join('_').to_sym
+        end
+
+        def metadata_to_headers
+          header_map = header_mapping
+          Hash[metadata.map {|k, v| [header_map[k], v] }]
+        end
+
+        def header_mapping
+          header_map = metadata.dup
+          header_map.each_pair {|k, v| header_map[k] = key_to_header(k)}
+        end
+
+        def key_to_header(key)
+          metadata_prefix + key.to_s.split(/[-_]/).map(&:capitalize).join('-')
+        end
+
+        def metadata_attributes
+          if etag
+            headers = connection.head_object(directory.key, self.key).headers
+            headers.reject! {|k, v| !metadata_attribute?(k)}
+          else
+            {}
+          end
+        end
+
+        def metadata_attribute?(key)
+          key.to_s =~ /^#{metadata_prefix}/
+        end
+
+        def metadata_prefix
+          "X-Object-Meta-"
+        end
+
+        def update_attributes_from(data)
+          merge_attributes(data.headers.reject {|key, value| ['Content-Length', 'Content-Type'].include?(key)})
+        end
       end
 
     end

data/lib/fog/rackspace/requests/compute_v2/create_server.rb

@@ -13,7 +13,10 @@ module Fog
             }
           }
 
+          data['server']['metadata'] = options[:metadata]  unless options[:metadata].nil?
           data['server']['OS-DCF:diskConfig'] = options[:disk_config] unless options[:disk_config].nil?
+          data['server']['metadata'] = options[:metadata] unless options[:metadata].nil?
+          data['server']['personality'] = options[:personality] unless options[:personality].nil?
 
           request(
             :body => Fog::JSON.encode(data),

data/lib/fog/version.rb

@@ -0,0 +1,5 @@
+module Fog
+  unless const_defined?(:VERSION)
+    VERSION = '1.8.0'
+  end
+end

data/lib/fog/vsphere/compute.rb

@@ -11,19 +11,50 @@ module Fog
       model_path 'fog/vsphere/models/compute'
       model :server
       collection :servers
+      model :datacenter
+      collection :datacenters
+      model :interface
+      collection :interfaces
+      model :volume
+      collection :volumes
+      model :template
+      collection :templates
+      model :cluster
+      collection :clusters
+      model :resource_pool
+      collection :resource_pools
+      model :network
+      collection :networks
+      model :datastore
+      collection :datastores
+      model :folder
+      collection :folders
 
       request_path 'fog/vsphere/requests/compute'
       request :current_time
-      request :find_vm_by_ref
       request :list_virtual_machines
       request :vm_power_off
       request :vm_power_on
       request :vm_reboot
       request :vm_clone
-      request :vm_create
       request :vm_destroy
       request :vm_migrate
-      request :datacenters
+      request :list_datacenters
+      request :get_datacenter
+      request :list_clusters
+      request :get_cluster
+      request :list_resource_pools
+      request :get_resource_pool
+      request :list_networks
+      request :get_network
+      request :list_datastores
+      request :get_datastore
+      request :get_folder
+      request :list_folders
+      request :create_vm
+      request :list_vm_interfaces
+      request :list_vm_volumes
+      request :get_virtual_machine
       request :vm_reconfig_hardware
       request :vm_reconfig_memory
       request :vm_reconfig_cpus
@@ -36,11 +67,12 @@ module Fog
         attr_reader :vsphere_server
         attr_reader :vsphere_username
 
+        protected
+
         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',
@@ -49,9 +81,10 @@ module Fog
           :hypervisor => 'runtime.host',
           :tools_state => 'guest.toolsStatus',
           :tools_version => 'guest.toolsVersionStatus',
-          :is_a_template => 'config.template',
           :memory_mb => 'config.hardware.memoryMB',
           :cpus   => 'config.hardware.numCPU',
+          :overall_status => 'overallStatus',
+          :guest_id => 'summary.guest.guestId',
         }
 
         # Utility method to convert a VMware managed object into an attribute hash.
@@ -75,9 +108,17 @@ module Fog
             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
+            if attrs['hypervisor'].kind_of?(RbVmomi::VIM::HostSystem)
+              begin
+                host = attrs['hypervisor']
+                attrs['datacenter'] = parent_attribute(host.path, :datacenter)[1]
+                attrs['cluster']    = parent_attribute(host.path, :cluster)[1]
+                attrs['hypervisor'] = host.name
+                attrs['resource_pool'] = (vm_mob_ref.resourcePool || host.resourcePool).name rescue nil
+              rescue
+                # If it's not ready, set the hypervisor to nil
+                attrs['hypervisor'] = nil
+              end
             end
             # This inline rescue catches any standard error.  While a VM is
             # cloning, a call to the macs method will throw and NoMethodError
@@ -86,6 +127,31 @@ module Fog
           end
         end
 
+        # returns the parent object based on a type
+        # provides both real RbVmomi object and its name.
+        # e.g.
+        #[Datacenter("datacenter-2"), "dc-name"]
+        def parent_attribute path, type
+          element = case type
+                      when :datacenter
+                        RbVmomi::VIM::Datacenter
+                      when :cluster
+                        RbVmomi::VIM::ClusterComputeResource
+                      when :host
+                        RbVmomi::VIM::HostSystem
+                      else
+                        raise "Unknown type"
+                    end
+          path.select {|x| x[0].is_a? element}.flatten
+        rescue
+          nil
+        end
+
+        # returns vmware managed obj id string
+        def managed_obj_id obj
+          obj.to_s.match(/\("(\S+)"\)/)[1]
+        end
+
       end
 
       class Mock

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

@@ -0,0 +1,31 @@
+module Fog
+  module Compute
+    class Vsphere
+
+      class Cluster < Fog::Model
+
+        identity :id
+
+        attribute :name
+        attribute :datacenter
+        attribute :num_host
+        attribute :num_cpu_cores
+        attribute :overall_status
+
+        def resource_pools(filters = { })
+          self.attributes[:resource_pools] ||= id.nil? ? [] : connection.resource_pools({
+                                                                                          :connection => connection,
+                                                                                          :cluster    => name,
+                                                                                          :datacenter => datacenter
+                                                                                        }.merge(filters))
+        end
+
+        def to_s
+          name
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'fog/core/collection'
+require 'fog/vsphere/models/compute/cluster'
+
+module Fog
+  module Compute
+    class Vsphere
+
+      class Clusters < Fog::Collection
+
+        model Fog::Compute::Vsphere::Cluster
+        attr_accessor :datacenter
+
+        def all(filters = {})
+          requires :datacenter
+          load connection.list_clusters(filters.merge(:datacenter => datacenter))
+        end
+
+        def get(id)
+          requires :datacenter
+          new connection.get_cluster(id, datacenter)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Fog
+  module Compute
+    class Vsphere
+
+      class Datacenter < Fog::Model
+
+        identity :id
+        attribute :name
+        attribute :status
+
+        def clusters filters = { }
+          connection.clusters({ :datacenter => name }.merge(filters))
+        end
+
+        def networks filters = { }
+          connection.networks({ :datacenter => name }.merge(filters))
+        end
+
+        def datastores filters = { }
+          connection.datastores({ :datacenter => name }.merge(filters))
+        end
+
+        def vm_folders filters = { }
+          connection.folders({ :datacenter => name, :type => :vm }.merge(filters))
+        end
+
+        def to_s
+          name
+        end
+
+      end
+
+    end
+  end
+end