← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/vfs.py

  • Committer: Patch Queue Manager
  • Date: 2016-04-21 04:10:52 UTC
  • mfrom: (6616.1.1 fix-en-user-guide)
  • Revision ID: pqm@pqm.ubuntu.com-20160421041052-clcye7ns1qcl2n7w
(richard-wilbur) Ensure build of English use guide always uses English text
 even when user's locale specifies a different language. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/vfs.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
2
2
#
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
12
12
#
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
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""VFS operations for the smart server.
18
18
 
24
24
protocol, as implemented in bzr 0.11 and later.
25
25
"""
26
26
 
 
27
from __future__ import absolute_import
 
28
 
27
29
import os
28
30
 
29
31
from bzrlib import errors
 
32
from bzrlib import urlutils
30
33
from bzrlib.smart import request
31
34
 
32
35
 
51
54
 
52
55
class VfsRequest(request.SmartServerRequest):
53
56
    """Base class for VFS requests.
54
 
    
 
57
 
55
58
    VFS requests are disabled if vfs_enabled() returns False.
56
59
    """
57
60
 
59
62
        if not vfs_enabled():
60
63
            raise errors.DisabledMethod(self.__class__.__name__)
61
64
 
 
65
    def translate_client_path(self, relpath):
 
66
        # VFS requests are made with escaped paths so the escaping done in
 
67
        # SmartServerRequest.translate_client_path leads to double escaping.
 
68
        # Remove it here -- the fact that the result is still escaped means
 
69
        # that the str() will not fail on valid input.
 
70
        x = request.SmartServerRequest.translate_client_path(self, relpath)
 
71
        return str(urlutils.unescape(x))
 
72
 
62
73
 
63
74
class HasRequest(VfsRequest):
64
75
 
65
76
    def do(self, relpath):
 
77
        relpath = self.translate_client_path(relpath)
66
78
        r = self._backing_transport.has(relpath) and 'yes' or 'no'
67
79
        return request.SuccessfulSmartServerResponse((r,))
68
80
 
70
82
class GetRequest(VfsRequest):
71
83
 
72
84
    def do(self, relpath):
73
 
        try:
74
 
            backing_bytes = self._backing_transport.get_bytes(relpath)
75
 
        except errors.ReadError:
76
 
            # cannot read the file
77
 
            return request.FailedSmartServerResponse(('ReadError', ))
 
85
        relpath = self.translate_client_path(relpath)
 
86
        backing_bytes = self._backing_transport.get_bytes(relpath)
78
87
        return request.SuccessfulSmartServerResponse(('ok',), backing_bytes)
79
88
 
80
89
 
81
90
class AppendRequest(VfsRequest):
82
91
 
83
92
    def do(self, relpath, mode):
 
93
        relpath = self.translate_client_path(relpath)
84
94
        self._relpath = relpath
85
95
        self._mode = _deserialise_optional_mode(mode)
86
 
    
 
96
 
87
97
    def do_body(self, body_bytes):
88
98
        old_length = self._backing_transport.append_bytes(
89
99
            self._relpath, body_bytes, self._mode)
93
103
class DeleteRequest(VfsRequest):
94
104
 
95
105
    def do(self, relpath):
 
106
        relpath = self.translate_client_path(relpath)
96
107
        self._backing_transport.delete(relpath)
97
108
        return request.SuccessfulSmartServerResponse(('ok', ))
98
109
 
100
111
class IterFilesRecursiveRequest(VfsRequest):
101
112
 
102
113
    def do(self, relpath):
 
114
        if not relpath.endswith('/'):
 
115
            relpath += '/'
 
116
        relpath = self.translate_client_path(relpath)
103
117
        transport = self._backing_transport.clone(relpath)
104
118
        filenames = transport.iter_files_recursive()
105
119
        return request.SuccessfulSmartServerResponse(('names',) + tuple(filenames))
108
122
class ListDirRequest(VfsRequest):
109
123
 
110
124
    def do(self, relpath):
 
125
        if not relpath.endswith('/'):
 
126
            relpath += '/'
 
127
        relpath = self.translate_client_path(relpath)
111
128
        filenames = self._backing_transport.list_dir(relpath)
112
129
        return request.SuccessfulSmartServerResponse(('names',) + tuple(filenames))
113
130
 
115
132
class MkdirRequest(VfsRequest):
116
133
 
117
134
    def do(self, relpath, mode):
 
135
        relpath = self.translate_client_path(relpath)
118
136
        self._backing_transport.mkdir(relpath,
119
137
                                      _deserialise_optional_mode(mode))
120
138
        return request.SuccessfulSmartServerResponse(('ok',))
123
141
class MoveRequest(VfsRequest):
124
142
 
125
143
    def do(self, rel_from, rel_to):
 
144
        rel_from = self.translate_client_path(rel_from)
 
145
        rel_to = self.translate_client_path(rel_to)
126
146
        self._backing_transport.move(rel_from, rel_to)
127
147
        return request.SuccessfulSmartServerResponse(('ok',))
128
148
 
130
150
class PutRequest(VfsRequest):
131
151
 
132
152
    def do(self, relpath, mode):
 
153
        relpath = self.translate_client_path(relpath)
133
154
        self._relpath = relpath
134
155
        self._mode = _deserialise_optional_mode(mode)
135
156
 
141
162
class PutNonAtomicRequest(VfsRequest):
142
163
 
143
164
    def do(self, relpath, mode, create_parent, dir_mode):
 
165
        relpath = self.translate_client_path(relpath)
144
166
        self._relpath = relpath
145
167
        self._dir_mode = _deserialise_optional_mode(dir_mode)
146
168
        self._mode = _deserialise_optional_mode(mode)
159
181
class ReadvRequest(VfsRequest):
160
182
 
161
183
    def do(self, relpath):
 
184
        relpath = self.translate_client_path(relpath)
162
185
        self._relpath = relpath
163
186
 
164
187
    def do_body(self, body_bytes):
182
205
class RenameRequest(VfsRequest):
183
206
 
184
207
    def do(self, rel_from, rel_to):
 
208
        rel_from = self.translate_client_path(rel_from)
 
209
        rel_to = self.translate_client_path(rel_to)
185
210
        self._backing_transport.rename(rel_from, rel_to)
186
211
        return request.SuccessfulSmartServerResponse(('ok', ))
187
212
 
189
214
class RmdirRequest(VfsRequest):
190
215
 
191
216
    def do(self, relpath):
 
217
        relpath = self.translate_client_path(relpath)
192
218
        self._backing_transport.rmdir(relpath)
193
219
        return request.SuccessfulSmartServerResponse(('ok', ))
194
220
 
196
222
class StatRequest(VfsRequest):
197
223
 
198
224
    def do(self, relpath):
 
225
        if not relpath.endswith('/'):
 
226
            relpath += '/'
 
227
        relpath = self.translate_client_path(relpath)
199
228
        stat = self._backing_transport.stat(relpath)
200
229
        return request.SuccessfulSmartServerResponse(
201
230
            ('stat', str(stat.st_size), oct(stat.st_mode)))