aliyun / aliyun-oss-ruby-sdk / 130

pending completion

Build # 130

Build Type

push

travis-ci

Committed by

mars-coder

Commit Message

<a href="https://github.com/aliyun/aliyun-oss-ruby-sdk/commit/<a class=hub.com/aliyun/aliyun-oss-ruby-sdk/commit/<a class="double-link" href="https://git"><a class=hub.com/aliyun/aliyun-oss-ruby-sdk/commit/<a class="double-link" href="https://git"><a class=hub.com/aliyun/aliyun-oss-ruby-sdk/commit/<a class="double-link" href="https://git"><a class=hub.com/aliyun/aliyun-oss-ruby-sdk/commit/ef191d5346012b19b505ac0cfb60c8f70de993e0">ef191d534">&lt;a href=&quot;https://github.com/aliyun/aliyun-oss-ruby-sdk/commit/</a><a class="double-link" href="https://github.com/aliyun/aliyun-oss-ruby-sdk/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/aliyun/aliyun-oss-ruby-sdk/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/aliyun/aliyun-oss-ruby-sdk/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/aliyun/aliyun-oss-ruby-sdk/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/aliyun/aliyun-oss-ruby-sdk/commit/ef191d5346012b19b505ac0cfb60c8f70de993e0">ef191d534</a><a href="https://github.com/aliyun/aliyun-oss-ruby-sdk/commit/ef191d5346012b19b505ac0cfb60c8f70de993e0">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/aliyun/aliyun-oss-ruby-sdk/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/aliyun/aliyun-oss-ruby-sdk/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/aliyun/aliyun-oss-ruby-sdk/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/aliyun/aliyun-oss-ruby-sdk/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/aliyun/aliyun-oss-ruby-sdk/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/aliyun/aliyun-oss-ruby-sdk/commit/ef191d5346012b19b505ac0cfb60c8f70de993e0&quot;&gt;ef191d534&lt;/a&gt;&lt;a href=&quot;https://github.com/aliyun/aliyun-oss-ruby-sdk/commit/ef191d5346012b19b505ac0cfb60c8f70de993e0&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/aliyun/aliyun-oss-ruby-sdk/co... (continued)

Run Details

101 of 101 new or added lines in 6 files covered. (100.0%)

3616 of 3687 relevant lines covered (98.07%)

91.23 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.47

/lib/aliyun/oss/http.rb

# -*- encoding: utf-8 -*-

require 'rest-client'
require 'resolv'
require 'fiber'

module Aliyun
  module OSS

    ##
    # HTTP wraps the HTTP functionalities for accessing OSS RESTful
    # API. It handles the OSS-specific protocol elements, and
    # rest-client details for the user, which includes:
    # * automatically generate signature for every request
    # * parse response headers/body
    # * raise exceptions and capture the request id
    # * encapsulates streaming upload/download
    # @example simple get
    #   headers, body = http.get({:bucket => 'bucket'})
    # @example streaming download
    #   http.get({:bucket => 'bucket', :object => 'object'}) do |chunk|
    #     # handle chunk
    #   end
    # @example streaming upload
    #   def streaming_upload(&block)
    #     http.put({:bucket => 'bucket', :object => 'object'},
    #              {:body => HTTP::StreamPlayload.new(block)})
    #   end
    #
    #   streaming_upload do |stream|
    #     stream << "hello world"
    #   end
    class HTTP

      DEFAULT_CONTENT_TYPE = 'application/octet-stream'
      DEFAULT_ACCEPT_ENCODING = 'identity'
      STS_HEADER = 'x-oss-security-token'
      OPEN_TIMEOUT = 10
      READ_TIMEOUT = 120

      ##
      # A stream implementation
      # A stream is any class that responds to :read(bytes, outbuf)
      #
      class StreamWriter
        attr_reader :data_crc

        def initialize(crc_enable = false, init_crc = 0)
          @buffer = ""
          @producer = Fiber.new { yield self if block_given? }
          @producer.resume
          @data_crc = init_crc.to_i
          @crc_enable = crc_enable
        end

        def read(bytes = nil, outbuf = nil)
          ret = ""
          loop do
            if bytes
              fail if bytes < 0
              piece = @buffer.slice!(0, bytes)
              if piece
                ret << piece
                bytes -= piece.size
                break if bytes == 0
              end
            else
              ret << @buffer
              @buffer.clear
            end

            if @producer.alive?
              @producer.resume
            else
              break
            end
          end

          if outbuf
            # WARNING: Using outbuf = '' here DOES NOT work!
            outbuf.clear
            outbuf << ret
          end

          # Conform to IO#read(length[, outbuf]):
          # At end of file, it returns nil or "" depend on
          # length. ios.read() and ios.read(nil) returns
          # "". ios.read(positive-integer) returns nil.
          return nil if ret.empty? && !bytes.nil? && bytes > 0

          @data_crc = Aliyun::OSS::Util.crc(ret, @data_crc) if @crc_enable

          ret
        end

        def write(chunk)
          @buffer << chunk.to_s.force_encoding(Encoding::ASCII_8BIT)
          Fiber.yield
          self
        end

        alias << write

        def closed?
          false
        end

        def inspect
          "@buffer: " + @buffer[0, 32].inspect + "...#{@buffer.size} bytes"
        end
      end

      # RestClient requires the payload to respones to :read(bytes)
      # and return a stream.
      # We are not doing the real read here, just return a
      # readable stream for RestClient playload.rb treats it as:
      #     def read(bytes=nil)
      #       @stream.read(bytes)
      #     end
      #     alias :to_s :read
      #     net_http_do_request(http, req, payload ? payload.to_s : nil,
      #                     &@block_response)
      class StreamPayload
        def initialize(crc_enable = false, init_crc = 0, &block)
          @stream = StreamWriter.new(crc_enable, init_crc, &block)
        end

        def read(bytes = nil)
          @stream
        end

        def close
        end

        def closed?
          false
        end
      end

      include Common::Logging

      def initialize(config)
        @config = config
      end

      def get_request_url(bucket, object)
        url = @config.endpoint.dup
        isIP = !!(url.host =~ Resolv::IPv4::Regex)
        url.host = "#{bucket}." + url.host if bucket && !@config.cname && !isIP
        url.path = '/'
        url.path << "#{bucket}/" if bucket && isIP
        url.path << "#{CGI.escape(object)}" if object

        url.to_s
      end

      def get_resource_path(bucket, object)
        res = '/'
        res << "#{bucket}/" if bucket
        res << "#{object}" if object

        res
      end

      # Handle Net::HTTPRespoonse
      def handle_response(r, &block)
        # read all body on error
        if r.code.to_i >= 300
          r.read_body
        else
        # streaming read body on success
          encoding = r['content-encoding']
          if encoding == 'gzip'
            stream = StreamWriter.new { |s| r.read_body { |chunk| s << chunk } }
            reader = Zlib::GzipReader.new(stream)
            yield reader.read(16 * 1024) until reader.eof?
          elsif encoding == 'deflate'
            begin
              stream = Zlib::Inflate.new
              # 1.9.x doesn't support streaming inflate
              if RUBY_VERSION < '2.0.0'
                yield stream.inflate(r.read_body)
              else
                r.read_body { |chunk| stream << chunk }
                stream.finish { |chunk| yield chunk }
              end
            rescue Zlib::DataError
              # No luck with Zlib decompression. Let's try with raw deflate,
              # like some broken web servers do.
              stream = Zlib::Inflate.new(-Zlib::MAX_WBITS)
              # 1.9.x doesn't support streaming inflate
              if RUBY_VERSION < '2.0.0'
                yield stream.inflate(r.read_body)
              else
                r.read_body { |chunk| stream << chunk }
                stream.finish { |chunk| yield chunk }
              end
            end
          else
            r.read_body { |chunk| yield chunk }
          end
        end
      end

      ##
      # helper methods
      #
      def get(resources = {}, http_options = {}, &block)
        do_request('GET', resources, http_options, &block)
      end

      def put(resources = {}, http_options = {}, &block)
        do_request('PUT', resources, http_options, &block)
      end

      def post(resources = {}, http_options = {}, &block)
        do_request('POST', resources, http_options, &block)
      end

      def delete(resources = {}, http_options = {}, &block)
        do_request('DELETE', resources, http_options, &block)
      end

      def head(resources = {}, http_options = {}, &block)
        do_request('HEAD', resources, http_options, &block)
      end

      def options(resources = {}, http_options = {}, &block)
        do_request('OPTIONS', resources, http_options, &block)
      end

      private
      # Do HTTP reqeust
      # @param verb [String] HTTP Verb: GET/PUT/POST/DELETE/HEAD/OPTIONS
      # @param resources [Hash] OSS related resources
      # @option resources [String] :bucket the bucket name
      # @option resources [String] :object the object name
      # @option resources [Hash] :sub_res sub-resources
      # @param http_options [Hash] HTTP options
      # @option http_options [Hash] :headers HTTP headers
      # @option http_options [Hash] :query HTTP queries
      # @option http_options [Object] :body HTTP body, may be String
      #  or Stream
      def do_request(verb, resources = {}, http_options = {}, &block)
        bucket = resources[:bucket]
        object = resources[:object]
        sub_res = resources[:sub_res]

        headers = http_options[:headers] || {}
        headers['user-agent'] = get_user_agent
        headers['date'] = Time.now.httpdate
        headers['content-type'] ||= DEFAULT_CONTENT_TYPE
        headers['accept-encoding'] ||= DEFAULT_ACCEPT_ENCODING
        headers[STS_HEADER] = @config.sts_token if @config.sts_token

        if body = http_options[:body]
          if body.respond_to?(:read)
            headers['transfer-encoding'] = 'chunked'
          else
            headers['content-md5'] = Util.get_content_md5(body)
          end
        end

        res = {
          :path => get_resource_path(bucket, object),
          :sub_res => sub_res,
        }

        if @config.access_key_id and @config.access_key_secret
          sig = Util.get_signature(@config.access_key_secret, verb, headers, res)
          headers['authorization'] = "OSS #{@config.access_key_id}:#{sig}"
        end

        logger.debug("Send HTTP request, verb: #{verb}, resources: " \
                      "#{resources}, http options: #{http_options}")

        # From rest-client:
        # "Due to unfortunate choices in the original API, the params
        # used to populate the query string are actually taken out of
        # the headers hash."
        headers[:params] = (sub_res || {}).merge(http_options[:query] || {})

        block_response = ->(r) { handle_response(r, &block) } if block
        r = RestClient::Request.execute(
          :method => verb,
          :url => get_request_url(bucket, object),
          :headers => headers,
          :payload => http_options[:body],
          :block_response => block_response,
          :open_timeout => @config.open_timeout || OPEN_TIMEOUT,
          :timeout => @config.read_timeout || READ_TIMEOUT
        ) do |response, request, result, &blk|

          if response.code >= 300
            e = ServerError.new(response)
            logger.error(e.to_s)
            raise e
          else
            response.return!(request, result, &blk)
          end
        end

        # If streaming read_body is used, we need to create the
        # RestClient::Response ourselves
        unless r.is_a?(RestClient::Response)
          if r.code.to_i >= 300
            r = RestClient::Response.create(
              RestClient::Request.decode(r['content-encoding'], r.body),
              r, nil, nil)
            e = ServerError.new(r)
            logger.error(e.to_s)
            raise e
          end
          r = RestClient::Response.create(nil, r, nil, nil)
          r.return!
        end

        logger.debug("Received HTTP response, code: #{r.code}, headers: " \
                      "#{r.headers}, body: #{r.body}")

        r
      end

      def get_user_agent
        "aliyun-sdk-ruby/#{VERSION} ruby-#{RUBY_VERSION}/#{RUBY_PLATFORM}"
      end

    end # HTTP
  end # OSS
end # Aliyun

# Monkey patch rest-client to exclude the 'Content-Length' header when
# 'Transfer-Encoding' is set to 'chuncked'. This may be a problem for
# some http servers like tengine.
module RestClient
  module Payload
    class Base
      def headers
        ({'content-length' => size.to_s} if size) || {}
      end
    end
  end
end

1	# -- encoding: utf-8 --
2
3	require 'rest-client'	4✔
4	require 'resolv'	4✔
5	require 'fiber'	4✔
6
7	module Aliyun	4✔
8	module OSS	4✔
9
10	##
11	# HTTP wraps the HTTP functionalities for accessing OSS RESTful
12	# API. It handles the OSS-specific protocol elements, and
13	# rest-client details for the user, which includes:
14	# * automatically generate signature for every request
15	# * parse response headers/body
16	# * raise exceptions and capture the request id
17	# * encapsulates streaming upload/download
18	# @example simple get
19	# headers, body = http.get({:bucket => 'bucket'})
20	# @example streaming download
21	# http.get({:bucket => 'bucket', :object => 'object'}) do \|chunk\|
22	# # handle chunk
23	# end
24	# @example streaming upload
25	# def streaming_upload(&block)
26	# http.put({:bucket => 'bucket', :object => 'object'},
27	# {:body => HTTP::StreamPlayload.new(block)})
28	# end
29	#
30	# streaming_upload do \|stream\|
31	# stream << "hello world"
32	# end
33	class HTTP	4✔
34
35	DEFAULT_CONTENT_TYPE = 'application/octet-stream'	4✔
36	DEFAULT_ACCEPT_ENCODING = 'identity'	4✔
37	STS_HEADER = 'x-oss-security-token'	4✔
38	OPEN_TIMEOUT = 10	4✔
39	READ_TIMEOUT = 120	4✔
40
41	##
42	# A stream implementation
43	# A stream is any class that responds to :read(bytes, outbuf)
44	#
45	class StreamWriter	4✔
46	attr_reader :data_crc	4✔
47
48	def initialize(crc_enable = false, init_crc = 0)	4✔
49	@buffer = ""	608✔
50	@producer = Fiber.new { yield self if block_given? }	1,216✔
51	@producer.resume	608✔
52	@data_crc = init_crc.to_i	608✔
53	@crc_enable = crc_enable	608✔
54	end
55
56	def read(bytes = nil, outbuf = nil)	4✔
57	ret = ""	680✔
58	loop do	680✔
59	if bytes	2,444✔
60	fail if bytes < 0	1,288✔
61	piece = @buffer.slice!(0, bytes)	1,288✔
62	if piece	1,288✔
63	ret << piece	1,288✔
64	bytes -= piece.size	1,288✔
65	break if bytes == 0	1,288✔
66	end
67	else
68	ret << @buffer	1,156✔
69	@buffer.clear	1,156✔
70	end
71
72	if @producer.alive?	2,376✔
73	@producer.resume	1,764✔
74	else
75	break	612✔
76	end
77	end
78
79	if outbuf	680✔
80	# WARNING: Using outbuf = '' here DOES NOT work!
81	outbuf.clear	48✔
82	outbuf << ret	48✔
83	end
84
85	# Conform to IO#read(length[, outbuf]):
86	# At end of file, it returns nil or "" depend on
87	# length. ios.read() and ios.read(nil) returns
88	# "". ios.read(positive-integer) returns nil.
89	return nil if ret.empty? && !bytes.nil? && bytes > 0	680✔
90
91	@data_crc = Aliyun::OSS::Util.crc(ret, @data_crc) if @crc_enable	676✔
92
93	ret	676✔
94	end
95
96	def write(chunk)	4✔
97	@buffer << chunk.to_s.force_encoding(Encoding::ASCII_8BIT)	1,764✔
98	Fiber.yield	1,764✔
99	self	1,764✔
100	end
101
102	alias << write	4✔
103
104	def closed?	4✔
105	false	×
106	end
107
108	def inspect	4✔
109	"@buffer: " + @buffer[0, 32].inspect + "...#{@buffer.size} bytes"	584✔
110	end
111	end
112
113	# RestClient requires the payload to respones to :read(bytes)
114	# and return a stream.
115	# We are not doing the real read here, just return a
116	# readable stream for RestClient playload.rb treats it as:
117	# def read(bytes=nil)
118	# @stream.read(bytes)
119	# end
120	# alias :to_s :read
121	# net_http_do_request(http, req, payload ? payload.to_s : nil,
122	# &@block_response)
123	class StreamPayload	4✔
124	def initialize(crc_enable = false, init_crc = 0, &block)	4✔
125	@stream = StreamWriter.new(crc_enable, init_crc, &block)	584✔
126	end
127
128	def read(bytes = nil)	4✔
129	@stream	608✔
130	end
131
132	def close	4✔
133	end
134
135	def closed?	4✔
136	false	584✔
137	end
138	end
139
140	include Common::Logging	4✔
141
142	def initialize(config)	4✔
143	@config = config	216✔
144	end
145
146	def get_request_url(bucket, object)	4✔
147	url = @config.endpoint.dup	1,652✔
148	isIP = !!(url.host =~ Resolv::IPv4::Regex)	1,652✔
149	url.host = "#{bucket}." + url.host if bucket && !@config.cname && !isIP	1,652✔
150	url.path = '/'	1,652✔
151	url.path << "#{bucket}/" if bucket && isIP	1,652✔
152	url.path << "#{CGI.escape(object)}" if object	1,652✔
153
154	url.to_s	1,652✔
155	end
156
157	def get_resource_path(bucket, object)	4✔
158	res = '/'	1,680✔
159	res << "#{bucket}/" if bucket	1,680✔
160	res << "#{object}" if object	1,680✔
161
162	res	1,680✔
163	end
164
165	# Handle Net::HTTPRespoonse
166	def handle_response(r, &block)	4✔
167	# read all body on error
168	if r.code.to_i >= 300	304✔
169	r.read_body	28✔
170	else
171	# streaming read body on success
172	encoding = r['content-encoding']	276✔
173	if encoding == 'gzip'	276✔
174	stream = StreamWriter.new { \|s\| r.read_body { \|chunk\| s << chunk } }	×
175	reader = Zlib::GzipReader.new(stream)	×
176	yield reader.read(16 * 1024) until reader.eof?	×
177	elsif encoding == 'deflate'	276✔
178	begin	×
179	stream = Zlib::Inflate.new	×
180	# 1.9.x doesn't support streaming inflate
181	if RUBY_VERSION < '2.0.0'	×
182	yield stream.inflate(r.read_body)	×
183	else
184	r.read_body { \|chunk\| stream << chunk }	×
185	stream.finish { \|chunk\| yield chunk }	×
186	end
187	rescue Zlib::DataError	×
188	# No luck with Zlib decompression. Let's try with raw deflate,
189	# like some broken web servers do.
190	stream = Zlib::Inflate.new(-Zlib::MAX_WBITS)	×
191	# 1.9.x doesn't support streaming inflate
192	if RUBY_VERSION < '2.0.0'	×
193	yield stream.inflate(r.read_body)	×
194	else
195	r.read_body { \|chunk\| stream << chunk }	×
196	stream.finish { \|chunk\| yield chunk }	×
197	end
198	end
199	else
200	r.read_body { \|chunk\| yield chunk }	520✔
201	end
202	end
203	end
204
205	##
206	# helper methods
207	#
208	def get(resources = {}, http_options = {}, &block)	4✔
209	do_request('GET', resources, http_options, &block)	448✔
210	end
211
212	def put(resources = {}, http_options = {}, &block)	4✔
213	do_request('PUT', resources, http_options, &block)	636✔
214	end
215
216	def post(resources = {}, http_options = {}, &block)	4✔
217	do_request('POST', resources, http_options, &block)	172✔
218	end
219
220	def delete(resources = {}, http_options = {}, &block)	4✔
221	do_request('DELETE', resources, http_options, &block)	48✔
222	end
223
224	def head(resources = {}, http_options = {}, &block)	4✔
225	do_request('HEAD', resources, http_options, &block)	328✔
226	end
227
228	def options(resources = {}, http_options = {}, &block)	4✔
229	do_request('OPTIONS', resources, http_options, &block)	4✔
230	end
231
232	private	4✔
233	# Do HTTP reqeust
234	# @param verb [String] HTTP Verb: GET/PUT/POST/DELETE/HEAD/OPTIONS
235	# @param resources [Hash] OSS related resources
236	# @option resources [String] :bucket the bucket name
237	# @option resources [String] :object the object name
238	# @option resources [Hash] :sub_res sub-resources
239	# @param http_options [Hash] HTTP options
240	# @option http_options [Hash] :headers HTTP headers
241	# @option http_options [Hash] :query HTTP queries
242	# @option http_options [Object] :body HTTP body, may be String
243	# or Stream
244	def do_request(verb, resources = {}, http_options = {}, &block)	4✔
245	bucket = resources[:bucket]	1,636✔
246	object = resources[:object]	1,636✔
247	sub_res = resources[:sub_res]	1,636✔
248
249	headers = http_options[:headers] \|\| {}	1,636✔
250	headers['user-agent'] = get_user_agent	1,636✔
251	headers['date'] = Time.now.httpdate	1,636✔
252	headers['content-type'] \|\|= DEFAULT_CONTENT_TYPE	1,636✔
253	headers['accept-encoding'] \|\|= DEFAULT_ACCEPT_ENCODING	1,636✔
254	headers[STS_HEADER] = @config.sts_token if @config.sts_token	1,636✔
255
256	if body = http_options[:body]	1,636✔
257	if body.respond_to?(:read)	684✔
258	headers['transfer-encoding'] = 'chunked'	584✔
259	else
260	headers['content-md5'] = Util.get_content_md5(body)	100✔
261	end
262	end
263
264	res = {	1,636✔
265	:path => get_resource_path(bucket, object),
266	:sub_res => sub_res,
267	}
268
269	if @config.access_key_id and @config.access_key_secret	1,636✔
270	sig = Util.get_signature(@config.access_key_secret, verb, headers, res)	1,632✔
271	headers['authorization'] = "OSS #{@config.access_key_id}:#{sig}"	1,632✔
272	end
273
274	logger.debug("Send HTTP request, verb: #{verb}, resources: " \	1,636✔
275	"#{resources}, http options: #{http_options}")
276
277	# From rest-client:
278	# "Due to unfortunate choices in the original API, the params
279	# used to populate the query string are actually taken out of
280	# the headers hash."
281	headers[:params] = (sub_res \|\| {}).merge(http_options[:query] \|\| {})	1,636✔
282
283	block_response = ->(r) { handle_response(r, &block) } if block	1,940✔
284	r = RestClient::Request.execute(	1,636✔
285	:method => verb,
286	:url => get_request_url(bucket, object),
287	:headers => headers,
288	:payload => http_options[:body],
289	:block_response => block_response,
290	:open_timeout => @config.open_timeout \|\| OPEN_TIMEOUT,
291	:timeout => @config.read_timeout \|\| READ_TIMEOUT
292	) do \|response, request, result, &blk\|
293
294	if response.code >= 300	1,332✔
295	e = ServerError.new(response)	100✔
296	logger.error(e.to_s)	100✔
297	raise e	100✔
298	else
299	response.return!(request, result, &blk)	1,232✔
300	end
301	end
302
303	# If streaming read_body is used, we need to create the
304	# RestClient::Response ourselves
305	unless r.is_a?(RestClient::Response)	1,536✔
306	if r.code.to_i >= 300	304✔
307	r = RestClient::Response.create(	28✔
308	RestClient::Request.decode(r['content-encoding'], r.body),
309	r, nil, nil)
310	e = ServerError.new(r)	28✔
311	logger.error(e.to_s)	28✔
312	raise e	28✔
313	end
314	r = RestClient::Response.create(nil, r, nil, nil)	276✔
315	r.return!	276✔
316	end
317
318	logger.debug("Received HTTP response, code: #{r.code}, headers: " \	1,508✔
319	"#{r.headers}, body: #{r.body}")
320
321	r	1,508✔
322	end
323
324	def get_user_agent	4✔
325	"aliyun-sdk-ruby/#{VERSION} ruby-#{RUBY_VERSION}/#{RUBY_PLATFORM}"	1,636✔
326	end
327
328	end # HTTP
329	end # OSS
330	end # Aliyun
331
332	# Monkey patch rest-client to exclude the 'Content-Length' header when
333	# 'Transfer-Encoding' is set to 'chuncked'. This may be a problem for
334	# some http servers like tengine.
335	module RestClient	4✔
336	module Payload	4✔
337	class Base	4✔
338	def headers	4✔
339	({'content-length' => size.to_s} if size) \|\| {}	696✔
340	end
341	end
342	end
343	end

aliyun / aliyun-oss-ruby-sdk / 130

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous