Wie lade ich eine Binärdatei über HTTP herunter?

Wie lade ich eine Binärdatei über HTTP mit Ruby herunter und speichere sie?

Die URL lautet http://somedomain.net/flv/sample/sample.flv.

Ich bin auf der Windows-Plattform und würde es vorziehen, kein externes Programm auszuführen.

Der einfachste Weg ist die plattformspezifische Lösung:

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

Wahrscheinlich suchen Sie nach:

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

Bearbeiten: Geändert. Danke.

Edit2: Die Lösung, die einen Teil einer Datei beim Herunterladen speichert:

# 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

Ich weiß, dass dies eine alte Frage ist, aber Google hat mich hierher geworfen und ich denke, ich habe eine einfachere Antwort gefunden.

In Railscasts Nr. 179 verwendete Ryan Bates die Ruby-Standardklasse OpenURI , um viele der folgenden Fragen zu beantworten :

( Warnung : ungetesteter Code. Möglicherweise müssen Sie ihn ändern / optimieren.)

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

Hier ist mein Ruby http zur Datei mit 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

Der Hauptvorteil hier ist es prägnant und einfach, weil ein openGroßteil des schweren Hebens erledigt.Und es liest nicht die gesamte Antwort im Speicher.

Die openMethode überträgt Antworten> 1 KB an a Tempfile. Wir können dieses Wissen nutzen, um diese Lean-Download-to-File-Methode zu implementieren. Siehe die OpenURI::BufferImplementierung hier.

Bitte seien Sie vorsichtig mit vom Benutzer bereitgestellten Eingaben! open(name, *rest, &block)ist unsicher, wenn namevon Benutzereingaben kommt!

Beispiel 3 in der net / http-Dokumentation von Ruby zeigt, wie Sie ein Dokument über HTTP herunterladen und die Datei ausgeben, anstatt sie nur in den Speicher zu laden. Ersetzen Sie Puts durch ein binäres Schreiben in eine Datei, z. B. wie in Dejws Antwort gezeigt.

Komplexere Fälle werden weiter unten im selben Dokument gezeigt.

Sie können Open-Uri verwenden, einen Einzeiler

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

Oder mit net / http

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

Erweiterung der Antwort von 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 
      }
    }
  }
}

wo filenameundurl sind Saiten.

Der sleepBefehl ist ein Hack, der die CPU-Auslastung drastisch reduzieren kann, wenn das Netzwerk der begrenzende Faktor ist. Net :: HTTP wartet nicht darauf, dass der Puffer (16 KB in Version 1.9.2) gefüllt wird, bevor er nachgibt, sodass die CPU selbst kleine Teile bewegt. Wenn Sie einen Moment lang schlafen, kann sich der Puffer zwischen den Schreibvorgängen füllen, und die CPU-Auslastung ist vergleichbar mit einer Curl-Lösung, die sich in meiner Anwendung um das 4-5-fache unterscheidet. Eine robustere Lösung könnte den Fortschritt von untersuchenf.pos und das Zeitlimit anpassen, um beispielsweise 95% der Puffergröße zu erreichen - tatsächlich habe ich in meinem Beispiel die 0,005-Zahl erhalten.

Entschuldigung, aber ich kenne keine elegantere Möglichkeit, Ruby warten zu lassen, bis sich der Puffer gefüllt hat.

Bearbeiten:

Dies ist eine Version, die sich automatisch anpasst, um den Puffer auf oder unter der Kapazität zu halten. Es ist eine unelegante Lösung, aber es scheint genauso schnell zu sein und so wenig CPU-Zeit zu verbrauchen, wie es zum Locken aufruft.

Es funktioniert in drei Stufen. Eine kurze Lernphase mit einer absichtlich langen Schlafzeit legt die Größe eines vollen Puffers fest. Die Drop-Periode reduziert die Ruhezeit bei jeder Iteration schnell, indem sie mit einem größeren Faktor multipliziert wird, bis ein unterfüllter Puffer gefunden wird. Während der normalen Zeit wird es dann um einen kleineren Faktor nach oben und unten angepasst.

Mein Ruby ist etwas rostig, daher bin ich mir sicher, dass dies verbessert werden kann. Erstens gibt es keine Fehlerbehandlung. Vielleicht könnte es auch in ein Objekt getrennt werden, weg vom Herunterladen selbst, so dass Sie einfach autosleep.sleep(f.pos)in Ihrer Schleife aufrufen würden ? Noch besser ist, dass Net :: HTTP geändert werden könnte, um auf einen vollen Puffer zu warten, bevor es ergibt :-)

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

Es gibt api-freundlichere Bibliotheken als Net::HTTPzum Beispiel 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

Ich hatte Probleme, wenn die Datei deutsche Umlaute enthielt (ä, ö, ü). Ich könnte das Problem lösen mit:

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

Wenn Sie nach einer Möglichkeit suchen, temporäre Dateien herunterzuladen, Dinge zu tun und sie zu löschen, versuchen Sie dieses Juwel 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