gitlab-fog-google 1.13.0

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

@@ -0,0 +1,121 @@
+module Fog
+  module Compute
+    class Google
+      class UrlMap < Fog::Model
+        identity :name
+
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :default_service, :aliases => "defaultService"
+        attribute :description, :aliases => "description"
+        attribute :fingerprint, :aliases => "fingerprint"
+        attribute :host_rules, :aliases => "hostRules"
+        attribute :id, :aliases => "id"
+        attribute :kind, :aliases => "kind"
+        attribute :path_matchers, :aliases => "pathMatchers"
+        attribute :self_link, :aliases => "selfLink"
+        attribute :tests, :aliases => "tests"
+
+        def save
+          requires :identity, :default_service
+
+          options = {
+            :default_service => default_service,
+            :description => description,
+            :fingerprint => fingerprint,
+            :host_rules => host_rules,
+            :path_matchers => path_matchers,
+            :tests => tests
+          }
+
+          # Update if creation_timestamp is set, create url map otherwise.
+          data = nil
+          if creation_timestamp
+            data = service.update_url_map(identity, options)
+          else
+            data = service.insert_url_map(identity, options)
+          end
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? }
+          reload
+        end
+
+        def destroy(async = true)
+          requires :identity
+
+          data = service.delete_url_map(identity)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
+          operation
+        end
+
+        def validate
+          requires :identity
+          service.validate_url_map(identity, attributes)
+        end
+
+        def add_host_rules(rules_to_add, async = true)
+          requires :identity
+
+          rules = (host_rules || []).concat rules_to_add
+          data = service.patch_url_map(identity, :host_rules => rules)
+
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
+          reload
+        end
+
+        def add_path_matchers(matchers_to_add, rules_to_add, async = true)
+          requires :identity
+
+          matchers = (path_matchers || []) + matchers_to_add
+          rules = (host_rules || []) + rules_to_add
+          data = service.patch_url_map(identity,
+                                       :host_rules => rules,
+                                       :path_matchers => matchers)
+
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
+          reload
+        end
+
+        def invalidate_cache(path, host = nil, async = true)
+          requires :identity
+
+          data = service.invalidate_url_map_cache(identity, path, host)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
+          operation
+        end
+
+        def ready?
+          service.get_url_map(name)
+          true
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          false
+        end
+
+        def reload
+          requires :name
+
+          return unless data = begin
+            collection.get(name)
+          rescue Excon::Errors::SocketError
+            nil
+          end
+
+          new_attributes = data.attributes
+          merge_attributes(new_attributes)
+          self
+        end
+
+        RUNNING_STATE = "READY".freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class UrlMaps < Fog::Collection
+        model Fog::Compute::Google::UrlMap
+
+        def all
+          data = service.list_url_maps.to_h[:items] || []
+          load(data)
+        end
+
+        def get(identity)
+          if identity
+            url_map = service.get_url_map(identity).to_h
+            return new(url_map)
+          end
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Fog
+  module Compute
+    class Google
+      class Zone < Fog::Model
+        identity :name
+
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :deprecated
+        attribute :description
+        attribute :id
+        attribute :kind
+        attribute :region
+        attribute :self_link, :aliases => "selfLink"
+        attribute :status
+
+        UP_STATE = "UP".freeze
+        DOWN_STATE = "DOWN".freeze
+
+        def up?
+          status == UP_STATE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class Zones < Fog::Collection
+        model Fog::Compute::Google::Zone
+
+        def all
+          data = service.list_zones.to_h[:items] || []
+          load(data)
+        end
+
+        def get(identity)
+          if identity
+            zone = service.get_zone(identity).to_h
+            new(zone)
+          end
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/real.rb

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class Real
+        include Fog::Google::Shared
+
+        attr_accessor :client
+        attr_reader :compute, :extra_global_projects, :exclude_projects
+
+        def initialize(options)
+          shared_initialize(options[:google_project], GOOGLE_COMPUTE_API_VERSION, GOOGLE_COMPUTE_BASE_URL)
+          options[:google_api_scope_url] = GOOGLE_COMPUTE_API_SCOPE_URLS.join(" ")
+
+          initialize_google_client(options)
+          @compute = ::Google::Apis::ComputeV1::ComputeService.new
+          apply_client_options(@compute, options)
+
+          @extra_global_projects = options[:google_extra_global_projects] || []
+          @exclude_projects = options[:google_exclude_projects] || []
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def abandon_instances(_instance_group_manager, _instances)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def abandon_instances(instance_group_manager, instances)
+          request = ::Google::Apis::ComputeV1::InstanceGroupManagersAbandonInstancesRequest.new(
+            :instances => instances.map{ |i| i.class == String ? i : i.self_link }
+          )
+          if instance_group_manager.zone
+            zone = instance_group_manager.zone.split("/")[-1]
+            @compute.abandon_instance_group_manager_instances(@project, zone, instance_group_manager.name, request)
+          else
+            region = instance_group_manager.region.split("/")[-1]
+            @compute.abandon_region_instance_group_manager_instances(@project, region, instance_group_manager.name, request)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def add_backend_service_backends(_backend_service, _new_backends)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def add_backend_service_backends(backend_service, _new_backends)
+          @compute.patch_backend_service(@project, backend_service.name, backend_service)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def add_instance_group_instances(_group_name, _zone, _instances)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def add_instance_group_instances(group_name, zone, instances)
+          instances.map! do |instance|
+            if instance.start_with?("https:")
+              ::Google::Apis::ComputeV1::InstanceReference.new(:instance => instance)
+            else
+              ::Google::Apis::ComputeV1::InstanceReference.new(
+                :instance => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone}/instances/#{instance}\n"
+              )
+            end
+          end
+
+          request = ::Google::Apis::ComputeV1::InstanceGroupsAddInstancesRequest.new(
+            :instances => instances
+          )
+          @compute.add_instance_group_instances(
+            @project,
+            zone,
+            group_name,
+            request
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def add_server_access_config(_identity, _zone, _nic, _options = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def add_server_access_config(identity, zone,
+                                     network_interface,
+                                     access_config_name = "External NAT",
+                                     nat_ip: nil)
+          @compute.add_instance_access_config(
+            @project,
+            zone.split("/")[-1],
+            identity,
+            network_interface,
+            ::Google::Apis::ComputeV1::AccessConfig.new(
+              :name => access_config_name,
+              :nat_ip => nat_ip,
+              :type => "ONE_TO_ONE_NAT"
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def add_target_pool_health_checks(_target_pool, _region, _health_checks)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def add_target_pool_health_checks(target_pool, region, health_checks)
+          check_list = health_checks.map do |health_check|
+            ::Google::Apis::ComputeV1::HealthCheckReference.new(
+              :health_check => health_check
+            )
+          end
+
+          @compute.add_target_pool_health_check(
+            @project,
+            region.split("/")[-1],
+            target_pool,
+            ::Google::Apis::ComputeV1::AddTargetPoolsHealthCheckRequest.new(
+              :health_checks => check_list
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def add_target_pool_instances(_target_pool, _region, _instances)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def add_target_pool_instances(target_pool, region, instances)
+          instances_lst = instances.map do |instance|
+            ::Google::Apis::ComputeV1::InstanceReference.new(:instance => instance)
+          end
+
+          @compute.add_target_pool_instance(
+            @project,
+            region.split("/")[-1],
+            target_pool,
+            ::Google::Apis::ComputeV1::AddTargetPoolsInstanceRequest.new(
+              :instances => instances_lst
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def attach_disk(_instance, _zone, _disk = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def attach_disk(instance, zone, disk = {})
+          @compute.attach_disk(
+            @project, zone.split("/")[-1], instance,
+            ::Google::Apis::ComputeV1::AttachedDisk.new(disk)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def create_disk_snapshot(_snapshot_name, _disk, _zone, _snapshot = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def create_disk_snapshot(snapshot_name, disk, zone, snapshot = {})
+          @compute.create_disk_snapshot(
+            @project, zone, disk,
+            ::Google::Apis::ComputeV1::Snapshot.new(
+              snapshot.merge(:name => snapshot_name)
+            )
+          )
+        end
+      end
+    end
+  end
+end