logstash-filter-cache-redis 0.1.0 → 0.2.0

data/vendor/bundle/jruby/1.9/gems/faraday-0.12.1/lib/faraday/request/authorization.rb

@@ -0,0 +1,41 @@
+module Faraday
+  class Request::Authorization < Faraday::Middleware
+    KEY = "Authorization".freeze unless defined? KEY
+
+    # Public
+    def self.header(type, token)
+      case token
+      when String, Symbol
+        "#{type} #{token}"
+      when Hash
+        build_hash(type.to_s, token)
+      else
+        raise ArgumentError, "Can't build an Authorization #{type} header from #{token.inspect}"
+      end
+    end
+
+    # Internal
+    def self.build_hash(type, hash)
+      comma = ", "
+      values = []
+      hash.each do |key, value|
+        values << "#{key}=#{value.to_s.inspect}"
+      end
+      "#{type} #{values * comma}"
+    end
+
+    def initialize(app, type, token)
+      @header_value = self.class.header(type, token)
+      super(app)
+    end
+
+    # Public
+    def call(env)
+      unless env.request_headers[KEY]
+        env.request_headers[KEY] = @header_value
+      end
+      @app.call(env)
+    end
+  end
+end
+

data/vendor/bundle/jruby/1.9/gems/faraday-0.12.1/lib/faraday/request/basic_authentication.rb

@@ -0,0 +1,13 @@
+require 'base64'
+
+module Faraday
+  class Request::BasicAuthentication < Request.load_middleware(:authorization)
+    # Public
+    def self.header(login, pass)
+      value = Base64.encode64([login, pass].join(':'))
+      value.gsub!("\n", '')
+      super(:Basic, value)
+    end
+  end
+end
+

data/vendor/bundle/jruby/1.9/gems/faraday-0.12.1/lib/faraday/request/instrumentation.rb

@@ -0,0 +1,36 @@
+module Faraday
+  class Request::Instrumentation < Faraday::Middleware
+    class Options < Faraday::Options.new(:name, :instrumenter)
+      def name
+        self[:name] ||= 'request.faraday'
+      end
+
+      def instrumenter
+        self[:instrumenter] ||= ActiveSupport::Notifications
+      end
+    end
+
+    # Public: Instruments requests using Active Support.
+    #
+    # Measures time spent only for synchronous requests.
+    #
+    # Examples
+    #
+    #   ActiveSupport::Notifications.subscribe('request.faraday') do |name, starts, ends, _, env|
+    #     url = env[:url]
+    #     http_method = env[:method].to_s.upcase
+    #     duration = ends - starts
+    #     $stderr.puts '[%s] %s %s (%.3f s)' % [url.host, http_method, url.request_uri, duration]
+    #   end
+    def initialize(app, options = nil)
+      super(app)
+      @name, @instrumenter = Options.from(options).values_at(:name, :instrumenter)
+    end
+
+    def call(env)
+      @instrumenter.instrument(@name, env) do
+        @app.call(env)
+      end
+    end
+  end
+end

data/vendor/bundle/jruby/1.9/gems/faraday-0.12.1/lib/faraday/request/multipart.rb

@@ -0,0 +1,68 @@
+require File.expand_path("../url_encoded", __FILE__)
+require 'securerandom'
+
+module Faraday
+  class Request::Multipart < Request::UrlEncoded
+    self.mime_type = 'multipart/form-data'.freeze
+    DEFAULT_BOUNDARY_PREFIX = "-----------RubyMultipartPost".freeze unless defined? DEFAULT_BOUNDARY_PREFIX
+
+    def call(env)
+      match_content_type(env) do |params|
+        env.request.boundary ||= unique_boundary
+        env.request_headers[CONTENT_TYPE] += "; boundary=#{env.request.boundary}"
+        env.body = create_multipart(env, params)
+      end
+      @app.call env
+    end
+
+    def process_request?(env)
+      type = request_type(env)
+      env.body.respond_to?(:each_key) and !env.body.empty? and (
+        (type.empty? and has_multipart?(env.body)) or
+        type == self.class.mime_type
+      )
+    end
+
+    def has_multipart?(obj)
+      # string is an enum in 1.8, returning list of itself
+      if obj.respond_to?(:each) && !obj.is_a?(String)
+        (obj.respond_to?(:values) ? obj.values : obj).each do |val|
+          return true if (val.respond_to?(:content_type) || has_multipart?(val))
+        end
+      end
+      false
+    end
+
+    def create_multipart(env, params)
+      boundary = env.request.boundary
+      parts = process_params(params) do |key, value|
+        Faraday::Parts::Part.new(boundary, key, value)
+      end
+      parts << Faraday::Parts::EpiloguePart.new(boundary)
+
+      body = Faraday::CompositeReadIO.new(parts)
+      env.request_headers[Faraday::Env::ContentLength] = body.length.to_s
+      return body
+    end
+
+    def unique_boundary
+      "#{DEFAULT_BOUNDARY_PREFIX}-#{SecureRandom.hex}"
+    end
+
+    def process_params(params, prefix = nil, pieces = nil, &block)
+      params.inject(pieces || []) do |all, (key, value)|
+        key = "#{prefix}[#{key}]" if prefix
+
+        case value
+        when Array
+          values = value.inject([]) { |a,v| a << [nil, v] }
+          process_params(values, key, all, &block)
+        when Hash
+          process_params(value, key, all, &block)
+        else
+          all << block.call(key, value)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/jruby/1.9/gems/faraday-0.12.1/lib/faraday/request/retry.rb

@@ -0,0 +1,164 @@
+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, a retry interval, a percentage of randomness to add to the retry
+  # interval, and a backoff factor.
+  #
+  # Examples
+  #
+  #   Faraday.new do |conn|
+  #     conn.request :retry, max: 2, interval: 0.05,
+  #                          interval_randomness: 0.5, backoff_factor: 2,
+  #                          exceptions: [CustomException, 'Timeout::Error']
+  #     conn.adapter ...
+  #   end
+  #
+  # This example will result in a first interval that is random between 0.05 and 0.075 and a second
+  # interval that is random between 0.1 and 0.15
+  #
+  class Request::Retry < Faraday::Middleware
+
+    IDEMPOTENT_METHODS = [:delete, :get, :head, :options, :put]
+
+    class Options < Faraday::Options.new(:max, :interval, :max_interval, :interval_randomness,
+                                         :backoff_factor, :exceptions, :methods, :retry_if)
+      DEFAULT_CHECK = lambda { |env,exception| false }
+
+      def self.from(value)
+        if Integer === value
+          new(value)
+        else
+          super(value)
+        end
+      end
+
+      def max
+        (self[:max] ||= 2).to_i
+      end
+
+      def interval
+        (self[:interval] ||= 0).to_f
+      end
+
+      def max_interval
+        (self[:max_interval] ||= Float::MAX).to_f
+      end
+
+      def interval_randomness
+        (self[:interval_randomness] ||= 0).to_f
+      end
+
+      def backoff_factor
+        (self[:backoff_factor] ||= 1).to_f
+      end
+
+      def exceptions
+        Array(self[:exceptions] ||= [Errno::ETIMEDOUT, 'Timeout::Error',
+                                     Error::TimeoutError])
+      end
+
+      def methods
+        Array(self[:methods] ||= IDEMPOTENT_METHODS)
+      end
+
+      def retry_if
+        self[:retry_if] ||= DEFAULT_CHECK
+      end
+
+    end
+
+    # Public: Initialize middleware
+    #
+    # Options:
+    # max                 - Maximum number of retries (default: 2)
+    # interval            - Pause in seconds between retries (default: 0)
+    # interval_randomness - The maximum random interval amount expressed
+    #                       as a float between 0 and 1 to use in addition to the
+    #                       interval. (default: 0)
+    # max_interval        - An upper limit for the interval (default: Float::MAX)
+    # backoff_factor      - The amount to multiple each successive retry's
+    #                       interval amount by in order to provide backoff
+    #                       (default: 1)
+    # exceptions          - The list of exceptions to handle. Exceptions can be
+    #                       given as Class, Module, or String. (default:
+    #                       [Errno::ETIMEDOUT, Timeout::Error,
+    #                       Error::TimeoutError])
+    # methods             - A list of HTTP methods to retry without calling retry_if.  Pass
+    #                       an empty Array to call retry_if for all exceptions.
+    #                       (defaults to the idempotent HTTP methods in IDEMPOTENT_METHODS)
+    # retry_if            - block that will receive the env object and the exception raised
+    #                       and should decide if the code should retry still the action or
+    #                       not independent of the retry count. This would be useful
+    #                       if the exception produced is non-recoverable or if the
+    #                       the HTTP method called is not idempotent.
+    #                       (defaults to return false)
+    def initialize(app, options = nil)
+      super(app)
+      @options = Options.from(options)
+      @errmatch = build_exception_matcher(@options.exceptions)
+    end
+
+    def sleep_amount(retries)
+      retry_index = @options.max - retries
+      current_interval = @options.interval * (@options.backoff_factor ** retry_index)
+      current_interval = [current_interval, @options.max_interval].min
+      random_interval  = rand * @options.interval_randomness.to_f * @options.interval
+      current_interval + random_interval
+    end
+
+    def call(env)
+      retries = @options.max
+      request_body = env[:body]
+      begin
+        env[:body] = request_body # after failure env[:body] is set to the response body
+        @app.call(env)
+      rescue @errmatch => exception
+        if retries > 0 && retry_request?(env, exception)
+          retries -= 1
+          rewind_files(request_body)
+          sleep sleep_amount(retries + 1)
+          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
+              error.is_a? ex
+            else
+              error.class.to_s == ex.to_s
+            end
+          end
+        end
+      end
+      matcher
+    end
+
+    private
+
+    def retry_request?(env, exception)
+      @options.methods.include?(env[:method]) || @options.retry_if.call(env, exception)
+    end
+
+    def rewind_files(body)
+      return unless body.is_a?(Hash)
+      body.each do |_, value|
+        if value.is_a? UploadIO
+          value.rewind
+        end
+      end
+    end
+
+  end
+end

data/vendor/bundle/jruby/1.9/gems/faraday-0.12.1/lib/faraday/request/token_authentication.rb

@@ -0,0 +1,15 @@
+module Faraday
+  class Request::TokenAuthentication < Request.load_middleware(:authorization)
+    # Public
+    def self.header(token, options = nil)
+      options ||= {}
+      options[:token] = token
+      super(:Token, options)
+    end
+
+    def initialize(app, token, options = nil)
+      super(app, token, options)
+    end
+  end
+end
+

data/vendor/bundle/jruby/1.9/gems/faraday-0.12.1/lib/faraday/request/url_encoded.rb

@@ -0,0 +1,36 @@
+module Faraday
+  class Request::UrlEncoded < Faraday::Middleware
+    CONTENT_TYPE = 'Content-Type'.freeze unless defined? CONTENT_TYPE
+
+    class << self
+      attr_accessor :mime_type
+    end
+    self.mime_type = 'application/x-www-form-urlencoded'.freeze
+
+    def call(env)
+      match_content_type(env) do |data|
+        params = Faraday::Utils::ParamsHash[data]
+        env.body = params.to_query(env.params_encoder)
+      end
+      @app.call env
+    end
+
+    def match_content_type(env)
+      if process_request?(env)
+        env.request_headers[CONTENT_TYPE] ||= self.class.mime_type
+        yield(env.body) unless env.body.respond_to?(:to_str)
+      end
+    end
+
+    def process_request?(env)
+      type = request_type(env)
+      env.body and (type.empty? or type == self.class.mime_type)
+    end
+
+    def request_type(env)
+      type = env.request_headers[CONTENT_TYPE].to_s
+      type = type.split(';', 2).first if type.index(';')
+      type
+    end
+  end
+end

data/vendor/bundle/jruby/1.9/gems/faraday-0.12.1/lib/faraday/response.rb

@@ -0,0 +1,97 @@
+require 'forwardable'
+
+module Faraday
+  class Response
+    # Used for simple response middleware.
+    class Middleware < Faraday::Middleware
+      def call(env)
+        @app.call(env).on_complete do |environment|
+          on_complete(environment)
+        end
+      end
+
+      # Override this to modify the environment after the response has finished.
+      # Calls the `parse` method if defined
+      def on_complete(env)
+        env.body = parse(env.body) if respond_to?(:parse) && env.parse_body?
+      end
+    end
+
+    extend Forwardable
+    extend MiddlewareRegistry
+
+    register_middleware File.expand_path('../response', __FILE__),
+      :raise_error => [:RaiseError, 'raise_error'],
+      :logger => [:Logger, 'logger']
+
+    def initialize(env = nil)
+      @env = Env.from(env) if env
+      @on_complete_callbacks = []
+    end
+
+    attr_reader :env
+
+    def_delegators :env, :to_hash
+
+    def status
+      finished? ? env.status : nil
+    end
+
+    def reason_phrase
+      finished? ? env.reason_phrase : nil
+    end
+
+    def headers
+      finished? ? env.response_headers : {}
+    end
+    def_delegator :headers, :[]
+
+    def body
+      finished? ? env.body : nil
+    end
+
+    def finished?
+      !!env
+    end
+
+    def on_complete
+      if not finished?
+        @on_complete_callbacks << Proc.new
+      else
+        yield(env)
+      end
+      return self
+    end
+
+    def finish(env)
+      raise "response already finished" if finished?
+      @env = env.is_a?(Env) ? env : Env.from(env)
+      @on_complete_callbacks.each { |callback| callback.call(@env) }
+      return self
+    end
+
+    def success?
+      finished? && env.success?
+    end
+
+    # because @on_complete_callbacks cannot be marshalled
+    def marshal_dump
+      !finished? ? nil : {
+        :status => @env.status, :body => @env.body,
+        :response_headers => @env.response_headers
+      }
+    end
+
+    def marshal_load(env)
+      @env = Env.from(env)
+    end
+
+    # Expand the env with more properties, without overriding existing ones.
+    # Useful for applying request params after restoring a marshalled Response.
+    def apply_request(request_env)
+      raise "response didn't finish yet" unless finished?
+      @env = Env.from(request_env).update(@env)
+      return self
+    end
+  end
+end