You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
231 lines
8.3 KiB
231 lines
8.3 KiB
import os |
|
import errno |
|
import urlparse |
|
|
|
from django.conf import settings |
|
from django.core.exceptions import ImproperlyConfigured, SuspiciousOperation |
|
from django.utils.encoding import force_unicode |
|
from django.utils.text import get_valid_filename |
|
from django.utils._os import safe_join |
|
from django.core.files import locks, File |
|
from django.core.files.move import file_move_safe |
|
|
|
__all__ = ('Storage', 'FileSystemStorage', 'DefaultStorage', 'default_storage') |
|
|
|
class Storage(object): |
|
""" |
|
A base storage class, providing some default behaviors that all other |
|
storage systems can inherit or override, as necessary. |
|
""" |
|
|
|
# The following methods represent a public interface to private methods. |
|
# These shouldn't be overridden by subclasses unless absolutely necessary. |
|
|
|
def open(self, name, mode='rb', mixin=None): |
|
""" |
|
Retrieves the specified file from storage, using the optional mixin |
|
class to customize what features are available on the File returned. |
|
""" |
|
file = self._open(name, mode) |
|
if mixin: |
|
# Add the mixin as a parent class of the File returned from storage. |
|
file.__class__ = type(mixin.__name__, (mixin, file.__class__), {}) |
|
return file |
|
|
|
def save(self, name, content): |
|
""" |
|
Saves new content to the file specified by name. The content should be a |
|
proper File object, ready to be read from the beginning. |
|
""" |
|
# Get the proper name for the file, as it will actually be saved. |
|
if name is None: |
|
name = content.name |
|
|
|
name = self.get_available_name(name) |
|
name = self._save(name, content) |
|
|
|
# Store filenames with forward slashes, even on Windows |
|
return force_unicode(name.replace('\\', '/')) |
|
|
|
# These methods are part of the public API, with default implementations. |
|
|
|
def get_valid_name(self, name): |
|
""" |
|
Returns a filename, based on the provided filename, that's suitable for |
|
use in the target storage system. |
|
""" |
|
return get_valid_filename(name) |
|
|
|
def get_available_name(self, name): |
|
""" |
|
Returns a filename that's free on the target storage system, and |
|
available for new content to be written to. |
|
""" |
|
# If the filename already exists, keep adding an underscore to the name |
|
# of the file until the filename doesn't exist. |
|
while self.exists(name): |
|
try: |
|
dot_index = name.rindex('.') |
|
except ValueError: # filename has no dot |
|
name += '_' |
|
else: |
|
name = name[:dot_index] + '_' + name[dot_index:] |
|
return name |
|
|
|
def path(self, name): |
|
""" |
|
Returns a local filesystem path where the file can be retrieved using |
|
Python's built-in open() function. Storage systems that can't be |
|
accessed using open() should *not* implement this method. |
|
""" |
|
raise NotImplementedError("This backend doesn't support absolute paths.") |
|
|
|
# The following methods form the public API for storage systems, but with |
|
# no default implementations. Subclasses must implement *all* of these. |
|
|
|
def delete(self, name): |
|
""" |
|
Deletes the specified file from the storage system. |
|
""" |
|
raise NotImplementedError() |
|
|
|
def exists(self, name): |
|
""" |
|
Returns True if a file referened by the given name already exists in the |
|
storage system, or False if the name is available for a new file. |
|
""" |
|
raise NotImplementedError() |
|
|
|
def listdir(self, path): |
|
""" |
|
Lists the contents of the specified path, returning a 2-tuple of lists; |
|
the first item being directories, the second item being files. |
|
""" |
|
raise NotImplementedError() |
|
|
|
def size(self, name): |
|
""" |
|
Returns the total size, in bytes, of the file specified by name. |
|
""" |
|
raise NotImplementedError() |
|
|
|
def url(self, name): |
|
""" |
|
Returns an absolute URL where the file's contents can be accessed |
|
directly by a web browser. |
|
""" |
|
raise NotImplementedError() |
|
|
|
class FileSystemStorage(Storage): |
|
""" |
|
Standard filesystem storage |
|
""" |
|
|
|
def __init__(self, location=settings.MEDIA_ROOT, base_url=settings.MEDIA_URL): |
|
self.location = os.path.abspath(location) |
|
self.base_url = base_url |
|
|
|
def _open(self, name, mode='rb'): |
|
return File(open(self.path(name), mode)) |
|
|
|
def _save(self, name, content): |
|
full_path = self.path(name) |
|
|
|
directory = os.path.dirname(full_path) |
|
if not os.path.exists(directory): |
|
os.makedirs(directory) |
|
elif not os.path.isdir(directory): |
|
raise IOError("%s exists and is not a directory." % directory) |
|
|
|
# There's a potential race condition between get_available_name and |
|
# saving the file; it's possible that two threads might return the |
|
# same name, at which point all sorts of fun happens. So we need to |
|
# try to create the file, but if it already exists we have to go back |
|
# to get_available_name() and try again. |
|
|
|
while True: |
|
try: |
|
# This file has a file path that we can move. |
|
if hasattr(content, 'temporary_file_path'): |
|
file_move_safe(content.temporary_file_path(), full_path) |
|
content.close() |
|
|
|
# This is a normal uploadedfile that we can stream. |
|
else: |
|
# This fun binary flag incantation makes os.open throw an |
|
# OSError if the file already exists before we open it. |
|
fd = os.open(full_path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, 'O_BINARY', 0)) |
|
try: |
|
locks.lock(fd, locks.LOCK_EX) |
|
for chunk in content.chunks(): |
|
os.write(fd, chunk) |
|
finally: |
|
locks.unlock(fd) |
|
os.close(fd) |
|
except OSError, e: |
|
if e.errno == errno.EEXIST: |
|
# Ooops, the file exists. We need a new file name. |
|
name = self.get_available_name(name) |
|
full_path = self.path(name) |
|
else: |
|
raise |
|
else: |
|
# OK, the file save worked. Break out of the loop. |
|
break |
|
|
|
if settings.FILE_UPLOAD_PERMISSIONS is not None: |
|
os.chmod(full_path, settings.FILE_UPLOAD_PERMISSIONS) |
|
|
|
return name |
|
|
|
def delete(self, name): |
|
name = self.path(name) |
|
# If the file exists, delete it from the filesystem. |
|
if os.path.exists(name): |
|
os.remove(name) |
|
|
|
def exists(self, name): |
|
return os.path.exists(self.path(name)) |
|
|
|
def listdir(self, path): |
|
path = self.path(path) |
|
directories, files = [], [] |
|
for entry in os.listdir(path): |
|
if os.path.isdir(os.path.join(path, entry)): |
|
directories.append(entry) |
|
else: |
|
files.append(entry) |
|
return directories, files |
|
|
|
def path(self, name): |
|
try: |
|
path = safe_join(self.location, name) |
|
except ValueError: |
|
raise SuspiciousOperation("Attempted access to '%s' denied." % name) |
|
return os.path.normpath(path) |
|
|
|
def size(self, name): |
|
return os.path.getsize(self.path(name)) |
|
|
|
def url(self, name): |
|
if self.base_url is None: |
|
raise ValueError("This file is not accessible via a URL.") |
|
return urlparse.urljoin(self.base_url, name).replace('\\', '/') |
|
|
|
def get_storage_class(import_path): |
|
try: |
|
dot = import_path.rindex('.') |
|
except ValueError: |
|
raise ImproperlyConfigured("%s isn't a storage module." % import_path) |
|
module, classname = import_path[:dot], import_path[dot+1:] |
|
try: |
|
mod = __import__(module, {}, {}, ['']) |
|
except ImportError, e: |
|
raise ImproperlyConfigured('Error importing storage module %s: "%s"' % (module, e)) |
|
try: |
|
return getattr(mod, classname) |
|
except AttributeError: |
|
raise ImproperlyConfigured('Storage module "%s" does not define a "%s" class.' % (module, classname)) |
|
|
|
DefaultStorage = get_storage_class(settings.DEFAULT_FILE_STORAGE) |
|
default_storage = DefaultStorage()
|
|
|