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
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
|
# Copyright (C) 2005 Canonical Ltd
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 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 General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""Transport is an abstraction layer to handle file access.
The abstraction is to allow access from the local filesystem, as well
as remote (such as http or sftp).
"""
from bzrlib.trace import mutter
from bzrlib.errors import (BzrError,
TransportError, TransportNotPossible, NonRelativePath,
NoSuchFile, FileExists, PermissionDenied,
ConnectionReset)
_protocol_handlers = {
}
def register_transport(prefix, klass, override=True):
global _protocol_handlers
if _protocol_handlers.has_key(prefix):
if override:
mutter('overriding transport: %s => %s' % (prefix, klass.__name__))
_protocol_handlers[prefix] = klass
else:
mutter('registering transport: %s => %s' % (prefix, klass.__name__))
_protocol_handlers[prefix] = klass
class Transport(object):
"""This class encapsulates methods for retrieving or putting a file
from/to a storage location.
Most functions have a _multi variant, which allows you to queue up
multiple requests. They generally have a dumb base implementation
which just iterates over the arguments, but smart Transport
implementations can do pipelining.
In general implementations should support having a generator or a list
as an argument (ie always iterate, never index)
"""
def __init__(self, base):
super(Transport, self).__init__()
self.base = base
def clone(self, offset=None):
"""Return a new Transport object, cloned from the current location,
using a subdirectory or parent directory. This allows connections
to be pooled, rather than a new one needed for each subdir.
"""
raise NotImplementedError
def should_cache(self):
"""Return True if the data pulled across should be cached locally.
"""
return False
def _pump(self, from_file, to_file):
"""Most children will need to copy from one file-like
object or string to another one.
This just gives them something easy to call.
"""
if isinstance(from_file, basestring):
to_file.write(from_file)
else:
from bzrlib.osutils import pumpfile
pumpfile(from_file, to_file)
def _get_total(self, multi):
"""Try to figure out how many entries are in multi,
but if not possible, return None.
"""
try:
return len(multi)
except TypeError: # We can't tell how many, because relpaths is a generator
return None
def _update_pb(self, pb, msg, count, total):
"""Update the progress bar based on the current count
and total available, total may be None if it was
not possible to determine.
"""
if pb is None:
return
if total is None:
pb.update(msg, count, count+1)
else:
pb.update(msg, count, total)
def _iterate_over(self, multi, func, pb, msg, expand=True):
"""Iterate over all entries in multi, passing them to func,
and update the progress bar as you go along.
:param expand: If True, the entries will be passed to the function
by expanding the tuple. If False, it will be passed
as a single parameter.
"""
total = self._get_total(multi)
count = 0
for entry in multi:
self._update_pb(pb, msg, count, total)
if expand:
func(*entry)
else:
func(entry)
count += 1
return count
def abspath(self, relpath):
"""Return the full url to the given relative path.
This can be supplied with a string or a list
"""
raise NotImplementedError
def relpath(self, abspath):
"""Return the local path portion from a given absolute path.
"""
raise NotImplementedError
def has(self, relpath):
"""Does the target location exist?"""
raise NotImplementedError
def has_multi(self, relpaths, pb=None):
"""Return True/False for each entry in relpaths"""
total = self._get_total(relpaths)
count = 0
for relpath in relpaths:
self._update_pb(pb, 'has', count, total)
yield self.has(relpath)
count += 1
def get(self, relpath):
"""Get the file at the given relative path.
:param relpath: The relative path to the file
"""
raise NotImplementedError
def get_multi(self, relpaths, pb=None):
"""Get a list of file-like objects, one for each entry in relpaths.
:param relpaths: A list of relative paths.
:param pb: An optional ProgressBar for indicating percent done.
:return: A list or generator of file-like objects
"""
# TODO: Consider having this actually buffer the requests,
# in the default mode, it probably won't give worse performance,
# and all children wouldn't have to implement buffering
total = self._get_total(relpaths)
count = 0
for relpath in relpaths:
self._update_pb(pb, 'get', count, total)
yield self.get(relpath)
count += 1
def get_partial(self, relpath, start, length=None):
"""Get just part of a file.
:param relpath: Path to the file, relative to base
:param start: The starting position to read from
:param length: The length to read. A length of None indicates
read to the end of the file.
:return: A file-like object containing at least the specified bytes.
Some implementations may return objects which can be read
past this length, but this is not guaranteed.
"""
raise NotImplementedError
def get_partial_multi(self, offsets, pb=None):
"""Put a set of files or strings into the location.
Requesting multiple portions of the same file can be dangerous.
:param offsets: A list of tuples of relpath, start, length
[(path1, start1, length1),
(path2, start2, length2),
(path3, start3), ...]
length is optional, defaulting to None
:param pb: An optional ProgressBar for indicating percent done.
:return: A generator of file-like objects.
"""
total = self._get_total(offsets)
count = 0
for offset in offsets:
self._update_pb(pb, 'get_partial', count, total)
yield self.get_partial(*offset)
count += 1
def put(self, relpath, f):
"""Copy the file-like or string object into the location.
:param relpath: Location to put the contents, relative to base.
:param f: File-like or string object.
"""
raise NotImplementedError
def put_multi(self, files, pb=None):
"""Put a set of files or strings into the location.
:param files: A list of tuples of relpath, file object [(path1, file1), (path2, file2),...]
:param pb: An optional ProgressBar for indicating percent done.
:return: The number of files copied.
"""
return self._iterate_over(files, self.put, pb, 'put', expand=True)
def mkdir(self, relpath):
"""Create a directory at the given path."""
raise NotImplementedError
def mkdir_multi(self, relpaths, pb=None):
"""Create a group of directories"""
return self._iterate_over(relpaths, self.mkdir, pb, 'mkdir', expand=False)
def append(self, relpath, f):
"""Append the text in the file-like or string object to
the supplied location.
"""
raise NotImplementedError
def append_multi(self, files, pb=None):
"""Append the text in each file-like or string object to
the supplied location.
:param files: A set of (path, f) entries
:param pb: An optional ProgressBar for indicating percent done.
"""
return self._iterate_over(files, self.append, pb, 'append', expand=True)
def copy(self, rel_from, rel_to):
"""Copy the item at rel_from to the location at rel_to"""
raise NotImplementedError
def copy_multi(self, relpaths, pb=None):
"""Copy a bunch of entries.
:param relpaths: A list of tuples of the form [(from, to), (from, to),...]
"""
# This is the non-pipelined implementation, so that
# implementors don't have to implement everything.
return self._iterate_over(relpaths, self.copy, pb, 'copy', expand=True)
def copy_to(self, relpaths, other, pb=None):
"""Copy a set of entries from self into another Transport.
:param relpaths: A list/generator of entries to be copied.
"""
# The dummy implementation just does a simple get + put
def copy_entry(path):
other.put(path, self.get(path))
return self._iterate_over(relpaths, copy_entry, pb, 'copy_to', expand=False)
def move(self, rel_from, rel_to):
"""Move the item at rel_from to the location at rel_to"""
raise NotImplementedError
def move_multi(self, relpaths, pb=None):
"""Move a bunch of entries.
:param relpaths: A list of tuples of the form [(from1, to1), (from2, to2),...]
"""
return self._iterate_over(relpaths, self.move, pb, 'move', expand=True)
def move_multi_to(self, relpaths, rel_to):
"""Move a bunch of entries to a single location.
This differs from move_multi in that you give a list of from, and
a single destination, rather than multiple destinations.
:param relpaths: A list of relative paths [from1, from2, from3, ...]
:param rel_to: A directory where each entry should be placed.
"""
# This is not implemented, because you need to do special tricks to
# extract the basename, and add it to rel_to
raise NotImplementedError
def delete(self, relpath):
"""Delete the item at relpath"""
raise NotImplementedError
def delete_multi(self, relpaths, pb=None):
"""Queue up a bunch of deletes to be done.
"""
return self._iterate_over(relpaths, self.delete, pb, 'delete', expand=False)
def stat(self, relpath):
"""Return the stat information for a file.
WARNING: This may not be implementable for all protocols, so use
sparingly.
"""
raise NotImplementedError
def stat_multi(self, relpaths, pb=None):
"""Stat multiple files and return the information.
"""
#TODO: Is it worth making this a generator instead of a
# returning a list?
stats = []
def gather(path):
stats.append(self.stat(path))
count = self._iterate_over(relpaths, gather, pb, 'stat', expand=False)
return stats
def list_dir(self, relpath):
"""Return a list of all files at the given location.
WARNING: many transports do not support this, so trying avoid using
it if at all possible.
"""
raise NotImplementedError
def lock_read(self, relpath):
"""Lock the given file for shared (read) access.
WARNING: many transports do not support this, so trying avoid using it
:return: A lock object, which should contain an unlock() function.
"""
raise NotImplementedError
def lock_write(self, relpath):
"""Lock the given file for exclusive (write) access.
WARNING: many transports do not support this, so trying avoid using it
:return: A lock object, which should contain an unlock() function.
"""
raise NotImplementedError
def get_transport(base):
global _protocol_handlers
if base is None:
base = '.'
for proto, klass in _protocol_handlers.iteritems():
if proto is not None and base.startswith(proto):
return klass(base)
# The default handler is the filesystem handler
# which has a lookup of None
return _protocol_handlers[None](base)
# Local transport should always be initialized
import bzrlib.transport.local
|