/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/smart/vfs.py

Use a Registry for smart server command handlers.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/vfs.py
27
27
from bzrlib.smart import request
28
28
 
29
29
 
30
 
# vfs_commands is the set of commands handlers for the version 1 protocol.
31
 
vfs_commands = request.version_one_commands.copy()
32
 
 
33
 
def register_command(command):
34
 
    vfs_commands[command.method] = command
35
 
 
36
 
 
37
30
def _deserialise_optional_mode(mode):
38
31
    # XXX: FIXME this should be on the protocol object.  Later protocol versions
39
32
    # might serialise modes differently.
45
38
 
46
39
class HasRequest(request.SmartServerRequest):
47
40
 
48
 
    method = 'has'
49
 
 
50
41
    def do(self, relpath):
51
42
        r = self._backing_transport.has(relpath) and 'yes' or 'no'
52
43
        return request.SmartServerResponse((r,))
53
 
register_command(HasRequest)
54
44
 
55
45
 
56
46
class GetRequest(request.SmartServerRequest):
57
47
 
58
 
    method = 'get'
59
 
 
60
48
    def do(self, relpath):
61
49
        backing_bytes = self._backing_transport.get_bytes(relpath)
62
50
        return request.SmartServerResponse(('ok',), backing_bytes)
63
 
register_command(GetRequest)
64
51
 
65
52
 
66
53
class AppendRequest(request.SmartServerRequest):
67
54
 
68
 
    method = 'append'
69
 
 
70
55
    def do(self, relpath, mode):
71
56
        self._relpath = relpath
72
57
        self._mode = _deserialise_optional_mode(mode)
76
61
            self._relpath, body_bytes, self._mode)
77
62
        return request.SmartServerResponse(('appended', '%d' % old_length))
78
63
 
79
 
register_command(AppendRequest)
80
 
 
81
64
 
82
65
class DeleteRequest(request.SmartServerRequest):
83
66
 
84
 
    method = 'delete'
85
 
 
86
67
    def do(self, relpath):
87
68
        self._backing_transport.delete(relpath)
88
69
        return request.SmartServerResponse(('ok', ))
89
 
register_command(DeleteRequest)
90
70
 
91
71
 
92
72
class IterFilesRecursive(request.SmartServerRequest):
93
73
 
94
 
    method = 'iter_files_recursive'
95
 
 
96
74
    def do(self, relpath):
97
75
        transport = self._backing_transport.clone(relpath)
98
76
        filenames = transport.iter_files_recursive()
99
77
        return request.SmartServerResponse(('names',) + tuple(filenames))
100
 
register_command(IterFilesRecursive)
101
78
 
102
79
 
103
80
class ListDirRequest(request.SmartServerRequest):
104
81
 
105
 
    method = 'list_dir'
106
 
 
107
82
    def do(self, relpath):
108
83
        filenames = self._backing_transport.list_dir(relpath)
109
84
        return request.SmartServerResponse(('names',) + tuple(filenames))
110
 
register_command(ListDirRequest)
111
85
 
112
86
 
113
87
class MkdirCommand(request.SmartServerRequest):
114
88
 
115
 
    method = 'mkdir'
116
 
 
117
89
    def do(self, relpath, mode):
118
90
        self._backing_transport.mkdir(relpath,
119
91
                                      _deserialise_optional_mode(mode))
120
92
        return request.SmartServerResponse(('ok',))
121
 
register_command(MkdirCommand)
122
93
 
123
94
 
124
95
class MoveCommand(request.SmartServerRequest):
125
96
 
126
 
    method = 'move'
127
 
 
128
97
    def do(self, rel_from, rel_to):
129
98
        self._backing_transport.move(rel_from, rel_to)
130
99
        return request.SmartServerResponse(('ok',))
131
 
register_command(MoveCommand)
132
100
 
133
101
 
134
102
class PutCommand(request.SmartServerRequest):
135
103
 
136
 
    method = 'put'
137
 
 
138
104
    def do(self, relpath, mode):
139
105
        self._relpath = relpath
140
106
        self._mode = _deserialise_optional_mode(mode)
142
108
    def do_body(self, body_bytes):
143
109
        self._backing_transport.put_bytes(self._relpath, body_bytes, self._mode)
144
110
        return request.SmartServerResponse(('ok',))
145
 
register_command(PutCommand)
146
111
 
147
112
 
148
113
class PutNonAtomicCommand(request.SmartServerRequest):
149
114
 
150
 
    method = 'put_non_atomic'
151
 
 
152
115
    def do(self, relpath, mode, create_parent, dir_mode):
153
116
        self._relpath = relpath
154
117
        self._dir_mode = _deserialise_optional_mode(dir_mode)
163
126
                create_parent_dir=self._create_parent,
164
127
                dir_mode=self._dir_mode)
165
128
        return request.SmartServerResponse(('ok',))
166
 
register_command(PutNonAtomicCommand)
167
129
 
168
130
 
169
131
class ReadvCommand(request.SmartServerRequest):
170
132
 
171
 
    method = 'readv'
172
 
 
173
133
    def do(self, relpath):
174
134
        self._relpath = relpath
175
135
 
189
149
            start, length = line.split(',')
190
150
            offsets.append((int(start), int(length)))
191
151
        return offsets
192
 
register_command(ReadvCommand)
193
152
 
194
153
 
195
154
class RenameCommand(request.SmartServerRequest):
196
155
 
197
 
    method = 'rename'
198
 
 
199
156
    def do(self, rel_from, rel_to):
200
157
        self._backing_transport.rename(rel_from, rel_to)
201
158
        return request.SmartServerResponse(('ok', ))
202
 
register_command(RenameCommand)
203
159
 
204
160
 
205
161
class RmdirCommand(request.SmartServerRequest):
206
162
 
207
 
    method = 'rmdir'
208
 
 
209
163
    def do(self, relpath):
210
164
        self._backing_transport.rmdir(relpath)
211
165
        return request.SmartServerResponse(('ok', ))
212
 
register_command(RmdirCommand)
213
166
 
214
167
 
215
168
class StatCommand(request.SmartServerRequest):
216
169
 
217
 
    method = 'stat'
218
 
 
219
170
    def do(self, relpath):
220
171
        stat = self._backing_transport.stat(relpath)
221
172
        return request.SmartServerResponse(
222
173
            ('stat', str(stat.st_size), oct(stat.st_mode)))
223
 
register_command(StatCommand)
224
174