parse-ruby-client 0.2.0 → 0.3.0

data/lib/faraday/better_retry.rb

@@ -0,0 +1,94 @@
+# -*- encoding : utf-8 -*-
+require 'ostruct'
+module Faraday
+  # Catches exceptions and retries each request a limited number of times.
+  #
+  # By default, it retries 2 times and handles only timeout exceptions. It can
+  # be configured with an arbitrary number of retries, a list of exceptions to
+  # handle an a retry interval.
+  #
+  # Examples
+  #
+  #   Faraday.new do |conn|
+  #     conn.request :retry, max: 2, interval: 0.05,
+  #                          exceptions: [CustomException, 'Timeout::Error']
+  #     conn.adapter ...
+  #   end
+  class BetterRetry < Faraday::Middleware
+    class Options < OpenStruct
+
+      def max
+        (self[:max] ||= 2).to_i
+      end
+
+      def interval
+        (self[:interval] ||= 0).to_f
+      end
+
+      def exceptions
+        Array(self[:exceptions] ||= [Errno::ETIMEDOUT, 'Timeout::Error', Error::TimeoutError])
+      end
+
+      # define for ruby less than 2.0
+      def [](name)
+        @table[name.to_sym]
+      end
+
+      def []=(name, value)
+        modifiable[new_ostruct_member(name)] = value
+      end
+
+    end
+
+    # Public: Initialize middleware
+    #
+    # Options:
+    # max        - Maximum number of retries (default: 2).
+    # interval   - Pause in seconds between retries (default: 0).
+    # exceptions - The list of exceptions to handle. Exceptions can be
+    #              given as Class, Module, or String. (default:
+    #              [Errno::ETIMEDOUT, Timeout::Error, Error::TimeoutError])
+    def initialize(app, options = {})
+      super(app)
+      @options = Options.new(options)
+      @errmatch = build_exception_matcher(@options.exceptions)
+      @logger = options[:logger]
+    end
+
+    def call(env)
+      env[:retries] = retries = @options.max
+      begin
+        @app.call(env)
+      rescue @errmatch => e
+        if retries > 0
+          if @logger
+            @logger.warn("Retrying Parse Error #{e.inspect} on request #{env[:url].to_s} #{env[:body].inspect} response #{env[:response].inspect}")
+          end
+          retries -= 1
+          env[:retries] = retries
+          sleep @options.interval if @options.interval > 0
+          retry
+        end
+        raise
+      end
+    end
+
+    # Private: construct an exception matcher object.
+    #
+    # An exception matcher for the rescue clause can usually be any object that
+    # responds to `===`, but for Ruby 1.8 it has to be a Class or Module.
+    def build_exception_matcher(exceptions)
+      matcher = Module.new
+      (class << matcher; self; end).class_eval do
+        define_method(:===) do |error|
+          exceptions.any? do |ex|
+            if ex.is_a? Module then error.is_a? ex
+            else error.class.to_s == ex.to_s
+            end
+          end
+        end
+      end
+      matcher
+    end
+  end
+end

data/lib/faraday/extended_parse_json.rb

@@ -0,0 +1,39 @@
+# -*- encoding : utf-8 -*-
+module Faraday
+
+  class ExtendedParseJson < FaradayMiddleware::ParseJson
+
+    def process_response(env)
+      env[:raw_body] = env[:body] if preserve_raw?(env)
+
+
+      if env[:status] >= 400
+        data = parse(env[:body]) || {} rescue {}
+
+        array_codes = [
+          Parse::Protocol::ERROR_INTERNAL,
+          Parse::Protocol::ERROR_TIMEOUT,
+          Parse::Protocol::ERROR_EXCEEDED_BURST_LIMIT
+        ]
+        error_hash = { "error" => "HTTP Status #{env[:status]} Body #{env[:body]}" }.merge(data)
+        if data['code'] && array_codes.include?(data['code'])
+          sleep 60 if data['code'] == Parse::Protocol::ERROR_EXCEEDED_BURST_LIMIT
+          raise exception(env).new(error_hash.merge(data))
+        elsif env[:status] >= 500
+          raise exception(env).new(error_hash.merge(data))
+        end
+        raise Parse::ParseProtocolError.new(error_hash)
+      else
+        data = parse(env[:body]) || {}
+
+        env[:body] = data
+      end
+    end
+
+    def exception env
+      # decide to retry or not
+      (env[:retries].to_i.zero? ? Parse::ParseProtocolError : Parse::ParseProtocolRetry)
+    end
+
+  end
+end

data/lib/faraday/get_method_override.rb

@@ -0,0 +1,32 @@
+# -*- encoding : utf-8 -*-
+
+require 'faraday'
+
+module Faraday
+  # Public: Writes the original HTTP method to "X-Http-Method-Override" header
+  # and sends the request as POST for GET requests that are too long.
+  class GetMethodOverride < Faraday::Middleware
+
+    HEADER = "X-Http-Method-Override".freeze
+
+    # Public: Initialize the middleware.
+    #
+    # app     - the Faraday app to wrap
+    def initialize(app, options = nil)
+      super(app)
+    end
+
+    def call(env)
+      if env[:method] == :get && env[:url].to_s.size > 2000
+        env[:request_headers][HEADER] = 'GET'
+        env[:request_headers]['Content-Type'] =
+          'application/x-www-form-urlencoded'
+        env[:body] = env[:url].query
+        env[:url].query = nil
+        env[:method] = :post
+      end
+
+      @app.call(env)
+    end
+  end
+end

data/lib/parse-ruby-client.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 ## ----------------------------------------------------------------------
 ##
 ## Ruby client for parse.com
@@ -5,18 +6,16 @@
 ## See https://parse.com/docs/rest for full documentation on the API.
 ##
 ## ----------------------------------------------------------------------
-require "rubygems"
-require "bundler/setup"
+require 'rubygems'
+require 'bundler/setup'
 
-require 'json'
+require 'faraday'
+require 'faraday_middleware'
+require 'faraday/better_retry'
+require 'faraday/extended_parse_json'
+require 'faraday/get_method_override'
 require 'date'
 require 'cgi'
-if defined?(JRUBY_VERSION)
-  require 'net/http'
-  require 'net/https'
-else
-  require 'patron' 
-end
 
 cwd = Pathname(__FILE__).dirname
 $:.unshift(cwd.to_s) unless $:.include?(cwd.to_s) || $:.include?(cwd.expand_path.to_s)
@@ -27,6 +26,7 @@ require 'parse/datatypes'
 require 'parse/util'
 require 'parse/protocol'
 require 'parse/user'
+require "parse/installation"
 require 'parse/push'
 require 'parse/cloud'
 require 'parse/model'

data/lib/parse/batch.rb

@@ -1,5 +1,4 @@
-require 'json'
-
+# -*- encoding : utf-8 -*-
 module Parse
   class Batch
     attr_reader :requests
@@ -51,4 +50,4 @@ module Parse
 
   end
 
-end
+end

data/lib/parse/client.rb

@@ -1,12 +1,9 @@
+# -*- encoding : utf-8 -*-
 require 'parse/protocol'
 require 'parse/error'
 require 'parse/util'
-require 'parse/http_client'
 
 require 'logger'
-
-require 'iron_mq'
-
 module Parse
 
   # A class which encapsulates the HTTPS communication with the Parse
@@ -21,7 +18,7 @@ module Parse
     attr_accessor :max_retries
     attr_accessor :logger
 
-    def initialize(data = {})
+    def initialize(data = {}, &blk)
       @host           = data[:host] || Protocol::HOST
       @application_id = data[:application_id]
       @api_key        = data[:api_key]
@@ -29,27 +26,26 @@ module Parse
       @session_token  = data[:session_token]
       @max_retries    = data[:max_retries] || 3
       @logger         = data[:logger] || Logger.new(STDERR).tap{|l| l.level = Logger::INFO}
-      @session        = data[:http_client] || Parse::DEFAULT_HTTP_CLIENT.new
 
-      if data[:ironio_project_id] && data[:ironio_token]
+      options = {:request => {:timeout => 30, :open_timeout => 30}}
 
-        if data[:max_concurrent_requests]
-          @max_concurrent_requests = data[:max_concurrent_requests]
-        else
-          @max_concurrent_requests = 50
-        end
+      @session = Faraday.new("https://#{host}", options) do |c|
+        c.request :json
 
-        @queue = IronMQ::Client.new({
-          :project_id => data[:ironio_project_id],
-          :token => data[:ironio_token]
-        }).queue("concurrent_parse_requests")
+        c.use Faraday::GetMethodOverride
 
-      end
+        c.use Faraday::BetterRetry,
+          max: @max_retries,
+          logger: @logger,
+          interval: 0.5,
+          exceptions: ['Faraday::Error::TimeoutError', 'Faraday::Error::ParsingError', 'Parse::ParseProtocolRetry']
+        c.use Faraday::ExtendedParseJson
+
+        c.response :logger, @logger
+        c.adapter Faraday.default_adapter
 
-      @session.base_url                 = "https://#{host}"
-      @session.headers["Content-Type"]  = "application/json"
-      @session.headers["Accept"]        = "application/json"
-      @session.headers["User-Agent"]    = "Parse for Ruby, 0.0"
+        yield(c) if block_given?
+      end
     end
 
     # Perform an HTTP request for the given uri and method
@@ -57,95 +53,20 @@ module Parse
     # ParseProtocolError if the response has an error status code,
     # and will return the parsed JSON body on success, if there is one.
     def request(uri, method = :get, body = nil, query = nil, content_type = nil)
-      options = {}
       headers = {}
 
-      headers[Protocol::HEADER_MASTER_KEY]    = @master_key if @master_key
-      headers[Protocol::HEADER_API_KEY]       = @api_key
-      headers[Protocol::HEADER_APP_ID]        = @application_id
-      headers[Protocol::HEADER_SESSION_TOKEN] = @session_token if @session_token
-
-      if body
-        options[:data] = body
-      end
-      if query
-        options[:query] = @session.build_query(query)
-
-        # Avoid 502 or 414 when sending a large querystring. See https://parse.com/questions/502-error-when-query-with-huge-contains
-        if options[:query].size > 2000 && method == :get && !body && !content_type
-          options[:data] = options[:query]
-          options[:query] = nil
-          method = :post
-          headers['X-HTTP-Method-Override'] = 'GET'
-          content_type = 'application/x-www-form-urlencoded'
-        end
+      {
+        "Content-Type"                  => content_type || 'application/json',
+        "User-Agent"                    => 'Parse for Ruby, 0.0',
+        Protocol::HEADER_MASTER_KEY     => @master_key,
+        Protocol::HEADER_APP_ID         => @application_id,
+        Protocol::HEADER_API_KEY        => @api_key,
+        Protocol::HEADER_SESSION_TOKEN  => @session_token,
+      }.each do |key, value|
+        headers[key] = value if value
       end
 
-      if content_type
-        headers["Content-Type"] = content_type
-      end
-
-      num_tries = 0
-      begin
-        num_tries += 1
-
-        if @queue
-
-          #while true
-          #  if @queue.reload.size >= @max_concurrent_requests
-          #    sleep 1
-          #  else
-              # add to queue before request
-              @queue.post("1")
-              response = @session.request(method, uri, headers, options)
-              # delete from queue after request
-              msg = @queue.get()
-              msg.delete
-          #  end
-          #end
-        else
-          response = @session.request(method, uri, headers, options)
-        end
-
-        parsed = JSON.parse(response.body)
-
-        if response.status >= 400
-          parsed ||= {}
-          raise ParseProtocolError.new({"error" => "HTTP Status #{response.status} Body #{response.body}"}.merge(parsed))
-        end
-
-        if content_type
-          @session.headers["Content-Type"] = "application/json"
-        end
-
-        return parsed
-      rescue JSON::ParserError => e
-        if num_tries <= max_retries && response.status >= 500
-          log_retry(e, uri, query, body, response)
-          retry
-        end
-        raise
-      rescue HttpClient::TimeoutError => e
-        if num_tries <= max_retries
-          log_retry(e, uri, query, body, response)
-          retry
-        end
-        raise
-      rescue ParseProtocolError => e
-        if num_tries <= max_retries
-          if e.code
-            sleep 60 if e.code == Protocol::ERROR_EXCEEDED_BURST_LIMIT
-            if [Protocol::ERROR_INTERNAL, Protocol::ERROR_TIMEOUT, Protocol::ERROR_EXCEEDED_BURST_LIMIT].include?(e.code)
-              log_retry(e, uri, query, body, response)
-              retry
-            end
-          elsif response.status >= 500
-            log_retry(e, uri, query, body, response)
-            retry
-          end
-        end
-        raise
-      end
+      @session.send(method, uri, query || body || {}, headers).body
     end
 
     def get(uri)
@@ -164,72 +85,62 @@ module Parse
       request(uri, :delete)
     end
 
-    protected
-
-    def log_retry(e, uri, query, body, response)
-      logger.warn{"Retrying Parse Error #{e.inspect} on request #{uri} #{CGI.unescape(query.inspect)} #{body.inspect} response #{response.inspect}"}
-    end
   end
 
 
   # Module methods
   # ------------------------------------------------------------
+  class << self
+    # A singleton client for use by methods in Object.
+    # Always use Parse.client to retrieve the client object.
+    @client = nil
+
+    # Initialize the singleton instance of Client which is used
+    # by all API methods. Parse.init must be called before saving
+    # or retrieving any objects.
+    def init(data = {}, &blk)
+      defaults = {:application_id => ENV["PARSE_APPLICATION_ID"], :api_key => ENV["PARSE_REST_API_KEY"]}
+      defaults.merge!(data)
+
+      # use less permissive key if both are specified
+      defaults[:master_key] = ENV["PARSE_MASTER_API_KEY"] unless data[:master_key] || defaults[:api_key]
+      @@client = Client.new(defaults, &blk)
+    end
 
-  # A singleton client for use by methods in Object.
-  # Always use Parse.client to retrieve the client object.
-  @@client = nil
-
-  # Initialize the singleton instance of Client which is used
-  # by all API methods. Parse.init must be called before saving
-  # or retrieving any objects.
-  def Parse.init(data = {})
-    defaulted = {:application_id => ENV["PARSE_APPLICATION_ID"],
-                 :api_key => ENV["PARSE_REST_API_KEY"]}
-    defaulted.merge!(data)
-
-    # use less permissive key if both are specified
-    defaulted[:master_key] = ENV["PARSE_MASTER_API_KEY"] unless data[:master_key] || defaulted[:api_key]
-
-
-    @@client = Client.new(defaulted)
-  end
-
-  # A convenience method for using global.json
-  def Parse.init_from_cloud_code(path="../config/global.json")
-    global = JSON.parse(Object::File.open(path).read) # warning: toplevel constant File referenced by Parse::Object::File
-    application_name = global["applications"]["_default"]["link"]
-    application_id = global["applications"][application_name]["applicationId"]
-    master_key = global["applications"][application_name]["masterKey"]
-    Parse.init :application_id => application_id,
-               :master_key     => master_key
-  end
-
-  # Used mostly for testing. Lets you delete the api key global vars.
-  def Parse.destroy
-    @@client = nil
-    self
-  end
+    # A convenience method for using global.json
+    def init_from_cloud_code(path = "../config/global.json")
+      # warning: toplevel constant File referenced by Parse::Object::File
+      global = JSON.parse(Object::File.open(path).read)
+      application_name  = global["applications"]["_default"]["link"]
+      application_id    = global["applications"][application_name]["applicationId"]
+      master_key        = global["applications"][application_name]["masterKey"]
+      self.init(:application_id => application_id, :master_key => master_key)
+    end
 
-  def Parse.client
-    if !@@client
-      raise ParseError, "API not initialized"
+    # Used mostly for testing. Lets you delete the api key global vars.
+    def destroy
+      @@client = nil
+      self
     end
-    @@client
-  end
 
-  # Perform a simple retrieval of a simple object, or all objects of a
-  # given class. If object_id is supplied, a single object will be
-  # retrieved. If object_id is not supplied, then all objects of the
-  # given class will be retrieved and returned in an Array.
-  def Parse.get(class_name, object_id = nil)
-    data = Parse.client.get( Protocol.class_uri(class_name, object_id) )
-    Parse.parse_json class_name, data
-  rescue ParseProtocolError => e
-    if e.code == Protocol::ERROR_OBJECT_NOT_FOUND_FOR_GET
-      e.message += ": #{class_name}:#{object_id}"
+    def client
+      raise ParseError, "API not initialized" if !@@client
+      @@client
     end
 
-    raise
+    # Perform a simple retrieval of a simple object, or all objects of a
+    # given class. If object_id is supplied, a single object will be
+    # retrieved. If object_id is not supplied, then all objects of the
+    # given class will be retrieved and returned in an Array.
+    def get(class_name, object_id = nil)
+      data = self.client.get( Protocol.class_uri(class_name, object_id) )
+      self.parse_json class_name, data
+    rescue ParseProtocolError => e
+      if e.code == Protocol::ERROR_OBJECT_NOT_FOUND_FOR_GET
+        e.message += ": #{class_name}:#{object_id}"
+      end
+      raise
+    end
   end
 
 end