1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
# GNU MediaGoblin -- federated, autonomous media hosting
# Copyright (C) 2011 Free Software Foundation, Inc
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import os
import uuid
from werkzeug.utils import secure_filename
class Error(Exception): pass
class InvalidFilepath(Error): pass
class NotImplementedError(Error): pass
def clean_listy_filepath(listy_filepath):
"""
Take a listy filepath (like ['dir1', 'dir2', 'filename.jpg']) and
clean out any nastiness from it.
For example:
>>> clean_listy_filepath([u'/dir1/', u'foo/../nasty', u'linooks.jpg'])
[u'dir1', u'foo_.._nasty', u'linooks.jpg']
Args:
- listy_filepath: a list of filepath components, mediagoblin
storage API style.
Returns:
A cleaned list of unicode objects.
"""
cleaned_filepath = [
unicode(secure_filename(filepath))
for filepath in listy_filepath]
if u'' in cleaned_filepath:
raise InvalidFilepath(
"A filename component could not be resolved into a usable name.")
return cleaned_filepath
class StorageInterface(object):
"""
Interface for the storage API.
This interface doesn't actually provide behavior, but it defines
what kind of storage patterns subclasses should provide.
It is important to note that the storage API idea of a "filepath"
is actually like ['dir1', 'dir2', 'file.jpg'], so keep that in
mind while reading method documentation.
"""
# def __init__(self, *args, **kwargs):
# pass
def __raise_not_implemented(self):
"""
Raise a warning about some component not implemented by a
subclass of this interface.
"""
raise NotImplementedError(
"This feature not implemented in this storage API implementation.")
def file_exists(self, filepath):
"""
Return a boolean asserting whether or not file at filepath
exists in our storage system.
Returns:
True / False depending on whether file exists or not.
"""
# Subclasses should override this method.
self.__raise_not_implemented()
def get_file(self, filepath, mode='r'):
"""
Return a file-like object for reading/writing from this filepath.
Should create directories, buckets, whatever, as necessary.
"""
# Subclasses should override this method.
self.__raise_not_implemented()
def delete_file(self, filepath):
"""
Delete or dereference the file at filepath.
This might need to delete directories, buckets, whatever, for
cleanliness. (Be sure to avoid race conditions on that though)
"""
# Subclasses should override this method.
self.__raise_not_implemented()
def url_for_file(self, filepath):
"""
Get the URL for this file. This assumes our storage has been
mounted with some kind of URL which makes this possible.
"""
# Subclasses should override this method.
self.__raise_not_implemented()
def get_unique_filepath(self, filepath):
"""
If a filename at filepath already exists, generate a new name.
Eg, if the filename doesn't exist:
>>> storage_handler.get_unique_filename(['dir1', 'dir2', 'fname.jpg'])
[u'dir1', u'dir2', u'fname.jpg']
But if a file does exist, let's get one back with at uuid tacked on:
>>> storage_handler.get_unique_filename(['dir1', 'dir2', 'fname.jpg'])
[u'dir1', u'dir2', u'd02c3571-dd62-4479-9d62-9e3012dada29-fname.jpg']
"""
if self.file_exists(filepath):
return filepath[:-1] + ["%s-%s" % (uuid.uuid4(), filepath[-1])]
else:
return filepath
class BasicFileStorage(StorageInterface):
"""
Basic local filesystem implementation of storage API
"""
def __init__(self, base_dir, serve_url=None):
"""
Keyword arguments:
- base_dir: Base directory things will be served out of. MUST
be an absolute path.
- serve_url: URL files will be served from
"""
self.base_dir = base_dir
self.serve_url = serve_url
def _resolve_filepath(self, filepath):
"""
Transform the given filepath into a local filesystem filepath.
"""
return os.path.join(
self.base_dir, *clean_listy_filepath(filepath))
def file_exists(self, filepath):
return os.path.exists(self._resolve_filepath(filepath))
def get_file(self, filepath, mode='r'):
# Make directories if necessary
if len(filepath) > 1:
directory = self._resolve_filepath(filepath[:-1])
if not os.path.exists('directory'):
os.makedirs(directory)
# Grab and return the file in the mode specified
return open(self._resolve_filepath(filepath), mode)
def delete_file(self, filepath):
pass
def url_for_file(self, filepath):
pass
|
