faraday 0.10.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc2292832e97072ea9b3292a56ee1c87e7f9ec19
-  data.tar.gz: 9aea82166ae97ea282ba1a4b5efc4740effeea14
+  metadata.gz: d6ed59b880f0d605e4efc8ce513ced0b4688c4ef
+  data.tar.gz: 21d3a0326416db1e19add553b8d5c0ef1c5a3b50
 SHA512:
-  metadata.gz: ba7bc351e2111733af22e1666f86d877050cd3256d3322e0418773aaf1a8c7447a02a780b812b0f2549b558c4c38a606189dad3c2915ed48019def848b8bc65c
-  data.tar.gz: d3cbb3fa12d1e37f162930bab8be286ca6b384e2ce622e8ebff9087386902b50aa318a423d054138d87064601034470a45d072c85bda910d29fbb84150a22a5f
+  metadata.gz: 9e882a5072cc36a986e8fc2f23f0563755bae2d0c4e6fed4adc51a6fd46b449ea6be3dd189662ea0aa4f427c5402969bfb0ad626c837e9bad68d06aa0a3cc6d3
+  data.tar.gz: 63856c35cbcceda6abeb3dc076574d7e880343e8ee7af5e80971c08637a647a079433b1220161c24871d3718c268d018ebdce009ca46d89c4da7c059fdaeaf72

data/README.md

@@ -1,5 +1,10 @@
 # Faraday
 
+[![Gem Version](https://badge.fury.io/rb/faraday.svg)](https://rubygems.org/gems/faraday)
+[![Build Status](https://travis-ci.org/lostisland/faraday.svg)](https://travis-ci.org/lostisland/faraday)
+[![Gitter](https://badges.gitter.im/lostisland/faraday.svg)](https://gitter.im/lostisland/faraday?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+
+
 Faraday is an HTTP client lib that provides a common interface over many
 adapters (such as Net::HTTP) and embraces the concept of Rack middleware when
 processing the request/response cycle.
@@ -9,7 +14,6 @@ Faraday supports these adapters:
 * [Net::HTTP][net_http] _(default)_
 * [Net::HTTP::Persistent][persistent]
 * [Excon][]
-* [Typhoeus][]
 * [Patron][]
 * [EventMachine][]
 * [HTTPClient][]
@@ -23,6 +27,23 @@ Available at [rubydoc.info](http://www.rubydoc.info/gems/faraday).
 
 ## Usage
 
+### Basic Use
+
+```ruby
+response = Faraday.get 'http://sushi.com/nigiri/sake.json'
+```
+A simple `get` request can be performed by using the syntax described above. This works if you don't need to set up anything; you can roll with just the default middleware
+stack and default adapter (see [Faraday::RackBuilder#initialize](https://github.com/lostisland/faraday/blob/master/lib/faraday/rack_builder.rb)).
+
+A more flexible way to use Faraday is to start with a Connection object. If you want to keep the same defaults, you can use this syntax:
+
+```ruby
+conn = Faraday.new(:url => 'http://www.example.com') 
+response = conn.get '/users'                 # GET http://www.example.com/users' 
+```
+
+Connections can also take an options hash as a parameter or be configured by using a block. Checkout the section called [Advanced middleware usage](#advanced-middleware-usage) for more details about how to use this block for configurations. 
+
 ```ruby
 conn = Faraday.new(:url => 'http://sushi.com') do |faraday|
   faraday.request  :url_encoded             # form-encode POST params
@@ -30,6 +51,19 @@ conn = Faraday.new(:url => 'http://sushi.com') do |faraday|
   faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
 end
 
+# Filter sensitive information from logs with a regex matcher
+
+conn = Faraday.new(:url => 'http://sushi.com/api_key=s3cr3t') do |faraday|
+  faraday.response :logger do | logger |
+    logger.filter(/(api_key=)(\w+)/,'\1[REMOVED]')
+  end
+  faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
+end
+```
+
+Once you have the connection object, use it to make HTTP requests. You can pass paramters to it in a few different ways:
+
+```ruby
 ## GET ##
 
 response = conn.get '/nigiri/sake.json'     # GET http://sushi.com/nigiri/sake.json
@@ -37,7 +71,7 @@ response.body
 
 conn.get '/nigiri', { :name => 'Maguro' }   # GET http://sushi.com/nigiri?name=Maguro
 
-conn.get do |req|                           # GET http://sushi.com/search?page=2&limit=100
+conn.get do |req|                           # GET http://sushi.com/search?page=2&limit=100  
   req.url '/search', :page => 2
   req.params['limit'] = 100
 end
@@ -45,7 +79,11 @@ end
 ## POST ##
 
 conn.post '/nigiri', { :name => 'Maguro' }  # POST "name=maguro" to http://sushi.com/nigiri
+```
+
+Some configuration options can be adjusted per request:
 
+```ruby
 # post payload as JSON instead of "www-form-urlencoded" encoding:
 conn.post do |req|
   req.url '/nigiri'
@@ -62,11 +100,18 @@ conn.get do |req|
 end
 ```
 
-If you don't need to set up anything, you can roll with just the default middleware
-stack and default adapter (see [Faraday::RackBuilder#initialize](https://github.com/lostisland/faraday/blob/master/lib/faraday/rack_builder.rb)):
+And you can inject arbitrary data into the request using the `context` option:
 
 ```ruby
-response = Faraday.get 'http://sushi.com/nigiri/sake.json'
+# Anything you inject using context option will be available in the env on all middlewares
+
+conn.get do |req|
+  req.url '/search'
+  req.options.context = {
+      foo: 'foo',
+      bar: 'bar'
+  }          
+end
 ```
 
 ### Changing how parameters are serialized
@@ -169,6 +214,53 @@ later, response. Some keys are:
 :response_headers
 ```
 
+## Ad-hoc adapters customization
+
+Faraday is intended to be a generic interface between your code and the adapter. However, sometimes you need to access a feature specific to one of the adapters that is not covered in Faraday's interface. 
+
+When that happens, you can pass a block when specifying the adapter to customize it. The block parameter will change based on the adapter you're using. See below for some examples.
+
+### NetHttp
+```ruby
+conn = Faraday.new(...) do |f|
+  f.adapter :net_http do |http| # yields Net::HTTP
+    http.idle_timeout = 100
+    http.verify_callback = lambda do | preverify_ok, cert_store |
+      # do something here...
+    end
+  end
+end
+```
+
+### NetHttpPersistent
+```ruby
+conn = Faraday.new(...) do |f|
+  f.adapter :net_http_persistent do |http| # yields Net::HTTP::Persistent
+    http.idle_timeout = 100
+    http.retry_change_requests = true
+  end
+end
+```
+
+### Patron
+```ruby
+conn = Faraday.new(...) do |f|
+  f.adapter :patron do |session| # yields Patron::Session
+    session.max_redirects = 10
+  end
+end
+```
+
+### HTTPClient
+```ruby
+conn = Faraday.new(...) do |f|
+  f.adapter :httpclient do |client| # yields HTTPClient
+    client.keep_alive_timeout = 20
+    client.ssl_config.timeout = 25
+  end
+end
+```
+
 ## Using Faraday for testing
 
 ```ruby
@@ -240,7 +332,6 @@ See [LICENSE][] for details.
 [persistent]:   https://github.com/drbrain/net-http-persistent
 [travis]:       https://travis-ci.org/lostisland/faraday
 [excon]:        https://github.com/excon/excon#readme
-[typhoeus]:     https://github.com/typhoeus/typhoeus#readme
 [patron]:       http://toland.github.io/patron/
 [eventmachine]: https://github.com/igrigorik/em-http-request#readme
 [httpclient]:   https://github.com/nahi/httpclient

data/lib/faraday/adapter/em_http.rb

@@ -138,7 +138,7 @@ module Faraday
 
       # TODO: reuse the connection to support pipelining
       def perform_single_request(env)
-        req = EventMachine::HttpRequest.new(env[:url], connection_config(env))
+        req = create_request(env)
         req.setup_request(env[:method], request_config(env)).callback { |client|
           status = client.response_header.status
           reason = client.response_header.http_reason
@@ -150,6 +150,10 @@ module Faraday
         }
       end
 
+      def create_request(env)
+        EventMachine::HttpRequest.new(env[:url], connection_config(env).merge(@connection_options))
+      end
+
       def error_message(client)
         client.error or "request failed"
       end

data/lib/faraday/adapter/em_synchrony.rb

@@ -19,7 +19,7 @@ module Faraday
 
       def call(env)
         super
-        request = EventMachine::HttpRequest.new(Utils::URI(env[:url].to_s), connection_config(env))
+        request = create_request(env)
 
         http_method = env[:method].to_s.downcase.to_sym
 
@@ -87,6 +87,10 @@ module Faraday
           raise
         end
       end
+
+      def create_request(env)
+        EventMachine::HttpRequest.new(Utils::URI(env[:url].to_s), connection_config(env).merge(@connection_options))
+      end
     end
   end
 end

data/lib/faraday/adapter/excon.rb

@@ -3,11 +3,6 @@ module Faraday
     class Excon < Faraday::Adapter
       dependency 'excon'
 
-      def initialize(app, connection_options = {})
-        @connection_options = connection_options
-        super(app)
-      end
-
       def call(env)
         super
 
@@ -50,7 +45,7 @@ module Faraday
           end
         end
 
-        conn = ::Excon.new(env[:url].to_s, opts.merge(@connection_options))
+        conn = create_connection(env, opts)
 
         resp = conn.request \
           :method  => env[:method].to_s.upcase,
@@ -72,6 +67,10 @@ module Faraday
         raise Error::TimeoutError, err
       end
 
+      def create_connection(env, opts)
+        ::Excon.new(env[:url].to_s, opts.merge(@connection_options))
+      end
+
       # TODO: support streaming requests
       def read_body(env)
         env[:body].respond_to?(:read) ? env[:body].read : env[:body]

data/lib/faraday/adapter/httpclient.rb

@@ -29,6 +29,8 @@ module Faraday
           configure_ssl ssl
         end
 
+        configure_client
+
         # TODO Don't stream yet.
         # https://github.com/nahi/httpclient/pull/90
         env[:body] = env[:body].read if env[:body].respond_to? :read
@@ -48,7 +50,7 @@ module Faraday
         else
           raise Faraday::Error::ClientError, $!
         end
-      rescue Errno::ECONNREFUSED, EOFError
+      rescue Errno::ECONNREFUSED, IOError
         raise Faraday::Error::ConnectionFailed, $!
       rescue => err
         if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
@@ -95,12 +97,21 @@ module Faraday
         end
       end
 
+      def configure_client
+        @config_block.call(client) if @config_block
+      end
+
       def ssl_cert_store(ssl)
         return ssl[:cert_store] if ssl[:cert_store]
-        # Use the default cert store by default, i.e. system ca certs
-        cert_store = OpenSSL::X509::Store.new
-        cert_store.set_default_paths
-        cert_store
+        # Memoize the cert store so that the same one is passed to
+        # HTTPClient each time, to avoid resyncing SSL sesions when
+        # it's changed
+        @cert_store ||= begin
+          # Use the default cert store by default, i.e. system ca certs
+          cert_store = OpenSSL::X509::Store.new
+          cert_store.set_default_paths
+          cert_store
+        end
       end
 
       def ssl_verify_mode(ssl)

data/lib/faraday/adapter/net_http.rb

@@ -10,7 +10,7 @@ module Faraday
   class Adapter
     class NetHttp < Faraday::Adapter
       NET_HTTP_EXCEPTIONS = [
-        EOFError,
+        IOError,
         Errno::ECONNABORTED,
         Errno::ECONNREFUSED,
         Errno::ECONNRESET,
@@ -32,10 +32,7 @@ module Faraday
         super
         with_net_http_connection(env) do |http|
           configure_ssl(http, env[:ssl]) if env[:url].scheme == 'https' and env[:ssl]
-
-          req = env[:request]
-          http.read_timeout = http.open_timeout = req[:timeout] if req[:timeout]
-          http.open_timeout = req[:open_timeout]                if req[:open_timeout]
+          configure_request(http, env[:request])
 
           begin
             http_response = perform_request(http, env)
@@ -109,6 +106,13 @@ module Faraday
         http.ssl_version  = ssl[:version]      if ssl[:version]
       end
 
+      def configure_request(http, req)
+        http.read_timeout = http.open_timeout = req[:timeout] if req[:timeout]
+        http.open_timeout = req[:open_timeout]                if req[:open_timeout]
+
+        @config_block.call(http) if @config_block
+      end
+
       def ssl_cert_store(ssl)
         return ssl[:cert_store] if ssl[:cert_store]
         # Use the default cert store by default, i.e. system ca certs

data/lib/faraday/adapter/net_http_persistent.rb

@@ -7,8 +7,8 @@ module Faraday
     class NetHttpPersistent < NetHttp
       dependency 'net/http/persistent'
 
-      def with_net_http_connection(env)
-        if proxy = env[:request][:proxy]
+      def net_http_connection(env)
+        if (proxy = env[:request][:proxy])
           proxy_uri = ::URI::HTTP === proxy[:uri] ? proxy[:uri].dup : ::URI.parse(proxy[:uri].to_s)
           proxy_uri.user = proxy_uri.password = nil
           # awful patch for net-http-persistent 2.8 not unescaping user/password
@@ -16,9 +16,10 @@ module Faraday
             define_method(:user) { proxy[:user] }
             define_method(:password) { proxy[:password] }
           end if proxy[:user]
+          return Net::HTTP::Persistent.new 'Faraday', proxy_uri
         end
 
-        yield Net::HTTP::Persistent.new 'Faraday', proxy_uri
+        Net::HTTP::Persistent.new 'Faraday'
       end
 
       def perform_request(http, env)

data/lib/faraday/adapter/patron.rb

@@ -3,11 +3,6 @@ module Faraday
     class Patron < Faraday::Adapter
       dependency 'patron'
 
-      def initialize(app, &block)
-        super(app)
-        @block = block
-      end
-
       def call(env)
         super
 
@@ -73,7 +68,7 @@ module Faraday
       def create_session
         session = ::Patron::Session.new
         session.insecure = true
-        @block.call(session) if @block
+        @config_block.call(session) if @config_block
         session
       end
     end

data/lib/faraday/adapter.rb

@@ -30,6 +30,12 @@ module Faraday
     extend Parallelism
     self.supports_parallel = false
 
+    def initialize(app = nil, opts = {}, &block)
+      super(app)
+      @connection_options = opts
+      @config_block = block
+    end
+
     def call(env)
       env.clear_body if env.needs_body?
     end

data/lib/faraday/connection.rb

@@ -55,11 +55,11 @@ module Faraday
     #                     :user     - String (optional)
     #                     :password - String (optional)
     def initialize(url = nil, options = nil)
+      options = ConnectionOptions.from(options)
+
       if url.is_a?(Hash)
-        options = options ? options.merge(url) : ConnectionOptions.from(url)
+        options = options.merge(url)
         url     = options.url
-      else
-        options = ConnectionOptions.from(options)
       end
 
       @parallel_manager = nil
@@ -81,11 +81,20 @@ module Faraday
 
       @proxy = nil
       proxy(options.fetch(:proxy) {
-        uri = ENV['http_proxy']
-        if uri && !uri.empty?
-          uri = 'http://' + uri if uri !~ /^http/i
-          uri
+        uri = nil
+        if URI.parse("").respond_to?(:find_proxy)
+          case url
+          when String
+            uri = URI.parse(url).find_proxy
+          when URI
+            uri = url.find_proxy
+          when nil
+            uri = find_default_proxy
+          end
+        else
+          uri = find_default_proxy
         end
+        uri
       })
 
       yield(self) if block_given?
@@ -433,5 +442,14 @@ module Faraday
         header(*args)
       headers[Faraday::Request::Authorization::KEY] = header
     end
+
+    def find_default_proxy
+      warn 'no_proxy is unsupported' if ENV['no_proxy'] || ENV['NO_PROXY']
+      uri = ENV['http_proxy']
+      if uri && !uri.empty?
+        uri = 'http://' + uri if uri !~ /^http/i
+        uri
+      end
+    end
   end
 end

data/lib/faraday/options.rb

@@ -18,23 +18,20 @@ module Faraday
     # Public
     def update(obj)
       obj.each do |key, value|
-        if sub_options = self.class.options_for(key)
-          value = sub_options.from(value) if value
-        elsif Hash === value
-          hash = {}
-          value.each do |hash_key, hash_value|
-            hash[hash_key] = hash_value
-          end
-          value = hash
+        sub_options = self.class.options_for(key)
+        if sub_options
+          new_value = sub_options.from(value) if value
+        elsif value.is_a?(Hash)
+          new_value = value.dup
+        else
+          new_value = value
         end
 
-        self.send("#{key}=", value) unless value.nil?
+        self.send("#{key}=", new_value) unless new_value.nil?
       end
       self
     end
 
-    alias merge! update
-
     # Public
     def delete(key)
       value = send(key)
@@ -48,8 +45,24 @@ module Faraday
     end
 
     # Public
-    def merge(value)
-      dup.update(value)
+    def merge!(other)
+      other.each do |key, other_value|
+        self_value = self.send(key)
+        sub_options = self.class.options_for(key)
+        new_value = sub_options ? self_value.merge(other_value) : other_value
+        self.send("#{key}=", new_value) unless new_value.nil?
+      end
+      self
+    end
+
+    # Public
+    def merge(other)
+      dup.merge!(other)
+    end
+
+    # Public
+    def deep_dup
+      self.class.from(self)
     end
 
     # Public
@@ -189,8 +202,7 @@ module Faraday
   end
 
   class RequestOptions < Options.new(:params_encoder, :proxy, :bind,
-    :timeout, :open_timeout, :boundary,
-    :oauth)
+    :timeout, :open_timeout, :boundary, :oauth, :context)
 
     def []=(key, value)
       if key && key.to_sym == :proxy

data/lib/faraday/request/authorization.rb

@@ -16,8 +16,7 @@ module Faraday
 
     # Internal
     def self.build_hash(type, hash)
-      offset = KEY.size + type.size + 3
-      comma = ",\n#{' ' * offset}"
+      comma = ", "
       values = []
       hash.each do |key, value|
         values << "#{key}=#{value.to_s.inspect}"

data/lib/faraday/request/multipart.rb

@@ -1,13 +1,14 @@
 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 = "-----------RubyMultipartPost".freeze unless defined? DEFAULT_BOUNDARY
+    DEFAULT_BOUNDARY_PREFIX = "-----------RubyMultipartPost".freeze unless defined? DEFAULT_BOUNDARY_PREFIX
 
     def call(env)
       match_content_type(env) do |params|
-        env.request.boundary ||= DEFAULT_BOUNDARY
+        env.request.boundary ||= unique_boundary
         env.request_headers[CONTENT_TYPE] += "; boundary=#{env.request.boundary}"
         env.body = create_multipart(env, params)
       end
@@ -44,6 +45,10 @@ module Faraday
       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

data/lib/faraday/request/retry.rb

@@ -10,7 +10,7 @@ module Faraday
   #
   #   Faraday.new do |conn|
   #     conn.request :retry, max: 2, interval: 0.05,
-  #                          interval_randomness: 0.5, backoff_factor: 2
+  #                          interval_randomness: 0.5, backoff_factor: 2,
   #                          exceptions: [CustomException, 'Timeout::Error']
   #     conn.adapter ...
   #   end
@@ -27,7 +27,7 @@ module Faraday
       DEFAULT_CHECK = lambda { |env,exception| false }
 
       def self.from(value)
-        if Fixnum === value
+        if Integer === value
           new(value)
         else
           super(value)
@@ -117,6 +117,7 @@ module Faraday
       rescue @errmatch => exception
         if retries > 0 && retry_request?(env, exception)
           retries -= 1
+          rewind_files(request_body)
           sleep sleep_amount(retries + 1)
           retry
         end
@@ -150,5 +151,13 @@ module Faraday
       @options.methods.include?(env[:method]) || @options.retry_if.call(env, exception)
     end
 
+    def rewind_files(env)
+      env && env.each do |_, value|
+        if value.is_a? UploadIO
+          value.rewind
+        end
+      end
+    end
+
   end
 end

data/lib/faraday/response/logger.rb

@@ -12,22 +12,28 @@ module Faraday
         require 'logger'
         ::Logger.new(STDOUT)
       end
+      @filter = []
       @options = DEFAULT_OPTIONS.merge(options)
+      yield self if block_given?
     end
 
     def_delegators :@logger, :debug, :info, :warn, :error, :fatal
 
     def call(env)
-      info "#{env.method} #{env.url.to_s}"
-      debug('request') { dump_headers env.request_headers } if log_headers?(:request)
-      debug('request') { dump_body(env[:body]) } if env[:body] && log_body?(:request)
+      info "#{env.method} #{apply_filters(env.url.to_s)}"
+      debug('request') { apply_filters( dump_headers env.request_headers ) } if log_headers?(:request)
+      debug('request') { apply_filters( dump_body(env[:body]) ) } if env[:body] && log_body?(:request)
       super
     end
 
     def on_complete(env)
       info('Status') { env.status.to_s }
-      debug('response') { dump_headers env.response_headers } if log_headers?(:response)
-      debug('response') { dump_body env[:body] } if env[:body] && log_body?(:response)
+      debug('response') { apply_filters( dump_headers env.response_headers ) } if log_headers?(:response)
+      debug('response') { apply_filters( dump_body env[:body] ) } if env[:body] && log_body?(:response)
+    end
+
+    def filter(filter_word, filter_replacement)
+      @filter.push([ filter_word, filter_replacement ])
     end
 
     private
@@ -62,5 +68,13 @@ module Faraday
       else @options[:bodies]
       end
     end
+
+    def apply_filters(output)
+      @filter.each do |pattern, replacement|
+        output = output.to_s.gsub(pattern, replacement)
+      end
+      output
+    end
+
   end
 end

data/lib/faraday/utils.rb

@@ -108,6 +108,14 @@ module Faraday
           }
       end
 
+      def init_with(coder)
+        @names = coder['names']
+      end
+
+      def encode_with(coder)
+        coder['names'] = @names
+      end
+
       protected
 
       def names

data/lib/faraday.rb

@@ -14,7 +14,7 @@ require 'forwardable'
 #   conn.get '/'
 #
 module Faraday
-  VERSION = "0.10.0"
+  VERSION = "0.12.0"
 
   class << self
     # Public: Gets or sets the root path that Faraday is being loaded from.
@@ -34,9 +34,6 @@ module Faraday
     #     Faraday.get "https://faraday.com"
     attr_writer :default_connection
 
-    # Public: Sets the default options used when calling Faraday#new.
-    attr_writer :default_connection_options
-
     # Public: Initializes a new Faraday::Connection.
     #
     # url     - The optional String base URL to use as a prefix for all
@@ -66,7 +63,7 @@ module Faraday
     # Returns a Faraday::Connection.
     def new(url = nil, options = nil)
       block = block_given? ? Proc.new : nil
-      options = options ? default_connection_options.merge(options) : default_connection_options.dup
+      options = options ? default_connection_options.merge(options) : default_connection_options
       Faraday::Connection.new(url, options, &block)
     end
 
@@ -122,6 +119,11 @@ module Faraday
     @default_connection_options ||= ConnectionOptions.new
   end
 
+  # Public: Sets the default options used when calling Faraday#new.
+  def self.default_connection_options=(options)
+    @default_connection_options = ConnectionOptions.from(options)
+  end
+
   unless const_defined? :Timer
     require 'timeout'
     Timer = Timeout

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faraday
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Rick Olson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-11 00:00:00.000000000 Z
+date: 2017-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multipart-post