gitlab-fog-google 1.13.0

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

@@ -0,0 +1,20 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def get_target_pool(_target_pool, _region)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def get_target_pool(target_pool, region)
+          region = region.split("/")[-1] if region.start_with? "http"
+          @compute.get_target_pool(@project, region, target_pool)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def get_target_pool_health(_target_pool, _region, _instance)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def get_target_pool_health(target_pool, region, instance)
+          @compute.get_target_pool_health(
+            @project, region.split("/")[-1], target_pool,
+            ::Google::Apis::ComputeV1::InstanceReference.new(
+              :instance => instance
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def get_url_map(_url_map_name)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def get_url_map(url_map_name)
+          @compute.get_url_map(@project, url_map_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def get_zone(_zone_name)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def get_zone(zone_name)
+          @compute.get_zone(@project, zone_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def get_zone_operation(_zone_name, _operation)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        # Get the updated status of a zone operation
+        # @see https://developers.google.com/compute/docs/reference/latest/zoneOperations/get
+        #
+        # @param zone_name [String] Zone the operation was peformed in
+        # @param operation [Google::Apis::ComputeV1::Operation] Return value from asynchronous actions
+        def get_zone_operation(zone_name, operation)
+          zone_name = zone_name.split("/")[-1] if zone_name.start_with? "http"
+          @compute.get_zone_operation(@project, zone_name, operation)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_address(_address_name, _region_name, _options = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        # Create an address resource in the specified project
+        # https://cloud.google.com/compute/docs/reference/latest/addresses/insert
+        #
+        # @param address_name [String] Project ID for this address
+        # @param region_name [String] Region for address
+        # @param options [Hash] Optional hash of options
+        # @option options [String] :description Description of resource
+        def insert_address(address_name, region_name, options = {})
+          address = ::Google::Apis::ComputeV1::Address.new(
+            :name => address_name,
+            :description => options[:description]
+          )
+          @compute.insert_address(@project, region_name, address)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_backend_service(_backend_service_name, _opts = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def insert_backend_service(backend_service_name, opts = {})
+          options = opts.reject { |_k, v| v.nil? }
+                        .merge(:name => backend_service_name)
+
+          be_service = ::Google::Apis::ComputeV1::BackendService.new(options)
+          @compute.insert_backend_service(@project, be_service)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_disk(_disk_name, _zone, _image_name = nil, _options = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        # Create a disk resource in a specific zone
+        # https://cloud.google.com/compute/docs/reference/latest/disks/insert
+        #
+        # @param disk_name [String] Name of the disk to create
+        # @param zone_name [String] Zone the disk reside in
+        # @param source_image [String] Optional self_link or family formatted url of the image to
+        # create the disk from, see https://cloud.google.com/compute/docs/reference/latest/disks/insert
+        # @param opts [Hash] Optional hash of options
+        # @option options [String] size_gb Number of GB to allocate to an empty disk
+        # @option options [String] source_snapshot Snapshot to create the disk from
+        # @option options [String] description Human friendly description of the disk
+        # @option options [String] type URL of the disk type resource describing which disk type to use
+        # TODO(2.0): change source_image to keyword argument in 2.0 and gracefully deprecate
+        def insert_disk(disk_name, zone, source_image = nil,
+                        description: nil, type: nil, size_gb: nil,
+                        source_snapshot: nil, labels: nil, **_opts)
+
+          if source_image && !source_image.include?("projects/")
+            raise ArgumentError.new("source_image needs to be self-link formatted or specify a family")
+          end
+          disk_opts = {
+            :name => disk_name,
+            :description => description,
+            :type => type,
+            :size_gb => size_gb,
+            :source_snapshot => source_snapshot,
+            :source_image => source_image
+          }
+          disk_opts[:labels] = labels if labels
+          disk = ::Google::Apis::ComputeV1::Disk.new(disk_opts)
+          @compute.insert_disk(@project, zone.split("/")[-1], disk)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_firewall(_firewall_name, _options = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        INSERTABLE_FIREWALL_FIELDS = %i{
+          allowed
+          denied
+          description
+          destination_ranges
+          direction
+          name
+          network
+          priority
+          source_ranges
+          source_service_accounts
+          source_tags
+          target_service_accounts
+          target_tags
+        }.freeze
+
+        ##
+        # Create a Firewall resource
+        #
+        # @param [Hash] opts The firewall object to create
+        # @option opts [Array<Hash>] allowed
+        # @option opts [Array<Hash>] denied
+        # @option opts [String] description
+        # @option opts [Array<String>] destination_ranges
+        # @option opts [String] direction
+        # @option opts [String] name
+        # @option opts [String] network
+        # @option opts [Fixnum] priority
+        # @option opts [Array<String>] source_ranges
+        # @option opts [Array<String>] source_service_accounts
+        # @option opts [Array<String>] source_tags
+        # @option opts [Array<String>] target_service_accounts
+        # @option opts [Array<String>] target_tags
+        #
+        # @see https://cloud.google.com/compute/docs/reference/latest/firewalls/insert
+        def insert_firewall(firewall_name, opts = {})
+          if opts.key?(:network) && !opts[:network].empty?
+            unless opts[:network].start_with?("http://", "https://", "projects/", "global/")
+              opts[:network] = "projects/#{@project}/global/networks/#{opts[:network]}"
+            end
+          end
+
+          opts = opts.select { |k, _| INSERTABLE_FIREWALL_FIELDS.include? k }
+                     .merge(:name => firewall_name)
+
+          @compute.insert_firewall(
+            @project, ::Google::Apis::ComputeV1::Firewall.new(opts)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_forwarding_rule(_rule_name, _region, _opts = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        ##
+        # Create a forwarding rule.
+        #
+        # @see https://cloud.google.com/compute/docs/reference/latest/forwardingRules/insert
+        def insert_forwarding_rule(rule_name, region, opts = {})
+          region = region.split("/")[-1] if region.start_with? "http"
+          @compute.insert_forwarding_rule(
+            @project, region,
+            ::Google::Apis::ComputeV1::ForwardingRule.new(
+              opts.merge(:name => rule_name)
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_global_address(_address_name, _options = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        INSERTABLE_ADDRESS_FIELDS = %i{description ip_version}.freeze
+
+        def insert_global_address(address_name, options = {})
+          opts = options.select { |k, _| INSERTABLE_ADDRESS_FIELDS.include? k }
+                        .merge(:name => address_name)
+          @compute.insert_global_address(
+            @project, ::Google::Apis::ComputeV1::Address.new(opts)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_global_forwarding_rule(_rule_name, _opts = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        ##
+        # Create a global forwarding rule.
+        #
+        # @see https://cloud.google.com/compute/docs/reference/latest/globalForwardingRules/insert
+        def insert_global_forwarding_rule(rule_name, opts = {})
+          opts = opts.merge(:name => rule_name)
+          @compute.insert_global_forwarding_rule(
+            @project, ::Google::Apis::ComputeV1::ForwardingRule.new(opts)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_http_health_check(_check_name, _options = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def insert_http_health_check(check_name, opts = {})
+          @compute.insert_http_health_check(
+            @project,
+            ::Google::Apis::ComputeV1::HttpHealthCheck.new(
+              opts.merge(:name => check_name)
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_image(_image_name, _image = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def insert_image(image_name, image = {}, project = @project)
+          image = image.merge(:name => image_name)
+          @compute.insert_image(
+            project,
+            ::Google::Apis::ComputeV1::Image.new(image)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_instance_group(_group_name, _zone, _options = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def insert_instance_group(group_name, zone, options = {})
+          if options["network"]
+            network_name = last_url_segment(options["network"])
+          else
+            network_name = GOOGLE_COMPUTE_DEFAULT_NETWORK
+          end
+
+          instance_group = ::Google::Apis::ComputeV1::InstanceGroup.new(
+            :description => options["description"],
+            :name => group_name,
+            :network => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/networks/#{network_name}"
+          )
+
+          @compute.insert_instance_group(@project,
+                                         last_url_segment(zone),
+                                         instance_group)
+        end
+
+        def last_url_segment(network)
+          network.split("/")[-1]
+        end
+      end
+    end
+  end
+end