¿Cómo descargo un archivo binario a través de HTTP?

¿Cómo descargo y guardo un archivo binario a través de HTTP usando Ruby?

La URL es http://somedomain.net/flv/sample/sample.flv.

Estoy en la plataforma de Windows y preferiría no ejecutar ningún programa externo.

La forma más simple es la solución específica de la plataforma:

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

Probablemente estés buscando:

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: modificado. Gracias.

Edit2: la solución que guarda parte de un archivo durante la descarga:

# 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

Sé que esta es una vieja pregunta, pero Google me arrojó aquí y creo que encontré una respuesta más simple.

En Railscasts # 179 , Ryan Bates utilizó la clase estándar Ruby OpenURI para hacer mucho de lo que se le pidió de esta manera:

( Advertencia : código no probado. Es posible que deba cambiarlo / 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

Aquí está mi Ruby http para presentar 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

La principal ventaja aquí es conciso y simple, porque openhace gran parte del trabajo pesado. Y no lee toda la respuesta en la memoria.

El openmétodo transmitirá respuestas> 1kb a a Tempfile. Podemos explotar este conocimiento para implementar este método de descarga magra a archivo. Vea la OpenURI::Bufferimplementación aquí.

¡Tenga cuidado con las aportaciones proporcionadas por el usuario! open(name, *rest, &block)no es seguro si nameproviene de la entrada del usuario!

El ejemplo 3 en la documentación de red / http de Ruby muestra cómo descargar un documento a través de HTTP y generar el archivo en lugar de simplemente cargarlo en la memoria.

Los casos más complejos se muestran más abajo en el mismo documento.

Puedes usar open-uri, que es un trazador de líneas

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

Ampliando la respuesta 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 
      }
    }
  }
}

donde filenamey urlson cuerdas.

El sleepcomando es un truco que puede reducir drásticamente el uso de la CPU cuando la red es el factor limitante. Net :: HTTP no espera a que se llene el búfer (16kB en v1.9.2) antes de ceder, por lo que la CPU se ocupa de mover pequeños trozos. Dormir por un momento le da al búfer la oportunidad de llenarse entre escrituras, y el uso de la CPU es comparable a una solución curl, con una diferencia de 4-5x en mi aplicación. Una solución más sólida podría examinar el progreso f.posy ajustar el tiempo de espera para alcanzar, por ejemplo, el 95% del tamaño del búfer; de hecho, así es como obtuve el número 0.005 en mi ejemplo.

Lo siento, pero no conozco una forma más elegante de hacer que Ruby espere a que se llene el búfer.

Editar:

Esta es una versión que se ajusta automáticamente para mantener el búfer a la capacidad o por debajo. Es una solución poco elegante, pero parece ser tan rápida y usar tan poco tiempo de CPU, como se dice que se encrespa.

Funciona en tres etapas. Un breve período de aprendizaje con un tiempo de sueño deliberadamente largo establece el tamaño de un búfer completo. El período de caída reduce el tiempo de suspensión rápidamente con cada iteración, multiplicándolo por un factor mayor, hasta que encuentra un búfer insuficientemente lleno. Luego, durante el período normal, se ajusta hacia arriba y hacia abajo en un factor menor.

Mi Ruby está un poco oxidado, así que estoy seguro de que esto se puede mejorar. En primer lugar, no hay manejo de errores. Además, ¿tal vez podría separarse en un objeto, lejos de la descarga en sí, para que simplemente llame autosleep.sleep(f.pos)a su bucle? Aún mejor, Net :: HTTP podría cambiarse para esperar un búfer completo antes de producir :-)

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

Hay más bibliotecas aptasNet::HTTP para api que , por ejemplo, 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

Tuve problemas si el archivo contenía Umlauts alemanes (ä, ö, ü). Podría resolver el problema usando:

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

si está buscando una manera de descargar un archivo temporal, hacer cosas y eliminarlo, pruebe 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