fog-google 0.6.0 → 1.0.0

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

@@ -8,20 +8,16 @@ module Fog
       end
 
       class Real
-        def insert_ssl_certificate(certificate_name, certificate, private_key, options = {})
-          api_method = @compute.ssl_certificates.insert
-          parameters = {
-            "project" => @project
-          }
-          body_object = {
-            "certificate" => certificate,
-            "name" => certificate_name,
-            "privateKey" => private_key
-          }
-
-          body_object["description"] = options[:description] if options[:description]
-
-          request(api_method, parameters, body_object)
+        def insert_ssl_certificate(certificate_name, certificate, private_key, description: nil)
+          @compute.insert_ssl_certificate(
+            @project,
+            ::Google::Apis::ComputeV1::SslCertificate.new(
+              :certificate => certificate,
+              :name => certificate_name,
+              :private_key => private_key,
+              :description => description
+            )
+          )
         end
       end
     end

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

@@ -2,72 +2,56 @@ module Fog
   module Compute
     class Google
       class Mock
-        def insert_subnetwork(subnetwork_name, region_name, network, ip_range, _options = {})
-          subnetwork_name = subnetwork_name.split("/")[-1] if subnetwork_name.start_with? "http"
-          region_name = region_name.split("/")[-1] if region_name.start_with? "http"
-          network_name = network.split("/")[-1]
-
-          gateway = ip_range.split("/").first.split(".")
-          gateway[-1] = "1"
-
-          id = Fog::Mock.random_numbers(19).to_s
-          object = {
-            "kind" => "compute#subnetwork",
-            "id" => id,
-            "creationTimestamp" => Time.now.iso8601,
-            "gatewayAddress" => gateway.join("."),
-            "name" => subnetwork_name,
-            "network" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/networks/#{network_name}",
-            "ipCidrRange" => ip_range,
-            "region" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/regions/#{region_name}",
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/regions/#{region_name}/subnetworks/#{subnetwork_name}"
-          }
-
-          data[:subnetworks][subnetwork_name] = object
-
-          operation = random_operation
-          data[:operations][operation] = {
-            "kind" => "compute#operation",
-            "id" => Fog::Mock.random_numbers(19).to_s,
-            "name" => operation,
-            "region" => object["region"],
-            "operationType" => "insert",
-            "targetLink" => object["selfLink"],
-            "targetId" => id,
-            "status" => Fog::Compute::Google::Operation::PENDING_STATE,
-            "user" => "123456789012-qwertyuiopasdfghjkl1234567890qwe@developer.gserviceaccount.com",
-            "progress" => 0,
-            "insertTime" => Time.now.iso8601,
-            "startTime" => Time.now.iso8601,
-            "selfLink" => "#{object['region']}/operations/#{operation}"
-          }
-
-          build_excon_response(data[:operations][operation])
+        def insert_subnetwork(_subnetwork_name, _region_name, _network, _ip_range, _options = {})
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
+        ##
+        # Create a subnetwork.
+        #
+        # @param subnetwork_name [String] the name of the subnetwork
+        # @param region_name [String] the name of the subnetwork's region
+        # @param network [String] URL of the network this subnetwork belongs to
+        # @param ip_range [String] The range of internal addresses that are owned
+        #   by this subnetwork.
+        # @param options [Hash] Other optional attributes to set on the subnetwork
+        # @option options [Boolean] private_ip_google_access Whether the VMs in
+        #   this subnet can access Google services without assigned external IP
+        #   addresses.
+        # @option options [String] description An optional description of this resource.
+        # @option options [Array<Hash>] secondary_ip_ranges An array of configurations
+        #   for secondary IP ranges
+        # @option secondary_ip_ranges [String] ip_cidr_range The range of IP
+        #   addresses for a secondary range
+        # @option secondary_ip_ranges [String] range_name The name associated
+        #   with a secondary range
+        #
+        # @return [Google::Apis::ComputeV1::Operation] an operation response
+        #
+        # @see https://cloud.google.com/compute/docs/reference/latest/subnetworks/insert
         def insert_subnetwork(subnetwork_name, region_name, network, ip_range, options = {})
           region_name = region_name.split("/")[-1] if region_name.start_with? "http"
-
           unless network.start_with? "http"
             network = "#{@api_url}#{@project}/global/networks/#{network}"
           end
 
-          api_method = @compute.subnetworks.insert
-          parameters = {
-            "project" => @project,
-            "region"  => region_name
-          }
-          body_object = {
-            "ipCidrRange" => ip_range,
-            "name"        => subnetwork_name,
-            "network"     => network
+          params = {
+            :name => subnetwork_name,
+            :ip_cidr_range => ip_range,
+            :region => region_name,
+            :network => network
           }
 
-          body_object["description"] = options[:description] if options[:description]
+          optional_fields = %i{private_ip_google_access description secondary_ip_ranges}
+          params = optional_fields.inject(params) do |data, field|
+            data[field] = options[field] unless options[field].nil?
+            data
+          end
 
-          request(api_method, parameters, body_object)
+          subnetwork = ::Google::Apis::ComputeV1::Subnetwork.new(params)
+          @compute.insert_subnetwork(@project, region_name, subnetwork)
         end
       end
     end

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

@@ -2,49 +2,21 @@ module Fog
   module Compute
     class Google
       class Mock
-        def insert_target_http_proxy(name, options = {})
-          id = Fog::Mock.random_numbers(19).to_s
-          data[:target_http_proxies][name] = {
-            "kind" => "compute#targetHttpProxy",
-            "id" => id,
-            "creationTimestamp" => Time.now.iso8601,
-            "name" => name,
-            "description" => "",
-            "urlMap" => options["urlMap"],
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/targetHttpProxies/#{name}"
-          }
-
-          operation = random_operation
-          data[:operations][operation] = {
-            "kind" => "compute#operation",
-            "id" => Fog::Mock.random_numbers(19).to_s,
-            "name" => operation,
-            "zone" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global",
-            "operationType" => "insert",
-            "targetLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/targetHttpProxies/#{name}",
-            "targetId" => id,
-            "status" => Fog::Compute::Google::Operation::PENDING_STATE,
-            "user" => "123456789012-qwertyuiopasdfghjkl1234567890qwe@developer.gserviceaccount.com",
-            "progress" => 0,
-            "insertTime" => Time.now.iso8601,
-            "startTime" => Time.now.iso8601,
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/operations/#{operation}"
-          }
-
-          build_excon_response(data[:operations][operation])
+        def insert_target_http_proxy(_proxy_name, _description: nil, _url_map: nil)
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def insert_target_http_proxy(name, opts = {})
-          api_method = @compute.target_http_proxies.insert
-          parameters = {
-            "project" => @project
-          }
-          body_object = { "name" => name }
-          body_object.merge!(opts)
-
-          request(api_method, parameters, body_object)
+        def insert_target_http_proxy(proxy_name, description: nil, url_map: nil)
+          @compute.insert_target_http_proxy(
+            @project,
+            ::Google::Apis::ComputeV1::TargetHttpProxy.new(
+              :name => proxy_name,
+              :description => description,
+              :url_map => url_map
+            )
+          )
         end
       end
     end

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

@@ -2,21 +2,24 @@ module Fog
   module Compute
     class Google
       class Mock
-        def insert_target_https_proxy(_name, _options = {})
+        def insert_target_https_proxy(_proxy_name, _description: nil,
+                                      _url_map: nil, _ssl_certificates: nil)
           Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def insert_target_https_proxy(name, opts = {})
-          api_method = @compute.target_https_proxies.insert
-          parameters = {
-            "project" => @project
-          }
-          body_object = { "name" => name }
-          body_object.merge!(opts)
-
-          request(api_method, parameters, body_object)
+        def insert_target_https_proxy(proxy_name, description: nil,
+                                      url_map: nil, ssl_certificates: nil)
+          @compute.insert_target_https_proxy(
+            @project,
+            ::Google::Apis::ComputeV1::TargetHttpsProxy.new(
+              :name => proxy_name,
+              :description => description,
+              :url_map => url_map,
+              :ssl_certificates => ssl_certificates
+            )
+          )
         end
       end
     end

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

@@ -2,52 +2,20 @@ module Fog
   module Compute
     class Google
       class Mock
-        def insert_target_instance(target_instance, zone_name, opts = {})
-          id = Fog::Mock.random_numbers(19).to_s
-          data[:target_instances][target_instance] = {
-            "kind" => "compute#targetInstance",
-            "id" => id,
-            "creationTimestamp" => Time.now.iso8601,
-            "name" => target_instance,
-            "description" => "",
-            "natPolicy" => "",
-            "zone" => zone_name,
-            "instance" => opts["instance"],
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}/targetInstances/#{target_instance}"
-          }
-
-          operation = random_operation
-          data[:operations][operation] = {
-            "kind" => "compute#operation",
-            "id" => Fog::Mock.random_numbers(19).to_s,
-            "name" => operation,
-            "zone" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}",
-            "operationType" => "insert",
-            "targetLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}/targetInstances/#{target_instance}",
-            "targetId" => id,
-            "status" => Fog::Compute::Google::Operation::PENDING_STATE,
-            "user" => "123456789012-qwertyuiopasdfghjkl1234567890qwe@developer.gserviceaccount.com",
-            "progress" => 0,
-            "insertTime" => Time.now.iso8601,
-            "startTime" => Time.now.iso8601,
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}/operations/#{operation}"
-          }
-
-          build_excon_response(data[:operations][operation])
+        def insert_target_instance(_target_name, _zone, _target_instance = {})
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def insert_target_instance(target_instance_name, zone_name, opts = {})
-          api_method = @compute.target_instances.insert
-          parameters = {
-            "project" => @project,
-            "zone" => zone_name
-          }
-          body_object = { "name" => target_instance_name }
-          body_object.merge!(opts)
-
-          request(api_method, parameters, body_object = body_object)
+        def insert_target_instance(target_name, zone, target_instance = {})
+          zone = zone.split("/")[-1] if zone.start_with? "http"
+          @compute.insert_target_instance(
+            @project, zone,
+            ::Google::Apis::ComputeV1::TargetInstance.new(
+              target_instance.merge(:name => target_name)
+            )
+          )
         end
       end
     end

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

@@ -2,55 +2,17 @@ module Fog
   module Compute
     class Google
       class Mock
-        def insert_target_pool(name, region_name, opts = {})
-          # check that region exists
-          get_region(region_name)
-
-          id = Fog::Mock.random_numbers(19).to_s
-          data[:target_pools][name] = {
-            "kind" => "compute#targetPools",
-            "id" => id,
-            "creationTimestamp" => Time.now.iso8601,
-            "name" => name,
-            "description" => "",
-            "region" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/regions/#{region_name}",
-            "instances" => opts["instances"],
-            "healthChecks" => opts["healthChecks"],
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/regions/#{region_name}/targetPools/#{name}"
-          }
-
-          operation = random_operation
-          data[:operations][operation] = {
-            "kind" => "compute#operation",
-            "id" => Fog::Mock.random_numbers(19).to_s,
-            "name" => operation,
-            "region" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/regions/#{region_name}",
-            "operationType" => "insert",
-            "targetLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/regions/#{region_name}/targetPools/#{name}",
-            "targetId" => id,
-            "status" => Fog::Compute::Google::Operation::PENDING_STATE,
-            "user" => "123456789012-qwertyuiopasdfghjkl1234567890qwe@developer.gserviceaccount.com",
-            "progress" => 0,
-            "insertTime" => Time.now.iso8601,
-            "startTime" => Time.now.iso8601,
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/regions/#{region_name}/operations/#{operation}"
-          }
-
-          build_excon_response(data[:operations][operation])
+        def insert_target_pool(_target_pool_name, _region, _target_pool = {})
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def insert_target_pool(target_pool_name, region_name, opts = {})
-          api_method = @compute.target_pools.insert
-          parameters = {
-            "project" => @project,
-            "region" => region_name
-          }
-          body_object = { "name" => target_pool_name }
-          body_object.merge!(opts)
-
-          request(api_method, parameters, body_object = body_object)
+        def insert_target_pool(target_pool_name, region, target_pool = {})
+          pool_obj = ::Google::Apis::ComputeV1::TargetPool.new(
+            target_pool.merge(:name => target_pool_name)
+          )
+          @compute.insert_target_pool(@project, region.split("/")[-1], pool_obj)
         end
       end
     end

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

@@ -2,52 +2,21 @@ module Fog
   module Compute
     class Google
       class Mock
-        def insert_url_map(url_map_name, opts)
-          id = Fog::Mock.random_numbers(19).to_s
-          data[:url_maps][url_map_name] = {
-            "kind" => "compute#urlMap",
-            "id" => id,
-            "creationTimestamp" => Time.now.iso8601,
-            "name" => url_map_name,
-            "description" => "",
-            "hostRules" => [],
-            "pathMatchers" => [],
-            "tests" => [],
-            "defaultService" => opts["defaultService"],
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/urlMaps/#{url_map_name}"
-          }
-
-          operation = random_operation
-          data[:operations][operation] = {
-            "kind" => "compute#operation",
-            "id" => Fog::Mock.random_numbers(19).to_s,
-            "name" => operation,
-            "zone" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global",
-            "operationType" => "insert",
-            "targetLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/urlMaps/#{url_map_name}",
-            "targetId" => id,
-            "status" => Fog::Compute::Google::Operation::PENDING_STATE,
-            "user" => "123456789012-qwertyuiopasdfghjkl1234567890qwe@developer.gserviceaccount.com",
-            "progress" => 0,
-            "insertTime" => Time.now.iso8601,
-            "startTime" => Time.now.iso8601,
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/operations/#{operation}"
-          }
-
-          build_excon_response(data[:operations][operation])
+        def insert_url_map(_url_map_name, _url_map = {})
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def insert_url_map(url_map_name, opts = {})
-          api_method = @compute.url_maps.insert
-          parameters = {
-            "project" => @project
-          }
-          body_object = { "name" => url_map_name }
-          body_object.merge!(opts)
+        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] || []
 
-          request(api_method, parameters, body_object = body_object)
+          url_map_obj = ::Google::Apis::ComputeV1::UrlMap.new(
+            url_map.merge(:name => url_map_name)
+          )
+          @compute.insert_url_map(@project, url_map_obj)
         end
       end
     end

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

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def invalidate_url_map_cache(_url_map_name, _path, _host = nil)
+          Fog::Mock.not_implemented
+        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