Avere Django che serve file scaricabili

Voglio che gli utenti sul sito siano in grado di scaricare file i cui percorsi sono oscurati in modo che non possano essere scaricati direttamente.

Ad esempio, vorrei che l'URL fosse qualcosa del genere: http://example.com/download/?f=somefile.txt

E sul server, so che tutti i file scaricabili risiedono nella cartella /home/user/files/.

C'è un modo per far sì che Django serva quel file per il download invece di provare a trovare un URL e Visualizza per visualizzarlo?

Per il "meglio di entrambi i mondi" è possibile combinare la soluzione di S.Lott con il modulo xsendfile : django genera il percorso del file (o del file stesso), ma l'effettivo servizio di file è gestito da Apache / Lighttpd. Dopo aver impostato mod_xsendfile, l'integrazione con la vista richiede alcune righe di codice:

from django.utils.encoding import smart_str

response = HttpResponse(mimetype='application/force-download') # mimetype is replaced by content_type for django 1.7
response['Content-Disposition'] = 'attachment; filename=%s' % smart_str(file_name)
response['X-Sendfile'] = smart_str(path_to_file)
# It's usually a good idea to set the 'Content-Length' header too.
# You can also set any other required headers: Cache-Control, etc.
return response

Ovviamente, questo funzionerà solo se hai il controllo sul tuo server o se la tua società di hosting ha già mod_xsendfile impostato.

MODIFICARE:

mimetype è sostituito da content_type per django 1.7

response = HttpResponse(content_type='application/force-download')  

EDIT: per nginxcontrollare questo , usa X-Accel-Redirectinvece l' apacheintestazione X-Sendfile.

Un "download" è semplicemente una modifica dell'intestazione HTTP.

Vedi http://docs.djangoproject.com/en/dev/ref/request-response/#telling-the-browser-to-treat-the-response-as-a-file-attachment per come rispondere con un download .

Hai solo bisogno di una definizione URL per "/download".

La richiesta GETo il POSTdizionario avranno le "f=somefile.txt"informazioni.

La funzione di visualizzazione unirà semplicemente il percorso di base con il fvalore " ", aprirà il file, creerà e restituirà un oggetto risposta. Dovrebbe essere inferiore a 12 righe di codice.

Per una soluzione molto semplice ma non efficiente o scalabile , puoi semplicemente usare la servevista django integrata . Questo è eccellente per prototipi rapidi o lavori una tantum, ma come è stato menzionato in questa domanda, dovresti usare qualcosa come apache o nginx in produzione.

from django.views.static import serve
filepath = '/some/path/to/local/file.txt'
return serve(request, os.path.basename(filepath), os.path.dirname(filepath))

S.Lott ha la soluzione "buona" / semplice e elo80ka ha la soluzione "migliore" / efficiente. Ecco una soluzione "migliore" / media: nessuna configurazione del server, ma più efficiente per file di grandi dimensioni rispetto alla soluzione ingenua:

http://djangosnippets.org/snippets/365/

Fondamentalmente, Django gestisce ancora il servizio del file ma non carica tutto in memoria contemporaneamente. Ciò consente al server di (lentamente) servire un file di grandi dimensioni senza aumentare l'utilizzo della memoria.

Ancora una volta, X-SendFile di S.Lott è ancora migliore per file più grandi. Ma se non puoi o non vuoi preoccuparti di questo, allora questa soluzione intermedia ti garantirà una migliore efficienza senza problemi.

Ho provato la soluzione @Rocketmonkeys ma i file scaricati sono stati archiviati come * .bin e hanno dato nomi casuali. Non va bene ovviamente. L'aggiunta di un'altra riga da @ elo80ka ha risolto il problema.
Ecco il codice che sto usando ora:

from wsgiref.util import FileWrapper
from django.http import HttpResponse

filename = "/home/stackoverflow-addict/private-folder(not-porn)/image.jpg"
wrapper = FileWrapper(file(filename))
response = HttpResponse(wrapper, content_type='text/plain')
response['Content-Disposition'] = 'attachment; filename=%s' % os.path.basename(filename)
response['Content-Length'] = os.path.getsize(filename)
return response

Ora puoi archiviare i file in una directory privata (non all'interno di / media né / public_html) ed esporli via django a determinati utenti o in determinate circostanze.
Spero che sia d'aiuto.

Grazie a @ elo80ka, @ S.Lott e @Rocketmonkeys per le risposte, ho ottenuto la soluzione perfetta combinandoli tutti =)

Solo menzionando l' oggetto FileResponse disponibile in Django 1.10

Modifica: ho appena incontrato la mia risposta durante la ricerca di un modo semplice per lo streaming di file tramite Django, quindi ecco un esempio più completo (per il futuro me). Presuppone che il nome FileField siaimported_file

views.py

from django.views.generic.detail import DetailView   
from django.http import FileResponse
class BaseFileDownloadView(DetailView):
  def get(self, request, *args, **kwargs):
    filename=self.kwargs.get('filename', None)
    if filename is None:
      raise ValueError("Found empty filename")
    some_file = self.model.objects.get(imported_file=filename)
    response = FileResponse(some_file.imported_file, content_type="text/csv")
    # https://docs.djangoproject.com/en/1.11/howto/outputting-csv/#streaming-large-csv-files
    response['Content-Disposition'] = 'attachment; filename="%s"'%filename
    return response

class SomeFileDownloadView(BaseFileDownloadView):
    model = SomeModel

urls.py

...
url(r'^somefile/(?P<filename>[-\w_\\-\\.]+)$', views.SomeFileDownloadView.as_view(), name='somefile-download'),
...

È stato menzionato sopra che il metodo mod_xsendfile non consente caratteri non ASCII nei nomi di file.

Per questo motivo, ho una patch disponibile per mod_xsendfile che consentirà l'invio di qualsiasi file, purché il nome sia codificato nell'URL e l'intestazione aggiuntiva:

X-SendFile-Encoding: url

Viene inviato anche.

http://ben.timby.com/?p=149

Prova: https://pypi.python.org/pypi/django-sendfile/

"Astrazione per scaricare i file caricati sul web-server (es. Apache con mod_xsendfile) dopo che Django ha verificato i permessi, ecc."

Dovresti usare le API di sendfile fornite da server popolari come apacheo nginx in produzione. Per molti anni ho usato l'API sendfile di questi server per proteggere i file. Quindi ha creato una semplice app django basata su middleware per questo scopo adatta sia allo scopo di sviluppo che di produzione . Qui puoi accedere al codice sorgente .
AGGIORNAMENTO: nella nuova versione il pythonprovider utilizza django FileResponsese disponibile e aggiunge anche il supporto per molte implementazioni di server da lighthttp, caddy a hiawatha

uso

pip install django-fileprovider

• aggiungi fileproviderapp alle INSTALLED_APPSimpostazioni,
• aggiungi fileprovider.middleware.FileProviderMiddlewarealle MIDDLEWARE_CLASSESimpostazioni
• impostare le FILEPROVIDER_NAMEimpostazioni su nginxo apachein produzione, per impostazione predefinita è pythona scopo di sviluppo.

nelle viste classbased o function imposta il X-Filevalore dell'intestazione della risposta sul percorso assoluto del file. Per esempio,

def hello(request):  
   // code to check or protect the file from unauthorized access
   response = HttpResponse()  
   response['X-File'] = '/absolute/path/to/file'  
   return response  

django-fileprovider implementato in modo tale che il codice richieda solo modifiche minime.

Configurazione di Nginx

Per proteggere il file dall'accesso diretto è possibile impostare la configurazione come

 location /files/ {
  internal;
  root   /home/sideffect0/secret_files/;
 }

Qui nginximposta un indirizzo URL /files/accessibile solo internamente, se stai utilizzando la configurazione sopra puoi impostare X-File come,

response['X-File'] = '/files/filename.extension' 

In questo modo con la configurazione di nginx, il file sarà protetto e inoltre potrai controllare il file da django views

Django consiglia di utilizzare un altro server per servire supporti statici (un altro server in esecuzione sullo stesso computer va bene.) Raccomandano l'uso di server come lighttp .

Questo è molto semplice da configurare. Però. se 'somefile.txt' viene generato su richiesta (il contenuto è dinamico), potresti voler django per servirlo.

Django Docs - File statici

def qrcodesave(request): 
    import urllib2;   
    url ="http://chart.apis.google.com/chart?cht=qr&chs=300x300&chl=s&chld=H|0"; 
    opener = urllib2.urlopen(url);  
    content_type = "application/octet-stream"
    response = HttpResponse(opener.read(), content_type=content_type)
    response["Content-Disposition"]= "attachment; filename=aktel.png"
    return response 

Un altro progetto da dare un'occhiata a: http://readthedocs.org/docs/django-private-files/en/latest/usage.html Sembra promettente, non l'ho ancora provato da solo.

Fondamentalmente il progetto estrae la configurazione mod_xsendfile e ti permette di fare cose come:

from django.db import models
from django.contrib.auth.models import User
from private_files import PrivateFileField

def is_owner(request, instance):
    return (not request.user.is_anonymous()) and request.user.is_authenticated and
                   instance.owner.pk = request.user.pk

class FileSubmission(models.Model):
    description = models.CharField("description", max_length = 200)
        owner = models.ForeignKey(User)
    uploaded_file = PrivateFileField("file", upload_to = 'uploads', condition = is_owner)

Ho affrontato lo stesso problema più di una volta e quindi implementato usando il modulo xsendfile e i decoratori di view view django-filelibrary . Sentiti libero di usarlo come ispirazione per la tua soluzione.

https://github.com/danielsokolowski/django-filelibrary

Fornire accesso protetto alla cartella html statica utilizzando https://github.com/johnsensible/django-sendfile : https://gist.github.com/iutinvg/9907731

Ho fatto un progetto su questo. Puoi guardare il mio repository github:

https://github.com/nishant-boro/django-rest-framework-download-expert

Questo modulo fornisce un modo semplice per servire i file da scaricare nel framework di riposo django usando il modulo Xsendfile di Apache. Ha anche una funzione aggiuntiva di servire i download solo per gli utenti appartenenti a un determinato gruppo