Hacer que Django sirva archivos descargables

Quiero que los usuarios del sitio puedan descargar archivos cuyas rutas están oscurecidas para que no se puedan descargar directamente.

Por ejemplo, me gustaría que la URL sea algo así: http://example.com/download/?f=somefile.txt

Y en el servidor, sé que todos los archivos descargables residen en la carpeta /home/user/files/.

¿Hay alguna manera de hacer que Django sirva ese archivo para descargar en lugar de intentar encontrar una URL y Ver para mostrarlo?

Para "lo mejor de ambos mundos", podría combinar la solución de S.Lott con el módulo xsendfile : django genera la ruta al archivo (o el archivo en sí), pero Apache / Lighttpd maneja el servicio del archivo real. Una vez que haya configurado mod_xsendfile, la integración con su vista requiere algunas líneas de código:

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

Por supuesto, esto solo funcionará si tiene control sobre su servidor, o si su empresa de alojamiento ya ha configurado mod_xsendfile.

EDITAR:

mimetype se reemplaza por content_type para django 1.7

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

EDITAR: Para nginxverificar esto , usa en X-Accel-Redirectlugar del apacheencabezado X-Sendfile.

Una "descarga" es simplemente un cambio de encabezado HTTP.

Ver http://docs.djangoproject.com/en/dev/ref/request-response/#telling-the-browser-to-treat-the-response-as-a-file-attachment para saber cómo responder con una descarga .

Solo necesita una definición de URL para "/download".

La solicitud GETo el POSTdiccionario tendrán la "f=somefile.txt"información.

Su función de vista simplemente fusionará la ruta base con el fvalor " ", abrirá el archivo, creará y devolverá un objeto de respuesta. Debe tener menos de 12 líneas de código.

Para una solución muy simple pero no eficiente o escalable , puede usar la servevista integrada de django . Esto es excelente para prototipos rápidos o trabajos únicos, pero como se ha mencionado a lo largo de esta pregunta, debe usar algo como apache o nginx en la producción.

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 tiene la solución "buena" / simple, y elo80ka tiene la "mejor" / solución eficiente. Aquí hay una solución "mejor" / intermedia: sin configuración del servidor, pero más eficiente para archivos grandes que la solución ingenua:

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

Básicamente, Django todavía maneja el servicio del archivo pero no carga todo en la memoria de una vez. Esto permite que su servidor sirva (lentamente) un archivo grande sin aumentar el uso de memoria.

Una vez más, X-SendFile de S.Lott es aún mejor para archivos más grandes. Pero si no puede o no quiere molestarse con eso, entonces esta solución intermedia le brindará una mayor eficiencia sin la molestia.

Intenté la solución @Rocketmonkeys pero los archivos descargados se almacenaron como * .bin y se les dio nombres aleatorios. Eso no está bien, por supuesto. Agregar otra línea de @ elo80ka resolvió el problema.
Aquí está el código que estoy usando ahora:

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

Ahora puede almacenar archivos en un directorio privado (no dentro de / media ni / public_html) y exponerlos a través de django a ciertos usuarios o bajo ciertas circunstancias.
Espero eso ayude.

Gracias a @ elo80ka, @ S.Lott y @Rocketmonkeys por las respuestas, obtuve la solución perfecta combinando todas ellas =)

Solo menciono el objeto FileResponse disponible en Django 1.10

Editar: acabo de encontrar mi propia respuesta mientras buscaba una manera fácil de transmitir archivos a través de Django, así que aquí hay un ejemplo más completo (para mí en el futuro). Se supone que el nombre de FileField esimported_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'),
...

Se mencionó anteriormente que el método mod_xsendfile no permite caracteres no ASCII en los nombres de archivo.

Por esta razón, tengo un parche disponible para mod_xsendfile que permitirá enviar cualquier archivo, siempre que el nombre esté codificado en url y el encabezado adicional:

X-SendFile-Encoding: url

También se envía.

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

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

"Abstracción para descargar archivos subidos al servidor web (por ejemplo, Apache con mod_xsendfile) una vez que Django haya verificado los permisos, etc."

Debe usar las apis sendfile proporcionadas por servidores populares como apacheo nginx en producción. Muchos años estuve usando sendfile api de estos servidores para proteger archivos. Luego creó una aplicación django basada en middleware simple para este propósito, adecuada tanto para el desarrollo como para la producción. Puede acceder al código fuente aquí .
ACTUALIZACIÓN: en la nueva versión, el pythonproveedor usa django FileResponsesi está disponible y también agrega soporte para muchas implementaciones de servidor desde lighthttp, caddy hasta hiawatha

Uso

pip install django-fileprovider

• agregar fileprovideraplicación a la INSTALLED_APPSconfiguración,
• agregar fileprovider.middleware.FileProviderMiddlewarea la MIDDLEWARE_CLASSESconfiguración
• establecer FILEPROVIDER_NAMEconfiguraciones en nginxo apacheen producción, por defecto es pythonpara fines de desarrollo.

en sus vistas de clase o función establezca el X-Filevalor del encabezado de respuesta en la ruta absoluta al archivo. Por ejemplo,

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 Se ha implementado de manera tal que su código solo necesitará una modificación mínima.

Configuración de Nginx

Para proteger el archivo del acceso directo, puede establecer la configuración como

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

Aquí nginxestablece una dirección URL de /files/acceso solo internamente, si está utilizando la configuración anterior, puede configurar X-File como,

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

Al hacer esto con la configuración nginx, el archivo estará protegido y también puede controlar el archivo desde django views

Django recomienda que use otro servidor para servir medios estáticos (otro servidor que se ejecuta en la misma máquina está bien). Recomienda el uso de servidores como lighttp .

Esto es muy simple de configurar. Sin embargo. si se genera 'somefile.txt' a pedido (el contenido es dinámico), entonces es posible que desee que django lo sirva.

Django Docs - Archivos estáticos

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 

Otro proyecto para echar un vistazo: http://readthedocs.org/docs/django-private-files/en/latest/usage.html Parece prometedor, aunque todavía no lo he probado.

Básicamente, el proyecto abstrae la configuración mod_xsendfile y le permite hacer cosas como:

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)

Me he enfrentado al mismo problema más de una vez y lo implementé usando el módulo xsendfile y los decoradores de vista de autenticación django-filelibrary . Siéntase libre de usarlo como inspiración para su propia solución.

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

Proporcionar acceso protegido a la carpeta estática html usando https://github.com/johnsensible/django-sendfile : https://gist.github.com/iutinvg/9907731

Hice un proyecto sobre esto. Puedes mirar mi repositorio github:

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

Este módulo proporciona una manera simple de servir archivos para descargar en django rest framework usando el módulo Apache Xsendfile. También tiene una función adicional de servir descargas solo a usuarios que pertenecen a un grupo en particular