fog-google 0.6.0 → 1.0.0

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

@@ -2,36 +2,19 @@ module Fog
   module Compute
     class Google
       class Mock
-        def get_target_pool_health(_target_pool, _instance)
+        def get_target_pool_health(_target_pool, _region, _instance)
           Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def get_target_pool_health(target_pool, instance = nil)
-          api_method = @compute.target_pools.get_health
-          parameters = {
-            "project" => @project,
-            "targetPool" => target_pool.name,
-            "region" => target_pool.region.split("/")[-1]
-          }
-
-          if instance
-            body = { "instance" => instance }
-            resp = request(api_method, parameters, body_object = body)
-            [instance, resp.data[:body]["healthStatus"]]
-          else
-            # TODO: Remove (introduced after 0.4.2)
-            Fog::Logger.deprecation(
-              "Do not use raw requests, use Fog::Compute::Google::TargetPool.get_health instead [light_black](#{caller.first})[/]"
+        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
             )
-            health_results = target_pool.instances.map do |instance_object|
-              body = { "instance" => instance_object }
-              resp = request(api_method, parameters, body_object = body)
-              [instance_object, resp.data[:body]["healthStatus"]]
-            end
-            Hash[health_results]
-          end
+          )
         end
       end
     end

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

@@ -2,22 +2,14 @@ module Fog
   module Compute
     class Google
       class Mock
-        def get_url_map(name)
-          url_map = data[:url_maps][name]
-          return nil if url_map.nil?
-          build_excon_response(url_map)
+        def get_url_map(_url_map_name)
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def get_url_map(name)
-          api_method = @compute.url_maps.get
-          parameters = {
-            "project" => @project,
-            "urlMap" => name
-          }
-
-          request(api_method, parameters)
+        def get_url_map(url_map_name)
+          @compute.get_url_map(@project, url_map_name)
         end
       end
     end

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

@@ -2,33 +2,14 @@ module Fog
   module Compute
     class Google
       class Mock
-        def get_zone(zone_name)
-          zone = data[:zones][zone_name] || {
-            "error" => {
-              "errors" => [
-                {
-                  "domain" => "global",
-                  "reason" => "notFound",
-                  "message" => "The resource 'projects/#{project}/zones/#{zone_name}' was not found"
-                }
-              ],
-              "code" => 404,
-              "message" => "The resource 'projects/#{project}/zones/#{zone_name}' was not found"
-            }
-          }
-          build_excon_response(zone)
+        def get_zone(_zone_name)
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
         def get_zone(zone_name)
-          api_method = @compute.zones.get
-          parameters = {
-            "project" => @project,
-            "zone" => zone_name
-          }
-
-          request(api_method, parameters)
+          @compute.get_zone(@project, zone_name)
         end
       end
     end

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

@@ -2,50 +2,20 @@ module Fog
   module Compute
     class Google
       class Mock
-        def get_zone_operation(zone_name, operation)
-          operation = data[:operations][operation]
-          if operation
-            case operation["status"]
-            when Fog::Compute::Google::Operation::PENDING_STATE
-              operation["status"] = Fog::Compute::Google::Operation::RUNNING_STATE
-              operation["progress"] = 50
-            else
-              operation["status"] = Fog::Compute::Google::Operation::DONE_STATE
-              operation["progress"] = 100
-            end
-          else
-            operation = {
-              "error" => {
-                "errors" => [
-                  {
-                    "domain" => "global",
-                    "reason" => "notFound",
-                    "message" => "The resource 'projects/#{project}/zones/#{zone_name}/operations/#{operation}' was not found"
-                  }
-                ],
-                "code" => 404,
-                "message" => "The resource 'projects/#{project}/zones/#{zone_name}/operations/#{operation}' was not found"
-              }
-            }
-          end
-          build_excon_response(operation)
+        def get_zone_operation(_zone_name, _operation)
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
-        # https://developers.google.com/compute/docs/reference/latest/zoneOperations
-
+        # 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"
-
-          api_method = @compute.zone_operations.get
-          parameters = {
-            "project" => @project,
-            "zone" => zone_name,
-            "operation" => operation
-          }
-
-          request(api_method, parameters)
+          @compute.get_zone_operation(@project, zone_name, operation)
         end
       end
     end

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

@@ -8,16 +8,19 @@ module Fog
       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 = {})
-          api_method = @compute.addresses.insert
-          parameters = {
-            "project" => @project,
-            "region" => region_name
-          }
-          body_object = { "name" => address_name }
-          body_object["description"] = options[:description] if options[:description]
-
-          request(api_method, parameters, body_object)
+          address = ::Google::Apis::ComputeV1::Address.new(
+            :name => address_name,
+            :description => options[:description]
+          )
+          @compute.insert_address(@project, region_name, address)
         end
       end
     end

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

@@ -2,60 +2,18 @@ module Fog
   module Compute
     class Google
       class Mock
-        def insert_backend_service(backend_service_name, opts = {})
-          id = Fog::Mock.random_numbers(19).to_s
-          data[:backend_services][backend_service_name] = {
-            "kind" => "compute#backendService",
-            "id" => id,
-            "creationTimestamp" => Time.now.iso8601,
-            "name" => backend_service_name,
-            "description" => "",
-            "backends" => [
-              {
-                "description" => "",
-                "group" => 'https://www.googleapis.com/resourceviews/v1beta1/projects#{@project}/zones/us-central1-a/zoneViews/name',
-                "balancingMode" => "RATE",
-                "capacityScaler" => 1.1,
-                "maxRate" => 0.5
-              }],
-            "healthChecks" => [opts["health_check"]],
-            "timeoutSec" => 30,
-            "port" => 80,
-            "protocol" => "TCP",
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/backendServices/#{backend_service_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/backendServces/#{backend_service_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])
-         end
+        def insert_backend_service(_backend_service_name, _opts = {})
+          Fog::Mock.not_implemented
+        end
       end
 
       class Real
         def insert_backend_service(backend_service_name, opts = {})
-          api_method = @compute.backend_services.insert
-          parameters = {
-            "project" => @project
-          }
-          body_object = { "name" => backend_service_name }
-          body_object.merge!(opts)
+          options = opts.reject { |_k, v| v.nil? }
+                        .merge(:name => backend_service_name)
 
-          request(api_method, parameters, body_object = body_object)
+          be_service = ::Google::Apis::ComputeV1::BackendService.new(options)
+          @compute.insert_backend_service(@project, be_service)
         end
       end
     end

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

@@ -2,106 +2,35 @@ module Fog
   module Compute
     class Google
       class Mock
-        def insert_disk(disk_name, zone_name, image_name = nil, options = {})
-          # check that image and zone exist
-          image = nil
-          if image_name
-            image = images.get(image_name)
-            raise ArgumentError.new("Invalid image specified: #{image_name}") unless image
-          end
-          get_zone(zone_name)
-
-          id = Fog::Mock.random_numbers(19).to_s
-          object = {
-            "kind" => "compute#disk",
-            "id" => id,
-            "creationTimestamp" => Time.now.iso8601,
-            "zone" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}",
-            "status" => "READY",
-            "name" => disk_name,
-            "sizeGb" => options["sizeGb"] || "10",
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}/disks/#{disk_name}"
-          }
-          if image
-            object.merge("sourceImage" => image.self_link,
-                         "sourceImageId" => image.id)
-          end
-          data[:disks][disk_name] = object
-
-          if image
-            object.merge!("sourceImage" => image.self_link,
-                          "sourceImageId" => image.id)
-          end
-          if disk_type = options.delete(:type)
-            object["type"] = type
-          else
-            object["type"] = "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}/diskTypes/pd-standard"
-          end
-          data[:disks][disk_name] = object
-
-          operation = random_operation
-          data[:operations][operation] = {
-            "kind" => "compute#operation",
-            "id" => Fog::Mock.random_numbers(19).to_s,
-            "name" => operation,
-            "zone" => object["zone"],
-            "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['zone']}/operations/#{operation}"
-          }
-
-          build_excon_response(data[:operations][operation])
+        def insert_disk(_disk_name, _zone, _image_name = nil, _options = {})
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def insert_disk(disk_name, zone_name, image_name = nil, opts = {})
-          api_method = @compute.disks.insert
-          parameters = {
-            "project" => @project,
-            "zone" => zone_name
-          }
-
-          if image_name
-            # New disk from image
-            image = images.get(image_name)
-            raise ArgumentError.new("Invalid image specified: #{image_name}") unless image
-            @image_url = @api_url + image.resource_url
-            parameters["sourceImage"] = @image_url
-          end
-
-          body_object = { "name" => disk_name }
-          body_object["type"] = opts.delete("type")
-
-          # According to Google docs, if image name is not present, only one of
-          # sizeGb or sourceSnapshot need to be present, one will create blank
-          # disk of desired size, other will create disk from snapshot
-          if image_name.nil?
-            if opts.key?("sourceSnapshot")
-              # New disk from snapshot
-              snap = snapshots.get(opts.delete("sourceSnapshot"))
-              raise ArgumentError.new("Invalid source snapshot") unless snap
-              body_object["sourceSnapshot"] = @api_url + snap.resource_url
-            elsif opts.key?("sizeGb")
-              # New blank disk
-              body_object["sizeGb"] = opts.delete("sizeGb")
-            else
-              raise ArgumentError.new("Must specify image OR snapshot OR "\
-                                      "disk size when creating a disk.")
-            end
-
-          end
-
-          # Merge in any remaining options (only 'description' should remain)
-          body_object.merge!(opts)
-
-          request(api_method, parameters, body_object)
+        # 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 image_name [String] Optional image name to create the disk from
+        # @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
+        def insert_disk(disk_name, zone, image_name = nil,
+                        description: nil, type: nil, size_gb: nil,
+                        source_snapshot: nil, **_opts)
+          disk = ::Google::Apis::ComputeV1::Disk.new(
+            :name => disk_name,
+            :description => description,
+            :type => type,
+            :size_gb => size_gb,
+            :source_snapshot => source_snapshot
+          )
+          @compute.insert_disk(@project, zone.split("/")[-1], disk,
+                               :source_image => image_name)
         end
       end
     end

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

@@ -2,40 +2,60 @@ module Fog
   module Compute
     class Google
       class Mock
-        def insert_firewall(_firewall_name, _allowed, _network = GOOGLE_COMPUTE_DEFAULT_NETWORK, _options = {})
+        def insert_firewall(_firewall_name, _options = {})
           Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def insert_firewall(firewall_name, allowed, network = GOOGLE_COMPUTE_DEFAULT_NETWORK, options = {})
-          unless network.start_with? "http"
-            network = "#{@api_url}#{@project}/global/networks/#{network}"
-          end
+        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
 
-          api_method = @compute.firewalls.insert
-          parameters = {
-            "project" => @project
-          }
-          body_object = {
-            "name" => firewall_name,
-            "network" => network,
-            "allowed" => allowed
-          }
-          unless options[:description].nil?
-            body_object["description"] = options[:description]
-          end
-          unless options[:source_ranges].nil? || options[:source_ranges].empty?
-            body_object["sourceRanges"] = options[:source_ranges]
-          end
-          unless options[:source_tags].nil? || options[:source_tags].empty?
-            body_object["sourceTags"] = options[:source_tags]
-          end
-          unless options[:target_tags].nil? || options[:target_tags].empty?
-            body_object["targetTags"] = options[:target_tags]
+        ##
+        # 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
 
-          request(api_method, parameters, body_object)
+          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