fog-google 0.6.0 → 1.0.0

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

@@ -18,8 +18,9 @@ module Fog
         attribute :status
         attribute :users
 
-        IN_USE_STATE   = "IN_USE"
-        RESERVED_STATE = "RESERVED"
+        IN_USE_STATE   = "IN_USE".freeze
+        RESERVED_STATE = "RESERVED".freeze
+        RESERVING_STATE = "RESERVING".freeze
 
         def server
           return nil if !in_use? || users.nil? || users.empty?
@@ -36,7 +37,9 @@ module Fog
           requires :identity, :region
 
           data = service.insert_address(identity, region, attributes)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], nil, data.body["region"])
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, nil, data.region)
           operation.wait_for { !pending? }
           reload
         end
@@ -45,7 +48,10 @@ module Fog
           requires :identity, :region
 
           data = service.delete_address(identity, region.split("/")[-1])
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], nil, data.body["region"])
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, nil, data.region)
+
           operation.wait_for { ready? } unless async
           operation
         end
@@ -62,26 +68,50 @@ module Fog
           status == IN_USE_STATE
         end
 
+        def ready?
+          status != RESERVING_STATE
+        end
+
         private
 
-        def associate(server)
-          nic = server.network_interfaces.first["name"]
-          data = service.add_server_access_config(server.name, server.zone_name, nic, :address => address)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
+        def associate(nic_name, async = true)
+          requires :address
+
+          data = service.add_server_access_config(
+            server.name, server.zone, nic_name, :nat_ip => address
+          )
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, data.zone)
+          operation.wait_for { ready? } unless async
         end
 
         def disassociate
+          requires :address
+
           return nil if !in_use? || users.nil? || users.empty?
 
+          server_name = users.first.split("/")[-1]
+
           # An address can only be associated with one server at a time
-          server = service.servers.get(users.first.split("/")[-1])
-          nic = server.network_interfaces.first["name"]
-          unless server.network_interfaces.first["accessConfigs"].nil? ||
-                 server.network_interfaces.first["accessConfigs"].empty?
-            access_config = server.network_interfaces.first["accessConfigs"].first["name"]
-            data = service.delete_server_access_config(server.name, server.zone_name, nic,
-                                                       :access_config => access_config)
-            Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
+          server = service.servers.get(server_name)
+          server.network_interfaces.each do |nic|
+            # Skip if nic has no access_config
+            next if nic[:access_configs].nil? || nic[:access_configs].empty?
+
+            access_config = nic[:access_configs].first
+
+            # Skip access_config with different address
+            next if access_config[:nat_ip] != address
+
+            data = service.delete_server_access_config(
+              server.name, server.zone, nic[:name], access_config[:name]
+            )
+            operation = Fog::Compute::Google::Operations
+                        .new(:service => service)
+                        .get(data.name, data.zone)
+            operation.wait_for { ready? } unless async
+            return operation
           end
         end
       end

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

@@ -4,40 +4,48 @@ module Fog
       class Addresses < Fog::Collection
         model Fog::Compute::Google::Address
 
-        def all(filters = {})
-          if filters[:region]
-            data = service.list_addresses(filters[:region]).body["items"] || []
+        def all(region: nil, filter: nil, max_results: nil, order_by: nil, page_token: nil)
+          opts = {
+            :filter => filter,
+            :max_results => max_results,
+            :order_by => order_by,
+            :page_token => page_token
+          }
+
+          if region
+            data = service.list_addresses(region, opts).items || []
           else
             data = []
-            service.list_aggregated_addresses.body["items"].each_value do |region|
-              data.concat(region["addresses"]) if region["addresses"]
+            service.list_aggregated_addresses(opts).items.each_value do |scoped_list|
+              data.concat(scoped_list.addresses) if scoped_list && scoped_list.addresses
             end
           end
-          load(data)
+          load(data.map(&:to_h))
         end
 
         def get(identity, region)
-          if address = service.get_address(identity, region).body
+          if address = service.get_address(identity, region).to_h
             new(address)
           end
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           nil
         end
 
         def get_by_ip_address(ip_address)
-          addresses = service.list_aggregated_addresses(:filter => "address eq .*#{ip_address}").body["items"]
-          address = addresses.each_value.select { |region| region.key?("addresses") }
+          addresses = service.list_aggregated_addresses(:filter => "address eq .*#{ip_address}").items
+          address = addresses.each_value.select(&:addresses)
 
           return nil if address.empty?
-          new(address.first["addresses"].first)
+          new(address.first.addresses.first.to_h)
         end
 
         def get_by_name(ip_name)
-          names = service.list_aggregated_addresses(:filter => "name eq .*#{ip_name}").body["items"]
-          name = names.each_value.select { |region| region.key?("addresses") }
+          names = service.list_aggregated_addresses(:filter => "name eq .*#{ip_name}").items
+          name = names.each_value.select(&:addresses)
 
           return nil if name.empty?
-          new(name.first["addresses"].first)
+          new(name.first.addresses.first.to_h)
         end
 
         def get_by_ip_address_or_name(ip_address_or_name)

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

@@ -4,15 +4,15 @@ module Fog
       class BackendService < Fog::Model
         identity :name
 
-        attribute :backends, :aliases => "backends"
-        attribute :creation_timestamp, :aliases => "kind"
-        attribute :description, :aliases => "description"
-        attribute :fingerprint, :aliases => "fingerprint"
+        attribute :backends
+        attribute :creation_timestamp
+        attribute :description
+        attribute :fingerprint
         attribute :health_checks, :aliases => "healthChecks"
-        attribute :id, :aliases => "id"
-        attribute :kind, :aliases => "kind"
-        attribute :port, :aliases => "port"
-        attribute :protocol, :aliases => "protocol"
+        attribute :id
+        attribute :kind
+        attribute :port
+        attribute :protocol
         attribute :self_link, :aliases => "selfLink"
         attribute :timeout_sec, :aliases => "timeoutSec"
 
@@ -20,17 +20,17 @@ module Fog
           requires :name, :health_checks
 
           options = {
-            "description" => description,
-            "backends" => backends,
-            "fingerprint" => fingerprint,
-            "healthChecks" => health_checks,
-            "port" => port,
-            "protocol" => protocol,
-            "timeoutSec" => timeout_sec
+            :description => description,
+            :backends => backends,
+            :fingerprint => fingerprint,
+            :health_checks => health_checks,
+            :port => port,
+            :protocol => protocol,
+            :timeout_sec => timeout_sec
           }
 
-          data = service.insert_backend_service(name, options).body
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data["name"])
+          data = service.insert_backend_service(name, options)
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.name)
           operation.wait_for { !pending? }
           reload
         end
@@ -39,13 +39,13 @@ module Fog
           requires :name
 
           data = service.delete_backend_service(name)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"])
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.name)
           operation.wait_for { ready? } unless async
           operation
         end
 
         def get_health
-          service.get_backend_service_health self
+          service.get_backend_service_health(self)
         end
 
         def add_backend(backend)
@@ -59,7 +59,8 @@ module Fog
         def ready?
           service.get_backend_service(name)
           true
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           false
         end
 
@@ -67,18 +68,18 @@ module Fog
           requires :name
 
           return unless data =
-            begin
-              collection.get(name)
-            rescue Excon::Errors::SocketError
-              nil
-            end
+                          begin
+                            collection.get(name)
+                          rescue Excon::Errors::SocketError
+                            nil
+                          end
 
           new_attributes = data.attributes
           merge_attributes(new_attributes)
           self
         end
 
-        RUNNING_STATE = "READY"
+        RUNNING_STATE = "READY".freeze
       end
     end
   end

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

@@ -5,15 +5,16 @@ module Fog
         model Fog::Compute::Google::BackendService
 
         def all(_filters = {})
-          data = service.list_backend_services.body["items"] || []
-          load(data)
+          data = service.list_backend_services.items || []
+          load(data.map(&:to_h))
         end
 
         def get(identity)
-          if backend_service = service.get_backend_service(identity).body
-            new(backend_service)
+          if backend_service = service.get_backend_service(identity)
+            new(backend_service.to_h)
           end
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           nil
         end
       end

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

@@ -18,25 +18,31 @@ module Fog
         attribute :source_snapshot_id, :aliases => "sourceSnapshotId"
         attribute :type
 
+        def default_description
+          if !source_image.nil?
+            "created from image: #{source_image}"
+          elsif !source_snapshot.nil?
+            "created from snapshot: #{source_snapshot}"
+          else
+            "created with fog"
+          end
+        end
+
         def save
           requires :name, :zone, :size_gb
 
-          options = {}
-          my_description = "Created with fog"
-          unless source_image.nil?
-            my_description = "Created from image: #{source_image}"
-          end
-          if source_image.nil? && !source_snapshot.nil?
-            options["sourceSnapshot"] = source_snapshot
-            my_description = "Created from snapshot: #{source_snapshot}"
-          end
-
-          options["sizeGb"] = size_gb
-          options["description"] = description || my_description
-          options["type"] = type
+          options = {
+            :description => description || default_description,
+            :source_image => source_image,
+            :source_snapshot => source_snapshot,
+            :size_gb => size_gb,
+            :type => type,
+            :zone => zone
+          }
 
           data = service.insert_disk(name, zone, source_image, options)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name, data.zone)
           operation.wait_for { !pending? }
           reload
         end
@@ -45,7 +51,8 @@ module Fog
           requires :name, :zone
 
           data = service.delete_disk(name, zone_name)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name, data.zone)
           operation.wait_for { ready? } unless async
           operation
         end
@@ -54,19 +61,9 @@ module Fog
           zone.nil? ? nil : zone.split("/")[-1]
         end
 
-        # auto_delete can only be applied to disks created before instance creation.
-        # auto_delete = true will automatically delete disk upon instance termination.
-        def get_object(writable = true, boot = false, device_name = nil, auto_delete = false)
-          mode = writable ? "READ_WRITE" : "READ_ONLY"
-          value = {
-            "autoDelete" => auto_delete,
-            "boot" => boot,
-            "source" => self_link,
-            "mode" => mode,
-            "deviceName" => device_name,
-            "type" => "PERSISTENT"
-          }.select { |_k, v| !v.nil? }
-          Hash[value]
+        def attached_disk_obj(opts = {})
+          requires :self_link
+          collection.attached_disk_obj(self_link, opts)
         end
 
         def get_as_boot_disk(writable = true, auto_delete = false)
@@ -82,7 +79,7 @@ module Fog
 
           return unless data = begin
             collection.get(identity, zone_name)
-          rescue Excon::Errors::SocketError
+          rescue Google::Apis::TransmissionError
             nil
           end
 
@@ -91,25 +88,18 @@ module Fog
           self
         end
 
-        def create_snapshot(snapshot_name, snapshot_description = "")
+        def create_snapshot(snapshot_name, snapshot = {})
           requires :name, :zone
+          raise ArgumentError, "Invalid snapshot name" unless snapshot_name
 
-          if snapshot_name.nil? || snapshot_name.empty?
-            raise ArgumentError, "Invalid snapshot name"
-          end
-
-          options = {
-            "name"        => snapshot_name,
-            "description" => snapshot_description
-          }
-
-          data = service.insert_snapshot(name, zone_name, service.project, options)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
+          data = service.create_disk_snapshot(snapshot_name, name, zone_name, snapshot)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name, data.zone)
           operation.wait_for { !pending? }
           service.snapshots.get(snapshot_name)
         end
 
-        RUNNING_STATE = "READY"
+        RUNNING_STATE = "READY".freeze
       end
     end
   end

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

@@ -7,6 +7,7 @@ module Fog
         attribute :kind
         attribute :id
         attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :default_disk_size_gb, :aliases => "defaultDiskSizeGb"
         attribute :deprecated
         attribute :description
         attribute :self_link, :aliases => "selfLink"

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

@@ -4,31 +4,37 @@ module Fog
       class DiskTypes < Fog::Collection
         model Fog::Compute::Google::DiskType
 
-        def all(filters = {})
-          if filters["zone"]
-            data = service.list_disk_types(filters["zone"]).body["items"] || []
+        def all(zone: nil, filter: nil, max_results: nil,
+                order_by: nil, page_token: nil)
+          opts = {
+            :filter => filter,
+            :max_results => max_results,
+            :order_by => order_by,
+            :page_token => page_token
+          }
+          if zone
+            data = service.list_disk_types(zone, opts).items
           else
             data = []
-            service.list_aggregated_disk_types.body["items"].each_value do |zone|
-              data.concat(zone["diskTypes"]) if zone["diskTypes"]
+            service.list_aggregated_disk_types(opts).items.each_value do |scoped_lst|
+              data.concat(scoped_lst.disk_types) if scoped_lst && scoped_lst.disk_types
             end
           end
-          load(data)
+          load(data.map(&:to_h))
         end
 
         def get(identity, zone = nil)
           response = nil
           if zone
-            response = service.get_disk_type(identity, zone).body
+            response = service.get_disk_type(identity, zone).to_h
           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?
+            disk_types = all(:filter => "name eq .*#{identity}")
+            response = disk_types.first.attributes unless disk_types.empty?
           end
           return nil if response.nil?
           new(response)
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           nil
         end
       end