← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: Martin Pool
  • Date: 2006-03-09 03:28:52 UTC
  • mto: This revision was merged to the branch mainline in revision 1602.
  • Revision ID: mbp@sourcefrog.net-20060309032852-1097eb1947d9bceb
doc

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[7:]
 
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 = urllib.quote(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
        self._pump(f, fp)
 
142
 
 
143
    def copy(self, rel_from, rel_to):
 
144
        """Copy the item at rel_from to the location at rel_to"""
 
145
        import shutil
 
146
        path_from = self.abspath(rel_from)
 
147
        path_to = self.abspath(rel_to)
 
148
        try:
 
149
            shutil.copy(path_from, path_to)
 
150
        except (IOError, OSError),e:
 
151
            # TODO: What about path_to?
 
152
            self._translate_error(e, path_from)
 
153
 
 
154
    def rename(self, rel_from, rel_to):
 
155
        path_from = self.abspath(rel_from)
 
156
        try:
 
157
            # *don't* call bzrlib.osutils.rename, because we want to 
 
158
            # detect errors on rename
 
159
            os.rename(path_from, self.abspath(rel_to))
 
160
        except (IOError, OSError),e:
 
161
            # TODO: What about path_to?
 
162
            self._translate_error(e, path_from)
 
163
 
 
164
    def move(self, rel_from, rel_to):
 
165
        """Move the item at rel_from to the location at rel_to"""
 
166
        path_from = self.abspath(rel_from)
 
167
        path_to = self.abspath(rel_to)
 
168
 
 
169
        try:
 
170
            # this version will delete the destination if necessary
 
171
            rename(path_from, path_to)
 
172
        except (IOError, OSError),e:
 
173
            # TODO: What about path_to?
 
174
            self._translate_error(e, path_from)
 
175
 
 
176
    def delete(self, relpath):
 
177
        """Delete the item at relpath"""
 
178
        path = relpath
 
179
        try:
 
180
            path = self.abspath(relpath)
 
181
            os.remove(path)
 
182
        except (IOError, OSError),e:
 
183
            # TODO: What about path_to?
 
184
            self._translate_error(e, path)
 
185
 
 
186
    def copy_to(self, relpaths, other, mode=None, pb=None):
 
187
        """Copy a set of entries from self into another Transport.
 
188
 
 
189
        :param relpaths: A list/generator of entries to be copied.
 
190
        """
 
191
        if isinstance(other, LocalTransport):
 
192
            # Both from & to are on the local filesystem
 
193
            # Unfortunately, I can't think of anything faster than just
 
194
            # copying them across, one by one :(
 
195
            import shutil
 
196
 
 
197
            total = self._get_total(relpaths)
 
198
            count = 0
 
199
            for path in relpaths:
 
200
                self._update_pb(pb, 'copy-to', count, total)
 
201
                try:
 
202
                    mypath = self.abspath(path)
 
203
                    otherpath = other.abspath(path)
 
204
                    shutil.copy(mypath, otherpath)
 
205
                    if mode is not None:
 
206
                        os.chmod(otherpath, mode)
 
207
                except (IOError, OSError),e:
 
208
                    self._translate_error(e, path)
 
209
                count += 1
 
210
            return count
 
211
        else:
 
212
            return super(LocalTransport, self).copy_to(relpaths, other, mode=mode, pb=pb)
 
213
 
 
214
    def listable(self):
 
215
        """See Transport.listable."""
 
216
        return True
 
217
 
 
218
    def list_dir(self, relpath):
 
219
        """Return a list of all files at the given location.
 
220
        WARNING: many transports do not support this, so trying avoid using
 
221
        it if at all possible.
 
222
        """
 
223
        path = relpath
 
224
        try:
 
225
            path = self.abspath(relpath)
 
226
            return os.listdir(path)
 
227
        except (IOError, OSError),e:
 
228
            self._translate_error(e, path)
 
229
 
 
230
    def stat(self, relpath):
 
231
        """Return the stat information for a file.
 
232
        """
 
233
        path = relpath
 
234
        try:
 
235
            path = self.abspath(relpath)
 
236
            return os.stat(path)
 
237
        except (IOError, OSError),e:
 
238
            self._translate_error(e, path)
 
239
 
 
240
    def lock_read(self, relpath):
 
241
        """Lock the given file for shared (read) access.
 
242
        :return: A lock object, which should be passed to Transport.unlock()
 
243
        """
 
244
        from bzrlib.lock import ReadLock
 
245
        path = relpath
 
246
        try:
 
247
            path = self.abspath(relpath)
 
248
            return ReadLock(path)
 
249
        except (IOError, OSError), e:
 
250
            self._translate_error(e, path)
 
251
 
 
252
    def lock_write(self, relpath):
 
253
        """Lock the given file for exclusive (write) access.
 
254
        WARNING: many transports do not support this, so trying avoid using it
 
255
 
 
256
        :return: A lock object, which should be passed to Transport.unlock()
 
257
        """
 
258
        from bzrlib.lock import WriteLock
 
259
        return WriteLock(self.abspath(relpath))
 
260
 
 
261
    def rmdir(self, relpath):
 
262
        """See Transport.rmdir."""
 
263
        path = relpath
 
264
        try:
 
265
            path = self.abspath(relpath)
 
266
            os.rmdir(path)
 
267
        except (IOError, OSError),e:
 
268
            self._translate_error(e, path)
 
269
 
 
270
class ScratchTransport(LocalTransport):
 
271
    """A transport that works in a temporary dir and cleans up after itself.
 
272
    
 
273
    The dir only exists for the lifetime of the Python object.
 
274
    Obviously you should not put anything precious in it.
 
275
    """
 
276
 
 
277
    def __init__(self, base=None):
 
278
        if base is None:
 
279
            base = tempfile.mkdtemp()
 
280
        super(ScratchTransport, self).__init__(base)
 
281
 
 
282
    def __del__(self):
 
283
        shutil.rmtree(self.base, ignore_errors=True)
 
284
        mutter("%r destroyed" % self)
 
285
 
 
286
 
 
287
class LocalRelpathServer(Server):
 
288
    """A pretend server for local transports, using relpaths."""
 
289
 
 
290
    def get_url(self):
 
291
        """See Transport.Server.get_url."""
 
292
        return "."
 
293
 
 
294
 
 
295
class LocalAbspathServer(Server):
 
296
    """A pretend server for local transports, using absolute paths."""
 
297
 
 
298
    def get_url(self):
 
299
        """See Transport.Server.get_url."""
 
300
        return os.path.abspath("")
 
301
 
 
302
 
 
303
class LocalURLServer(Server):
 
304
    """A pretend server for local transports, using file:// urls."""
 
305
 
 
306
    def get_url(self):
 
307
        """See Transport.Server.get_url."""
 
308
        # FIXME: \ to / on windows
 
309
        return "file://%s" % os.path.abspath("")
 
310
 
 
311
 
 
312
def get_test_permutations():
 
313
    """Return the permutations to be used in testing."""
 
314
    return [(LocalTransport, LocalRelpathServer),
 
315
            (LocalTransport, LocalAbspathServer),
 
316
            (LocalTransport, LocalURLServer),
 
317
            ]