gitlab-fog-google 1.13.0

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

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class TargetHttpsProxies < Fog::Collection
+        model Fog::Compute::Google::TargetHttpsProxy
+
+        def all(_filters = {})
+          data = service.list_target_https_proxies.to_h[:items] || []
+          load(data)
+        end
+
+        def get(identity)
+          if identity
+            target_https_proxy = service.get_target_https_proxy(identity).to_h
+            return new(target_https_proxy)
+          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/target_https_proxy.rb

@@ -0,0 +1,105 @@
+module Fog
+  module Compute
+    class Google
+      class TargetHttpsProxy < Fog::Model
+        identity :name
+
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :description, :aliases => "description"
+        attribute :id, :aliases => "id"
+        attribute :kind, :aliases => "kind"
+        attribute :self_link, :aliases => "selfLink"
+        attribute :url_map, :aliases => "urlMap"
+        # Array of SSL Certificates
+        # @example
+        #
+        #   [cert_one.self_link', cert_two.self_link]
+        #
+        # , where 'cert_one' and 'cert_two' are instances of
+        # Fog::Compute::Google::SslCertificate
+        #
+        # @return [Array<String>]
+        attribute :ssl_certificates, :aliases => "sslCertificates"
+
+        def save
+          requires :identity, :url_map, :ssl_certificates
+
+          unless ssl_certificates.is_a?(Array)
+            raise Fog::Errors::Error.new("ssl_certificates attribute must be an array")
+          end
+
+          data = service.insert_target_https_proxy(
+            identity,
+            :description => description,
+            :url_map => url_map,
+            :ssl_certificates => ssl_certificates
+          )
+          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_target_https_proxy(identity)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
+          operation
+        end
+
+        def set_url_map(url_map, async = true)
+          requires :identity
+
+          data = service.set_target_https_proxy_url_map(
+            identity, url_map
+          )
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
+          reload
+        end
+
+        def set_ssl_certificates(ssl_certificates, async = true)
+          requires :identity
+
+          data = service.set_target_https_proxy_ssl_certificates(
+            identity, ssl_certificates
+          )
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
+          reload
+        end
+
+        def ready?
+          requires :identity
+
+          service.get_target_https_proxy(identity)
+          true
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          false
+        end
+
+        def reload
+          requires :identity
+
+          return unless data = begin
+            collection.get(identity)
+          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/target_instance.rb

@@ -0,0 +1,67 @@
+module Fog
+  module Compute
+    class Google
+      class TargetInstance < Fog::Model
+        identity :name
+
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :description
+        attribute :id
+        attribute :instance
+        attribute :kind
+        attribute :nat_policy, :aliases => "natPolicy"
+        attribute :self_link, :aliases => "selfLink"
+        attribute :zone
+
+        def save
+          requires :identity, :zone
+
+          options = {
+            :description => description,
+            :zone => zone,
+            :nat_policy => nat_policy,
+            :instance => instance
+          }
+
+          data = service.insert_target_instance(identity, zone, options)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name, data.zone)
+          operation.wait_for { ready? }
+          reload
+        end
+
+        def destroy(async = true)
+          requires :name, :zone
+          data = service.delete_target_instance(name, zone)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name, data.zone)
+          operation.wait_for { ready? } unless async
+          operation
+        end
+
+        def ready?
+          service.get_target_instance(name, zone)
+          true
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          false
+        end
+
+        def reload
+          requires :name, :zone
+
+          begin
+            data = collection.get(name, zone)
+            new_attributes = data.attributes
+            merge_attributes(new_attributes)
+            return self
+          rescue Excon::Errors::SocketError
+            return nil
+          end
+        end
+
+        RUNNING_STATE = "READY".freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Fog
+  module Compute
+    class Google
+      class TargetInstances < Fog::Collection
+        model Fog::Compute::Google::TargetInstance
+
+        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_target_instances(zone, opts).to_h[:items] || []
+          else
+            data = []
+            service.list_aggregated_target_instances(opts).items.each_value do |scoped_list|
+              unless scoped_list.nil? || scoped_list.target_instances.nil?
+                data += scoped_list.target_instances.map(&:to_h)
+              end
+            end
+          end
+          load(data)
+        end
+
+        def get(identity, zone = nil)
+          if zone
+            target_instance = service.get_target_instance(target_instance, zone).to_h
+            return new(target_instance)
+          elsif identity
+            response = all(:filter => "name eq #{identity}",
+                           :max_results => 1)
+            target_instance = response.first unless response.empty?
+            return target_instance
+          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/target_pool.rb

@@ -0,0 +1,171 @@
+module Fog
+  module Compute
+    class Google
+      class TargetPool < Fog::Model
+        identity :name
+
+        attribute :backup_pool, :aliases => "backupPool"
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :description
+        attribute :failover_ratio, :aliases => "failoverRatio"
+        attribute :health_checks, :aliases => "healthChecks"
+        attribute :id
+        attribute :instances
+        attribute :kind
+        attribute :region
+        attribute :self_link, :aliases => "selfLink"
+        attribute :session_affinity, :aliases => "sessionAffinity"
+
+        def save
+          requires :name, :region
+
+          data = service.insert_target_pool(
+            name, region, attributes.reject { |_k, v| v.nil? }
+          )
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, nil, data.region)
+          operation.wait_for { ready? }
+          reload
+        end
+
+        def destroy(async = true)
+          requires :identity, :region
+          data = service.delete_target_pool(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 add_instance(instance, async = true)
+          requires :identity
+          instance = instance.self_link unless instance.class == String
+          data = service.add_target_pool_instances(identity, region, [instance])
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, nil, data.region)
+          operation.wait_for { ready? } unless async
+
+          reload
+        end
+
+        def remove_instance(instance, async = true)
+          requires :identity
+
+          instance = instance.self_link unless instance.class == String
+          data = service.remove_target_pool_instances(identity, region, [instance])
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, nil, data.region)
+
+          operation.wait_for { ready? } unless async
+
+          reload
+        end
+
+        def add_health_check(health_check, async = true)
+          requires :identity, :region
+
+          health_check = health_check.self_link unless health_check.class == String
+          data = service.add_target_pool_health_checks(identity, region, [health_check])
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, nil, data.region)
+          operation.wait_for { ready? } unless async
+
+          reload
+        end
+
+        def remove_health_check(health_check, async = true)
+          requires :identity, :region
+
+          health_check = health_check.self_link unless health_check.class == String
+          data = service.remove_target_pool_health_checks(identity, region, [health_check])
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, nil, data.region)
+          operation.wait_for { ready? } unless async
+          reload
+        end
+
+        ##
+        # Get most recent health checks for each IP for instances.
+        #
+        # @param [String] instance_name a specific instance to look up. Default
+        #   behavior returns health checks for all instances associated with
+        #   this check.
+        # @returns [Hash<String, Array<Hash>>] a map of instance URL to health checks
+        #
+        # Example Hash:
+        # {
+        #   "https://www.googleapis.com/compute/v1/projects/myproject/zones/us-central1-f/instances/myinstance"=>
+        # [{:health_state=>"UNHEALTHY",
+        #   :instance=>"https://www.googleapis.com/compute/v1/projects/myproject/zones/us-central1-f/instances/myinstance"
+        # }]
+        # }
+        #
+        def get_health(instance_name = nil)
+          requires :identity, :region
+
+          if instance_name
+            instance = service.servers.get(instance_name)
+            data = service.get_target_pool_health(identity, region, instance.self_link)
+                          .to_h[:health_status] || []
+            results = [[instance.self_link, data]]
+          else
+            results = instances.map do |self_link|
+              # TODO: Improve the returned object, current is hard to navigate
+              # [{instance => @instance, health_state => "HEALTHY"}, ...]
+              data = service.get_target_pool_health(identity, region, self_link)
+                            .to_h[:health_status] || []
+              [self_link, data]
+            end
+          end
+          Hash[results]
+        end
+
+        def set_backup(backup = nil)
+          requires :identity, :region
+
+          backup ||= backup_pool
+
+          service.set_target_pool_backup(
+            identity, region, backup,
+            :failover_ratio => failover_ratio
+          )
+          reload
+        end
+
+        def ready?
+          service.get_target_pool(name, region)
+          true
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          false
+        end
+
+        def region_name
+          region.nil? ? nil : region.split("/")[-1]
+        end
+
+        def reload
+          requires :name, :region
+
+          return unless data = begin
+            collection.get(name, region)
+          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/target_pools.rb

@@ -0,0 +1,43 @@
+module Fog
+  module Compute
+    class Google
+      class TargetPools < Fog::Collection
+        model Fog::Compute::Google::TargetPool
+
+        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.nil?
+            data = []
+            service.list_aggregated_target_pools(opts).items.each_value do |lst|
+              unless lst.nil? || lst.target_pools.nil?
+                data += lst.to_h[:target_pools]
+              end
+            end
+          else
+            data = service.list_target_pools(region, opts).to_h[:items]
+          end
+          load(data)
+        end
+
+        def get(identity, region = nil)
+          if region
+            target_pool = service.get_target_pool(identity, region).to_h
+            return new(target_pool)
+          elsif identity
+            response = all(:filter => "name eq #{identity}")
+            target_pool = response.first unless response.empty?
+            return target_pool
+          end
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code = 404
+          nil
+        end
+      end
+    end
+  end
+end