JRuby가 SSL을 통한 스팀 전송으로 높은 메모리 사용량을 초래합니다.

Question

JRuby (jruby-openssl 0.9.21을 사용하여 9.1.8.0)를 사용하여 큰 JSON 파일 (~ 300MB)을 Solr에 스트리밍하려고합니다. 원격 Solr 서버가 SSL 인증을 사용 중입니다. 아래 스크립트를 포함 시켰습니다.

JRuby를 사용할 때 기본값 500MB를 사용하여 거의 즉시 힙 공간이 부족합니다. MRI를 사용하면 사용량이 40MB를 넘지 않습니다. SSL을 사용하지 않으면 JRuby가 정상적으로 작동합니다. 필자는 순수 Java로 유사한 프로세스를 수행했지만 이런 종류의 문제는 없었습니다. ... 여기에 어떤 제안에 대한

감사합니다 ... 무슨 일이 일어나고 있는지 확실하지

require 'openssl' 
require 'net/http' 
require 'json' 

PEM_FILE = ENV["CLIENT_CERT"] 
SOLR_URL = ENV["SOLR_URL"] 

class SolrClient 

    DEFAULT_OPTIONS = { 
    use_ssl: true, 
    verify_mode: OpenSSL::SSL::VERIFY_PEER, 
    keep_alive_timeout: 30, 
    cert: OpenSSL::X509::Certificate.new(IO.read(PEM_FILE)), 
    key: OpenSSL::PKey::RSA.new(IO.read(PEM_FILE)), 
    } 


    def initialize(http = nil) 
    if http 
     @http = http 
    else 
     @http = Net::HTTP.start('my.solr.url', 443, DEFAULT_OPTIONS) 
    end 
    end 

    def update() 
    bytes = File.open('index_batch.json', 'rb').bytes.count.to_s 
    stream = File.open('index_batch.json', 'rb') 
    puts "starting request..." 
    request = Net::HTTP::Post.new "/solr/archivesspace/update" 
    request['Content-Type'] = 'application/json' 
    request['Content-Length'] = bytes 
    request.body_stream = stream 

    response = @http.request request 
    puts response.body 
    end 

end 


SolrClient.new.update 

Answer 1

는 JRuby에서의 GitHub의에 문제를 게시하고 즉시 응답을 얻었다 : A와

https://github.com/jruby/jruby/issues/4842

임시 픽스, 패치 중입니다. http :

class Net::HTTPGenericRequest 

    def send_request_with_body_stream(sock, ver, path, f)                                  
    unless content_length() or chunked?                                      
     raise ArgumentError,                                         
      "Content-Length not given and Transfer-Encoding is not `chunked'"                             
    end                                              
    supply_default_content_type                                        
    write_header sock, ver, path                                        
    wait_for_continue sock, ver if sock.continue_timeout                                  
    if chunked?                                            
     chunker = Chunker.new(sock)                                        
     IO.copy_stream(f, chunker)                                        
     chunker.finish                                           
    else                                              
     # copy_stream can sendfile() to sock.io unless we use SSL.                                
     # If sock.io is an SSLSocket, copy_stream will hit SSL_write()                               
     if sock.io.is_a? OpenSSL::SSL::SSLSocket                                    
     IO.copy_stream(f, sock.io, 16 * 1024 * 1024) until f.eof?                                
     else                                             
     IO.copy_stream(f, sock.io)                                       
     end                                              
    end                                              
    end                                               
end