← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: Robert Collins
  • Date: 2006-04-02 22:42:19 UTC
  • mto: (1634.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 1635.
  • Revision ID: robertc@robertcollins.net-20060402224219-d5a818dc987491fe
Refactor the FakeNFS support into a TransportDecorator.
 * Move the existing boilerplate ReadOnly decorator logic in to a base class
   'bzrlib.transport.decorator.TransportDecorator.'
 * Do the same to the ReadOnlyServer to create
   'bzrlib.transport.decorator.DecoratorServer'.
 * Use the new decorator support to create a trivial FakeNFSTransportDecorator
   class in bzrlib.transport.fakenfs.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/local.py
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""Transport for the local filesystem.
 
18
 
 
19
This is a fairly thin wrapper on regular file IO."""
 
20
 
 
21
import os
 
22
import shutil
 
23
from stat import ST_MODE, S_ISDIR, ST_SIZE
 
24
import tempfile
 
25
import urllib
 
26
 
 
27
from bzrlib.trace import mutter
 
28
from bzrlib.transport import Transport, Server
 
29
from bzrlib.osutils import abspath, realpath, normpath, pathjoin, rename
 
30
 
 
31
 
 
32
class LocalTransport(Transport):
 
33
    """This is the transport agent for local filesystem access."""
 
34
 
 
35
    def __init__(self, base):
 
36
        """Set the base path where files will be stored."""
 
37
        if base.startswith('file://'):
 
38
            base = base[len('file://'):]
 
39
        # realpath is incompatible with symlinks. When we traverse
 
40
        # up we might be able to normpath stuff. RBC 20051003
 
41
        base = normpath(abspath(base))
 
42
        if base[-1] != '/':
 
43
            base = base + '/'
 
44
        super(LocalTransport, self).__init__(base)
 
45
 
 
46
    def should_cache(self):
 
47
        return False
 
48
 
 
49
    def clone(self, offset=None):
 
50
        """Return a new LocalTransport with root at self.base + offset
 
51
        Because the local filesystem does not require a connection, 
 
52
        we can just return a new object.
 
53
        """
 
54
        if offset is None:
 
55
            return LocalTransport(self.base)
 
56
        else:
 
57
            return LocalTransport(self.abspath(offset))
 
58
 
 
59
    def abspath(self, relpath):
 
60
        """Return the full url to the given relative URL.
 
61
        This can be supplied with a string or a list
 
62
        """
 
63
        assert isinstance(relpath, basestring), (type(relpath), relpath)
 
64
        return pathjoin(self.base, urllib.unquote(relpath))
 
65
 
 
66
    def relpath(self, abspath):
 
67
        """Return the local path portion from a given absolute path.
 
68
        """
 
69
        from bzrlib.osutils import relpath
 
70
        if abspath is None:
 
71
            abspath = u'.'
 
72
        if abspath.endswith('/'):
 
73
            abspath = abspath[:-1]
 
74
        return relpath(self.base[:-1], abspath)
 
75
 
 
76
    def has(self, relpath):
 
77
        return os.access(self.abspath(relpath), os.F_OK)
 
78
 
 
79
    def get(self, relpath):
 
80
        """Get the file at the given relative path.
 
81
 
 
82
        :param relpath: The relative path to the file
 
83
        """
 
84
        try:
 
85
            path = self.abspath(relpath)
 
86
            return open(path, 'rb')
 
87
        except (IOError, OSError),e:
 
88
            self._translate_error(e, path)
 
89
 
 
90
    def put(self, relpath, f, mode=None):
 
91
        """Copy the file-like or string object into the location.
 
92
 
 
93
        :param relpath: Location to put the contents, relative to base.
 
94
        :param f:       File-like or string object.
 
95
        """
 
96
        from bzrlib.atomicfile import AtomicFile
 
97
 
 
98
        path = relpath
 
99
        try:
 
100
            path = self.abspath(relpath)
 
101
            fp = AtomicFile(path, 'wb', new_mode=mode)
 
102
        except (IOError, OSError),e:
 
103
            self._translate_error(e, path)
 
104
        try:
 
105
            self._pump(f, fp)
 
106
            fp.commit()
 
107
        finally:
 
108
            fp.close()
 
109
 
 
110
    def iter_files_recursive(self):
 
111
        """Iter the relative paths of files in the transports sub-tree."""
 
112
        queue = list(self.list_dir(u'.'))
 
113
        while queue:
 
114
            relpath = queue.pop(0)
 
115
            st = self.stat(relpath)
 
116
            if S_ISDIR(st[ST_MODE]):
 
117
                for i, basename in enumerate(self.list_dir(relpath)):
 
118
                    queue.insert(i, relpath+'/'+basename)
 
119
            else:
 
120
                yield relpath
 
121
 
 
122
    def mkdir(self, relpath, mode=None):
 
123
        """Create a directory at the given path."""
 
124
        path = relpath
 
125
        try:
 
126
            path = self.abspath(relpath)
 
127
            os.mkdir(path)
 
128
            if mode is not None:
 
129
                os.chmod(path, mode)
 
130
        except (IOError, OSError),e:
 
131
            self._translate_error(e, path)
 
132
 
 
133
    def append(self, relpath, f):
 
134
        """Append the text in the file-like object into the final
 
135
        location.
 
136
        """
 
137
        try:
 
138
            fp = open(self.abspath(relpath), 'ab')
 
139
        except (IOError, OSError),e:
 
140
            self._translate_error(e, relpath)
 
141
        result = fp.tell()
 
142
        self._pump(f, fp)
 
143
        return result
 
144
 
 
145
    def copy(self, rel_from, rel_to):
 
146
        """Copy the item at rel_from to the location at rel_to"""
 
147
        import shutil
 
148
        path_from = self.abspath(rel_from)
 
149
        path_to = self.abspath(rel_to)
 
150
        try:
 
151
            shutil.copy(path_from, path_to)
 
152
        except (IOError, OSError),e:
 
153
            # TODO: What about path_to?
 
154
            self._translate_error(e, path_from)
 
155
 
 
156
    def rename(self, rel_from, rel_to):
 
157
        path_from = self.abspath(rel_from)
 
158
        try:
 
159
            # *don't* call bzrlib.osutils.rename, because we want to 
 
160
            # detect errors on rename
 
161
            os.rename(path_from, self.abspath(rel_to))
 
162
        except (IOError, OSError),e:
 
163
            # TODO: What about path_to?
 
164
            self._translate_error(e, path_from)
 
165
 
 
166
    def move(self, rel_from, rel_to):
 
167
        """Move the item at rel_from to the location at rel_to"""
 
168
        path_from = self.abspath(rel_from)
 
169
        path_to = self.abspath(rel_to)
 
170
 
 
171
        try:
 
172
            # this version will delete the destination if necessary
 
173
            rename(path_from, path_to)
 
174
        except (IOError, OSError),e:
 
175
            # TODO: What about path_to?
 
176
            self._translate_error(e, path_from)
 
177
 
 
178
    def delete(self, relpath):
 
179
        """Delete the item at relpath"""
 
180
        path = relpath
 
181
        try:
 
182
            path = self.abspath(relpath)
 
183
            os.remove(path)
 
184
        except (IOError, OSError),e:
 
185
            # TODO: What about path_to?
 
186
            self._translate_error(e, path)
 
187
 
 
188
    def copy_to(self, relpaths, other, mode=None, pb=None):
 
189
        """Copy a set of entries from self into another Transport.
 
190
 
 
191
        :param relpaths: A list/generator of entries to be copied.
 
192
        """
 
193
        if isinstance(other, LocalTransport):
 
194
            # Both from & to are on the local filesystem
 
195
            # Unfortunately, I can't think of anything faster than just
 
196
            # copying them across, one by one :(
 
197
            import shutil
 
198
 
 
199
            total = self._get_total(relpaths)
 
200
            count = 0
 
201
            for path in relpaths:
 
202
                self._update_pb(pb, 'copy-to', count, total)
 
203
                try:
 
204
                    mypath = self.abspath(path)
 
205
                    otherpath = other.abspath(path)
 
206
                    shutil.copy(mypath, otherpath)
 
207
                    if mode is not None:
 
208
                        os.chmod(otherpath, mode)
 
209
                except (IOError, OSError),e:
 
210
                    self._translate_error(e, path)
 
211
                count += 1
 
212
            return count
 
213
        else:
 
214
            return super(LocalTransport, self).copy_to(relpaths, other, mode=mode, pb=pb)
 
215
 
 
216
    def listable(self):
 
217
        """See Transport.listable."""
 
218
        return True
 
219
 
 
220
    def list_dir(self, relpath):
 
221
        """Return a list of all files at the given location.
 
222
        WARNING: many transports do not support this, so trying avoid using
 
223
        it if at all possible.
 
224
        """
 
225
        path = self.abspath(relpath)
 
226
        try:
 
227
            return [urllib.quote(entry) for entry in os.listdir(path)]
 
228
        except (IOError, OSError), e:
 
229
            self._translate_error(e, path)
 
230
 
 
231
    def stat(self, relpath):
 
232
        """Return the stat information for a file.
 
233
        """
 
234
        path = relpath
 
235
        try:
 
236
            path = self.abspath(relpath)
 
237
            return os.stat(path)
 
238
        except (IOError, OSError),e:
 
239
            self._translate_error(e, path)
 
240
 
 
241
    def lock_read(self, relpath):
 
242
        """Lock the given file for shared (read) access.
 
243
        :return: A lock object, which should be passed to Transport.unlock()
 
244
        """
 
245
        from bzrlib.lock import ReadLock
 
246
        path = relpath
 
247
        try:
 
248
            path = self.abspath(relpath)
 
249
            return ReadLock(path)
 
250
        except (IOError, OSError), e:
 
251
            self._translate_error(e, path)
 
252
 
 
253
    def lock_write(self, relpath):
 
254
        """Lock the given file for exclusive (write) access.
 
255
        WARNING: many transports do not support this, so trying avoid using it
 
256
 
 
257
        :return: A lock object, which should be passed to Transport.unlock()
 
258
        """
 
259
        from bzrlib.lock import WriteLock
 
260
        return WriteLock(self.abspath(relpath))
 
261
 
 
262
    def rmdir(self, relpath):
 
263
        """See Transport.rmdir."""
 
264
        path = relpath
 
265
        try:
 
266
            path = self.abspath(relpath)
 
267
            os.rmdir(path)
 
268
        except (IOError, OSError),e:
 
269
            self._translate_error(e, path)
 
270
 
 
271
 
 
272
class ScratchTransport(LocalTransport):
 
273
    """A transport that works in a temporary dir and cleans up after itself.
 
274
    
 
275
    The dir only exists for the lifetime of the Python object.
 
276
    Obviously you should not put anything precious in it.
 
277
    """
 
278
 
 
279
    def __init__(self, base=None):
 
280
        if base is None:
 
281
            base = tempfile.mkdtemp()
 
282
        super(ScratchTransport, self).__init__(base)
 
283
 
 
284
    def __del__(self):
 
285
        shutil.rmtree(self.base, ignore_errors=True)
 
286
        mutter("%r destroyed" % self)
 
287
 
 
288
 
 
289
class LocalRelpathServer(Server):
 
290
    """A pretend server for local transports, using relpaths."""
 
291
 
 
292
    def get_url(self):
 
293
        """See Transport.Server.get_url."""
 
294
        return "."
 
295
 
 
296
 
 
297
class LocalAbspathServer(Server):
 
298
    """A pretend server for local transports, using absolute paths."""
 
299
 
 
300
    def get_url(self):
 
301
        """See Transport.Server.get_url."""
 
302
        return os.path.abspath("")
 
303
 
 
304
 
 
305
class LocalURLServer(Server):
 
306
    """A pretend server for local transports, using file:// urls."""
 
307
 
 
308
    def get_url(self):
 
309
        """See Transport.Server.get_url."""
 
310
        # FIXME: \ to / on windows
 
311
        return "file://%s" % os.path.abspath("")
 
312
 
 
313
 
 
314
def get_test_permutations():
 
315
    """Return the permutations to be used in testing."""
 
316
    return [(LocalTransport, LocalRelpathServer),
 
317
            (LocalTransport, LocalAbspathServer),
 
318
            (LocalTransport, LocalURLServer),
 
319
            ]