fog 1.22.1 → 1.23.0

data/lib/fog/google/models/compute/disk.rb

@@ -18,9 +18,10 @@ module Fog
         attribute :source_image_id, :aliases => 'sourceImageId'
         attribute :source_snapshot, :aliases => 'sourceSnapshot'
         attribute :source_snapshot_id, :aliases => 'sourceSnapshotId'
+        attribute :type
 
         def save
-          requires :name, :zone
+          requires :name, :zone, :size_gb
 
           options = {}
           my_description = "Created with fog"
@@ -34,6 +35,7 @@ module Fog
 
           options['sizeGb'] = size_gb
           options['description'] = description || my_description
+          options['type'] = type
 
           data = service.insert_disk(name, zone, source_image, options)
           operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])

data/lib/fog/google/models/compute/disk_type.rb

@@ -0,0 +1,28 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Google
+      class DiskType < Fog::Model
+        identity :name
+
+        attribute :kind
+        attribute :id
+        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :deprecated
+        attribute :description
+        attribute :self_link, :aliases => 'selfLink'
+        attribute :valid_disk_size, :aliases => 'validDiskSize'
+        attribute :zone
+
+        def reload
+          requires :identity, :zone
+
+          data = collection.get(identity, self.zone)
+          merge_attributes(data.attributes)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/models/compute/disk_types.rb

@@ -0,0 +1,40 @@
+require 'fog/core/collection'
+require 'fog/google/models/compute/disk_type'
+
+module Fog
+  module Compute
+    class Google
+      class DiskTypes < Fog::Collection
+        model Fog::Compute::Google::DiskType
+
+        def all(filters = {})
+          if filters['zone']
+            data = service.list_disk_types(filters['zone']).body['items'] || []
+          else
+            data = []
+            service.list_aggregated_disk_types.body['items'].each_value do |zone|
+              data.concat(zone['diskTypes']) if zone['diskTypes']
+            end
+          end
+          load(data)
+        end
+
+        def get(identity, zone = nil)
+          response = nil
+          if zone
+            response = service.get_disk_type(identity, zone).body
+          else
+            disk_types = service.list_aggregated_disk_types(:filter => "name eq .*#{identity}").body['items'] || {}
+            disk_type = disk_types.each_value.detect { |zone| zone.key?('diskTypes') } || {}
+
+            response = disk_type['diskTypes'].first unless disk_type.empty?
+          end
+          return nil if response.nil?
+          new(response)
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/models/compute/forwarding_rule.rb

@@ -29,10 +29,10 @@ module Fog
             'target' => target
           }
 
-          service.insert_forwarding_rule(name, region, options).body
-          data = service.backoff_if_unfound {service.get_forwarding_rule(name, region).body}
-          merge_attributes(data)
-          self
+          data = service.insert_forwarding_rule(name, region, options).body
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data['name'], nil, data['region'])
+          operation.wait_for { !pending? }
+          reload
         end
 
         def set_target new_target

data/lib/fog/google/models/compute/http_health_check.rb

@@ -33,9 +33,10 @@ module Fog
             'healthyThreshold' => healthy_threshold || 2,
           }
 
-          service.insert_http_health_check(name, options).body
-          data = service.backoff_if_unfound {service.get_http_health_check(name).body}
-          merge_attributes(data)
+          data = service.insert_http_health_check(name, options).body
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data['name'], data['zone'])
+          operation.wait_for { !pending? }
+          reload
         end
 
         def destroy(async=true)

data/lib/fog/google/models/compute/image.rb

@@ -12,6 +12,7 @@ module Fog
         attribute :creation_timestamp, :aliases => 'creationTimestamp'
         attribute :deprecated
         attribute :description
+        attribute :disk_size_gb, :aliases => 'diskSizeGb'
         attribute :self_link, :aliases => 'selfLink'
         attribute :source_type, :aliases => 'sourceType'
         attribute :status

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

@@ -11,8 +11,9 @@ module Fog
         # licenses needed to use some of them.
         # https://developers.google.com/compute/docs/premium-operating-systems
         GLOBAL_PROJECTS = [
-          'debian-cloud',
           'centos-cloud',
+          'debian-cloud',
+          'google-containers',
           'rhel-cloud',
           'suse-cloud'
         ]

data/lib/fog/google/models/compute/target_pool.rb

@@ -31,10 +31,10 @@ module Fog
             'backupPool' => backup_pool
           }
 
-          service.insert_target_pool(name, region, options).body
-          data = service.backoff_if_unfound {service.get_target_pool(name, region).body}
-          merge_attributes(data)
-          self
+          data = service.insert_target_pool(name, region, options).body
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data['name'], nil, data['region'])
+          operation.wait_for { !pending? }
+          reload
         end
 
         def destroy(async=true)

data/lib/fog/google/requests/compute/get_disk_type.rb

@@ -0,0 +1,43 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def get_disk_type(identity, zone)
+          disk_types = list_disk_types(zone).body['items']
+          disk_type = disk_types.select { |dt| dt['name'] == identity } || []
+          if disk_type.empty?
+            return build_response(:body => {
+              'error' => {
+                'errors' => [
+                  {
+                    'domain' => 'global',
+                    'reason' => 'notFound',
+                    'message' => "The resource 'projects/#{@project}/zones/#{zone}/diskTypes/#{identity}' was not found",
+                  }
+                ],
+                'code' => 404,
+                'message' => "The resource 'projects/#{@project}/zones/#{zone}/diskTypes/#{identity}' was not found",
+              }
+            })
+          end
+
+          build_response(:body => disk_type.first)
+        end
+      end
+
+      class Real
+        def get_disk_type(identity, zone)
+          api_method = @compute.disk_types.get
+          parameters = {
+            'project'  => @project,
+            'zone'     => zone.split('/')[-1],
+            'diskType' => identity,
+          }
+
+          result = self.build_result(api_method, parameters)
+          response = self.build_response(result)
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/requests/compute/get_machine_type.rb

@@ -11,11 +11,11 @@ module Fog
               {
                "domain" => "global",
                "reason" => "notFound",
-               "message" => "The resource 'projects/google/zones/#{zone_name}/machineTypes/#{machine_type_name}' was not found"
+               "message" => "The resource 'projects/#{@project}/zones/#{zone_name}/machineTypes/#{machine_type_name}' was not found"
               }
              ],
              "code" => 404,
-             "message" => "The resource 'projects/google/zones/#{zone_name}/machineTypes/#{machine_type_name}' was not found"
+             "message" => "The resource 'projects/#{@project}/zones/#{zone_name}/machineTypes/#{machine_type_name}' was not found"
             }
           }
           build_response(:body => machine_type)
@@ -31,7 +31,7 @@ module Fog
           api_method = @compute.machine_types.get
           parameters = {
             'zone' => zone_name,
-            'project' => 'google',
+            'project' => @project,
             'machineType' => machine_type_name
           }
 

data/lib/fog/google/requests/compute/insert_disk.rb

@@ -36,6 +36,11 @@ module Fog
               "sourceImageId" => image.id
             })
           end
+          if disk_type = options.delete(:type)
+            object["type"] = type
+          else
+            object["type"] = "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}/diskTypes/pd-standard"
+          end
           self.data[:disks][disk_name] = object
 
           operation = self.random_operation
@@ -76,6 +81,7 @@ module Fog
           end
 
           body_object = { 'name' => disk_name }
+          body_object['type'] = opts.delete('type')
 
           # According to Google docs, if image name is not present, only one of
           # sizeGb or sourceSnapshot need to be present, one will create blank

data/lib/fog/google/requests/compute/list_aggregated_disk_types.rb

@@ -0,0 +1,41 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def list_aggregated_disk_types(options = {})
+          disk_types_items = {}
+          if options[:filter]
+            disk_type = options[:filter].gsub(/name eq \.\*/, '')
+            self.data[:zones].keys.each do |zone|
+              disk_types = list_disk_types(zone).body['items'].select { |dt| dt['name'] == disk_type } || []
+              disk_types_items["zones/#{zone}"] = { 'diskTypes' => disk_types } unless disk_types.empty?
+            end
+          else
+            self.data[:zones].keys.each do |zone|
+              disk_types = list_disk_types(zone).body['items']
+              disk_types_items["zones/#{zone}"] = { 'diskTypes' => disk_types }
+            end
+          end
+          build_response(:body => {
+            'kind' => 'compute#diskTypeAggregatedList',
+            'selfLink' => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/aggregated/diskTypes",
+            'items' => disk_types_items,
+          })
+        end
+      end
+
+      class Real
+        def list_aggregated_disk_types(options = {})
+          api_method = @compute.disk_types.aggregated_list
+          parameters = {
+            'project' => @project,
+          }
+          parameters['filter'] = options[:filter] if options[:filter]
+
+          result = self.build_result(api_method, parameters)
+          response = self.build_response(result)
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/requests/compute/list_disk_types.rb

@@ -0,0 +1,47 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def list_disk_types(zone)
+          build_response(:body => {
+            'kind' => 'compute#diskTypeList',
+            'selfLink' => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone}/diskTypes",
+            'items' => [
+              {
+                'kind' => 'compute#diskType',
+                'creationTimestamp' => '2014-06-02T18:07:28.530Z',
+                'name' => 'pd-standard',
+                'description' => 'Standard Persistent Disk',
+                'validDiskSize' => '10GB-10TB',
+                'zone' => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone}",
+                'selfLink' => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone}/diskTypes/pd-standard",
+              },
+              {
+                'kind' => 'compute#diskType',
+                'creationTimestamp' => '2014-06-02T18:07:28.529Z',
+                'name' => 'pd-ssd',
+                'description' => 'SSD Persistent Disk',
+                'validDiskSize' => '10GB-1TB',
+                "zone" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone}",
+                "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone}/diskTypes/pd-ssd",
+              }
+            ]
+          })
+        end
+      end
+
+      class Real
+        def list_disk_types(zone)
+          api_method = @compute.disk_types.list
+          parameters = {
+            'project' => @project,
+            'zone'    => zone.split('/')[-1],
+          }
+
+          result = self.build_result(api_method, parameters)
+          response = self.build_response(result)
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/requests/storage/get_service.rb

@@ -22,8 +22,7 @@ module Fog
             :host     => @host,
             :idempotent => true,
             :method   => 'GET',
-            :parser   => Fog::Parsers::Storage::Google::GetService.new,
-            :url      => @host
+            :parser   => Fog::Parsers::Storage::Google::GetService.new
           })
         end
       end

data/lib/fog/hp/storage.rb

@@ -205,7 +205,6 @@ module Fog
         #   * body<~String> - url for object
         def create_temp_url(container, object, expires, method, options = {})
           raise ArgumentError, "Insufficient parameters specified." unless (container && object && expires && method)
-          raise ArgumentError, "Storage must my instantiated with the :os_account_meta_temp_url_key option" if @os_account_meta_temp_url_key.nil?
 
           # POST not allowed
           allowed_methods = %w{GET PUT HEAD}
@@ -231,6 +230,11 @@ module Fog
             hmac      = OpenSSL::HMAC.new(@os_account_meta_temp_url_key, OpenSSL::Digest::SHA1.new)
             signature= hmac.update(string_to_sign).hexdigest
           else
+            #Note if the value of the @hp_secret_key is really a password, this will NOT work
+            #HP Public Cloud FormPost and Temporary URL hashing algorithms require the secret key NOT password.
+            if Fog::HP.instance_variable_get("@hp_use_upass_auth_style")
+              raise ArgumentError, "Temporary URLS cannot be generated unless you login via access_key/secret_key"
+            end
             # Only works with 1.9+ Not compatible with 1.8.7
             #signed_string = Digest::HMAC.hexdigest(string_to_sign, @hp_secret_key, Digest::SHA1)
 
@@ -308,6 +312,10 @@ module Fog
           unless @hp_access_key
             raise ArgumentError.new("Missing required arguments: hp_access_key. :hp_account_id is deprecated, please use :hp_access_key instead.")
           end
+          if options[:os_account_meta_temp_url_key]
+            Fog::Logger.deprecation(":os_account_meta_temp_url_key is deprecated, and will be removed in a future release. please use the :openstack provider instead.")
+            @os_account_meta_temp_url_key = options.delete(:os_account_meta_temp_url_key)
+          end
           @hp_secret_key = options[:hp_secret_key]
           @hp_auth_uri   = options[:hp_auth_uri]
           @hp_cdn_ssl    = options[:hp_cdn_ssl]
@@ -321,7 +329,6 @@ module Fog
           options[:hp_service_type] ||= "Object Storage"
           @hp_tenant_id = options[:hp_tenant_id]
           @hp_avl_zone  = options[:hp_avl_zone]
-          @os_account_meta_temp_url_key = options[:os_account_meta_temp_url_key]
 
           ### Make the authentication call
           if (auth_version == :v2)

data/lib/fog/linode/compute.rb

@@ -39,6 +39,8 @@ module Fog
       request :linode_ip_addprivate
       request :linode_config_list
       request :linode_config_create
+      request :linode_config_delete
+      request :linode_config_update
       request :linode_create
       request :linode_delete
       request :linode_list

data/lib/fog/linode/models/compute/flavor.rb

@@ -13,20 +13,22 @@ module Fog
         def cores
           case id
           when 1
+            1
+          when 2
           	2
-          when 3
+          when 4
           	4
-          when 5
-          	6
           when 6
-          	8
+          	6
           when 7
-          	12
+          	8
           when 8
-          	16
+          	12
           when 9
+          	16
+          when 10
           	20
-          when 11
+          when 12
           	20
           else
           	0

data/lib/fog/linode/requests/compute/linode_config_delete.rb

@@ -0,0 +1,32 @@
+module Fog
+  module Compute
+    class Linode
+      class Real
+        def linode_config_delete(linode_id, config_id)
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => {
+              :api_action => 'linode.config.delete',
+              :linodeId => linode_id,
+              :configId => config_id
+            }
+          )
+        end
+      end
+
+      class Mock
+        def linode_config_delete(linode_id, config_id)
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            "ERRORARRAY" => [],
+            "ACTION"     => "linode.config.delete",
+            "DATA"       => { "ConfigID" => rand(10000..99999) }
+          }
+          response
+        end
+      end
+    end
+  end
+end