/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/git/fetch.py

  • Committer: Jelmer Vernooij
  • Date: 2018-11-11 04:08:32 UTC
  • mto: (7143.16.20 even-more-cleanups)
  • mto: This revision was merged to the branch mainline in revision 7175.
  • Revision ID: jelmer@jelmer.uk-20181111040832-nsljjynzzwmznf3h
Run autopep8.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/fetch.py
75
75
 
76
76
 
77
77
def import_git_blob(texts, mapping, path, name, hexshas,
78
 
        base_bzr_tree, parent_id, revision_id,
79
 
        parent_bzr_trees, lookup_object, modes, store_updater,
80
 
        lookup_file_id):
 
78
                    base_bzr_tree, parent_id, revision_id,
 
79
                    parent_bzr_trees, lookup_object, modes, store_updater,
 
80
                    lookup_file_id):
81
81
    """Import a git blob object into a bzr repository.
82
82
 
83
83
    :param texts: VersionedFiles to add to
130
130
        except errors.NoSuchId:
131
131
            continue
132
132
        pkind = ptree.kind(ppath, file_id)
133
 
        if (pkind == ie.kind and
134
 
            ((pkind == "symlink" and ptree.get_symlink_target(ppath, file_id) == ie.symlink_target) or
 
133
        if (pkind == ie.kind
 
134
            and ((pkind == "symlink" and ptree.get_symlink_target(ppath, file_id) == ie.symlink_target) or
135
135
             (pkind == "file" and ptree.get_file_sha1(ppath, file_id) == ie.text_sha1 and
136
 
                ptree.is_executable(ppath, file_id) == ie.executable))):
 
136
                  ptree.is_executable(ppath, file_id) == ie.executable))):
137
137
            # found a revision in one of the parents to use
138
138
            ie.revision = ptree.get_file_revision(ppath, file_id)
139
139
            break
151
151
            chunks = blob.chunked
152
152
        texts.insert_record_stream([
153
153
            ChunkedContentFactory((file_id, ie.revision),
154
 
                tuple(parent_keys), ie.text_sha1, chunks)])
 
154
                                  tuple(parent_keys), ie.text_sha1, chunks)])
155
155
    invdelta = []
156
156
    if base_hexsha is not None:
157
 
        old_path = decoded_path # Renames are not supported yet
 
157
        old_path = decoded_path  # Renames are not supported yet
158
158
        if stat.S_ISDIR(base_mode):
159
159
            invdelta.extend(remove_disappeared_children(base_bzr_tree, old_path,
160
 
                lookup_object(base_hexsha), [], lookup_object))
 
160
                                                        lookup_object(base_hexsha), [], lookup_object))
161
161
    else:
162
162
        old_path = None
163
163
    invdelta.append((old_path, decoded_path, file_id, ie))
173
173
 
174
174
 
175
175
def import_git_submodule(texts, mapping, path, name, hexshas,
176
 
    base_bzr_tree, parent_id, revision_id, parent_bzr_trees, lookup_object,
177
 
    modes, store_updater, lookup_file_id):
 
176
                         base_bzr_tree, parent_id, revision_id, parent_bzr_trees, lookup_object,
 
177
                         modes, store_updater, lookup_file_id):
178
178
    """Import a git submodule."""
179
179
    (base_hexsha, hexsha) = hexshas
180
180
    (base_mode, mode) = modes
185
185
    ie = TreeReference(file_id, name.decode("utf-8"), parent_id)
186
186
    ie.revision = revision_id
187
187
    if base_hexsha is not None:
188
 
        old_path = path.decode("utf-8") # Renames are not supported yet
 
188
        old_path = path.decode("utf-8")  # Renames are not supported yet
189
189
        if stat.S_ISDIR(base_mode):
190
190
            invdelta.extend(remove_disappeared_children(base_bzr_tree, old_path,
191
 
                lookup_object(base_hexsha), [], lookup_object))
 
191
                                                        lookup_object(base_hexsha), [], lookup_object))
192
192
    else:
193
193
        old_path = None
194
194
    ie.reference_revision = mapping.revision_id_foreign_to_bzr(hexsha)
199
199
 
200
200
 
201
201
def remove_disappeared_children(base_bzr_tree, path, base_tree, existing_children,
202
 
        lookup_object):
 
202
                                lookup_object):
203
203
    """Generate an inventory delta for removed children.
204
204
 
205
205
    :param base_bzr_tree: Base bzr tree against which to generate the
228
228
 
229
229
 
230
230
def import_git_tree(texts, mapping, path, name, hexshas,
231
 
        base_bzr_tree, parent_id, revision_id, parent_bzr_trees,
232
 
        lookup_object, modes, store_updater,
233
 
        lookup_file_id, allow_submodules=False):
 
231
                    base_bzr_tree, parent_id, revision_id, parent_bzr_trees,
 
232
                    lookup_object, modes, store_updater,
 
233
                    lookup_file_id, allow_submodules=False):
234
234
    """Import a git tree object into a bzr repository.
235
235
 
236
236
    :param texts: VersionedFiles object to add to
256
256
    tree = lookup_object(hexsha)
257
257
    if base_hexsha is None:
258
258
        base_tree = None
259
 
        old_path = None # Newly appeared here
 
259
        old_path = None  # Newly appeared here
260
260
    else:
261
261
        base_tree = lookup_object(base_hexsha)
262
 
        old_path = path.decode("utf-8") # Renames aren't supported yet
 
262
        old_path = path.decode("utf-8")  # Renames aren't supported yet
263
263
    new_path = path.decode("utf-8")
264
264
    if base_tree is None or type(base_tree) is not Tree:
265
265
        ie.revision = revision_id
283
283
            child_base_mode = 0
284
284
        if stat.S_ISDIR(child_mode):
285
285
            subinvdelta, grandchildmodes = import_git_tree(texts, mapping,
286
 
                child_path, name, (child_base_hexsha, child_hexsha),
287
 
                base_bzr_tree, file_id, revision_id, parent_bzr_trees,
288
 
                lookup_object, (child_base_mode, child_mode), store_updater,
289
 
                lookup_file_id, allow_submodules=allow_submodules)
290
 
        elif S_ISGITLINK(child_mode): # submodule
 
286
                                                           child_path, name, (
 
287
                                                               child_base_hexsha, child_hexsha),
 
288
                                                           base_bzr_tree, file_id, revision_id, parent_bzr_trees,
 
289
                                                           lookup_object, (
 
290
                                                               child_base_mode, child_mode), store_updater,
 
291
                                                           lookup_file_id, allow_submodules=allow_submodules)
 
292
        elif S_ISGITLINK(child_mode):  # submodule
291
293
            if not allow_submodules:
292
294
                raise SubmodulesRequireSubtrees()
293
295
            subinvdelta, grandchildmodes = import_git_submodule(texts, mapping,
294
 
                child_path, name, (child_base_hexsha, child_hexsha),
295
 
                base_bzr_tree, file_id, revision_id, parent_bzr_trees,
296
 
                lookup_object, (child_base_mode, child_mode), store_updater,
297
 
                lookup_file_id)
 
296
                                                                child_path, name, (
 
297
                                                                    child_base_hexsha, child_hexsha),
 
298
                                                                base_bzr_tree, file_id, revision_id, parent_bzr_trees,
 
299
                                                                lookup_object, (
 
300
                                                                    child_base_mode, child_mode), store_updater,
 
301
                                                                lookup_file_id)
298
302
        else:
299
303
            if not mapping.is_special_file(name):
300
304
                subinvdelta = import_git_blob(texts, mapping, child_path, name,
301
 
                    (child_base_hexsha, child_hexsha), base_bzr_tree, file_id,
302
 
                    revision_id, parent_bzr_trees, lookup_object,
303
 
                    (child_base_mode, child_mode), store_updater, lookup_file_id)
 
305
                                              (child_base_hexsha,
 
306
                                               child_hexsha), base_bzr_tree, file_id,
 
307
                                              revision_id, parent_bzr_trees, lookup_object,
 
308
                                              (child_base_mode, child_mode), store_updater, lookup_file_id)
304
309
            else:
305
310
                subinvdelta = []
306
311
            grandchildmodes = {}
307
312
        child_modes.update(grandchildmodes)
308
313
        invdelta.extend(subinvdelta)
309
314
        if child_mode not in (stat.S_IFDIR, DEFAULT_FILE_MODE,
310
 
                        stat.S_IFLNK, DEFAULT_FILE_MODE|0o111,
311
 
                        S_IFGITLINK):
 
315
                              stat.S_IFLNK, DEFAULT_FILE_MODE | 0o111,
 
316
                              S_IFGITLINK):
312
317
            child_modes[child_path] = child_mode
313
318
    # Remove any children that have disappeared
314
319
    if base_tree is not None and type(base_tree) is Tree:
315
320
        invdelta.extend(remove_disappeared_children(base_bzr_tree, old_path,
316
 
            base_tree, existing_children, lookup_object))
 
321
                                                    base_tree, existing_children, lookup_object))
317
322
    store_updater.add_object(tree, (file_id, revision_id), path)
318
323
    return invdelta, child_modes
319
324
 
320
325
 
321
326
def verify_commit_reconstruction(target_git_object_retriever, lookup_object,
322
 
    o, rev, ret_tree, parent_trees, mapping, unusual_modes, verifiers):
 
327
                                 o, rev, ret_tree, parent_trees, mapping, unusual_modes, verifiers):
323
328
    new_unusual_modes = mapping.export_unusual_file_modes(rev)
324
329
    if new_unusual_modes != unusual_modes:
325
330
        raise AssertionError("unusual modes don't match: %r != %r" % (
326
331
            unusual_modes, new_unusual_modes))
327
332
    # Verify that we can reconstruct the commit properly
328
333
    rec_o = target_git_object_retriever._reconstruct_commit(rev, o.tree, True,
329
 
        verifiers)
 
334
                                                            verifiers)
330
335
    if rec_o != o:
331
336
        raise AssertionError("Reconstructed commit differs: %r != %r" % (
332
337
            rec_o, o))
333
338
    diff = []
334
339
    new_objs = {}
335
340
    for path, obj, ie in _tree_to_objects(ret_tree, parent_trees,
336
 
        target_git_object_retriever._cache.idmap, unusual_modes,
337
 
        mapping.BZR_DUMMY_FILE):
 
341
                                          target_git_object_retriever._cache.idmap, unusual_modes,
 
342
                                          mapping.BZR_DUMMY_FILE):
338
343
        old_obj_id = tree_lookup_path(lookup_object, o.tree, path)[1]
339
344
        new_objs[path] = obj
340
345
        if obj.id != old_obj_id:
341
346
            diff.append((path, lookup_object(old_obj_id), obj))
342
347
    for (path, old_obj, new_obj) in diff:
343
 
        while (old_obj.type_name == "tree" and
344
 
               new_obj.type_name == "tree" and
345
 
               sorted(old_obj) == sorted(new_obj)):
 
348
        while (old_obj.type_name == "tree"
 
349
               and new_obj.type_name == "tree"
 
350
               and sorted(old_obj) == sorted(new_obj)):
346
351
            for name in old_obj:
347
352
                if old_obj[name][0] != new_obj[name][0]:
348
353
                    raise AssertionError("Modes for %s differ: %o != %o" %
349
 
                        (path, old_obj[name][0], new_obj[name][0]))
 
354
                                         (path, old_obj[name][0], new_obj[name][0]))
350
355
                if old_obj[name][1] != new_obj[name][1]:
351
356
                    # Found a differing child, delve deeper
352
357
                    path = posixpath.join(path, name)
354
359
                    new_obj = new_objs[path]
355
360
                    break
356
361
        raise AssertionError("objects differ for %s: %r != %r" % (path,
357
 
            old_obj, new_obj))
 
362
                                                                  old_obj, new_obj))
358
363
 
359
364
 
360
365
def ensure_inventories_in_repo(repo, trees):
392
397
    store_updater = target_git_object_retriever._get_updater(rev)
393
398
    tree_supplement = mapping.get_fileid_map(lookup_object, o.tree)
394
399
    inv_delta, unusual_modes = import_git_tree(repo.texts,
395
 
            mapping, b"", b"", (base_tree, o.tree), base_bzr_tree,
396
 
            None, rev.revision_id, parent_trees,
397
 
            lookup_object, (base_mode, stat.S_IFDIR), store_updater,
398
 
            tree_supplement.lookup_file_id,
399
 
            allow_submodules=repo._format.supports_tree_reference)
 
400
                                               mapping, b"", b"", (base_tree,
 
401
                                                                   o.tree), base_bzr_tree,
 
402
                                               None, rev.revision_id, parent_trees,
 
403
                                               lookup_object, (base_mode,
 
404
                                                               stat.S_IFDIR), store_updater,
 
405
                                               tree_supplement.lookup_file_id,
 
406
                                               allow_submodules=repo._format.supports_tree_reference)
400
407
    if unusual_modes != {}:
401
408
        for path, mode in unusual_modes.iteritems():
402
409
            warn_unusual_mode(rev.foreign_revid, path, mode)
409
416
    else:
410
417
        base_bzr_inventory = base_bzr_tree.root_inventory
411
418
    rev.inventory_sha1, inv = repo.add_inventory_by_delta(basis_id,
412
 
              inv_delta, rev.revision_id, rev.parent_ids,
413
 
              base_bzr_inventory)
 
419
                                                          inv_delta, rev.revision_id, rev.parent_ids,
 
420
                                                          base_bzr_inventory)
414
421
    ret_tree = InventoryRevisionTree(repo, inv, rev.revision_id)
415
422
    # Check verifiers
416
423
    if verifiers and roundtrip_revid is not None:
417
424
        testament = StrictTestament3(rev, ret_tree)
418
 
        calculated_verifiers = { "testament3-sha1": testament.as_sha1() }
 
425
        calculated_verifiers = {"testament3-sha1": testament.as_sha1()}
419
426
        if calculated_verifiers != verifiers:
420
427
            trace.mutter("Testament SHA1 %r for %r did not match %r.",
421
428
                         calculated_verifiers["testament3-sha1"],
422
429
                         rev.revision_id, verifiers["testament3-sha1"])
423
430
            rev.revision_id = original_revid
424
431
            rev.inventory_sha1, inv = repo.add_inventory_by_delta(basis_id,
425
 
              inv_delta, rev.revision_id, rev.parent_ids, base_bzr_tree)
 
432
                                                                  inv_delta, rev.revision_id, rev.parent_ids, base_bzr_tree)
426
433
            ret_tree = InventoryRevisionTree(repo, inv, rev.revision_id)
427
434
    else:
428
435
        calculated_verifiers = {}
432
439
    repo.add_revision(rev.revision_id, rev)
433
440
    if "verify" in debug.debug_flags:
434
441
        verify_commit_reconstruction(target_git_object_retriever,
435
 
            lookup_object, o, rev, ret_tree, parent_trees, mapping,
436
 
            unusual_modes, verifiers)
 
442
                                     lookup_object, o, rev, ret_tree, parent_trees, mapping,
 
443
                                     unusual_modes, verifiers)
437
444
 
438
445
 
439
446
def import_git_objects(repo, mapping, object_iter,
440
 
    target_git_object_retriever, heads, pb=None, limit=None):
 
447
                       target_git_object_retriever, heads, pb=None, limit=None):
441
448
    """Import a set of git objects into a bzr repository.
442
449
 
443
450
    :param repo: Target Bazaar repository
469
476
            continue
470
477
        if isinstance(o, Commit):
471
478
            rev, roundtrip_revid, verifiers = mapping.import_commit(o,
472
 
                mapping.revision_id_foreign_to_bzr)
473
 
            if (repo.has_revision(rev.revision_id) or
474
 
                (roundtrip_revid and repo.has_revision(roundtrip_revid))):
 
479
                                                                    mapping.revision_id_foreign_to_bzr)
 
480
            if (repo.has_revision(rev.revision_id)
 
481
                    or (roundtrip_revid and repo.has_revision(roundtrip_revid))):
475
482
                continue
476
483
            graph.append((o.id, o.parents))
477
484
            heads.extend([p for p in o.parents if p not in checked])
496
503
            repo.start_write_group()
497
504
            try:
498
505
                for i, head in enumerate(
499
 
                    revision_ids[offset:offset+batch_size]):
 
506
                        revision_ids[offset:offset + batch_size]):
500
507
                    if pb is not None:
501
 
                        pb.update("fetching revisions", offset+i,
 
508
                        pb.update("fetching revisions", offset + i,
502
509
                                  len(revision_ids))
503
510
                    import_git_commit(repo, mapping, head, lookup_object,
504
 
                        target_git_object_retriever, trees_cache)
 
511
                                      target_git_object_retriever, trees_cache)
505
512
                    last_imported = head
506
513
            except:
507
514
                repo.abort_write_group()
531
538
        self.remote_refs = refs
532
539
        self.wants = self.actual(refs)
533
540
        return self.wants
534
 
 
535
 
 
536