/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 breezy/shelf.py

  • Committer: Jelmer Vernooij
  • Date: 2017-06-10 16:40:42 UTC
  • mfrom: (6653.6.7 rename-controldir)
  • mto: This revision was merged to the branch mainline in revision 6690.
  • Revision ID: jelmer@jelmer.uk-20170610164042-zrxqgy2htyduvke2
Merge rename-controldir branch.

Show diffs side-by-side

added added

removed removed

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