← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/shelf.py

  • Committer: v.ladeuil+lp at free
  • Date: 2006-10-12 14:29:32 UTC
  • mto: (2145.1.1 keepalive)
  • mto: This revision was merged to the branch mainline in revision 2146.
  • Revision ID: v.ladeuil+lp@free.fr-20061012142932-7221fe16d2b48fa3
Shuffle http related test code. Hopefully it ends up at the right place :)

* bzrlib/tests/HttpServer.py: 
New file. bzrlib.tests.ChrootedTestCase use HttpServer. So the
class can't be defined in bzrlib.tests.HTTPUtils because it
creates a circular dependency (bzrlib.tests.HTTPUtils needs to
import bzrlib.tests).

* bzrlib/transport/http/_urllib.py: 
Transfer test server definition to bzrlib.tests.HttpServer. Clean
up imports.

* bzrlib/transport/http/_pycurl.py: 
Transfer test server definition to bzrlib.tests.HttpServer. Clean
up imports.

* bzrlib/transport/http/__init__.py: 
Transfer all test related code to either bzrlib.tests.HttpServer
and bzrlib.tests.HTTPUtils.
Fix all use of TransportNotPossible and InvalidURL by prefixing it
by 'errors.' (this seems to be the preferred way in the rest of
bzr).
Get rid of unused imports.

* bzrlib/tests/test_transport.py:
(ReadonlyDecoratorTransportTest.test_local_parameters,
FakeNFSDecoratorTests.test_http_parameters): Use HttpServer from
bzrlib.tests.HttpServer instead of bzrlib.transport.http.

* bzrlib/tests/test_sftp_transport.py:
(set_test_transport_to_sftp): Use HttpServer from
bzrlib.tests.HttpServer instead of bzrlib.transport.http.

* bzrlib/tests/test_selftest.py:
(TestTestCaseWithTransport.test_get_readonly_url_http): Use
HttpServer from bzrlib.tests.HttpServer instead of
bzrlib.transport.http.

* bzrlib/tests/test_repository.py: 
Does *not* use HttpServer.

* bzrlib/tests/test_http.py: 
Build on top of bzrlib.tests.HttpServer and bzrlib.tests.HTTPUtils
instead of bzrlib.transport.http.

* bzrlib/tests/test_bzrdir.py:
(ChrootedTests.setUp): Use HttpServer from bzrlib.tests.HttpServer
instead of bzrlib.transport.http.

* bzrlib/tests/branch_implementations/test_http.py:
(HTTPBranchTests.setUp): Use HttpServer from bzrlib.tests.HttpServer
instead of bzrlib.transport.http.

* bzrlib/tests/branch_implementations/test_branch.py:
(ChrootedTests.setUp): Use HttpServer from bzrlib.tests.HttpServer
instead of bzrlib.transport.http.

* bzrlib/tests/__init__.py:
(ChrootedTestCase.setUp): Use HttpServer from
bzrlib.tests.HttpServer instead of bzrlib.transport.http.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/shelf.py
1
 
# Copyright (C) 2008 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
 
18
 
import errno
19
 
import re
20
 
 
21
 
from bzrlib import (
22
 
    bencode,
23
 
    errors,
24
 
    merge,
25
 
    merge3,
26
 
    pack,
27
 
    transform,
28
 
)
29
 
 
30
 
 
31
 
class ShelfCreator(object):
32
 
    """Create a transform to shelve objects and its inverse."""
33
 
 
34
 
    def __init__(self, work_tree, target_tree, file_list=None):
35
 
        """Constructor.
36
 
 
37
 
        :param work_tree: The working tree to apply changes to. This is not
38
 
            required to be locked - a tree_write lock will be taken out.
39
 
        :param target_tree: The tree to make the working tree more similar to.
40
 
            This is not required to be locked - a read_lock will be taken out.
41
 
        :param file_list: The files to make more similar to the target.
42
 
        """
43
 
        self.work_tree = work_tree
44
 
        self.work_transform = transform.TreeTransform(work_tree)
45
 
        try:
46
 
            self.target_tree = target_tree
47
 
            self.shelf_transform = transform.TransformPreview(self.target_tree)
48
 
            try:
49
 
                self.renames = {}
50
 
                self.creation = {}
51
 
                self.deletion = {}
52
 
                self.iter_changes = work_tree.iter_changes(
53
 
                    self.target_tree, specific_files=file_list)
54
 
            except:
55
 
                self.shelf_transform.finalize()
56
 
                raise
57
 
        except:
58
 
            self.work_transform.finalize()
59
 
            raise
60
 
 
61
 
    def iter_shelvable(self):
62
 
        """Iterable of tuples describing shelvable changes.
63
 
 
64
 
        As well as generating the tuples, this updates several members.
65
 
        Tuples may be:
66
 
           ('add file', file_id, work_kind, work_path)
67
 
           ('delete file', file_id, target_kind, target_path)
68
 
           ('rename', file_id, target_path, work_path)
69
 
           ('change kind', file_id, target_kind, work_kind, target_path)
70
 
           ('modify text', file_id)
71
 
           ('modify target', file_id, target_target, work_target)
72
 
        """
73
 
        for (file_id, paths, changed, versioned, parents, names, kind,
74
 
             executable) in self.iter_changes:
75
 
            # don't shelve add of tree root.  Working tree should never
76
 
            # lack roots, and bzr misbehaves when they do.
77
 
            # FIXME ADHB (2009-08-09): should still shelve adds of tree roots
78
 
            # when a tree root was deleted / renamed.
79
 
            if kind[0] is None and names[1] == '':
80
 
                continue
81
 
            if kind[0] is None or versioned[0] == False:
82
 
                self.creation[file_id] = (kind[1], names[1], parents[1],
83
 
                                          versioned)
84
 
                yield ('add file', file_id, kind[1], paths[1])
85
 
            elif kind[1] is None or versioned[0] == False:
86
 
                self.deletion[file_id] = (kind[0], names[0], parents[0],
87
 
                                          versioned)
88
 
                yield ('delete file', file_id, kind[0], paths[0])
89
 
            else:
90
 
                if names[0] != names[1] or parents[0] != parents[1]:
91
 
                    self.renames[file_id] = (names, parents)
92
 
                    yield ('rename', file_id) + paths
93
 
 
94
 
                if kind[0] != kind [1]:
95
 
                    yield ('change kind', file_id, kind[0], kind[1], paths[0])
96
 
                elif kind[0] == 'symlink':
97
 
                    t_target = self.target_tree.get_symlink_target(file_id)
98
 
                    w_target = self.work_tree.get_symlink_target(file_id)
99
 
                    yield ('modify target', file_id, paths[0], t_target,
100
 
                            w_target)
101
 
                elif changed:
102
 
                    yield ('modify text', file_id)
103
 
 
104
 
    def shelve_change(self, change):
105
 
        """Shelve a change in the iter_shelvable format."""
106
 
        if change[0] == 'rename':
107
 
            self.shelve_rename(change[1])
108
 
        elif change[0] == 'delete file':
109
 
            self.shelve_deletion(change[1])
110
 
        elif change[0] == 'add file':
111
 
            self.shelve_creation(change[1])
112
 
        elif change[0] in ('change kind', 'modify text'):
113
 
            self.shelve_content_change(change[1])
114
 
        elif change[0] == 'modify target':
115
 
            self.shelve_modify_target(change[1])
116
 
        else:
117
 
            raise ValueError('Unknown change kind: "%s"' % change[0])
118
 
 
119
 
    def shelve_all(self):
120
 
        """Shelve all changes."""
121
 
        for change in self.iter_shelvable():
122
 
            self.shelve_change(change)
123
 
 
124
 
    def shelve_rename(self, file_id):
125
 
        """Shelve a file rename.
126
 
 
127
 
        :param file_id: The file id of the file to shelve the renaming of.
128
 
        """
129
 
        names, parents = self.renames[file_id]
130
 
        w_trans_id = self.work_transform.trans_id_file_id(file_id)
131
 
        work_parent = self.work_transform.trans_id_file_id(parents[0])
132
 
        self.work_transform.adjust_path(names[0], work_parent, w_trans_id)
133
 
 
134
 
        s_trans_id = self.shelf_transform.trans_id_file_id(file_id)
135
 
        shelf_parent = self.shelf_transform.trans_id_file_id(parents[1])
136
 
        self.shelf_transform.adjust_path(names[1], shelf_parent, s_trans_id)
137
 
 
138
 
    def shelve_modify_target(self, file_id):
139
 
        """Shelve a change of symlink target.
140
 
 
141
 
        :param file_id: The file id of the symlink which changed target.
142
 
        :param new_target: The target that the symlink should have due
143
 
            to shelving.
144
 
        """
145
 
        new_target = self.target_tree.get_symlink_target(file_id)
146
 
        w_trans_id = self.work_transform.trans_id_file_id(file_id)
147
 
        self.work_transform.delete_contents(w_trans_id)
148
 
        self.work_transform.create_symlink(new_target, w_trans_id)
149
 
 
150
 
        old_target = self.work_tree.get_symlink_target(file_id)
151
 
        s_trans_id = self.shelf_transform.trans_id_file_id(file_id)
152
 
        self.shelf_transform.delete_contents(s_trans_id)
153
 
        self.shelf_transform.create_symlink(old_target, s_trans_id)
154
 
 
155
 
    def shelve_lines(self, file_id, new_lines):
156
 
        """Shelve text changes to a file, using provided lines.
157
 
 
158
 
        :param file_id: The file id of the file to shelve the text of.
159
 
        :param new_lines: The lines that the file should have due to shelving.
160
 
        """
161
 
        w_trans_id = self.work_transform.trans_id_file_id(file_id)
162
 
        self.work_transform.delete_contents(w_trans_id)
163
 
        self.work_transform.create_file(new_lines, w_trans_id)
164
 
 
165
 
        s_trans_id = self.shelf_transform.trans_id_file_id(file_id)
166
 
        self.shelf_transform.delete_contents(s_trans_id)
167
 
        inverse_lines = self._inverse_lines(new_lines, file_id)
168
 
        self.shelf_transform.create_file(inverse_lines, s_trans_id)
169
 
 
170
 
    @staticmethod
171
 
    def _content_from_tree(tt, tree, file_id):
172
 
        trans_id = tt.trans_id_file_id(file_id)
173
 
        tt.delete_contents(trans_id)
174
 
        transform.create_from_tree(tt, trans_id, tree, file_id)
175
 
 
176
 
    def shelve_content_change(self, file_id):
177
 
        """Shelve a kind change or binary file content change.
178
 
 
179
 
        :param file_id: The file id of the file to shelve the content change
180
 
            of.
181
 
        """
182
 
        self._content_from_tree(self.work_transform, self.target_tree, file_id)
183
 
        self._content_from_tree(self.shelf_transform, self.work_tree, file_id)
184
 
 
185
 
    def shelve_creation(self, file_id):
186
 
        """Shelve creation of a file.
187
 
 
188
 
        This handles content and inventory id.
189
 
        :param file_id: The file_id of the file to shelve creation of.
190
 
        """
191
 
        kind, name, parent, versioned = self.creation[file_id]
192
 
        version = not versioned[0]
193
 
        self._shelve_creation(self.work_tree, file_id, self.work_transform,
194
 
                              self.shelf_transform, kind, name, parent,
195
 
                              version)
196
 
 
197
 
    def shelve_deletion(self, file_id):
198
 
        """Shelve deletion of a file.
199
 
 
200
 
        This handles content and inventory id.
201
 
        :param file_id: The file_id of the file to shelve deletion of.
202
 
        """
203
 
        kind, name, parent, versioned = self.deletion[file_id]
204
 
        existing_path = self.target_tree.id2path(file_id)
205
 
        if not self.work_tree.has_filename(existing_path):
206
 
            existing_path = None
207
 
        version = not versioned[1]
208
 
        self._shelve_creation(self.target_tree, file_id, self.shelf_transform,
209
 
                              self.work_transform, kind, name, parent,
210
 
                              version, existing_path=existing_path)
211
 
 
212
 
    def _shelve_creation(self, tree, file_id, from_transform, to_transform,
213
 
                         kind, name, parent, version, existing_path=None):
214
 
        w_trans_id = from_transform.trans_id_file_id(file_id)
215
 
        if parent is not None and kind is not None:
216
 
            from_transform.delete_contents(w_trans_id)
217
 
        from_transform.unversion_file(w_trans_id)
218
 
 
219
 
        if existing_path is not None:
220
 
            s_trans_id = to_transform.trans_id_tree_path(existing_path)
221
 
        else:
222
 
            s_trans_id = to_transform.trans_id_file_id(file_id)
223
 
        if parent is not None:
224
 
            s_parent_id = to_transform.trans_id_file_id(parent)
225
 
            to_transform.adjust_path(name, s_parent_id, s_trans_id)
226
 
            if existing_path is None:
227
 
                if kind is None:
228
 
                    to_transform.create_file('', s_trans_id)
229
 
                else:
230
 
                    transform.create_from_tree(to_transform, s_trans_id,
231
 
                                               tree, file_id)
232
 
        if version:
233
 
            to_transform.version_file(file_id, s_trans_id)
234
 
 
235
 
    def _inverse_lines(self, new_lines, file_id):
236
 
        """Produce a version with only those changes removed from new_lines."""
237
 
        target_lines = self.target_tree.get_file_lines(file_id)
238
 
        work_lines = self.work_tree.get_file_lines(file_id)
239
 
        return merge3.Merge3(new_lines, target_lines, work_lines).merge_lines()
240
 
 
241
 
    def finalize(self):
242
 
        """Release all resources used by this ShelfCreator."""
243
 
        self.work_transform.finalize()
244
 
        self.shelf_transform.finalize()
245
 
 
246
 
    def transform(self):
247
 
        """Shelve changes from working tree."""
248
 
        self.work_transform.apply()
249
 
 
250
 
    def write_shelf(self, shelf_file, message=None):
251
 
        """Serialize the shelved changes to a file.
252
 
 
253
 
        :param shelf_file: A file-like object to write the shelf to.
254
 
        :param message: An optional message describing the shelved changes.
255
 
        :return: the filename of the written file.
256
 
        """
257
 
        transform.resolve_conflicts(self.shelf_transform)
258
 
        serializer = pack.ContainerSerialiser()
259
 
        shelf_file.write(serializer.begin())
260
 
        metadata = {
261
 
            'revision_id': self.target_tree.get_revision_id(),
262
 
        }
263
 
        if message is not None:
264
 
            metadata['message'] = message.encode('utf-8')
265
 
        shelf_file.write(serializer.bytes_record(
266
 
            bencode.bencode(metadata), (('metadata',),)))
267
 
        for bytes in self.shelf_transform.serialize(serializer):
268
 
            shelf_file.write(bytes)
269
 
        shelf_file.write(serializer.end())
270
 
 
271
 
 
272
 
class Unshelver(object):
273
 
    """Unshelve shelved changes."""
274
 
 
275
 
    def __init__(self, tree, base_tree, transform, message):
276
 
        """Constructor.
277
 
 
278
 
        :param tree: The tree to apply the changes to.
279
 
        :param base_tree: The basis to apply the tranform to.
280
 
        :param message: A message from the shelved transform.
281
 
        """
282
 
        self.tree = tree
283
 
        self.base_tree = base_tree
284
 
        self.transform = transform
285
 
        self.message = message
286
 
 
287
 
    @staticmethod
288
 
    def iter_records(shelf_file):
289
 
        parser = pack.ContainerPushParser()
290
 
        parser.accept_bytes(shelf_file.read())
291
 
        return iter(parser.read_pending_records())
292
 
 
293
 
    @staticmethod
294
 
    def parse_metadata(records):
295
 
        names, metadata_bytes = records.next()
296
 
        if names[0] != ('metadata',):
297
 
            raise errors.ShelfCorrupt
298
 
        metadata = bencode.bdecode(metadata_bytes)
299
 
        message = metadata.get('message')
300
 
        if message is not None:
301
 
            metadata['message'] = message.decode('utf-8')
302
 
        return metadata
303
 
 
304
 
    @classmethod
305
 
    def from_tree_and_shelf(klass, tree, shelf_file):
306
 
        """Create an Unshelver from a tree and a shelf file.
307
 
 
308
 
        :param tree: The tree to apply shelved changes to.
309
 
        :param shelf_file: A file-like object containing shelved changes.
310
 
        :return: The Unshelver.
311
 
        """
312
 
        records = klass.iter_records(shelf_file)
313
 
        metadata = klass.parse_metadata(records)
314
 
        base_revision_id = metadata['revision_id']
315
 
        try:
316
 
            base_tree = tree.revision_tree(base_revision_id)
317
 
        except errors.NoSuchRevisionInTree:
318
 
            base_tree = tree.branch.repository.revision_tree(base_revision_id)
319
 
        tt = transform.TransformPreview(base_tree)
320
 
        tt.deserialize(records)
321
 
        return klass(tree, base_tree, tt, metadata.get('message'))
322
 
 
323
 
    def make_merger(self, task=None):
324
 
        """Return a merger that can unshelve the changes."""
325
 
        target_tree = self.transform.get_preview_tree()
326
 
        merger = merge.Merger.from_uncommitted(self.tree, target_tree,
327
 
            task, self.base_tree)
328
 
        merger.merge_type = merge.Merge3Merger
329
 
        return merger
330
 
 
331
 
    def finalize(self):
332
 
        """Release all resources held by this Unshelver."""
333
 
        self.transform.finalize()
334
 
 
335
 
 
336
 
class ShelfManager(object):
337
 
    """Maintain a list of shelved changes."""
338
 
 
339
 
    def __init__(self, tree, transport):
340
 
        self.tree = tree
341
 
        self.transport = transport.clone('shelf')
342
 
        self.transport.ensure_base()
343
 
 
344
 
    def get_shelf_filename(self, shelf_id):
345
 
        return 'shelf-%d' % shelf_id
346
 
 
347
 
    def get_shelf_ids(self, filenames):
348
 
        matcher = re.compile('shelf-([1-9][0-9]*)')
349
 
        shelf_ids = []
350
 
        for filename in filenames:
351
 
            match = matcher.match(filename)
352
 
            if match is not None:
353
 
                shelf_ids.append(int(match.group(1)))
354
 
        return shelf_ids
355
 
 
356
 
    def new_shelf(self):
357
 
        """Return a file object and id for a new set of shelved changes."""
358
 
        last_shelf = self.last_shelf()
359
 
        if last_shelf is None:
360
 
            next_shelf = 1
361
 
        else:
362
 
            next_shelf = last_shelf + 1
363
 
        filename = self.get_shelf_filename(next_shelf)
364
 
        shelf_file = open(self.transport.local_abspath(filename), 'wb')
365
 
        return next_shelf, shelf_file
366
 
 
367
 
    def shelve_changes(self, creator, message=None):
368
 
        """Store the changes in a ShelfCreator on a shelf."""
369
 
        next_shelf, shelf_file = self.new_shelf()
370
 
        try:
371
 
            creator.write_shelf(shelf_file, message)
372
 
        finally:
373
 
            shelf_file.close()
374
 
        creator.transform()
375
 
        return next_shelf
376
 
 
377
 
    def read_shelf(self, shelf_id):
378
 
        """Return the file associated with a shelf_id for reading.
379
 
 
380
 
        :param shelf_id: The id of the shelf to retrive the file for.
381
 
        """
382
 
        filename = self.get_shelf_filename(shelf_id)
383
 
        try:
384
 
            return open(self.transport.local_abspath(filename), 'rb')
385
 
        except IOError, e:
386
 
            if e.errno != errno.ENOENT:
387
 
                raise
388
 
            from bzrlib import errors
389
 
            raise errors.NoSuchShelfId(shelf_id)
390
 
 
391
 
    def get_unshelver(self, shelf_id):
392
 
        """Return an unshelver for a given shelf_id.
393
 
 
394
 
        :param shelf_id: The shelf id to return the unshelver for.
395
 
        """
396
 
        shelf_file = self.read_shelf(shelf_id)
397
 
        try:
398
 
            return Unshelver.from_tree_and_shelf(self.tree, shelf_file)
399
 
        finally:
400
 
            shelf_file.close()
401
 
 
402
 
    def get_metadata(self, shelf_id):
403
 
        """Return the metadata associated with a given shelf_id."""
404
 
        shelf_file = self.read_shelf(shelf_id)
405
 
        try:
406
 
            records = Unshelver.iter_records(shelf_file)
407
 
        finally:
408
 
            shelf_file.close()
409
 
        return Unshelver.parse_metadata(records)
410
 
 
411
 
    def delete_shelf(self, shelf_id):
412
 
        """Delete the shelved changes for a given id.
413
 
 
414
 
        :param shelf_id: id of the shelved changes to delete.
415
 
        """
416
 
        filename = self.get_shelf_filename(shelf_id)
417
 
        self.transport.delete(filename)
418
 
 
419
 
    def active_shelves(self):
420
 
        """Return a list of shelved changes."""
421
 
        active = self.get_shelf_ids(self.transport.list_dir('.'))
422
 
        active.sort()
423
 
        return active
424
 
 
425
 
    def last_shelf(self):
426
 
        """Return the id of the last-created shelved change."""
427
 
        active = self.active_shelves()
428
 
        if len(active) > 0:
429
 
            return active[-1]
430
 
        else:
431
 
            return None