Rails: à la volée en streaming de sortie au format zip?

J'ai besoin de servir des données de ma base de données dans un fichier zip, en streaming sur la volée tels que:

Je n'écris pas un fichier temporaire sur le disque
Je ne compose pas la totalité du fichier dans la RAM

Je sais que je peux faire du streaming génération de fichiers zip à l'filesystemk à l'aide de ZipOutputStream comme ici. Je sais aussi que je peux faire du streaming de sortie à partir d'un rails de contrôleur par la mise en response_body à un Proc comme ici. Ce dont j'ai besoin (je pense) est un moyen de brancher ces deux choses ensemble. Puis-je faire des rails de servir une réponse à partir d'un ZipOutputStream? Puis-je obtenir ZipOutputStream me donner des différentiels de morceaux de données que je peux alimenter mon response_body Proc? Ou est-il un autre moyen?

ZipOutputStream ne peut pas le faire parce qu'il cherche avant en arrière à travers le flux lors de l'écriture de la zippé données (voir ZipOutputStream#update_local_headers, appelé à partir de ZipOutputStream#close). Ainsi, il est impossible de se servir des blocs de données avec ZipOutputStream avant l'opération est terminée.

InformationsquelleAutor kdt | 2011-01-25

3

J'ai eu un problème similaire. Je n'ai pas besoin de diffuser directement, mais seulement eu votre premier cas de ne pas vouloir écrire un fichier temp. Vous pouvez facilement modifier ZipOutputStream à accepter un IO objet au lieu de simplement un nom de fichier.
```
module Zip
  class IOOutputStream < ZipOutputStream
    def initialize io
      super '-'
      @outputStream = io
    end

    def stream
      @outputStream
    end
  end
end
```
À partir de là, il doit juste être une question de l'utilisation de la nouvelle Zip::IOOutputStream dans votre Proc. Dans votre contrôleur, vous auriez probablement faire quelque chose comme:
```
self.response_body =  proc do |response, output|
  Zip::IOOutputStream.open(output) do |zip|
    my_files.each do |file|
      zip.put_next_entry file
      zip << IO.read file
    end
  end
end
```
- ce n'est pas le travail en lui-même... les fichiers zip s'attendre à la taille, compressed_size, et un CRC des données avant de les... ce code génère le fichier dans la mémoire, et le serveur attend toujours qu'elle soit terminée pour lancer l'envoi. utiliser mon gem github.com/fringd/zipline
InformationsquelleAutor j05h

Version Courte

https://github.com/fringd/zipline

Version Longue

donc jo5h la réponse n'a pas fonctionné pour moi dans les rails 3.1.1

j'ai trouvé une vidéo sur youtube qui a aidé, cependant.

http://www.youtube.com/watch?v=K0XvnspdPsc

le cœur du problème est la création d'un objet qui répond à chaque... c'est ce que j'ai fait:

  class ZipGenerator                                                                    
    def initialize(model)                                                               
      @model = model                                                                    
    end                                                                                 

    def each( &block )                                                                  
      output = Object.new                                                               
      output.define_singleton_method :tell, Proc.new { 0 }                              
      output.define_singleton_method :pos=, Proc.new { |x| 0 }                          
      output.define_singleton_method :<<, Proc.new { |x| block.call(x) }                
      output.define_singleton_method :close, Proc.new { nil }                           
      Zip::IoZip.open(output) do |zip|                                                  
        @model.attachments.all.each do |attachment|                                     
          zip.put_next_entry "#{attachment.name}.pdf"                                   
          file = attachment.file.file.send :file                                        
          file = File.open(file) if file.is_a? String                                   
          while buffer = file.read(2048)                                                
            zip << buffer                                                               
          end                                                                           
        end                                                                             
      end                                                                               
      sleep 10                                                                          
    end                                                                                 

  end

  def getzip                                                                            
    self.response_body = ZipGenerator.new(@model)                                       

    #this is a hack to preven middleware from buffering                                 
    headers['Last-Modified'] = Time.now.to_s                                            
  end

EDIT:

la solution ci-dessus ne FAIT pas travailler... le problème est que rubyzip besoins de sauter autour du fichier à réécrire les en-têtes pour les entrées comme il va. en particulier, il doit écrire la taille compressée AVANT d'écrire les données. ce n'est tout simplement pas possible dans un véritable streaming de la situation... si, finalement, cette tâche peut s'avérer impossible. il y a une chance qu'il pourrait être possible de mettre en tampon un ensemble de fichiers à la fois, mais cela semblait de moins en moins la peine. en fin de compte je viens d'écrire à un fichier tmp... sur heroku, je peux écrire des Rails.root/tmp moins une rétroaction instantanée, et n'est pas idéal, mais nécessaire.

UN AUTRE EDIT:

j'ai eu une autre idée récemment... on POURRAIT savoir la taille compressée des fichiers si nous n'avons pas les compresser. le plan va quelque chose comme ceci:

sous-classe de la ZipStreamOutput classe comme suit:

toujours utiliser le "stockés" méthode de compression, en d'autres termes ne pas compresser
de nous assurer que nous ne cherchons jamais en arrière pour modifier les en-têtes de fichier, obtenir toutes sur le devant de
réécrire le code lié à la table des matières qui cherche

Je n'ai pas essayé de mettre en œuvre cette encore, mais rendra compte si il n'y a aucun succès.

OK UNE DERNIÈRE ÉDITION:

Dans le zip standard: http://en.wikipedia.org/wiki/Zip_(file_format)#File_headers

ils mentionnent qu'il y a un peu, vous pouvez le retourner pour le mettre à la taille, taille compressée et crc d'APRÈS un fichier. donc, mon nouveau plan était à la sous-classe zipoutput cours d'eau afin qu'il

définit cet indicateur
écrit tailles et CRCs après les données
jamais rembobine sortie

de plus, j'ai besoin d'obtenir tous les hacks dans l'ordre de sortie de flux dans des rails fixés jusqu'...

de toute façon tout a fonctionné!

voici une perle!

https://github.com/fringd/zipline

InformationsquelleAutor fringd

Il est maintenant possible de le faire directement:

class SomeController < ApplicationController
  def some_action
    compressed_filestream = Zip::ZipOutputStream.write_buffer do |zos|
      zos.put_next_entry "some/filename.ext"
      zos.print data
    end
    compressed_filestream .rewind
    respond_to do |format|
      format.zip do
        send_data compressed_filestream .read, filename: "some.zip"
      end
    end
    # or some other return of send_data
  end
end

InformationsquelleAutor noel

0

C'est le lien que vous voulez:

http://info.michael-simons.eu/2008/01/21/using-rubyzip-to-create-zip-files-on-the-fly/

Il construit et génère le zipfile à l'aide de ZipOutputStream et utilise ensuite send_file de l'envoyer directement à partir du contrôleur.
- Nope. La question précise "ce qui fait que ... je n'écris pas un fichier temporaire sur le disque". Cet exemple crée un fichier temporaire. C'est aussi plus ou moins identique à celui du premier lien dans la question.
- La question précise que le fichier temporaire n'est pas écrit sur le disque. Il est raisonnable de supposer, c'est que vous ne voulez pas les fichiers temporaires accumulent dans certains aléatoire à l'annuaire d'avoir à être détruit. La solution donnée détruit le fichier temporaire immédiatement après son utilisation. Si il existe une autre hypothèse, s'il vous plaît laissez - nous savoir ou de vos questions n'est pas complète.
- Comme il est de votre deux exigences sont presque mutuellement exclusifs. Que ce soit sur disque ou en mémoire vive... alors qu'est-ce que vous voulez vraiment et pourquoi?
- Vous POUVEZ compresser/envoyer un DVD avec un serveur qui n'a que 100 mo de RAM + 100 MO de disque dur. Cela signifie que l'envoi de la zippée immédiatement le contenu plutôt que de les diffuser. Donc kdt les exigences ne sont pas mutuellement exclusives. Peut-être kdt veut efficacement envoyer d'énormes quantités de données à l'aide d'un serveur qui n'est pas trop cher. Un autre avantage est que la compression et les temps de téléchargement sont parallèles plutôt que sur l'ajout de. Cheers!
InformationsquelleAutor Taryn East
0

Utilisation chunked HTTP codage de transfert pour la sortie: en-tête HTTP "Transfer-Encoding: chunked" et de la restructuration de la sortie en fonction du codage mémorisé en bloc de spécification, donc pas besoin de connaître le résultant ZIP taille du fichier à la base du transfert. Peut facilement être codé en Ruby avec l'aide de Open3.popen3 et les threads.

InformationsquelleAutor Konstantin

Vous devez vous connecter pour publier un commentaire.