fog-google 0.0.2

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

@@ -0,0 +1,23 @@
+require 'fog/core/collection'
+require 'fog/google/models/compute/global_forwarding_rule'
+
+module Fog
+  module Compute
+    class Google
+      class GlobalForwardingRules < Fog::Collection
+        model Fog::Compute::Google::GlobalForwardingRule
+
+        def all
+          data = service.list_global_forwarding_rules.body['items'] || []
+          load(data)
+        end
+
+        def get(identity, region='global')
+          response = service.get_global_forwarding_rule(identity, region)
+          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,84 @@
+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,
+          }
+
+          data = service.insert_http_health_check(name, options).body
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data['name'], data['zone'])
+          operation.wait_for { !pending? }
+          reload
+        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)
+          resonse = nil
+          response = service.get_http_health_check(identity)
+          return nil if response.nil?
+          new(response.body)
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Google
+      class Image < Fog::Model
+        identity :name
+
+        attribute :id
+        attribute :kind
+        attribute :archive_size_bytes, :aliases => 'archiveSizeBytes'
+        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :deprecated
+        attribute :description
+        attribute :disk_size_gb, :aliases => 'diskSizeGb'
+        attribute :self_link, :aliases => 'selfLink'
+        attribute :source_type, :aliases => 'sourceType'
+        attribute :status
+
+        # This attribute is not available in the representation of an
+        # 'image' returned by the GCE servser (see GCE API). However,
+        # images are a global resource and a user can query for images
+        # across projects. Therefore we try to remember which project
+        # the image belongs to by tracking it in this attribute.
+        attribute :project
+
+        # A RawDisk, e.g. -
+        # {
+        #   :source         => url_to_gcs_file,
+        #   :container_type => 'TAR',
+        #   :sha1Checksum   => ,
+        # }
+        attribute :raw_disk, :aliases => 'rawDisk'
+
+        def preferred_kernel=(args)
+          Fog::Logger.deprecation("preferred_kernel= is no longer used [light_black](#{caller.first})[/]")
+        end
+
+        def preferred_kernel
+          Fog::Logger.deprecation("preferred_kernel is no longer used [light_black](#{caller.first})[/]")
+          nil
+        end
+
+        READY_STATE = "READY"
+
+        def ready?
+          self.status == READY_STATE
+        end
+
+        def destroy(async=true)
+          data = service.delete_image(name)
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'])
+          unless async
+            operation.wait_for { ready? }
+          end
+          operation
+        end
+
+        def reload
+          requires :name
+
+          self.project = self.service.project
+          data = service.get_image(name, self.project).body
+
+          self.merge_attributes(data)
+          self
+        end
+
+        def save
+          requires :name
+          requires :raw_disk
+
+          options = {
+            'rawDisk'         => raw_disk,
+            'description'     => description,
+          }
+
+          data = service.insert_image(name, options)
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'])
+          operation.wait_for { !pending? }
+          reload
+        end
+
+        def resource_url
+          "#{self.project}/global/images/#{name}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+require 'fog/core/collection'
+require 'fog/google/models/compute/image'
+
+module Fog
+  module Compute
+    class Google
+      class Images < Fog::Collection
+        model Fog::Compute::Google::Image
+
+        # NOTE: Not everyone has access to these projects because of the
+        # licenses needed to use some of them.
+        # https://developers.google.com/compute/docs/premium-operating-systems
+        GLOBAL_PROJECTS = [
+          'centos-cloud',
+          'coreos-cloud',
+          'debian-cloud',
+          'google-containers',
+          'opensuse-cloud',
+          'rhel-cloud',
+          'suse-cloud',
+          'ubuntu-os-cloud'
+        ]
+
+        def all
+          data = []
+          all_projects = GLOBAL_PROJECTS + [ self.service.project ]
+
+          all_projects.each do |project|
+            begin
+              images = service.list_images(project).body["items"] || []
+
+              # Keep track of the project in which we found the image(s)
+              images.each { |img| img[:project] = project }
+              data += images
+            rescue Fog::Errors::NotFound
+              # Not everyone has access to every Global Project. Requests
+              # return 404 if you don't have access.
+              next
+            end
+          end
+
+          load(data)
+        end
+
+        def get(identity)
+          # Search own project before global projects
+          all_projects = [ self.service.project ] + GLOBAL_PROJECTS
+
+          data = nil
+          all_projects.each do |project|
+            begin
+              data = service.get_image(identity, project).body
+              data[:project] = project
+            rescue Fog::Errors::NotFound
+              next
+            else
+              break
+            end
+          end
+
+          # If it wasn't found in any project, raise
+          return nil if data.nil?
+
+          new(data)
+        
+        rescue Fog::Errors::NotFound.new(
+          "Unable to find the image #{identity} in the following projects: #{all_projects.join(', ')}")
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+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,25 @@
+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

@@ -0,0 +1,75 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Google
+      class Operation < Fog::Model
+        identity :name
+
+        attribute :kind
+        attribute :id
+        attribute :client_operation_id, :aliases => 'clientOperationId'
+        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        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
+        end
+
+        def pending?
+          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, region)
+          new_attributes = data.attributes
+          merge_attributes(new_attributes)
+          self
+        end
+
+        PENDING_STATE = "PENDING"
+        RUNNING_STATE = "RUNNING"
+        DONE_STATE = "DONE"
+      end
+    end
+  end
+end