/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/transform.py

  • Committer: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2020-02-03 23:21:15 UTC
  • mfrom: (7290.42.6 paramiko-compat)
  • Revision ID: breezy.the.bot@gmail.com-20200203232115-g7k11bhsfeiqcprv
Fix compatibility with newer versions of paramiko, which break on noise before keys in pem files.

Merged from https://code.launchpad.net/~jelmer/brz/paramiko-compat/+merge/378480

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/transform.py
16
16
 
17
17
from __future__ import absolute_import
18
18
 
19
 
import contextlib
20
19
import os
21
20
import errno
22
21
from stat import S_ISREG, S_IEXEC
34
33
from breezy import (
35
34
    annotate,
36
35
    bencode,
 
36
    cleanup,
37
37
    controldir,
38
38
    commit,
39
39
    conflicts,
65
65
    supports_symlinks,
66
66
    )
67
67
from .progress import ProgressPhase
 
68
from .sixish import (
 
69
    text_type,
 
70
    viewitems,
 
71
    viewvalues,
 
72
    )
68
73
from .tree import (
69
74
    find_previous_path,
70
75
    TreeChange,
234
239
        irrelevant.
235
240
 
236
241
        """
237
 
        new_roots = [k for k, v in self._new_parent.items()
 
242
        new_roots = [k for k, v in viewitems(self._new_parent)
238
243
                     if v == ROOT_PARENT]
239
244
        if len(new_roots) < 1:
240
245
            return
475
480
        file_id = self.tree_file_id(trans_id)
476
481
        if file_id is not None:
477
482
            return file_id
478
 
        for key, value in self._non_present_ids.items():
 
483
        for key, value in viewitems(self._non_present_ids):
479
484
            if value == trans_id:
480
485
                return key
481
486
 
505
510
        Only new paths and parents of tree files with assigned ids are used.
506
511
        """
507
512
        by_parent = {}
508
 
        items = list(self._new_parent.items())
 
513
        items = list(viewitems(self._new_parent))
509
514
        items.extend((t, self.final_parent(t))
510
515
                     for t in list(self._tree_id_paths))
511
516
        for trans_id, parent_id in items:
630
635
    def _unversioned_parents(self, by_parent):
631
636
        """If parent directories are versioned, children must be versioned."""
632
637
        conflicts = []
633
 
        for parent_id, children in by_parent.items():
 
638
        for parent_id, children in viewitems(by_parent):
634
639
            if parent_id == ROOT_PARENT:
635
640
                continue
636
641
            if self.final_file_id(parent_id) is not None:
692
697
        conflicts = []
693
698
        if (self._new_name, self._new_parent) == ({}, {}):
694
699
            return conflicts
695
 
        for children in by_parent.values():
 
700
        for children in viewvalues(by_parent):
696
701
            name_ids = []
697
702
            for child_tid in children:
698
703
                name = self.final_name(child_tid)
727
732
        removed_tree_ids = set((self.tree_file_id(trans_id) for trans_id in
728
733
                                self._removed_id))
729
734
        active_tree_ids = all_ids.difference(removed_tree_ids)
730
 
        for trans_id, file_id in self._new_id.items():
 
735
        for trans_id, file_id in viewitems(self._new_id):
731
736
            if file_id in active_tree_ids:
732
737
                path = self._tree.id2path(file_id)
733
738
                old_trans_id = self.trans_id_tree_path(path)
737
742
    def _parent_type_conflicts(self, by_parent):
738
743
        """Children must have a directory parent"""
739
744
        conflicts = []
740
 
        for parent_id, children in by_parent.items():
 
745
        for parent_id, children in viewitems(by_parent):
741
746
            if parent_id == ROOT_PARENT:
742
747
                continue
743
748
            no_children = True
1107
1112
        :param serializer: A Serialiser like pack.ContainerSerializer.
1108
1113
        """
1109
1114
        new_name = {k.encode('utf-8'): v.encode('utf-8')
1110
 
                    for k, v in self._new_name.items()}
 
1115
                    for k, v in viewitems(self._new_name)}
1111
1116
        new_parent = {k.encode('utf-8'): v.encode('utf-8')
1112
 
                      for k, v in self._new_parent.items()}
 
1117
                      for k, v in viewitems(self._new_parent)}
1113
1118
        new_id = {k.encode('utf-8'): v
1114
 
                  for k, v in self._new_id.items()}
 
1119
                  for k, v in viewitems(self._new_id)}
1115
1120
        new_executability = {k.encode('utf-8'): int(v)
1116
 
                             for k, v in self._new_executability.items()}
 
1121
                             for k, v in viewitems(self._new_executability)}
1117
1122
        tree_path_ids = {k.encode('utf-8'): v.encode('utf-8')
1118
 
                         for k, v in self._tree_path_ids.items()}
 
1123
                         for k, v in viewitems(self._tree_path_ids)}
1119
1124
        non_present_ids = {k: v.encode('utf-8')
1120
 
                           for k, v in self._non_present_ids.items()}
 
1125
                           for k, v in viewitems(self._non_present_ids)}
1121
1126
        removed_contents = [trans_id.encode('utf-8')
1122
1127
                            for trans_id in self._removed_contents]
1123
1128
        removed_id = [trans_id.encode('utf-8')
1135
1140
            }
1136
1141
        yield serializer.bytes_record(bencode.bencode(attribs),
1137
1142
                                      ((b'attribs',),))
1138
 
        for trans_id, kind in sorted(self._new_contents.items()):
 
1143
        for trans_id, kind in sorted(viewitems(self._new_contents)):
1139
1144
            if kind == 'file':
1140
1145
                with open(self._limbo_name(trans_id), 'rb') as cur_file:
1141
1146
                    lines = cur_file.readlines()
1161
1166
        attribs = bencode.bdecode(content)
1162
1167
        self._id_number = attribs[b'_id_number']
1163
1168
        self._new_name = {k.decode('utf-8'): v.decode('utf-8')
1164
 
                          for k, v in attribs[b'_new_name'].items()}
 
1169
                          for k, v in viewitems(attribs[b'_new_name'])}
1165
1170
        self._new_parent = {k.decode('utf-8'): v.decode('utf-8')
1166
 
                            for k, v in attribs[b'_new_parent'].items()}
 
1171
                            for k, v in viewitems(attribs[b'_new_parent'])}
1167
1172
        self._new_executability = {
1168
1173
            k.decode('utf-8'): bool(v)
1169
 
            for k, v in attribs[b'_new_executability'].items()}
 
1174
            for k, v in viewitems(attribs[b'_new_executability'])}
1170
1175
        self._new_id = {k.decode('utf-8'): v
1171
 
                        for k, v in attribs[b'_new_id'].items()}
1172
 
        self._r_new_id = {v: k for k, v in self._new_id.items()}
 
1176
                        for k, v in viewitems(attribs[b'_new_id'])}
 
1177
        self._r_new_id = {v: k for k, v in viewitems(self._new_id)}
1173
1178
        self._tree_path_ids = {}
1174
1179
        self._tree_id_paths = {}
1175
 
        for bytepath, trans_id in attribs[b'_tree_path_ids'].items():
 
1180
        for bytepath, trans_id in viewitems(attribs[b'_tree_path_ids']):
1176
1181
            path = bytepath.decode('utf-8')
1177
1182
            trans_id = trans_id.decode('utf-8')
1178
1183
            self._tree_path_ids[path] = trans_id
1184
1189
            for trans_id in attribs[b'_removed_contents'])
1185
1190
        self._non_present_ids = {
1186
1191
            k: v.decode('utf-8')
1187
 
            for k, v in attribs[b'_non_present_ids'].items()}
 
1192
            for k, v in viewitems(attribs[b'_non_present_ids'])}
1188
1193
        for ((trans_id, kind),), content in records:
1189
1194
            trans_id = trans_id.decode('utf-8')
1190
1195
            kind = kind.decode('ascii')
1275
1280
        if self._tree is None:
1276
1281
            return
1277
1282
        try:
1278
 
            limbo_paths = list(self._limbo_files.values())
 
1283
            limbo_paths = list(viewvalues(self._limbo_files))
1279
1284
            limbo_paths.extend(self._possibly_stale_limbo_files)
1280
1285
            limbo_paths.sort(reverse=True)
1281
1286
            for path in limbo_paths:
1743
1748
                            in (trans_id, None)):
1744
1749
                        use_direct_path = True
1745
1750
                else:
1746
 
                    for l_filename, l_trans_id in (
1747
 
                            self._limbo_children_names[parent].items()):
 
1751
                    for l_filename, l_trans_id in viewitems(
 
1752
                            self._limbo_children_names[parent]):
1748
1753
                        if l_trans_id == trans_id:
1749
1754
                            continue
1750
1755
                        if l_filename.lower() == filename.lower():
1873
1878
 
1874
1879
        If inventory_delta is None, no inventory delta generation is performed.
1875
1880
        """
1876
 
        tree_paths = sorted(self._tree_path_ids.items(), reverse=True)
 
1881
        tree_paths = sorted(viewitems(self._tree_path_ids), reverse=True)
1877
1882
        with ui.ui_factory.nested_progress_bar() as child_pb:
1878
1883
            for num, (path, trans_id) in enumerate(tree_paths):
1879
1884
                # do not attempt to move root into a subdirectory of itself.
1958
1963
        #       problems. (we could observe start time, and finish time, and if
1959
1964
        #       it is less than eg 10% overhead, add a sleep call.)
1960
1965
        paths = FinalPaths(self)
1961
 
        for trans_id, observed in self._observed_sha1s.items():
 
1966
        for trans_id, observed in viewitems(self._observed_sha1s):
1962
1967
            path = paths.get_path(trans_id)
1963
1968
            self._tree._observed_sha1(path, observed)
1964
1969
 
2105
2110
        tree_ids = set(self._transform._tree.all_file_ids())
2106
2111
        tree_ids.difference_update(self._transform.tree_file_id(t)
2107
2112
                                   for t in self._transform._removed_id)
2108
 
        tree_ids.update(self._transform._new_id.values())
 
2113
        tree_ids.update(viewvalues(self._transform._new_id))
2109
2114
        return tree_ids
2110
2115
 
2111
2116
    def all_versioned_paths(self):
2403
2408
                executable = None
2404
2409
            if kind == 'symlink':
2405
2410
                link_or_sha1 = os.readlink(limbo_name)
2406
 
                if not isinstance(link_or_sha1, str):
 
2411
                if not isinstance(link_or_sha1, text_type):
2407
2412
                    link_or_sha1 = link_or_sha1.decode(osutils._fs_enc)
2408
2413
        executable = tt._new_executability.get(trans_id, executable)
2409
2414
        return kind, size, executable, link_or_sha1
2588
2593
    :param delta_from_tree: If true, build_tree may use the input Tree to
2589
2594
        generate the inventory delta.
2590
2595
    """
2591
 
    with contextlib.ExitStack() as exit_stack:
 
2596
    with cleanup.ExitStack() as exit_stack:
2592
2597
        exit_stack.enter_context(wt.lock_tree_write())
2593
2598
        exit_stack.enter_context(tree.lock_read())
2594
2599
        if accelerator_tree is not None:
2697
2702
            precomputed_delta = None
2698
2703
        conflicts = cook_conflicts(raw_conflicts, tt)
2699
2704
        for conflict in conflicts:
2700
 
            trace.warning(str(conflict))
 
2705
            trace.warning(text_type(conflict))
2701
2706
        try:
2702
2707
            wt.add_conflicts(conflicts)
2703
2708
        except errors.UnsupportedOperation:
2891
2896
                    unversioned_filter=working_tree.is_ignored)
2892
2897
                delta.report_changes(tt.iter_changes(), change_reporter)
2893
2898
            for conflict in conflicts:
2894
 
                trace.warning(str(conflict))
 
2899
                trace.warning(text_type(conflict))
2895
2900
            pp.next_phase()
2896
2901
            tt.apply()
2897
2902
            if working_tree.supports_merge_modified():