fog 1.21.0 → 1.22.0

data/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

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

@@ -0,0 +1,85 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Google
+
+      class HttpHealthCheck < 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 :host, :aliases => 'host'
+        attribute :request_path, :aliases => 'requestPath'
+        attribute :port, :aliases => 'port'
+        attribute :check_interval_sec, :aliases => 'checkIntervalSec'
+        attribute :timeout_sec, :aliases => 'timeoutSec'
+        attribute :unhealthy_threshold, :aliases => 'unhealthyThreshold'
+        attribute :healthy_threshold, :aliases => 'healthyThreshold'
+
+        def save
+          requires :name
+
+          options = {
+            'description' => description,
+            'host' => host,
+            'requestPath' => request_path || "/",
+            'port' => port || 80,
+            'checkIntervalSec' => check_interval_sec || 5,
+            'timeoutSec' => timeout_sec || 5,
+            'unhealthyThreshold' => unhealthy_threshold || 2,
+            'healthyThreshold' => healthy_threshold || 2,
+          }
+
+          service.insert_http_health_check(name, options).body
+          data = service.backoff_if_unfound {service.get_http_health_check(name).body}
+          merge_attributes(data)
+        end
+
+        def destroy(async=true)
+          requires :name
+          operation = service.delete_http_health_check(name)
+
+          if not async
+            # wait until "DONE" to ensure the operation doesn't fail, raises
+            # exception on error
+            Fog.wait_for do
+              operation = service.get_global_operation(operation.body["name"])
+              operation.body["status"] == "DONE"
+            end
+          end
+          operation
+        end
+
+        def ready?
+          begin
+            service.get_http_health_check(self.name)
+            true
+          rescue Fog::Errors::NotFound
+            false
+          end
+        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"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'fog/core/collection'
+require 'fog/google/models/compute/http_health_check'
+
+module Fog
+  module Compute
+    class Google
+
+      class HttpHealthChecks < Fog::Collection
+
+        model Fog::Compute::Google::HttpHealthCheck
+
+        def all(filters={})
+          data = service.list_http_health_checks.body['items'] || []
+          load(data)
+        end
+
+        def get(identity)
+          response = service.get_http_health_check(identity)
+          new(response.body) unless response.nil?
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Google
+
+      ##
+      # Represents a Network resource
+      #
+      # @see https://developers.google.com/compute/docs/reference/latest/networks
+      class Network < Fog::Model
+        identity :name
+
+        attribute :kind
+        attribute :id
+        attribute :ipv4_range, :aliases => 'IPv4Range'
+        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :description
+        attribute :gateway_ipv4, :aliases => 'gatewayIPv4'
+        attribute :self_link, :aliases => 'selfLink'
+
+        def save
+          requires :identity, :ipv4_range
+
+          data = service.insert_network(identity, self.ipv4_range, self.attributes)
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'])
+          operation.wait_for { !pending? }
+          reload
+        end
+
+        def destroy(async=true)
+          requires :identity
+
+          data = service.delete_network(identity)
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'])
+          unless async
+            operation.wait_for { ready? }
+          end
+          operation
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/google/models/compute/network'
+
+module Fog
+  module Compute
+    class Google
+
+      class Networks < Fog::Collection
+        model Fog::Compute::Google::Network
+
+        def all
+          data = service.list_networks.body
+          load(data['items'] || [])
+        end
+
+        def get(identity)
+          if network = service.get_network(identity).body
+            new(network)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+
+    end
+  end
+end

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

@@ -8,12 +8,27 @@ module Fog
 
         identity :name
 
-        attribute :kind, :aliases => 'kind'
-        attribute :id, :aliases => 'id'
+        attribute :kind
+        attribute :id
+        attribute :client_operation_id, :aliases => 'clientOperationId'
         attribute :creation_timestamp, :aliases => 'creationTimestamp'
-        attribute :zone_name, :aliases => 'zone'
-        attribute :status, :aliases => 'status'
+        attribute :end_time, :aliases => 'endTime'
+        attribute :error
+        attribute :http_error_message, :aliases => 'httpErrorMessage'
+        attribute :http_error_status_code, :aliases => 'httpErrorStatusCode'
+        attribute :insert_time, :aliases => 'insertTime'
+        attribute :operation_type, :aliases => 'operationType'
+        attribute :progress
+        attribute :region
         attribute :self_link, :aliases => 'selfLink'
+        attribute :start_time, :aliases => 'startTime'
+        attribute :status
+        attribute :status_message, :aliases => 'statusMessage'
+        attribute :target_id, :aliases => 'targetId'
+        attribute :target_link, :aliases => 'targetLink'
+        attribute :user
+        attribute :warnings
+        attribute :zone
 
         def ready?
           self.status == DONE_STATE
@@ -23,10 +38,31 @@ module Fog
           self.status == PENDING_STATE
         end
 
+        def region_name
+          region.nil? ? nil : region.split('/')[-1]
+        end
+
+        def zone_name
+          zone.nil? ? nil : zone.split('/')[-1]
+        end
+
+        def destroy
+          requires :identity
+
+          if zone
+            service.delete_zone_operation(zone, identity)
+          elsif region
+            service.delete_region_operation(region, identity)
+          else
+            service.delete_global_operation(identity)
+          end
+          true
+        end
+
         def reload
           requires :identity
 
-          data = collection.get(identity, zone)
+          data = collection.get(identity, zone, region)
           new_attributes = data.attributes
           merge_attributes(new_attributes)
           self

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

@@ -9,14 +9,29 @@ module Fog
 
         model Fog::Compute::Google::Operation
 
-        def get(identity, zone=nil)
-          if zone.nil?
-            response = service.get_global_operation(identity)
+        def all(filters = {})
+          if filters['zone']
+            data = service.list_zone_operations(filters['zone']).body
+          elsif filters['region']
+            data = service.list_region_operations(filters['region']).body
           else
+            data = service.list_global_operations.body
+          end
+          load(data['items'] || [])
+        end
+
+        def get(identity, zone=nil, region=nil)
+          if not zone.nil?
             response = service.get_zone_operation(zone, identity)
+          elsif not region.nil?
+            response = service.get_region_operation(region, identity)
+          else
+            response = service.get_global_operation(identity)
           end
           return nil if response.nil?
           new(response.body)
+        rescue Fog::Errors::NotFound
+          nil
         end
 
       end

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

@@ -0,0 +1,32 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Google
+
+      ##
+      # Represents a Project resource
+      #
+      # @see https://developers.google.com/compute/docs/reference/latest/projects
+      class Project < Fog::Model
+        identity :name
+
+        attribute :kind
+        attribute :id
+        attribute :common_instance_metadata, :aliases => 'commonInstanceMetadata'
+        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :description
+        attribute :quotas
+        attribute :self_link, :aliases => 'selfLink'
+
+        def set_metadata(metadata = {})
+          requires :identity
+
+          data = service.set_common_instance_metadata(identity, self.common_instance_metadata['fingerprint'], metadata)
+          Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'])
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'fog/core/collection'
+require 'fog/google/models/compute/project'
+
+module Fog
+  module Compute
+    class Google
+
+      class Projects < Fog::Collection
+        model Fog::Compute::Google::Project
+
+        def get(identity)
+          if project = service.get_project(identity).body
+            new(project)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Google
+
+      ##
+      # Represents a Region resource
+      #
+      # @see https://developers.google.com/compute/docs/reference/latest/regions
+      class Region < Fog::Model
+        identity :name
+
+        attribute :kind
+        attribute :id
+        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :deprecated
+        attribute :description
+        attribute :quotas
+        attribute :self_link, :aliases => 'selfLink'
+        attribute :status
+        attribute :zones
+
+        DOWN_STATE = 'DOWN'
+        UP_STATE   = 'UP'
+
+        def up?
+          self.status == UP_STATE
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/google/models/compute/region'
+
+module Fog
+  module Compute
+    class Google
+
+      class Regions < Fog::Collection
+        model Fog::Compute::Google::Region
+
+        def all
+          data = service.list_regions.body
+          load(data['items'] || [])
+        end
+
+        def get(identity)
+          if region = service.get_region(identity).body
+            new(region)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+
+    end
+  end
+end