fog-google 0.2.0 → 0.3.0

data/lib/fog/compute/google/real.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class Google
+      class Real
+        include Fog::Google::Shared
+
+        attr_accessor :client
+        attr_reader :compute, :extra_global_projects
+
+        def initialize(options)
+          shared_initialize(options[:google_project], GOOGLE_COMPUTE_API_VERSION, GOOGLE_COMPUTE_BASE_URL)
+          options[:google_api_scope_url] = GOOGLE_COMPUTE_API_SCOPE_URLS.join(" ")
+
+          @client = initialize_google_client(options)
+          @compute = @client.discovered_api("compute", api_version)
+          @resourceviews = @client.discovered_api("resourceviews", "v1beta1")
+          @extra_global_projects = options[:google_extra_global_projects] || []
+        end
+      end
+    end
+  end
+end

data/lib/fog/dns/google.rb

@@ -1,6 +1,9 @@
 module Fog
   module DNS
     class Google < Fog::Service
+      autoload :Mock, File.expand_path("../google/mock", __FILE__)
+      autoload :Real, File.expand_path("../google/real", __FILE__)
+
       requires :google_project
       recognizes :app_name, :app_version, :google_client_email, :google_key_location, :google_key_string,
                  :google_client, :google_json_key_location, :google_json_key_string
@@ -49,48 +52,6 @@ module Fog
 
       # Project
       request :get_project
-
-      class Mock
-        include Fog::Google::Shared
-
-        def initialize(options)
-          shared_initialize(options[:google_project], GOOGLE_DNS_API_VERSION, GOOGLE_DNS_BASE_URL)
-        end
-
-        def self.data(_api_version)
-          @data ||= {}
-        end
-
-        def self.reset
-          @data = nil
-        end
-
-        def data(project = @project)
-          self.class.data(api_version)[project] ||= {
-            :managed_zones => {},
-            :resource_record_sets => {},
-            :changes => {}
-          }
-        end
-
-        def reset_data
-          self.class.data(api_version).delete(@project)
-        end
-      end
-
-      class Real
-        include Fog::Google::Shared
-
-        attr_accessor :client
-        attr_reader :dns
-
-        def initialize(options)
-          shared_initialize(options[:google_project], GOOGLE_DNS_API_VERSION, GOOGLE_DNS_BASE_URL)
-          options.merge!(:google_api_scope_url => GOOGLE_DNS_API_SCOPE_URLS.join(" "))
-          @client = initialize_google_client(options)
-          @dns = @client.discovered_api("dns", api_version)
-        end
-      end
     end
   end
 end

data/lib/fog/dns/google/mock.rb

@@ -0,0 +1,33 @@
+module Fog
+  module DNS
+    class Google
+      class Mock
+        include Fog::Google::Shared
+
+        def initialize(options)
+          shared_initialize(options[:google_project], GOOGLE_DNS_API_VERSION, GOOGLE_DNS_BASE_URL)
+        end
+
+        def self.data(_api_version)
+          @data ||= {}
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def data(project = @project)
+          self.class.data(api_version)[project] ||= {
+            :managed_zones => {},
+            :resource_record_sets => {},
+            :changes => {}
+          }
+        end
+
+        def reset_data
+          self.class.data(api_version).delete(@project)
+        end
+      end
+    end
+  end
+end

data/lib/fog/dns/google/real.rb

@@ -0,0 +1,19 @@
+module Fog
+  module DNS
+    class Google
+      class Real
+        include Fog::Google::Shared
+
+        attr_accessor :client
+        attr_reader :dns
+
+        def initialize(options)
+          shared_initialize(options[:google_project], GOOGLE_DNS_API_VERSION, GOOGLE_DNS_BASE_URL)
+          options[:google_api_scope_url] = GOOGLE_DNS_API_SCOPE_URLS.join(" ")
+          @client = initialize_google_client(options)
+          @dns = @client.discovered_api("dns", api_version)
+        end
+      end
+    end
+  end
+end

data/lib/fog/google.rb

@@ -4,15 +4,27 @@ require "fog/xml"
 require "fog/google/version"
 
 module Fog
+  module Compute
+    autoload :Google, File.expand_path("../compute/google", __FILE__)
+  end
+
+  module DNS
+    autoload :Google, File.expand_path("../dns/google", __FILE__)
+  end
+
   module Google
-    autoload :Monitoring, "fog/google/monitoring"
-    autoload :SQL, "fog/google/sql"
+    autoload :Mock, File.expand_path("../google/mock", __FILE__)
+    autoload :Monitoring, File.expand_path("../google/monitoring", __FILE__)
+    autoload :Pubsub, File.expand_path("../google/pubsub", __FILE__)
+    autoload :Shared, File.expand_path("../google/shared", __FILE__)
+    autoload :SQL, File.expand_path("../google/sql", __FILE__)
 
     extend Fog::Provider
 
     service(:compute, "Compute")
     service(:dns, "DNS")
     service(:monitoring, "Monitoring")
+    service(:pubsub, "Pubsub")
     service(:storage, "Storage")
     service(:sql, "SQL")
 
@@ -25,212 +37,6 @@ module Fog
         "%" + Regexp.last_match(1).unpack("H2" * Regexp.last_match(1).bytesize).join("%").upcase
       end
     end
-
-    class Mock
-      def self.etag
-        hex(32)
-      end
-
-      def self.hex(length)
-        max = ("f" * length).to_i(16)
-        rand(max).to_s(16)
-      end
-    end
-
-    module Shared
-      attr_reader :project, :api_version, :api_url
-
-      ##
-      # Initializes shared attributes
-      #
-      # @param [String] project Google Cloud Project
-      # @param [String] api_version Google API version
-      # @param [String] base_url Google API base url
-      # @return [void]
-      def shared_initialize(project, api_version, base_url)
-        @project = project
-        @api_version = api_version
-        @api_url = base_url + api_version + "/projects/"
-      end
-
-      ##
-      # Initializes the Google API Client
-      #
-      # @param [Hash] options Google API options
-      # @option options [String] :google_client_email A @developer.gserviceaccount.com email address to use
-      # @option options [String] :google_key_location The location of a pkcs12 key file
-      # @option options [String] :google_key_string The content of the pkcs12 key file
-      # @option options [String] :google_json_key_location The location of a JSON key file
-      # @option options [String] :google_json_key_string The content of the JSON key file
-      # @option options [String] :google_api_scope_url The access scope URLs
-      # @option options [String] :app_name The app name to set in the user agent
-      # @option options [String] :app_version The app version to set in the user agent
-      # @option options [Google::APIClient] :google_client Existing Google API Client
-      # @return [Google::APIClient] Google API Client
-      # @raises [ArgumentError] If there is any missing argument
-      def initialize_google_client(options)
-        # NOTE: loaded here to avoid requiring this as a core Fog dependency
-        begin
-          require "google/api_client"
-        rescue LoadError => error
-          Fog::Logger.warning("Please install the google-api-client gem before using this provider")
-          raise error
-        end
-
-        # User can provide an existing Google API Client
-        client = options[:google_client]
-        return client unless client.nil?
-
-        # Create a signing key
-        signing_key = create_signing_key(options)
-
-        # Validate required arguments
-        unless options[:google_client_email]
-          raise ArgumentError.new("Missing required arguments: google_client_email")
-        end
-
-        unless options[:google_api_scope_url]
-          raise ArgumentError.new("Missing required arguments: google_api_scope_url")
-        end
-
-        # Create a new Google API Client
-        new_pk12_google_client(
-          options[:google_client_email],
-          signing_key,
-          options[:google_api_scope_url],
-          options[:app_name],
-          options[:app_version]
-        )
-      end
-
-      ##
-      # Creates a Google signing key
-      #
-      def create_signing_key(options)
-        if options[:google_json_key_location] || options[:google_json_key_string]
-          if options[:google_json_key_location]
-            json_key_location = File.expand_path(options[:google_json_key_location])
-            json_key = File.open(json_key_location, "r", &:read)
-          else
-            json_key = options[:google_json_key_string]
-          end
-
-          json_key_hash = Fog::JSON.decode(json_key)
-          unless json_key_hash.key?("client_email") || json_key_hash.key?("private_key")
-            raise ArgumentError.new("Invalid Google JSON key")
-          end
-
-          options[:google_client_email] = json_key_hash["client_email"]
-          ::Google::APIClient::KeyUtils.load_from_pem(json_key_hash["private_key"], "notasecret")
-        elsif options[:google_key_location] || options[:google_key_string]
-          if options[:google_key_location]
-            google_key = File.expand_path(options[:google_key_location])
-          else
-            google_key = options[:google_key_string]
-          end
-
-          ::Google::APIClient::KeyUtils.load_from_pkcs12(google_key, "notasecret")
-        else
-          raise ArgumentError.new("Missing required arguments: google_key_location, google_key_string, " \
-                                  "google_json_key_location or google_json_key_string")
-        end
-      end
-
-      ##
-      # Create a Google API Client with a user email and a pkcs12 key
-      #
-      # @param [String] google_client_email A @developer.gserviceaccount.com email address to use
-      # @param [OpenSSL::PKey] signing_key The private key for signing
-      # @param [String] google_api_scope_url Access scope URLs
-      # @param [String] app_name The app name to set in the user agent
-      # @param [String] app_version The app version to set in the user agent
-      # @return [Google::APIClient] Google API Client
-      def new_pk12_google_client(google_client_email, signing_key, google_api_scope_url, app_name = nil, app_version = nil)
-        application_name = app_name.nil? ? "fog" : "#{app_name}/#{app_version || '0.0.0'} fog"
-        api_client_options = {
-          :application_name => application_name,
-          :application_version => Fog::Google::VERSION
-        }
-        client = ::Google::APIClient.new(api_client_options)
-
-        client.authorization = Signet::OAuth2::Client.new(
-          :audience => "https://accounts.google.com/o/oauth2/token",
-          :auth_provider_x509_cert_url => "https://www.googleapis.com/oauth2/v1/certs",
-          :client_x509_cert_url => "https://www.googleapis.com/robot/v1/metadata/x509/#{google_client_email}",
-          :issuer => google_client_email,
-          :scope => google_api_scope_url,
-          :signing_key => signing_key,
-          :token_credential_uri => "https://accounts.google.com/o/oauth2/token"
-        )
-        client.authorization.fetch_access_token!
-
-        client
-      end
-
-      ##
-      # Executes a request and wraps it in a result object
-      #
-      # @param [Google::APIClient::Method] api_method The method object or the RPC name of the method being executed
-      # @param [Hash] parameters The parameters to send to the method
-      # @param [Hash] body_object The body object of the request
-      # @return [Excon::Response] The result from the API
-      def request(api_method, parameters, body_object = nil, media = nil)
-        client_parms = {
-          :api_method => api_method,
-          :parameters => parameters
-        }
-        # The Google API complains when given null values for enums, so just don't pass it any null fields
-        # XXX It may still balk if we have a nested object, e.g.:
-        #   {:a_field => "string", :a_nested_field => { :an_empty_nested_field => nil } }
-        client_parms[:body_object] = body_object.reject { |_k, v| v.nil? } if body_object
-        client_parms[:media] = media if media
-
-        result = @client.execute(client_parms)
-
-        build_excon_response(result.body.nil? || result.body.empty? ? nil : Fog::JSON.decode(result.body), result.status)
-      end
-
-      ##
-      # Builds an Excon response
-      #
-      # @param [Hash] Response body
-      # @param [Integer] Response status
-      # @return [Excon::Response] Excon response
-      def build_excon_response(body, status = 200)
-        response = Excon::Response.new(:body => body, :status => status)
-        if body && body.key?("error")
-          msg = "Google Cloud did not return an error message"
-
-          if body["error"].is_a?(Hash)
-            response.status = body["error"]["code"]
-            if body["error"].key?("errors")
-              msg = body["error"]["errors"].map { |error| error["message"] }.join(", ")
-            elsif body["error"].key?("message")
-              msg = body["error"]["message"]
-            end
-          elsif body["error"].is_a?(Array)
-            msg = body["error"].map { |error| error["code"] }.join(", ")
-          end
-
-          case response.status
-          when 404
-            raise Fog::Errors::NotFound.new(msg)
-          else
-            raise Fog::Errors::Error.new(msg)
-          end
-        end
-
-        response
-      end
-    end
-  end
-
-  module Compute
-    autoload :Google, File.expand_path("../compute/google", __FILE__)
-  end
-
-  module DNS
-    autoload :Google, File.expand_path("../dns/google", __FILE__)
   end
 
   module Parsers

data/lib/fog/google/mock.rb

@@ -0,0 +1,14 @@
+module Fog
+  module Google
+    class Mock
+      def self.etag
+        hex(32)
+      end
+
+      def self.hex(length)
+        max = ("f" * length).to_i(16)
+        rand(max).to_s(16)
+      end
+    end
+  end
+end

data/lib/fog/google/models/pubsub/received_message.rb

@@ -0,0 +1,40 @@
+require "fog/core/model"
+
+module Fog
+  module Google
+    class Pubsub
+      # Represents a ReceivedMessage retrieved from a Google Pubsub
+      # subscription. Note that ReceivedMessages are immutable.
+      #
+      # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.subscriptions/pull#ReceivedMessage
+      class ReceivedMessage < Fog::Model
+        identity :ack_id, :aliases => "ackId"
+
+        attribute :message
+
+        def initialize(new_attributes = {})
+          # Here we secretly store the subscription name we were received on
+          # in order to support #acknowledge
+          attributes = new_attributes.clone
+          @subscription_name = attributes.delete(:subscription_name)
+          super(attributes)
+        end
+
+        # Acknowledges a message.
+        #
+        # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.subscriptions/acknowledge
+        def acknowledge
+          requires :ack_id
+
+          service.acknowledge_subscription(@subscription_name, [ack_id])
+          nil
+        end
+
+        def reload
+          # Message is immutable - do nothing
+          Fog::Logger.warning("#reload called on immutable ReceivedMessage")
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/models/pubsub/subscription.rb

@@ -0,0 +1,86 @@
+module Fog
+  module Google
+    class Pubsub
+      # Represents a Pubsub subscription resource
+      #
+      # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.subscriptions
+      class Subscription < Fog::Model
+        identity :name
+        attribute :topic
+        attribute :push_config, :aliases => "pushConfig"
+        attribute :ack_deadline_seconds, :aliases => "ackDeadlineSeconds"
+
+        # Pulls from this subscription, returning any available messages. By
+        # default, this method returns immediately with up to 10 messages. The
+        # option 'return_immediately' allows the method to block until a
+        # message is received, or the remote service closes the connection.
+        #
+        # Note that this method automatically performs a base64 decode on the
+        # 'data' field.
+        #
+        # @param options [Hash] options to modify the pull request
+        # @option options [Boolean] :return_immediately If true, method returns
+        #   after checking for messages. Otherwise the method blocks until one
+        #   or more messages are available, or the connection is closed.
+        # @option options [Number] :max_messages maximum number of messages to
+        #   receive
+        # @return [Array<Fog::Google::Pubsub::ReceivedMessage>] list of
+        #   received messages, or an empty list if no messages are available.
+        # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.subscriptions/pull
+        def pull(options = { :return_immediately => true, :max_messages => 10 })
+          requires :name
+
+          data = service.pull_subscription(name, options).body
+
+          return [] unless data.key?("receivedMessages")
+          # Turn into a list of ReceivedMessage, but ensure we perform a base64 decode first
+          data["receivedMessages"].map do |recv_message|
+            attrs = {
+              :service => service,
+              :subscription_name => name
+            }.merge(recv_message)
+
+            attrs["message"]["data"] = Base64.decode64(recv_message["message"]["data"]) if recv_message["message"].key?("data")
+            ReceivedMessage.new(attrs)
+          end
+        end
+
+        # Acknowledges a list of received messages for this subscription.
+        #
+        # @param messages [Array<Fog::Google::Pubsub::ReceivedMessage, #to_s>]
+        #   A list containing either ReceivedMessage instances to acknowledge,
+        #   or a list of ackIds (@see
+        #   https://cloud.google.com/pubsub/reference/rest/v1/projects.subscriptions/pull#ReceivedMessage).
+        # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.subscriptions/acknowledge
+        def acknowledge(messages)
+          return if messages.empty?
+
+          ack_ids = messages.map { |m| m.is_a?(ReceivedMessage) ? m.ack_id : m.to_s }
+
+          service.acknowledge_subscription(name, ack_ids)
+          nil
+        end
+
+        # Save this instance on the remove service.
+        #
+        # @return [Fog::Google::Pubsub::Subscription] this instance
+        # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.subscriptions/create
+        def save
+          requires :name, :topic
+
+          data = service.create_subscription(name, topic, push_config, ack_deadline_seconds).body
+          merge_attributes(data)
+        end
+
+        # Deletes this subscription on the remote service.
+        #
+        # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.subscriptions/delete
+        def destroy
+          requires :name
+
+          service.delete_subscription(name)
+        end
+      end
+    end
+  end
+end