Schienen-media-stream-Datei akzeptieren byte-range-request über send_data oder Methode send_file

Ich habe Folgendes problem. Sounds werden von der öffentlichkeit verborgen, Ordner, da es nur bestimmte Benutzer, die Zugriff auf die sound-Dateien. Also habe ich eine gewisse Methode, die wirkt wie ein sound-url, sondern berechnet zunächst, ob der aktuelle user berechtigt ist, Zugriff auf diese Datei.

Die Datei gesendet wird, von der send_data-Methode. Das problem ist nur, dass ich es funktioniert ziemlich langsam, wenn es funktioniert sogar... Die Entwickler der jplayer-plugin, das ich benutze, um den Ton wiederzugeben, erzählte mir, dass ich sollte in der Lage sein zu akzeptieren, byte-range-Anfragen, damit es richtig funktioniert...

Wie kann ich dies tun, innerhalb einer rails-controller, indem Sie die Datei mit send_data oder send_file?

Dank,
Markus

welche web-server benutzt du?
apache 2 mit PKW-modul
haben Sie versucht, gist.github.com/mikhailov/3174601 ?

InformationsquelleAutor Markus | 2011-07-20

Habe ich in der Lage zu dienen bis die Dateien mit einigem Erfolg mit send_file. Ich habe zwar einen kleinen Haken, auf der Suche nach einem älteren Lied, das bewirkt, dass eine neue Anfrage, die macht den song zu starten, von 0:00 anstelle der wahren Position von der seekbar. Dies ist, was ich habe, für mich zu arbeiten so weit:

  file_begin = 0
  file_size = @media.file_file_size 
  file_end = file_size - 1

  if !request.headers["Range"]
    status_code = "200 OK"
  else
    status_code = "206 Partial Content"
    match = request.headers['range'].match(/bytes=(\d+)-(\d*)/)
    if match
      file_begin = match[1]
      file_end = match[1] if match[2] && !match[2].empty?
    end
    response.header["Content-Range"] = "bytes " + file_begin.to_s + "-" + file_end.to_s + "/" + file_size.to_s
  end
  response.header["Content-Length"] = (file_end.to_i - file_begin.to_i + 1).to_s
  response.header["Last-Modified"] = @media.file_updated_at.to_s

  response.header["Cache-Control"] = "public, must-revalidate, max-age=0"
  response.header["Pragma"] = "no-cache"
  response.header["Accept-Ranges"]=  "bytes"
  response.header["Content-Transfer-Encoding"] = "binary"
  send_file(DataAccess.getUserMusicDirectory(current_user.public_token) + @media.sub_path, 
            :filename => @media.file_file_name,
            :type => @media.file_content_type, 
            :disposition => "inline",
            :status => status_code,
            :stream =>  'true',
            :buffer_size  =>  4096)

ich habe gerade versucht, und es funktioniert. obwohl die streaming-Optionen (:stream :buffer_size) sind nicht wirklich nötig hier.

InformationsquelleAutor Garrett

Hier ist meine version. Ich benutze Edelstein "ogginfo-rb' zu berechnen, die Dauer, die erforderlich ist, um zu dienen ogg-Dateien ordnungsgemäß.
p.s. Ich habe immer drei Formate - wav, mp3, ogg.

the_file = File.open(file_path)

file_begin = 0
file_size = the_file.size
file_end = file_size - 1

if request.headers['Range']
  status_code = :partial_content

  match = request.headers['range'].match(/bytes=(\d+)-(\d*)/)

  if match
    file_begin = match[1]
    file_end = match[1]  if match[2] and not match[2].empty?
  end

  response.headers['Content-Range'] = "bytes #{file_begin}-#{file_end.to_i + (match[2] == '1' ? 1 : 0)}/#{file_size}"
else
  status_code = :ok
end

response.headers['Content-Length'] = (file_end.to_i - file_begin.to_i + 1).to_s
response.headers['Last-Modified'] = the_file.mtime

response.headers['Cache-Control'] = 'public, must-revalidate, max-age=0'
response.headers['Pragma'] = 'no-cache'
response.headers['Accept-Ranges'] = 'bytes'
response.headers['Content-Transfer-Encoding'] = 'binary'

require 'ogginfo-rb'
ogginfo = Ogg::Info::open(the_file.path.gsub(/.mp3|.wav/,'.ogg'))
duration = ogginfo.duration.to_f

response.headers['Content-Duration'] = duration
response.headers['X-Content-Duration'] = duration

send_file file_path,
          filename: "#{call.id}.#{ext}",
          type: Mime::Type.lookup_by_extension(ext),
          status: status_code,
          disposition: 'inline',
          stream: 'true',
          buffer_size: 32768

Der Teil rund um den " Accept-Ranges-header ist genau das, was nötig war, um instrument NGINX, die es sendet byte-ranges. Wir kann sich nicht auf Inhalte,-Dauer, denn wir senden nicht nur audios, sondern einige Arten von videos, wie gut. So verzichteten wir auf diesen Teil, und das scheint zu funktionieren nur fine.

InformationsquelleAutor dRwg

Anderen geänderten Fassung - ich habe versucht, laden Sie eine zip-Datei als Binär-Inhalt und das ist was für mich gearbeitet -

  def byte_range_response (request, response, content)
    file_begin = 0
    file_size = content.bytesize
    file_end = file_size - 1

    status_code = '206 Partial Content'
    match = request.headers['range'].match(/bytes=(\d+)-(\d*)/)
    if match
      file_begin = match[1]
      file_end = match[2] if match[2] && !match[2].empty?
    end
    content_length = file_end.to_i - file_begin.to_i + 1
    response.header['Content-Range'] = 'bytes ' + file_begin.to_s + '-' + file_end.to_s + '/' + file_size.to_s
    response.header['Content-Length'] = content_length.to_s
    response.header['Cache-Control'] = 'public, must-revalidate, max-age=0'
    response.header['Pragma'] = 'no-cache'
    response.header['Accept-Ranges']= 'bytes'
    response.header['Content-Transfer-Encoding'] = 'binary'
    send_data get_partial_content(content, content_length, file_begin.to_i), type: 'application/octet-stream', status: status_code
  end

  def get_partial_content(content, content_length, offset)
    test_file = Tempfile.new(['test-file', '.zip'])
    test_file.puts(content)
    partial_content = IO.binread(test_file.path, content_length, offset)
    test_file.close
    test_file.unlink
    partial_content
  end

InformationsquelleAutor FrailWords

Ich verwendet, Garrett ' s Antwort und es geändert (auch ein oder zwei Bugfixes). Ich habe auch send_data statt Lesen aus einer Datei:

  def stream_data data, options={}
    range_start = 0
    file_size = data.length
    range_end = file_size - 1
    status_code = "200"

    if request.headers["Range"]
      status_code = "206"
      request.headers['range'].match(/bytes=(\d+)-(\d*)/).try do |match|
        range_start = match[1].to_i
        range_end = match[2].to_i unless match[2]&.empty?
      end
      response.header["Content-Range"] = "bytes #{range_start}-#{range_end}/#{file_size}"
    end

    response.header["Content-Length"] = (range_end - range_start + 1).to_s
    response.header["Accept-Ranges"] = "bytes"

    send_data(data[range_start, range_end],
              filename: options[:filename],
              type: options[:type],
              disposition: "inline",
              status: status_code)
  end

InformationsquelleAutor Matt

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.