Como faço para baixar um arquivo binário via HTTP?

Como faço para baixar e salvar um arquivo binário em HTTP usando Ruby?

A URL é http://somedomain.net/flv/sample/sample.flv.

Estou na plataforma Windows e prefiro não executar nenhum programa externo.

A maneira mais simples é a solução específica da plataforma:

 #!/usr/bin/env ruby
`wget http://somedomain.net/flv/sample/sample.flv`

Provavelmente você está procurando:

require 'net/http'
# Must be somedomain.net instead of somedomain.net/, otherwise, it will throw exception.
Net::HTTP.start("somedomain.net") do |http|
    resp = http.get("/flv/sample/sample.flv")
    open("sample.flv", "wb") do |file|
        file.write(resp.body)
    end
end
puts "Done."

Editar: alterado. Obrigado.

Edit2: A solução que salva parte de um arquivo durante o download:

# instead of http.get
f = open('sample.flv')
begin
    http.request_get('/sample.flv') do |resp|
        resp.read_body do |segment|
            f.write(segment)
        end
    end
ensure
    f.close()
end

Sei que essa é uma pergunta antiga, mas o Google me jogou aqui e acho que encontrei uma resposta mais simples.

No Railscasts # 179 , Ryan Bates usou a classe padrão Ruby OpenURI para fazer muito do que foi solicitado assim:

( Aviso : código não testado. Pode ser necessário alterá-lo / ajustá-lo.)

require 'open-uri'

File.open("/my/local/path/sample.flv", "wb") do |saved_file|
  # the following "open" is provided by open-uri
  open("http://somedomain.net/flv/sample/sample.flv", "rb") do |read_file|
    saved_file.write(read_file.read)
  end
end

Aqui está o meu http Ruby para arquivar usando open(name, *rest, &block).

require "open-uri"
require "fileutils"

def download(url, path)
  case io = open(url)
  when StringIO then File.open(path, 'w') { |f| f.write(io) }
  when Tempfile then io.close; FileUtils.mv(io.path, path)
  end
end

A principal vantagem aqui é concisa e simples, porque openfaz grande parte do trabalho pesado. E não lê toda a resposta na memória.

O openmétodo transmitirá respostas> 1kb para a Tempfile. Podemos explorar esse conhecimento para implementar esse método lean de download para arquivo. Veja a OpenURI::Bufferimplementação aqui.

Tenha cuidado com a entrada fornecida pelo usuário! open(name, *rest, &block)é inseguro se namevier da entrada do usuário!

O exemplo 3 da documentação net / http do Ruby mostra como fazer o download de um documento por HTTP e, como resultado, em vez de apenas carregá-lo na memória, o substituto coloca uma gravação binária em um arquivo, por exemplo, como mostrado na resposta de Dejw.

Casos mais complexos são mostrados mais abaixo no mesmo documento.

Você pode usar o open-uri, que é um liner

require 'open-uri'
content = open('http://example.com').read

Ou usando net / http

require 'net/http'
File.write("file_name", Net::HTTP.get(URI.parse("http://url.com")))

Expandindo a resposta de Dejw (edit2):

File.open(filename,'w'){ |f|
  uri = URI.parse(url)
  Net::HTTP.start(uri.host,uri.port){ |http| 
    http.request_get(uri.path){ |res| 
      res.read_body{ |seg|
        f << seg
#hack -- adjust to suit:
        sleep 0.005 
      }
    }
  }
}

onde filenameeurl são strings.

O sleepcomando é um hack que pode reduzir drasticamente o uso da CPU quando a rede é o fator limitante. O Net :: HTTP não espera que o buffer (16kB na v1.9.2) seja preenchido antes de render, então a CPU se ocupa movendo pequenos pedaços. Dormir por um momento dá ao buffer a chance de preencher entre gravações e o uso da CPU é comparável a uma solução de curl, diferença de 4-5x no meu aplicativo. Uma solução mais robusta pode examinar o progresso def.pos e ajustar o tempo limite para atingir, digamos, 95% do tamanho do buffer - na verdade, foi assim que obtive o número 0,005 no meu exemplo.

Desculpe, mas não conheço uma maneira mais elegante de fazer com que Ruby aguarde o buffer preencher.

Editar:

Esta é uma versão que se ajusta automaticamente para manter o buffer igual ou inferior à capacidade. É uma solução deselegante, mas parece ser tão rápida e usar tão pouco tempo de CPU, como está chamando a curl.

Funciona em três etapas. Um breve período de aprendizado com um tempo de sono deliberadamente longo estabelece o tamanho de um buffer completo. O período de queda reduz o tempo de suspensão rapidamente a cada iteração, multiplicando-o por um fator maior, até encontrar um buffer insuficiente. Então, durante o período normal, ele se ajusta para cima e para baixo por um fator menor.

Meu Ruby está um pouco enferrujado, então tenho certeza de que isso pode ser melhorado. Primeiro de tudo, não há tratamento de erros. Além disso, talvez ele possa ser separado em um objeto, longe do próprio download, para que você apenas chame autosleep.sleep(f.pos)no seu loop? Melhor ainda, o Net :: HTTP pode ser alterado para aguardar um buffer completo antes de produzir :-)

def http_to_file(filename,url,opt={})
  opt = {
    :init_pause => 0.1,    #start by waiting this long each time
                           # it's deliberately long so we can see 
                           # what a full buffer looks like
    :learn_period => 0.3,  #keep the initial pause for at least this many seconds
    :drop => 1.5,          #fast reducing factor to find roughly optimized pause time
    :adjust => 1.05        #during the normal period, adjust up or down by this factor
  }.merge(opt)
  pause = opt[:init_pause]
  learn = 1 + (opt[:learn_period]/pause).to_i
  drop_period = true
  delta = 0
  max_delta = 0
  last_pos = 0
  File.open(filename,'w'){ |f|
    uri = URI.parse(url)
    Net::HTTP.start(uri.host,uri.port){ |http|
      http.request_get(uri.path){ |res|
        res.read_body{ |seg|
          f << seg
          delta = f.pos - last_pos
          last_pos += delta
          if delta > max_delta then max_delta = delta end
          if learn <= 0 then
            learn -= 1
          elsif delta == max_delta then
            if drop_period then
              pause /= opt[:drop_factor]
            else
              pause /= opt[:adjust]
            end
          elsif delta < max_delta then
            drop_period = false
            pause *= opt[:adjust]
          end
          sleep(pause)
        }
      }
    }
  }
end

Existem mais bibliotecas compatíveis com API do que Net::HTTP, por exemplo, activationparty :

require "httparty"
File.open("/tmp/my_file.flv", "wb") do |f| 
  f.write HTTParty.get("http://somedomain.net/flv/sample/sample.flv").parsed_response
end

Eu tive problemas, se o arquivo continha trema alemão (ä, ö, ü). Eu poderia resolver o problema usando:

ec = Encoding::Converter.new('iso-8859-1', 'utf-8')
...
f << ec.convert(seg)
...

se você estiver procurando uma maneira de baixar um arquivo temporário, faça coisas e exclua-o, tente esta gema https://github.com/equivalent/pull_tempfile

require 'pull_tempfile'

PullTempfile.transaction(url: 'https://mycompany.org/stupid-csv-report.csv', original_filename: 'dont-care.csv') do |tmp_file|
  CSV.foreach(tmp_file.path) do |row|
    # ....
  end
end