1
1
# Copyright (C) 2005, 2006 Canonical Ltd
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23
from stat import ST_MODE, S_ISDIR, ST_SIZE, S_IMODE
26
from bzrlib.lazy_import import lazy_import
27
lazy_import(globals(), """
25
from stat import ST_MODE, S_ISDIR, ST_SIZE
28
from bzrlib.osutils import (abspath, realpath, normpath, pathjoin, rename,
29
check_legal_path, rmtree)
30
from bzrlib.symbol_versioning import warn
37
31
from bzrlib.trace import mutter
38
from bzrlib.transport import LateReadError
41
32
from bzrlib.transport import Transport, Server
44
_append_flags = os.O_CREAT | os.O_APPEND | os.O_WRONLY | osutils.O_BINARY
45
_put_non_atomic_flags = os.O_CREAT | os.O_TRUNC | os.O_WRONLY | osutils.O_BINARY
33
import bzrlib.urlutils as urlutils
48
36
class LocalTransport(Transport):
142
123
path = self._abspath(relpath)
143
124
return open(path, 'rb')
144
125
except (IOError, OSError),e:
145
if e.errno == errno.EISDIR:
146
return LateReadError(relpath)
147
126
self._translate_error(e, path)
149
def put_file(self, relpath, f, mode=None):
150
"""Copy the file-like object into the location.
128
def put(self, relpath, f, mode=None):
129
"""Copy the file-like or string object into the location.
152
131
:param relpath: Location to put the contents, relative to base.
153
:param f: File-like object.
154
:param mode: The mode for the newly created file,
155
None means just use the default
132
:param f: File-like or string object.
134
from bzrlib.atomicfile import AtomicFile
160
138
path = self._abspath(relpath)
161
osutils.check_legal_path(path)
162
fp = atomicfile.AtomicFile(path, 'wb', new_mode=mode)
139
check_legal_path(path)
140
fp = AtomicFile(path, 'wb', new_mode=mode)
163
141
except (IOError, OSError),e:
164
142
self._translate_error(e, path)
171
def put_bytes(self, relpath, bytes, mode=None):
172
"""Copy the string into the location.
174
:param relpath: Location to put the contents, relative to base.
180
path = self._abspath(relpath)
181
osutils.check_legal_path(path)
182
fp = atomicfile.AtomicFile(path, 'wb', new_mode=mode)
183
except (IOError, OSError),e:
184
self._translate_error(e, path)
191
def _put_non_atomic_helper(self, relpath, writer,
193
create_parent_dir=False,
195
"""Common functionality information for the put_*_non_atomic.
197
This tracks all the create_parent_dir stuff.
199
:param relpath: the path we are putting to.
200
:param writer: A function that takes an os level file descriptor
201
and writes whatever data it needs to write there.
202
:param mode: The final file mode.
203
:param create_parent_dir: Should we be creating the parent directory
206
abspath = self._abspath(relpath)
208
# os.open() will automatically use the umask
213
fd = os.open(abspath, _put_non_atomic_flags, local_mode)
214
except (IOError, OSError),e:
215
# We couldn't create the file, maybe we need to create
216
# the parent directory, and try again
217
if (not create_parent_dir
218
or e.errno not in (errno.ENOENT,errno.ENOTDIR)):
219
self._translate_error(e, relpath)
220
parent_dir = os.path.dirname(abspath)
222
self._translate_error(e, relpath)
223
self._mkdir(parent_dir, mode=dir_mode)
224
# We created the parent directory, lets try to open the
227
fd = os.open(abspath, _put_non_atomic_flags, local_mode)
228
except (IOError, OSError), e:
229
self._translate_error(e, relpath)
232
if mode is not None and mode != S_IMODE(st.st_mode):
233
# Because of umask, we may still need to chmod the file.
234
# But in the general case, we won't have to
235
os.chmod(abspath, mode)
240
def put_file_non_atomic(self, relpath, f, mode=None,
241
create_parent_dir=False,
243
"""Copy the file-like object into the target location.
245
This function is not strictly safe to use. It is only meant to
246
be used when you already know that the target does not exist.
247
It is not safe, because it will open and truncate the remote
248
file. So there may be a time when the file has invalid contents.
250
:param relpath: The remote location to put the contents.
251
:param f: File-like object.
252
:param mode: Possible access permissions for new file.
253
None means do not set remote permissions.
254
:param create_parent_dir: If we cannot create the target file because
255
the parent directory does not exist, go ahead and
256
create it, and then try again.
259
self._pump_to_fd(f, fd)
260
self._put_non_atomic_helper(relpath, writer, mode=mode,
261
create_parent_dir=create_parent_dir,
264
def put_bytes_non_atomic(self, relpath, bytes, mode=None,
265
create_parent_dir=False, dir_mode=None):
268
self._put_non_atomic_helper(relpath, writer, mode=mode,
269
create_parent_dir=create_parent_dir,
272
149
def iter_files_recursive(self):
273
150
"""Iter the relative paths of files in the transports sub-tree."""
274
151
queue = list(self.list_dir(u'.'))
284
def _mkdir(self, abspath, mode=None):
285
"""Create a real directory, filtering through mode"""
287
# os.mkdir() will filter through umask
292
os.mkdir(abspath, local_mode)
294
# It is probably faster to just do the chmod, rather than
295
# doing a stat, and then trying to compare
296
os.chmod(abspath, mode)
297
except (IOError, OSError),e:
298
self._translate_error(e, abspath)
300
161
def mkdir(self, relpath, mode=None):
301
162
"""Create a directory at the given path."""
302
self._mkdir(self._abspath(relpath), mode=mode)
304
def _get_append_file(self, relpath, mode=None):
305
"""Call os.open() for the given relpath"""
306
file_abspath = self._abspath(relpath)
308
# os.open() will automatically use the umask
313
return file_abspath, os.open(file_abspath, _append_flags, local_mode)
165
path = self._abspath(relpath)
314
169
except (IOError, OSError),e:
315
self._translate_error(e, relpath)
317
def _check_mode_and_size(self, file_abspath, fd, mode=None):
318
"""Check the mode of the file, and return the current size"""
320
if mode is not None and mode != S_IMODE(st.st_mode):
321
# Because of umask, we may still need to chmod the file.
322
# But in the general case, we won't have to
323
os.chmod(file_abspath, mode)
326
def append_file(self, relpath, f, mode=None):
170
self._translate_error(e, path)
172
def append(self, relpath, f, mode=None):
327
173
"""Append the text in the file-like object into the final location."""
328
file_abspath, fd = self._get_append_file(relpath, mode=mode)
330
result = self._check_mode_and_size(file_abspath, fd, mode=mode)
331
self._pump_to_fd(f, fd)
336
def append_bytes(self, relpath, bytes, mode=None):
337
"""Append the text in the string into the final location."""
338
file_abspath, fd = self._get_append_file(relpath, mode=mode)
340
result = self._check_mode_and_size(file_abspath, fd, mode=mode)
346
def _pump_to_fd(self, fromfile, to_fd):
347
"""Copy contents of one file to another."""
350
b = fromfile.read(BUFSIZE)
174
abspath = self._abspath(relpath)
178
fp = open(abspath, 'ab')
179
# FIXME should we really be chmodding every time ? RBC 20060523
181
os.chmod(abspath, mode)
182
except (IOError, OSError),e:
183
self._translate_error(e, relpath)
184
# win32 workaround (tell on an unwritten file returns 0)
355
193
def copy(self, rel_from, rel_to):
356
194
"""Copy the item at rel_from to the location at rel_to"""
491
class EmulatedWin32LocalTransport(LocalTransport):
492
"""Special transport for testing Win32 [UNC] paths on non-windows"""
494
def __init__(self, base):
497
super(LocalTransport, self).__init__(base)
498
self._local_base = urlutils._win32_local_path_from_url(base)
500
def abspath(self, relpath):
501
assert isinstance(relpath, basestring), (type(relpath), relpath)
502
path = osutils.normpath(osutils.pathjoin(
503
self._local_base, urlutils.unescape(relpath)))
504
return urlutils._win32_local_path_to_url(path)
506
def clone(self, offset=None):
507
"""Return a new LocalTransport with root at self.base + offset
508
Because the local filesystem does not require a connection,
509
we can just return a new object.
512
return EmulatedWin32LocalTransport(self.base)
514
abspath = self.abspath(offset)
515
if abspath == 'file://':
516
# fix upwalk for UNC path
517
# when clone from //HOST/path updir recursively
518
# we should stop at least at //HOST part
520
return EmulatedWin32LocalTransport(abspath)
323
class LocalRelpathServer(Server):
324
"""A pretend server for local transports, using relpaths."""
327
"""See Transport.Server.get_url."""
331
class LocalAbspathServer(Server):
332
"""A pretend server for local transports, using absolute paths."""
335
"""See Transport.Server.get_url."""
336
return os.path.abspath("")
523
339
class LocalURLServer(Server):
524
"""A pretend server for local transports, using file:// urls.
526
Of course no actual server is required to access the local filesystem, so
527
this just exists to tell the test code how to get to it.
531
"""Setup the server to service requests.
533
:param decorated_transport: ignored by this implementation.
340
"""A pretend server for local transports, using file:// urls."""
536
342
def get_url(self):
537
343
"""See Transport.Server.get_url."""
added
removed
bzrlib/transport/local.py
