gitlab-fog-google 1.13.0

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

@@ -0,0 +1,37 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_url_map(_url_map_name, _url_map = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def insert_url_map(url_map_name, url_map = {})
+          url_map[:host_rules] = url_map[:host_rules] || []
+          url_map[:path_matchers] = url_map[:path_matchers] || []
+          url_map[:tests] = url_map[:tests] || []
+
+          url_map_obj = ::Google::Apis::ComputeV1::UrlMap.new(
+            url_map.merge(:name => url_map_name)
+          )
+          # HACK: Currently URL map insert may fail even though the backend
+          # service operation is done. Retriable is not used to not add another
+          # runtime dependency.
+          # TODO: Remove after that has been corrected.
+          begin
+            retries ||= 0
+            @compute.insert_url_map(@project, url_map_obj)
+          rescue ::Google::Apis::ClientError
+            Fog::Logger.warning("URL map insert failed, retrying...")
+            sleep 10
+            retry if (retries += 1) < 2
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def invalidate_url_map_cache(_url_map_name, _path, _host = nil)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def invalidate_url_map_cache(url_map_name, path, host = nil)
+          @compute.invalidate_url_map_cache(
+            @project, url_map_name,
+            ::Google::Apis::ComputeV1::CacheInvalidationRule.new(
+              :path => path, :host => host
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def list_addresses(_region_name, _opts = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        # List address resources in the specified project
+        # @see https://cloud.google.com/compute/docs/reference/latest/addresses/list
+        def list_addresses(region_name, filter: nil, max_results: nil,
+                           order_by: nil, page_token: nil)
+          @compute.list_addresses(
+            @project, region_name,
+            :filter => filter,
+            :max_results => max_results,
+            :order_by => order_by,
+            :page_token => page_token
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def list_aggregated_addresses(_options = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        # Retrieves an aggregated list of addresses
+        # https://cloud.google.com/compute/docs/reference/latest/addresses/aggregatedList
+        # @param options [Hash] Optional hash of options
+        # @option options [String] :filter Filter expression for filtering listed resources
+        def list_aggregated_addresses(options = {})
+          @compute.list_aggregated_addresses(@project, options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def list_aggregated_disk_types(_options = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def list_aggregated_disk_types(filter: nil, max_results: nil,
+                                       order_by: nil, page_token: nil)
+          @compute.list_aggregated_disk_types(
+            @project,
+            :filter => filter, :max_results => max_results,
+            :order_by => order_by, :page_token => page_token
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def list_aggregated_disks(_options = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        # Retrieves an aggregated list of disks
+        # https://cloud.google.com/compute/docs/reference/latest/disks/aggregatedList
+        #
+        # @param options [Hash] Optional hash of options
+        # @option options [String] :filter Filter expression for filtering listed resources
+        # @option options [String] :max_results
+        # @option options [String] :order_by
+        # @option options [String] :page_token
+        def list_aggregated_disks(filter: nil, max_results: nil,
+                                  order_by: nil, page_token: nil)
+          @compute.list_aggregated_disk(
+            @project,
+            :filter => filter, :max_results => max_results,
+            :order_by => order_by, :page_token => page_token
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def list_aggregated_forwarding_rules(_opts = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def list_aggregated_forwarding_rules(filter: nil, max_results: nil,
+                                             order_by: nil, page_token: nil)
+          @compute.list_aggregated_forwarding_rules(
+            @project,
+            :filter => filter, :max_results => max_results,
+            :order_by => order_by, :page_token => page_token
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def list_aggregated_instance_group_managers(_opts = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def list_aggregated_instance_group_managers(filter: nil, max_results: nil,
+                                                    order_by: nil, page_token: nil)
+          @compute.list_aggregated_instance_group_managers(
+            @project,
+            :filter => filter,
+            :max_results => max_results,
+            :order_by => order_by,
+            :page_token => page_token
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def list_aggregated_instance_groups(_options = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def list_aggregated_instance_groups(options = {})
+          @compute.list_aggregated_instance_groups(@project, options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def list_aggregated_machine_types(_opts = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def list_aggregated_machine_types(filter: nil, max_results: nil,
+                                          page_token: nil, order_by: nil)
+          @compute.list_aggregated_machine_types(
+            @project,
+            :filter => filter, :max_results => max_results,
+            :page_token => page_token, :order_by => order_by
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def list_aggregated_servers(_opts = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def list_aggregated_servers(filter: nil, max_results: nil,
+                                    order_by: nil, page_token: nil)
+          @compute.list_aggregated_instances(
+            @project,
+            :filter => filter, :max_results => max_results,
+            :order_by => order_by, :page_token => page_token
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def list_aggregated_subnetworks(_options = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        ##
+        # Retrieves an aggregated list of subnetworks across a project.
+        #
+        # @param filter [String] A filter expression for filtering listed resources.
+        # @param max_results [Fixnum] Max number of results to return
+        # @param order_by [String] Sorts list results by a certain order
+        # @param page_token [String] specifies a page token to use
+        # @return [Google::Apis::ComputeV1::SubnetworkAggregatedList] list result
+        #
+        # @see https://cloud.google.com/compute/docs/reference/latest/subnetworks/aggregatedList
+        def list_aggregated_subnetworks(filter: nil, max_results: nil,
+                                        page_token: nil, order_by: nil)
+          @compute.aggregated_subnetwork_list(
+            @project,
+            :filter => filter,
+            :max_results => max_results,
+            :page_token => page_token,
+            :order_by => order_by
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def list_aggregated_target_instances(_options = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def list_aggregated_target_instances(filter: nil, max_results: nil,
+                                             order_by: nil, page_token: nil)
+          @compute.list_aggregated_target_instance(
+            @project,
+            :filter => filter,
+            :max_results => max_results,
+            :order_by => order_by,
+            :page_token => page_token
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def list_aggregated_target_pools(_opts = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def list_aggregated_target_pools(filter: nil, max_results: nil,
+                                         order_by: nil, page_token: nil)
+          @compute.list_aggregated_target_pools(
+            @project,
+            :filter => filter,
+            :max_results => max_results,
+            :order_by => order_by,
+            :page_token => page_token
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def list_backend_services
+          backend_services = data[:backend_services].values
+
+          build_excon_response("kind" => "compute#backendServiceList",
+                               "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/backendServices",
+                               "id" => "projects/#{@project}/global/backendServices",
+                               "items" => backend_services)
+        end
+      end
+
+      class Real
+        def list_backend_services
+          @compute.list_backend_services(@project)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def list_disk_types(_zone, _options: {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def list_disk_types(zone, filter: nil, max_results: nil,
+                            order_by: nil, page_token: nil)
+          @compute.list_disk_types(
+            @project, zone.split("/")[-1],
+            :filter => filter, :max_results => max_results,
+            :order_by => order_by, :page_token => page_token
+          )
+        end
+      end
+    end
+  end
+end