← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: John Arbash Meinel
  • Date: 2006-08-09 14:43:27 UTC
  • mto: This revision was merged to the branch mainline in revision 1912.
  • Revision ID: john@arbash-meinel.com-20060809144327-d604af2edf646794
Clean up and write tests for permissions. Now we use fstat which should be cheap, and lets us check the permissions and the file size

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/local.py
22
22
import os
23
23
import shutil
24
24
import sys
25
 
from stat import ST_MODE, S_ISDIR, ST_SIZE
 
25
from stat import ST_MODE, S_ISDIR, ST_SIZE, S_IMODE
26
26
import tempfile
27
27
 
28
 
from bzrlib.osutils import (abspath, realpath, normpath, pathjoin, rename, 
 
28
from bzrlib import (
 
29
    osutils,
 
30
    urlutils,
 
31
    )
 
32
from bzrlib.osutils import (abspath, realpath, normpath, pathjoin, rename,
29
33
                            check_legal_path, rmtree)
30
34
from bzrlib.symbol_versioning import warn
31
35
from bzrlib.trace import mutter
32
36
from bzrlib.transport import Transport, Server
33
 
import bzrlib.urlutils as urlutils
 
37
 
 
38
 
 
39
_append_flags = os.O_CREAT | os.O_APPEND | os.O_WRONLY | osutils.O_BINARY
34
40
 
35
41
 
36
42
class LocalTransport(Transport):
51
57
            base = base + '/'
52
58
        super(LocalTransport, self).__init__(base)
53
59
        self._local_base = urlutils.local_path_from_url(base)
54
 
        ## mutter("_local_base: %r => %r", base, self._local_base)
 
60
        self._get_default_modes()
 
61
 
 
62
    def _get_default_modes(self):
 
63
        """Figure out what the default file and directory modes are"""
 
64
        umask = osutils.get_umask()
 
65
        self._default_file_mode = 0666 & ~umask
 
66
        self._default_dir_mode = 0777 & ~umask
55
67
 
56
68
    def should_cache(self):
57
69
        return False
125
137
        except (IOError, OSError),e:
126
138
            self._translate_error(e, path)
127
139
 
128
 
    def put(self, relpath, f, mode=0666):
 
140
    def put(self, relpath, f, mode=None):
129
141
        """Copy the file-like or string object into the location.
130
142
 
131
143
        :param relpath: Location to put the contents, relative to base.
134
146
        from bzrlib.atomicfile import AtomicFile
135
147
 
136
148
        if mode is None:
137
 
            mode = 0666
 
149
            mode = self._default_file_mode
138
150
        path = relpath
139
151
        try:
140
152
            path = self._abspath(relpath)
164
176
        """Create a directory at the given path."""
165
177
        path = relpath
166
178
        try:
 
179
            if mode is None:
 
180
                local_mode = self._default_dir_mode
 
181
            else:
 
182
                local_mode = mode
167
183
            path = self._abspath(relpath)
168
 
            os.mkdir(path)
 
184
            os.mkdir(path, local_mode)
169
185
            if mode is not None:
 
186
                # It is probably faster to just do the chmod, rather than
 
187
                # doing a stat, and then trying to compare
170
188
                os.chmod(path, mode)
171
189
        except (IOError, OSError),e:
172
190
            self._translate_error(e, path)
173
191
 
174
 
    def append(self, relpath, f, mode=0666):
 
192
    def append(self, relpath, f, mode=None):
175
193
        """Append the text in the file-like object into the final location."""
176
194
        abspath = self._abspath(relpath)
177
195
        if mode is None:
178
 
            mode = 0666
 
196
            local_mode = self._default_file_mode
 
197
        else:
 
198
            local_mode = mode
179
199
        try:
180
 
            fd = os.open(abspath, os.O_CREAT | os.O_APPEND | os.O_WRONLY, mode)
 
200
            fd = os.open(abspath, _append_flags, local_mode)
181
201
        except (IOError, OSError),e:
182
202
            self._translate_error(e, relpath)
183
203
        try:
184
 
            result = os.lseek(fd, 0, 2)
 
204
            st = os.fstat(fd)
 
205
            result = st.st_size
 
206
            if mode is not None and mode != S_IMODE(st.st_mode):
 
207
                # Because of umask, we may still need to chmod the file.
 
208
                # But in the general case, we won't have to
 
209
                os.chmod(abspath, mode)
185
210
            # TODO: make a raw FD version of _pump ?
186
211
            self._pump_to_fd(f, fd)
187
212
        finally: