Adds forwarding rules. It is possible to set up a load balancer.

lib/fog/google/compute.rb

@@ -25,6 +25,7 @@ module Fog
       request :list_snapshots
       request :list_http_health_checks
       request :list_target_pools
+      request :list_forwarding_rules
 
       request :get_server
       request :get_address
@@ -40,6 +41,7 @@ module Fog
       request :get_zone_operation
       request :get_http_health_check
       request :get_target_pool
+      request :get_forwarding_rule
 
       request :delete_address
       request :delete_disk
@@ -53,6 +55,7 @@ module Fog
       request :delete_zone_operation
       request :delete_http_health_check
       request :delete_target_pool
+      request :delete_forwarding_rule
 
       request :insert_address
       request :insert_disk
@@ -63,6 +66,7 @@ module Fog
       request :insert_snapshot
       request :insert_http_health_check
       request :insert_target_pool
+      request :insert_forwarding_rule
 
       request :set_metadata
       request :set_tags
@@ -95,6 +99,9 @@ module Fog
       model :target_pool
       collection :target_pools
 
+      model :forwarding_rule
+      collection :forwarding_rules
+
       module Shared
         attr_reader :project, :api_version
 

lib/fog/google/models/compute/forwarding_rule.rb

@@ -0,0 +1,68 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Google
+
+      class ForwardingRule < Fog::Model
+
+        identity :name
+
+        attribute :kind, :aliases => 'kind'
+        attribute :self_link, :aliases => 'selfLink'
+        attribute :id, :aliases => 'id'
+        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :description, :aliases => 'description'
+        attribute :region, :aliases => 'region'
+        attribute :ip_address, :aliases => 'IPAddress'
+        attribute :ip_protocol, :aliases => 'IPProtocol'
+        attribute :port_range, :aliases => 'portRange'
+        attribute :target, :aliases => 'target'
+
+        def save
+          requires :name, :region, :port_range, :target
+
+          options = {
+            'description' => description,
+            'region' => region,
+            'IPAddress' => ip_address,
+            'IPProtocol' => ip_protocol,
+            'portRange' => port_range,
+            'target' => target
+          }
+
+          service.insert_forwarding_rule(name, region, options).body
+          data = service.backoff_if_unfound {service.get_forwarding_rule(name, region).body}
+          service.forwarding_rules.merge_attributes(data)
+        end
+
+        def destroy
+          requires :name, :region
+          operation = service.delete_forwarding_rule(name, region)
+          # wait until "RUNNING" or "DONE" to ensure the operation doesn't fail, raises exception on error
+          Fog.wait_for do
+            operation = service.get_region_operation(region, operation.body["name"])
+            operation.body["status"] != "PENDING"
+          end
+          operation
+        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"
+      end
+    end
+  end
+end

lib/fog/google/models/compute/forwarding_rules.rb

@@ -0,0 +1,45 @@
+require 'fog/core/collection'
+require 'fog/google/models/compute/forwarding_rule'
+
+module Fog
+  module Compute
+    class Google
+
+      class ForwardingRules < Fog::Collection
+
+        model Fog::Compute::Google::ForwardingRule
+
+        def all(filters={})
+          if filters['region'].nil?
+            data = []
+            service.list_regions.body['items'].each do |region|
+              data += service.list_forwarding_rules(region['name']).body['items'] || []
+            end
+          else
+            data = service.list_forwarding_rules(filters['region']).body['items'] || []
+          end
+          load(data)
+        end
+
+        def get(identity, region=nil)
+          response = nil
+          if region.nil?
+            service.list_regions.body['items'].each do |region|
+              begin
+                response = service.get_forwarding_rule(identity, region['name'])
+                break if response.status == 200
+              rescue Fog::Errors::Error
+              end
+            end
+          else
+            response = service.get_forwarding_rule(identity, region)
+          end
+          return nil if response.nil?
+          new(response.body)
+        end
+
+      end
+
+    end
+  end
+end

lib/fog/google/models/compute/http_health_check.rb

@@ -56,7 +56,7 @@ module Fog
           requires :zone_name
 
           return unless data = begin
-            collection.get(identity, zone_name)
+            collection.get(identity)
           rescue Excon::Errors::SocketError
             nil
           end

lib/fog/google/requests/compute/delete_forwarding_rule.rb

@@ -0,0 +1,36 @@
+module Fog
+  module Compute
+    class Google
+
+      class Mock
+
+        def delete_forwarding_rule(forwarding_rule_name, region_name)
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+      class Real
+        # https://developers.google.com/compute/docs/reference/latest/regionOperations
+
+        def delete_forwarding_rule(forwarding_rule_name, region_name)
+          if region_name.start_with? 'http'
+            region_name = region_name.split('/')[-1]
+          end
+
+          api_method = @compute.forwarding_rules.delete
+          parameters = {
+            'project' => @project,
+            'forwardingRule' => forwarding_rule_name,
+            'region' => region_name
+          }
+
+          result = self.build_result(api_method, parameters)
+          response = self.build_response(result)
+        end
+
+      end
+
+    end
+  end
+end

lib/fog/google/requests/compute/delete_target_pool.rb

@@ -24,7 +24,6 @@ module Fog
             'targetPool' => target_pool_name,
             'region' => region_name
           }
-          puts "Deleting target pool: #{parameters}"
 
           result = self.build_result(api_method, parameters)
           response = self.build_response(result)

lib/fog/google/requests/compute/get_forwarding_rule.rb

@@ -0,0 +1,33 @@
+module Fog
+  module Compute
+    class Google
+
+      class Mock
+        def get_forwarding_rule(forwarding_rule_name, region_name)
+          Fog::Mock.not_implemented
+        end
+      end
+
+      class Real
+
+        def get_forwarding_rule(forwarding_rule_name, region_name)
+          if region_name.start_with? 'http'
+            region_name = region_name.split('/')[-1]
+          end
+
+          api_method = @compute.forwarding_rules.get
+          parameters = {
+            'project' => @project,
+            'forwardingRule' => forwarding_rule_name,
+            'region' => region_name
+          }
+
+          result = self.build_result(api_method, parameters)
+          response = self.build_response(result)
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Fog
+  module Compute
+    class Google
+
+      class Mock
+
+        def insert_forwarding_rule(forwarding_rule_name, region_name)
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+      class Real
+
+        def insert_forwarding_rule(forwarding_rule_name, region_name, opts = {})
+          api_method = @compute.forwarding_rules.insert
+          parameters = {
+            'project' => @project,
+            'region' => region_name
+          }
+          body_object = { 'name' => forwarding_rule_name }
+          body_object.merge!(opts)
+
+          result = self.build_result(api_method, parameters,
+                                     body_object=body_object)
+          response = self.build_response(result)
+        end
+      end
+    end
+  end
+end

lib/fog/google/requests/compute/list_forwarding_rules.rb

@@ -0,0 +1,36 @@
+module Fog
+  module Compute
+    class Google
+
+      class Mock
+
+        def list_forwarding_rules(region_name)
+          forwarding_rules = self.data[:forwarding_rules].values.select{|d| d["region"].split("/")[-1] == region_name}
+          build_response(:body => {
+            "kind" => "compute#forwardingRuleList",
+            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/regions/#{region_name}/forwardingRules",
+            "id" => "projects/#{@project}/regions/#{region_name}/regions",
+            "items" => forwarding_rules
+          })
+        end
+
+      end
+
+      class Real
+
+        def list_forwarding_rules(region_name)
+          api_method = @compute.forwarding_rules.list
+          parameters = {
+            'project' => @project,
+            'region' => region_name
+          }
+
+          result = self.build_result(api_method, parameters)
+          response = self.build_response(result)
+        end
+
+      end
+
+    end
+  end
+end