1 files changed, 181 insertions, 0 deletions

diff --git a/src/amazons3/django/__init__.py b/src/amazons3/django/__init__.py
new file mode 100644
index 0000000..3e57e15
--- /dev/null
+++ b/src/amazons3/django/__init__.py
@@ -0,0 +1,181 @@
+import os
+from StringIO import StringIO
+from django.conf import settings
+from amazons3 import S3
+
+from django.core.files.storage import Storage
+
+class S3OpenFile(StringIO):
+    """
+    Wrapper for StringIO which allows open() to be called on it.
+    
+    This is for FileField form fields, which expect to be able to call open()
+    and then retrieve data from the file.
+    ** NOTE: The behavior of calling open() and then writing to the file is
+    currently unknown. **
+    """
+    def open(self, *args, **kwargs):
+        self.seek(0)
+
+class S3Error(Exception):
+    "Misc. S3 Service Error"
+    pass
+
+class S3Storage(Storage):
+    options = None
+
+    def __init__(self, options=None):
+        if not options:
+            options = settings.S3_SETTINGS
+            self.options = options
+        self.perm_tuple = (
+            'private',
+            'public-read',
+            'public-read-write',
+            'authenticated-read'
+        )
+        if self.options['default_perm'] not in self.perm_tuple:
+            self.options['default_perm'] = 'private'
+
+        self.connect()
+
+    def connect(self):
+        self.conn = S3.AWSAuthConnection(self.options['aws_key'], self.options['aws_secret_key'])
+
+        res = self.conn.check_bucket_exists(self.options['bucket'])
+
+        if res.status != 200:
+            res = self.conn.create_bucket(self.options['bucket'])
+            if res.http_response.status != 200:
+                raise S3Error, 'Unable to create bucket %s' % (self.options['bucket'])
+
+        return True
+
+    def exists(self, filename):
+        contents = self.conn.list_bucket(self.options['bucket'], {'prefix': os.path.dirname(filename)})
+        if filename in [f.key for f in contents.entries]:
+            return True
+        else:
+            return False
+
+    def size(self, filename):
+        contents = self.conn.list_bucket(self.options['bucket'], {'prefix': os.path.dirname(filename)} )
+        for f in contents.entries:
+            if f.key == filename:
+                return f.size
+
+        return False
+
+    def url(self, filename):
+        server = self.options['bucket']
+        if not self.options['vanity_url']:
+            server += '.s3.amazonaws.com'
+        else:
+            server = self.options['vanity_url']
+        return 'http://' + server + '/' + filename
+
+
+    def _save(self, filename, content):
+        # a stupid hack
+        try:
+            content.url = self.url
+        except AttributeError, e:
+            content = content.file
+
+        try:
+            data = content.read()
+        except IOError, err:
+            raise S3Error, 'Unable to read %s: %s' % (filename, err.strerror)
+
+        guess_type = False
+        try:
+            content.content_type
+        except AttributeError, e:
+            guess_type = True
+        
+        if guess_type or not content.content_type:
+            import mimetypes
+            content_type = mimetypes.guess_type(filename)[0]
+            if content_type is None:
+                content_type = 'text/plain'
+        else:
+            content_type = content.content_type
+
+        perm = self.options['default_perm']
+
+        res = self.conn.put(
+            self.options['bucket'],
+            filename,
+            S3.S3Object(data),
+            {
+                'x-amz-acl': perm,
+                'Content-Type': content_type
+            }
+        )
+
+        if res.http_response.status != 200:
+            raise S3Error, 'Unable to upload file %s: Error code %s: %s' % (filename, self.options['bucket'], res.body)
+
+
+        content.filename = filename
+        content.url = self.url(filename)
+
+        return filename
+
+    def delete(self, filename):
+        res = self.conn.delete(self.options['bucket'], filename)
+        if res.http_response.status != 204:
+            pass
+            #raise S3Error, 'Unable to delete file %s' % (filename)
+
+        return (res.http_response.status == 204)
+
+    def path(self, filename):
+        raise NotImplementedError
+
+    def open(self, filename, mode):
+        from urllib import urlopen
+        # Download data from S3 and save 
+        # into a file wrapper, which allows its
+        # use as normal in FileFields.
+        #
+        # Note: This saves the file data into memory.
+        data = urlopen(self.url(filename))
+        openfile = S3OpenFile()
+        openfile.write(data.read())
+        return openfile 
+
+    def get_available_name(self, filename):
+        import os
+        basefilename = os.path.splitext(filename)
+        i = 1
+        while self.exists(filename):
+            i += 1
+            filename = '%s-%d%s' % (basefilename[0], i, basefilename[1])
+
+        return filename
+
+class CxStorage(S3Storage):
+    """
+    This storage engine provides the naming scheme for phonese3. It hashes
+    the file names before storage.
+    To use, set DEFAULT_STORAGE_ENGINE="CxStorage"
+    
+    Author: Jason Braegger
+    License: AGPLv3
+    Source: http://code.twi.gs/phonese3/
+    """
+    def get_valid_name(self, name):
+        """
+        This returns a hashed name to use for storage on the filesystem
+        """
+        import os.path
+        from hashlib import md5
+        import time
+        
+        extension = os.path.splitext(name)[1].lower()
+        # Ensure an ascii string for .hexdigest() later.
+        name = name.encode('ascii', 'ignore')
+
+        return str(md5(str(time.time()) + name).hexdigest()) + \
+            str(extension)