fog-google 0.6.0 → 1.0.0

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

@@ -4,34 +4,50 @@ module Fog
       class Disks < Fog::Collection
         model Fog::Compute::Google::Disk
 
-        def all(filters = {})
-          if filters["zone"]
-            data = service.list_disks(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_disks(zone, opts).items || []
           else
             data = []
-            service.list_aggregated_disks.body["items"].each_value do |zone|
-              data.concat(zone["disks"]) if zone["disks"]
+            service.list_aggregated_disks(opts).items.each_value do |scoped_list|
+              data.concat(scoped_list.disks) if scoped_list.disks
             end
           end
-          load(data)
+          load(data.map(&:to_h))
         end
 
-        def get(identity, zone = nil)
-          response = nil
-          if zone
-            response = service.get_disk(identity, zone).body
-          else
-            disks = service.list_aggregated_disks(:filter => "name eq .*#{identity}").body["items"]
-            disk = disks.each_value.select { |zone| zone.key?("disks") }
-
-            # It can only be 1 disk with the same name across all regions
-            response = disk.first["disks"].first unless disk.empty?
-          end
+        def get(identity, zone)
+          response = service.get_disk(identity, zone)
           return nil if response.nil?
-          new(response)
-        rescue Fog::Errors::NotFound
+          new(response.to_h)
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           nil
         end
+
+        def attached_disk_obj(source,
+                              writable: true,
+                              boot: false,
+                              device_name: nil,
+                              encryption_key: nil,
+                              auto_delete: false)
+          {
+            :auto_delete => auto_delete,
+            :boot => boot,
+            :device_name => device_name,
+            :disk_encryption_key => encryption_key,
+            :mode => writable ? "READ_WRITE" : "READ_ONLY",
+            :source => source,
+            :type => "PERSISTENT"
+          }.reject { |_k, v| v.nil? }
+        end
       end
     end
   end

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

@@ -8,22 +8,33 @@ module Fog
       class Firewall < Fog::Model
         identity :name
 
-        attribute :kind
-        attribute :id
         attribute :allowed
         attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :denied
         attribute :description
+        attribute :destination_ranges, :aliases => "destinationRanges"
+        attribute :direction
+        attribute :id
+        attribute :kind
         attribute :network
+        attribute :priority
         attribute :self_link, :aliases => "selfLink"
         attribute :source_ranges, :aliases => "sourceRanges"
+        attribute :source_service_accounts, :aliases => "sourceServiceAccounts"
         attribute :source_tags, :aliases => "sourceTags"
+        attribute :target_service_accounts, :aliases => "targetServiceAccounts"
         attribute :target_tags, :aliases => "targetTags"
 
         def save
-          requires :identity, :allowed, :network
+          requires :identity
+
+          id.nil? ? create : update
+        end
 
-          data = service.insert_firewall(identity, allowed, network, attributes)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"])
+        def create
+          data = service.insert_firewall(identity, attributes)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
           operation.wait_for { !pending? }
           reload
         end
@@ -31,8 +42,19 @@ module Fog
         def update
           requires :identity, :allowed, :network
 
-          data = service.update_firewall(identity, allowed, network, attributes)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"])
+          data = service.update_firewall(identity, attributes)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { !pending? }
+          reload
+        end
+
+        def patch(diff = {})
+          requires :identity
+
+          data = service.patch_firewall(identity, diff)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
           operation.wait_for { !pending? }
           reload
         end
@@ -41,7 +63,8 @@ module Fog
           requires :identity
 
           data = service.delete_firewall(identity)
-          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

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

@@ -4,16 +4,17 @@ module Fog
       class Firewalls < Fog::Collection
         model Fog::Compute::Google::Firewall
 
-        def all
-          data = service.list_firewalls.body
-          load(data["items"] || [])
+        def all(opts = {})
+          data = service.list_firewalls(opts).to_h[:items]
+          load(data || [])
         end
 
         def get(identity)
-          if firewall = service.get_firewall(identity).body
-            new(firewall)
+          if firewall = service.get_firewall(identity)
+            new(firewall.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/forwarding_rule.rb

@@ -4,60 +4,59 @@ module Fog
       class ForwardingRule < Fog::Model
         identity :name
 
-        attribute :kind, :aliases => "kind"
-        attribute :self_link, :aliases => "selfLink"
-        attribute :id, :aliases => "id"
-        attribute :creation_timestamp, :aliases => "creationTimestamp"
-        attribute :description, :aliases => "description"
-        attribute :region, :aliases => "region"
         attribute :ip_address, :aliases => "IPAddress"
         attribute :ip_protocol, :aliases => "IPProtocol"
+        attribute :backend_service, :aliases => "backendService"
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :description
+        attribute :id
+        attribute :ip_version, :aliases => "ipVersion"
+        attribute :kind
+        attribute :load_balancing_scheme, :aliases => "loadBalancingScheme"
+        attribute :network
         attribute :port_range, :aliases => "portRange"
-        attribute :target, :aliases => "target"
+        attribute :ports
+        attribute :region
+        attribute :self_link, :aliases => "selfLink"
+        attribute :subnetwork
+        attribute :target
 
         def save
-          requires :name, :region, :target
-
-          options = {
-            "description" => description,
-            "region" => region,
-            "IPAddress" => ip_address,
-            "IPProtocol" => ip_protocol || "TCP",
-            "portRange" => port_range,
-            "target" => target
-          }
+          requires :identity, :region
 
-          data = service.insert_forwarding_rule(name, region, options).body
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data["name"], nil, data["region"])
+          data = service.insert_forwarding_rule(identity, region, attributes)
+          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)
+          requires :identity, :region
+
           new_target = new_target.self_link unless new_target.class == String
           self.target = new_target
-          service.set_forwarding_rule_target(self, new_target)
+          service.set_forwarding_rule_target(
+            identity, region, :target => new_target
+          )
           reload
         end
 
         def destroy(async = true)
-          requires :name, :region
-          operation = service.delete_forwarding_rule(name, region)
-          unless async
-            # wait until "RUNNING" or "DONE" to ensure the operation doesn't
-            # fail, raises exception on error
-            Fog.wait_for do
-              operation = service.get_region_operation(region, operation.body["name"])
-              operation.body["status"] == "DONE"
-            end
-          end
+          requires :identity, :region
+          data = service.delete_forwarding_rule(identity, region)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name, nil, data.region)
+          operation.wait_for { ready? } unless async
           operation
         end
 
         def ready?
-          service.get_forwarding_rule(name, region)
+          requires :identity
+          service.get_forwarding_rule(identity, region)
           true
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           false
         end
 
@@ -74,8 +73,6 @@ module Fog
           merge_attributes(new_attributes)
           self
         end
-
-        RUNNING_STATE = "READY"
       end
     end
   end

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

@@ -4,33 +4,43 @@ module Fog
       class ForwardingRules < Fog::Collection
         model Fog::Compute::Google::ForwardingRule
 
-        def all(filters = {})
-          if filters["region"].nil?
+        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_forwarding_rules(region, opts).items
+          else
             data = []
-            service.list_regions.body["items"].each do |region|
-              data += service.list_forwarding_rules(region["name"]).body["items"] || []
+            service.list_aggregated_forwarding_rules(opts).items
+                   .each_value do |scoped_list|
+              if scoped_list && scoped_list.forwarding_rules
+                data.concat(scoped_list.forwarding_rules)
+              end
             end
-          else
-            data = service.list_forwarding_rules(filters["region"]).body["items"] || []
           end
-          load(data)
+          load(data.map(&:to_h))
         end
 
         def get(identity, region = nil)
           response = nil
-          if region.nil?
-            service.list_regions.body["items"].each do |region|
-              begin
-                response = service.get_forwarding_rule(identity, region["name"])
-                break if response.status == 200
-              rescue Fog::Errors::Error
-              end
-            end
+          if region
+            response = service.get_forwarding_rule(identity, region).to_h
           else
-            response = service.get_forwarding_rule(identity, region)
+            response = all(
+              :filter => "name eq #{identity}", :max_results => 1
+            ).first
+            response = response.attributes unless response.nil?
           end
+
           return nil if response.nil?
-          new(response.body)
+          new(response)
         end
       end
     end

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

@@ -8,11 +8,12 @@ module Fog
       class GlobalAddress < Fog::Model
         identity :name
 
-        attribute :kind
-        attribute :id
         attribute :address
         attribute :creation_timestamp, :aliases => "creationTimestamp"
         attribute :description
+        attribute :id
+        attribute :ip_version, :aliases => "ipVersion"
+        attribute :kind
         attribute :self_link, :aliases => "selfLink"
         attribute :status
         attribute :users
@@ -20,22 +21,12 @@ module Fog
         IN_USE_STATE   = "IN_USE".freeze
         RESERVED_STATE = "RESERVED".freeze
 
-        def server
-          return nil if !in_use? || users.nil? || users.empty?
-
-          service.servers.get(users.first.split("/")[-1])
-        end
-
-        def server=(server)
-          requires :identity
-          server ? associate(server) : disassociate
-        end
-
         def save
           requires :identity
 
           data = service.insert_global_address(identity, attributes)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], nil)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
           operation.wait_for { !pending? }
           reload
         end
@@ -44,7 +35,8 @@ module Fog
           requires :identity
 
           data = service.delete_global_address(identity)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], nil)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
           operation.wait_for { ready? } unless async
           operation
         end
@@ -60,28 +52,6 @@ module Fog
         def in_use?
           status == IN_USE_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"])
-        end
-
-        def disassociate
-          return nil if !in_use? || users.nil? || users.empty?
-
-          # 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"])
-          end
-        end
       end
     end
   end

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

@@ -4,36 +4,36 @@ module Fog
       class GlobalAddresses < Fog::Collection
         model Fog::Compute::Google::GlobalAddress
 
-        def all(_filters = {})
-          data = []
-          service.list_aggregated_addresses.body["items"].each_value do |region|
-              data.concat(region["addresses"]) if region["addresses"]
-          end
+        def all(options = {})
+          data = service.list_global_addresses(options).to_h[:items] || []
           load(data)
         end
 
         def get(identity)
-          if address = service.get_global_address(identity).body
+          if address = service.get_global_address(identity).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") }
-
-          return nil if address.empty?
-          new(address.first["addresses"].first)
+          data = service.list_global_addresses(:filter => "address eq #{ip_address}")
+          if data.nil? || data.items.nil?
+            nil
+          else
+            new(data.items.first.to_h)
+          end
         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") }
-
-          return nil if name.empty?
-          new(name.first["addresses"].first)
+          data = service.list_global_addresses(:filter => "name eq #{ip_name}")
+          if data.nil? || data.items.nil?
+            nil
+          else
+            new(data.items.first.to_h)
+          end
         end
 
         def get_by_ip_address_or_name(ip_address_or_name)