Come faccio a scaricare un file binario su HTTP?

Come faccio a scaricare e salvare un file binario su HTTP utilizzando Ruby?

L'URL è http://somedomain.net/flv/sample/sample.flv.

Sono sulla piattaforma Windows e preferirei non eseguire alcun programma esterno.

Il modo più semplice è la soluzione specifica per la piattaforma:

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

Probabilmente stai cercando:

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."

Modifica: modificato. Grazie.

Edit2: la soluzione che salva parte di un file durante il 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

So che questa è una vecchia domanda, ma Google mi ha lanciato qui e penso di aver trovato una risposta più semplice.

In Railscasts # 179 , Ryan Bates ha usato la classe standard Ruby OpenURI per fare gran parte di ciò che è stato chiesto in questo modo:

( Avviso : codice non testato. Potrebbe essere necessario modificarlo / modificarlo.)

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

Ecco il mio ruby ​​http per file 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

Il vantaggio principale qui è conciso e semplice, perché openfa gran parte del sollevamento pesante. E non legge l'intera risposta in memoria.

Il openmetodo eseguirà lo streaming delle risposte> 1kb a a Tempfile. Siamo in grado di sfruttare questa conoscenza per implementare questo metodo di download snello su file. Vedi l' OpenURI::Bufferimplementazione qui.

Si prega di fare attenzione con l'input fornito dall'utente! open(name, *rest, &block)non è sicuro se nameproviene dall'input dell'utente!

L'esempio 3 nella documentazione net / http di Ruby mostra come scaricare un documento su HTTP e come produrre il file invece di caricarlo semplicemente in memoria, i sostituti inseriscono una scrittura binaria in un file, ad esempio come mostrato nella risposta di Dejw.

Casi più complessi sono mostrati più in basso nello stesso documento.

Puoi usare open-uri, che è una fodera

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

O usando net / http

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

Espandendo la risposta di Dejw (modifica2):

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 
      }
    }
  }
}

dove filenamee urlsono stringhe.

Il sleepcomando è un hack che può ridurre drasticamente l'utilizzo della CPU quando la rete è il fattore limitante. Net :: HTTP non attende che il buffer (16kB in v1.9.2) si riempia prima di cedere, quindi la CPU si impegna a spostare piccoli pezzi in giro. La sospensione per un momento offre al buffer la possibilità di riempire tra le scritture e l'utilizzo della CPU è paragonabile a una soluzione di arricciatura, con una differenza di 4-5 volte nella mia applicazione. Una soluzione più solida potrebbe esaminare l'avanzamento f.pose regolare il timeout per target, diciamo, il 95% della dimensione del buffer - in effetti è così che ho ottenuto il numero 0,005 nel mio esempio.

Scusa, ma non conosco un modo più elegante di far aspettare Ruby per riempire il buffer.

Modificare:

Questa è una versione che si regola automaticamente per mantenere il buffer appena o al di sotto della capacità. È una soluzione non elegante, ma sembra essere altrettanto veloce e utilizza meno tempo della CPU, come sta chiamando per arricciarsi.

Funziona in tre fasi. Un breve periodo di apprendimento con un tempo di sonno deliberatamente lungo stabilisce le dimensioni di un buffer completo. Il periodo di rilascio riduce rapidamente il tempo di sospensione a ogni iterazione, moltiplicandolo per un fattore maggiore, fino a quando non trova un buffer insufficiente. Quindi, durante il periodo normale, si regola su e giù di un fattore minore.

Il mio Ruby è un po 'arrugginito, quindi sono sicuro che questo può essere migliorato. Prima di tutto, non c'è gestione degli errori. Inoltre, forse potrebbe essere separato in un oggetto, lontano dal download stesso, in modo da chiamare semplicemente autosleep.sleep(f.pos)nel tuo loop? Ancora meglio, Net :: HTTP potrebbe essere modificato per attendere un buffer completo prima di cedere :-)

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

Esistono più librerie compatibili con api di Net::HTTP, ad esempio httparty :

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

Ho avuto problemi, se il file conteneva German Umlauts (ä, ö, ü). Potrei risolvere il problema utilizzando:

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

se stai cercando un modo per scaricare un file temporaneo, fai cose ed eliminalo prova questo gioiello 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