fog-google 0.2.0 → 0.3.0

data/lib/fog/google/requests/pubsub/create_topic.rb

@@ -0,0 +1,36 @@
+module Fog
+  module Google
+    class Pubsub
+      class Real
+        # Create a topic on the remote service.
+        #
+        # @param topic_name [#to_s] name of topic to create; note that it must
+        #   obey the naming rules for a topic (e.g.
+        #   'projects/myProject/topics/my_topic')
+        # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.topics/create
+        def create_topic(topic_name)
+          api_method = @pubsub.projects.topics.create
+          parameters = {
+            "name" => topic_name.to_s
+          }
+
+          request(api_method, parameters)
+        end
+      end
+
+      class Mock
+        def create_topic(topic_name)
+          data = {
+            "name" => topic_name
+          }
+          self.data[:topics][topic_name] = data
+
+          body = data.clone
+          status = 200
+
+          build_excon_response(body, status)
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/requests/pubsub/delete_subscription.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Google
+    class Pubsub
+      class Real
+        # Delete a subscription on the remote service.
+        #
+        # @param subscription_name [#to_s] name of subscription to delete
+        # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.subscriptions/delete
+        def delete_subscription(subscription_name)
+          api_method = @pubsub.projects.subscriptions.delete
+          parameters = {
+            "subscription" => subscription_name.to_s
+          }
+
+          request(api_method, parameters)
+        end
+      end
+
+      class Mock
+        def delete_subscription(subscription_name)
+          data[:subscriptions].delete(subscription_name)
+
+          build_excon_response(nil, 200)
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/requests/pubsub/delete_topic.rb

@@ -0,0 +1,29 @@
+module Fog
+  module Google
+    class Pubsub
+      class Real
+        # Delete a topic on the remote service.
+        #
+        # @param topic_name [#to_s] name of topic to delete
+        # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.topics/delete
+        def delete_topic(topic_name)
+          api_method = @pubsub.projects.topics.delete
+          parameters = {
+            "topic" => topic_name.to_s
+          }
+
+          request(api_method, parameters)
+        end
+      end
+
+      class Mock
+        def delete_topic(topic_name)
+          data[:topics].delete(topic_name)
+
+          status = 200
+          build_excon_response(nil, status)
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/requests/pubsub/get_subscription.rb

@@ -0,0 +1,44 @@
+module Fog
+  module Google
+    class Pubsub
+      class Real
+        # Retrieves a subscription by name from the remote service.
+        #
+        # @param subscription_name [#to_s] name of subscription to retrieve
+        # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.topics/get
+        def get_subscription(subscription_name)
+          api_method = @pubsub.projects.subscriptions.get
+          parameters = {
+            "subscription" => subscription_name.to_s
+          }
+
+          request(api_method, parameters)
+        end
+      end
+
+      class Mock
+        def get_subscription(subscription_name)
+          sub = data[:subscriptions][subscription_name]
+          if sub.nil?
+            subscription_resource = subscription_name.split("/")[-1]
+            body = {
+              "error" => {
+                "code"    => 404,
+                "message" => "Resource not found (resource=#{subscription_resource}).",
+                "status"  => "NOT_FOUND"
+              }
+            }
+            return build_excon_response(body, 404)
+          end
+
+          body = sub.select do |k, _|
+            %w(name topic pushConfig ackDeadlineSeconds).include?(k)
+          end
+          status = 200
+
+          build_excon_response(body, status)
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/requests/pubsub/get_topic.rb

@@ -0,0 +1,41 @@
+module Fog
+  module Google
+    class Pubsub
+      class Real
+        # Retrieves a resource describing a topic.
+        #
+        # @param topic_name [#to_s] name of topic to retrieve
+        # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.topics/get
+        def get_topic(topic_name)
+          api_method = @pubsub.projects.topics.get
+          parameters = {
+            "topic" => topic_name.to_s
+          }
+
+          request(api_method, parameters)
+        end
+      end
+
+      class Mock
+        def get_topic(topic_name)
+          if !data[:topics].key?(topic_name)
+            topic_resource = topic_name.split("/")[-1]
+            body = {
+              "error" => {
+                "code"    => 404,
+                "message" => "Resource not found (resource=#{topic_resource}).",
+                "status"  => "NOT_FOUND"
+              }
+            }
+            status = 404
+          else
+            body = data[:topics][topic_name].clone
+            status = 200
+          end
+
+          build_excon_response(body, status)
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/requests/pubsub/list_subscriptions.rb

@@ -0,0 +1,39 @@
+module Fog
+  module Google
+    class Pubsub
+      class Real
+        # Gets a list of all subscriptions for a given project.
+        #
+        # @param_name project [#to_s] Project path to list subscriptions under;
+        #   must be a project url prefix (e.g. 'projects/my-project'). If nil,
+        #   the project configured on the client is used.
+        # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.topics/list
+        def list_subscriptions(project = nil)
+          api_method = @pubsub.projects.subscriptions.list
+          parameters = {
+            "project" => (project.nil? ? "projects/#{@project}" : project.to_s)
+          }
+
+          request(api_method, parameters)
+        end
+      end
+
+      class Mock
+        def list_subscriptions(_project = nil)
+          subs = data[:subscriptions].values.map do |sub|
+            # Filter out any keys that aren't part of the response object
+            sub.select do |k, _|
+              %w(name topic pushConfig ackDeadlineSeconds).include?(k)
+            end
+          end
+
+          body = {
+            "subscriptions" => subs
+          }
+          status = 200
+          build_excon_response(body, status)
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/requests/pubsub/list_topics.rb

@@ -0,0 +1,33 @@
+module Fog
+  module Google
+    class Pubsub
+      class Real
+        # Gets a list of all topics for a given project.
+        #
+        # @param_name project [#to_s] Project path to list topics under; must
+        #   be a project url prefix (e.g. 'projects/my-project'). If nil, the
+        #   project configured on the client is used.
+        # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.topics/list
+        def list_topics(project = nil)
+          api_method = @pubsub.projects.topics.list
+          parameters = {
+            "project" => (project.nil? ? "projects/#{@project}" : project.to_s)
+          }
+
+          request(api_method, parameters)
+        end
+      end
+
+      class Mock
+        def list_topics(_project = nil)
+          body = {
+            "topics" => data[:topics].values
+          }
+          status = 200
+
+          build_excon_response(body, status)
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/requests/pubsub/publish_topic.rb

@@ -0,0 +1,61 @@
+module Fog
+  module Google
+    class Pubsub
+      class Real
+        # Publish a list of messages to a topic.
+        #
+        # @param messages [Array<Hash>] List of messages to be published to a
+        #   topic; each hash should have a value defined for 'data' or for
+        #   'attributes' (or both). Note that the value associated with 'data'
+        #   must be base64 encoded.
+        # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.topics/publish
+        def publish_topic(topic, messages)
+          api_method = @pubsub.projects.topics.publish
+
+          parameters = {
+            "topic" => topic
+          }
+
+          body = {
+            "messages" => messages
+          }
+
+          request(api_method, parameters, body)
+        end
+      end
+
+      class Mock
+        def publish_topic(topic, messages)
+          if data[:topics].key?(topic)
+            published_messages = messages.map do |msg|
+              msg.merge("messageId" => Fog::Mock.random_letters(16), "publishTime" => Time.now.iso8601)
+            end
+
+            # Gather the subscriptions and publish
+            data[:subscriptions].values.each do |sub|
+              next unless sub["topic"] == topic
+              sub[:messages] += published_messages
+            end
+
+            body = {
+              "messageIds" => published_messages.map { |msg| msg["messageId"] }
+            }
+            status = 200
+          else
+            topic_resource = topic_name.split("/")[-1]
+            body = {
+              "error" => {
+                "code"    => 404,
+                "message" => "Resource not found (resource=#{topic_resource}).",
+                "status"  => "NOT_FOUND"
+              }
+            }
+            status = 404
+          end
+
+          build_excon_response(body, status)
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/requests/pubsub/pull_subscription.rb

@@ -0,0 +1,77 @@
+module Fog
+  module Google
+    class Pubsub
+      class Real
+        # Pulls from a subscription. If option 'return_immediately' is
+        # false, then this method blocks until one or more messages is
+        # available or the remote server closes the connection.
+        #
+        # @param subscription [Subscription, #to_s] subscription instance or
+        #   name of subscription to pull from
+        # @param options [Hash] options to modify the pull request
+        # @option options [Boolean] :return_immediately if true, method returns
+        #   after API call; otherwise the connection is held open until
+        #   messages are available or the remote server closes the connection
+        #   (defaults to true)
+        # @option options [Number] :max_messages maximum number of messages to
+        #   retrieve (defaults to 10)
+        # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.subscriptions/pull
+        def pull_subscription(subscription, options = { :return_immediately => true, :max_messages => 10 })
+          api_method = @pubsub.projects.subscriptions.pull
+
+          parameters = {
+            "subscription" => Fog::Google::Pubsub.subscription_name(subscription)
+          }
+
+          body = {
+            "returnImmediately" => options[:return_immediately],
+            "maxMessages" => options[:max_messages]
+          }
+
+          request(api_method, parameters, body)
+        end
+      end
+
+      class Mock
+        def pull_subscription(subscription, options = { :return_immediately => true, :max_messages => 10 })
+          # We're going to ignore return_immediately; feel free to add support
+          # if you need it for testing
+          subscription_name = Fog::Google::Pubsub.subscription_name(subscription)
+          sub = data[:subscriptions][subscription_name]
+
+          if sub.nil?
+            subscription_resource = subscription_name.split("/")[-1]
+            body = {
+              "error" => {
+                "code"    => 404,
+                "message" => "Resource not found (resource=#{subscription_resource}).",
+                "status"  => "NOT_FOUND"
+              }
+            }
+            return build_excon_response(body, 404)
+          end
+
+          # This implementation is a bit weak; instead of "hiding" messages for
+          # some period of time after they are pulled, instead we always return
+          # them until acknowledged. This might cause issues with clients that
+          # refuse to acknowledge.
+          #
+          # Also, note that here we use the message id as the ack id - again,
+          # this might cause problems with some strange-behaving clients.
+          msgs = sub[:messages].take(options[:max_messages]).map do |msg|
+            {
+              "ackId"   => msg["messageId"],
+              "message" => msg
+            }
+          end
+
+          body = {
+            "receivedMessages" => msgs
+          }
+          status = 200
+          build_excon_response(body, status)
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/shared.rb

@@ -0,0 +1,191 @@
+module Fog
+  module Google
+    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]
+          google_key =
+            if options[:google_key_location]
+              File.expand_path(options[:google_key_location])
+            else
+              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
+end