/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/git/fetch.py

• browse files at revision 7175
• compare with another revision
• compare with revision 5200.3.2
• download diff
• download tarball
• view history from revision 7175

Show diffs side-by-side

added

removed

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

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

 

            invdelta.extend(remove_disappeared_children(base_bzr_tree, old_path,

160

 

                lookup_object(base_hexsha), [], lookup_object))

 

159

            invdelta.extend(remove_disappeared_children(

 

160

                base_bzr_tree, old_path, lookup_object(base_hexsha), [],

 

161

                lookup_object))

161

162

    else:

162

163

        old_path = None

163

164

    invdelta.append((old_path, decoded_path, file_id, ie))

173

174

 

174

175

 

175

176

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):

 

177

                         base_bzr_tree, parent_id, revision_id,

 

178

                         parent_bzr_trees, lookup_object,

 

179

                         modes, store_updater, lookup_file_id):

178

180

    """Import a git submodule."""

179

181

    (base_hexsha, hexsha) = hexshas

180

182

    (base_mode, mode) = modes

185

187

    ie = TreeReference(file_id, name.decode("utf-8"), parent_id)

186

188

    ie.revision = revision_id

187

189

    if base_hexsha is not None:

188

 

        old_path = path.decode("utf-8") # Renames are not supported yet

 

190

        old_path = path.decode("utf-8")  # Renames are not supported yet

189

191

        if stat.S_ISDIR(base_mode):

190

 

            invdelta.extend(remove_disappeared_children(base_bzr_tree, old_path,

191

 

                lookup_object(base_hexsha), [], lookup_object))

 

192

            invdelta.extend(remove_disappeared_children(

 

193

                base_bzr_tree, old_path, lookup_object(base_hexsha), [],

 

194

                lookup_object))

192

195

    else:

193

196

        old_path = None

194

197

    ie.reference_revision = mapping.revision_id_foreign_to_bzr(hexsha)

198

201

    return invdelta, {}

199

202

 

200

203

 

201

 

def remove_disappeared_children(base_bzr_tree, path, base_tree, existing_children,

202

 

        lookup_object):

 

204

def remove_disappeared_children(base_bzr_tree, path, base_tree,

 

205

                                existing_children, lookup_object):

203

206

    """Generate an inventory delta for removed children.

204

207

 

205

208

    :param base_bzr_tree: Base bzr tree against which to generate the

223

226

        ret.append((c_path, None, file_id, None))

224

227

        if stat.S_ISDIR(mode):

225

228

            ret.extend(remove_disappeared_children(

226

 

                base_bzr_tree, c_path, lookup_object(hexsha), [], lookup_object))

 

229

                base_bzr_tree, c_path, lookup_object(hexsha), [],

 

230

                lookup_object))

227

231

    return ret

228

232

 

229

233

 

230

234

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):

 

235

                    base_bzr_tree, parent_id, revision_id, parent_bzr_trees,

 

236

                    lookup_object, modes, store_updater,

 

237

                    lookup_file_id, allow_submodules=False):

234

238

    """Import a git tree object into a bzr repository.

235

239

 

236

240

    :param texts: VersionedFiles object to add to

237

241

    :param path: Path in the tree (str)

238

242

    :param name: Name of the tree (str)

239

243

    :param tree: A git tree object

240

 

    :param base_bzr_tree: Base inventory against which to return inventory delta

 

244

    :param base_bzr_tree: Base inventory against which to return inventory

 

245

        delta

241

246

    :return: Inventory delta for this subtree

242

247

    """

243

248

    (base_hexsha, hexsha) = hexshas

256

261

    tree = lookup_object(hexsha)

257

262

    if base_hexsha is None:

258

263

        base_tree = None

259

 

        old_path = None # Newly appeared here

 

264

        old_path = None  # Newly appeared here

260

265

    else:

261

266

        base_tree = lookup_object(base_hexsha)

262

 

        old_path = path.decode("utf-8") # Renames aren't supported yet

 

267

        old_path = path.decode("utf-8")  # Renames aren't supported yet

263

268

    new_path = path.decode("utf-8")

264

269

    if base_tree is None or type(base_tree) is not Tree:

265

270

        ie.revision = revision_id

282

287

            child_base_hexsha = None

283

288

            child_base_mode = 0

284

289

        if stat.S_ISDIR(child_mode):

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

 

290

            subinvdelta, grandchildmodes = import_git_tree(

 

291

                texts, mapping, child_path, name,

 

292

                (child_base_hexsha, child_hexsha), base_bzr_tree, file_id,

 

293

                revision_id, parent_bzr_trees, lookup_object,

 

294

                (child_base_mode, child_mode), store_updater, lookup_file_id,

 

295

                allow_submodules=allow_submodules)

 

296

        elif S_ISGITLINK(child_mode):  # submodule

291

297

            if not allow_submodules:

292

298

                raise SubmodulesRequireSubtrees()

293

 

            subinvdelta, grandchildmodes = import_git_submodule(texts, mapping,

294

 

                child_path, name, (child_base_hexsha, child_hexsha),

 

299

            subinvdelta, grandchildmodes = import_git_submodule(

 

300

                texts, mapping, child_path, name,

 

301

                (child_base_hexsha, child_hexsha),

295

302

                base_bzr_tree, file_id, revision_id, parent_bzr_trees,

296

303

                lookup_object, (child_base_mode, child_mode), store_updater,

297

304

                lookup_file_id)

298

305

        else:

299

306

            if not mapping.is_special_file(name):

300

 

                subinvdelta = import_git_blob(texts, mapping, child_path, name,

 

307

                subinvdelta = import_git_blob(

 

308

                    texts, mapping, child_path, name,

301

309

                    (child_base_hexsha, child_hexsha), base_bzr_tree, file_id,

302

310

                    revision_id, parent_bzr_trees, lookup_object,

303

 

                    (child_base_mode, child_mode), store_updater, lookup_file_id)

 

311

                    (child_base_mode, child_mode), store_updater,

 

312

                    lookup_file_id)

304

313

            else:

305

314

                subinvdelta = []

306

315

            grandchildmodes = {}

307

316

        child_modes.update(grandchildmodes)

308

317

        invdelta.extend(subinvdelta)

309

318

        if child_mode not in (stat.S_IFDIR, DEFAULT_FILE_MODE,

310

 

                        stat.S_IFLNK, DEFAULT_FILE_MODE|0o111,

311

 

                        S_IFGITLINK):

 

319

                              stat.S_IFLNK, DEFAULT_FILE_MODE | 0o111,

 

320

                              S_IFGITLINK):

312

321

            child_modes[child_path] = child_mode

313

322

    # Remove any children that have disappeared

314

323

    if base_tree is not None and type(base_tree) is Tree:

315

 

        invdelta.extend(remove_disappeared_children(base_bzr_tree, old_path,

316

 

            base_tree, existing_children, lookup_object))

 

324

        invdelta.extend(remove_disappeared_children(

 

325

            base_bzr_tree, old_path, base_tree, existing_children,

 

326

            lookup_object))

317

327

    store_updater.add_object(tree, (file_id, revision_id), path)

318

328

    return invdelta, child_modes

319

329

 

320

330

 

321

331

def verify_commit_reconstruction(target_git_object_retriever, lookup_object,

322

 

    o, rev, ret_tree, parent_trees, mapping, unusual_modes, verifiers):

 

332

                                 o, rev, ret_tree, parent_trees, mapping,

 

333

                                 unusual_modes, verifiers):

323

334

    new_unusual_modes = mapping.export_unusual_file_modes(rev)

324

335

    if new_unusual_modes != unusual_modes:

325

336

        raise AssertionError("unusual modes don't match: %r != %r" % (

326

337

            unusual_modes, new_unusual_modes))

327

338

    # Verify that we can reconstruct the commit properly

328

339

    rec_o = target_git_object_retriever._reconstruct_commit(rev, o.tree, True,

329

 

        verifiers)

 

340

                                                            verifiers)

330

341

    if rec_o != o:

331

342

        raise AssertionError("Reconstructed commit differs: %r != %r" % (

332

343

            rec_o, o))

333

344

    diff = []

334

345

    new_objs = {}

335

 

    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):

 

346

    for path, obj, ie in _tree_to_objects(

 

347

            ret_tree, parent_trees, target_git_object_retriever._cache.idmap,

 

348

            unusual_modes, mapping.BZR_DUMMY_FILE):

338

349

        old_obj_id = tree_lookup_path(lookup_object, o.tree, path)[1]

339

350

        new_objs[path] = obj

340

351

        if obj.id != old_obj_id:

341

352

            diff.append((path, lookup_object(old_obj_id), obj))

342

353

    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)):

 

354

        while (old_obj.type_name == "tree"

 

355

               and new_obj.type_name == "tree"

 

356

               and sorted(old_obj) == sorted(new_obj)):

346

357

            for name in old_obj:

347

358

                if old_obj[name][0] != new_obj[name][0]:

348

 

                    raise AssertionError("Modes for %s differ: %o != %o" %

 

359

                    raise AssertionError(

 

360

                        "Modes for %s differ: %o != %o" %

349

361

                        (path, old_obj[name][0], new_obj[name][0]))

350

362

                if old_obj[name][1] != new_obj[name][1]:

351

363

                    # Found a differing child, delve deeper

353

365

                    old_obj = lookup_object(old_obj[name][1])

354

366

                    new_obj = new_objs[path]

355

367

                    break

356

 

        raise AssertionError("objects differ for %s: %r != %r" % (path,

357

 

            old_obj, new_obj))

 

368

        raise AssertionError(

 

369

            "objects differ for %s: %r != %r" % (path, old_obj, new_obj))

358

370

 

359

371

 

360

372

def ensure_inventories_in_repo(repo, trees):

391

403

        base_mode = stat.S_IFDIR

392

404

    store_updater = target_git_object_retriever._get_updater(rev)

393

405

    tree_supplement = mapping.get_fileid_map(lookup_object, o.tree)

394

 

    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)

 

406

    inv_delta, unusual_modes = import_git_tree(

 

407

        repo.texts, mapping, b"", b"", (base_tree, o.tree), base_bzr_tree,

 

408

        None, rev.revision_id, parent_trees, lookup_object,

 

409

        (base_mode, stat.S_IFDIR), store_updater,

 

410

        tree_supplement.lookup_file_id,

 

411

        allow_submodules=repo._format.supports_tree_reference)

400

412

    if unusual_modes != {}:

401

413

        for path, mode in unusual_modes.iteritems():

402

414

            warn_unusual_mode(rev.foreign_revid, path, mode)

408

420

        base_bzr_inventory = None

409

421

    else:

410

422

        base_bzr_inventory = base_bzr_tree.root_inventory

411

 

    rev.inventory_sha1, inv = repo.add_inventory_by_delta(basis_id,

412

 

              inv_delta, rev.revision_id, rev.parent_ids,

413

 

              base_bzr_inventory)

 

423

    rev.inventory_sha1, inv = repo.add_inventory_by_delta(

 

424

        basis_id, inv_delta, rev.revision_id, rev.parent_ids,

 

425

        base_bzr_inventory)

414

426

    ret_tree = InventoryRevisionTree(repo, inv, rev.revision_id)

415

427

    # Check verifiers

416

428

    if verifiers and roundtrip_revid is not None:

417

429

        testament = StrictTestament3(rev, ret_tree)

418

 

        calculated_verifiers = { "testament3-sha1": testament.as_sha1() }

 

430

        calculated_verifiers = {"testament3-sha1": testament.as_sha1()}

419

431

        if calculated_verifiers != verifiers:

420

432

            trace.mutter("Testament SHA1 %r for %r did not match %r.",

421

433

                         calculated_verifiers["testament3-sha1"],

422

434

                         rev.revision_id, verifiers["testament3-sha1"])

423

435

            rev.revision_id = original_revid

424

 

            rev.inventory_sha1, inv = repo.add_inventory_by_delta(basis_id,

425

 

              inv_delta, rev.revision_id, rev.parent_ids, base_bzr_tree)

 

436

            rev.inventory_sha1, inv = repo.add_inventory_by_delta(

 

437

                basis_id, inv_delta, rev.revision_id, rev.parent_ids,

 

438

                base_bzr_tree)

426

439

            ret_tree = InventoryRevisionTree(repo, inv, rev.revision_id)

427

440

    else:

428

441

        calculated_verifiers = {}

431

444

    trees_cache.add(ret_tree)

432

445

    repo.add_revision(rev.revision_id, rev)

433

446

    if "verify" in debug.debug_flags:

434

 

        verify_commit_reconstruction(target_git_object_retriever,

435

 

            lookup_object, o, rev, ret_tree, parent_trees, mapping,

436

 

            unusual_modes, verifiers)

 

447

        verify_commit_reconstruction(

 

448

            target_git_object_retriever, lookup_object, o, rev, ret_tree,

 

449

            parent_trees, mapping, unusual_modes, verifiers)

437

450

 

438

451

 

439

452

def import_git_objects(repo, mapping, object_iter,

440

 

    target_git_object_retriever, heads, pb=None, limit=None):

 

453

                       target_git_object_retriever, heads, pb=None,

 

454

                       limit=None):

441

455

    """Import a set of git objects into a bzr repository.

442

456

 

443

457

    :param repo: Target Bazaar repository

468

482

        except KeyError:

469

483

            continue

470

484

        if isinstance(o, Commit):

471

 

            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))):

 

485

            rev, roundtrip_revid, verifiers = mapping.import_commit(

 

486

                o, mapping.revision_id_foreign_to_bzr)

 

487

            if (repo.has_revision(rev.revision_id)

 

488

                    or (roundtrip_revid and

 

489

                        repo.has_revision(roundtrip_revid))):

475

490

                continue

476

491

            graph.append((o.id, o.parents))

477

492

            heads.extend([p for p in o.parents if p not in checked])

496

511

            repo.start_write_group()

497

512

            try:

498

513

                for i, head in enumerate(

499

 

                    revision_ids[offset:offset+batch_size]):

 

514

                        revision_ids[offset:offset + batch_size]):

500

515

                    if pb is not None:

501

 

                        pb.update("fetching revisions", offset+i,

 

516

                        pb.update("fetching revisions", offset + i,

502

517

                                  len(revision_ids))

503

518

                    import_git_commit(repo, mapping, head, lookup_object,

504

 

                        target_git_object_retriever, trees_cache)

 

519

                                      target_git_object_retriever, trees_cache)

505

520

                    last_imported = head

506

 

            except:

 

521

            except BaseException:

507

522

                repo.abort_write_group()

508

523

                raise

509

524

            else:

510

525

                hint = repo.commit_write_group()

511

526

                if hint is not None:

512

527

                    pack_hints.extend(hint)

513

 

        except:

 

528

        except BaseException:

514

529

            target_git_object_retriever.abort_write_group()

515

530

            raise

516

531

        else:

531

546

        self.remote_refs = refs

532

547

        self.wants = self.actual(refs)

533

548

        return self.wants

534

 

 

535

 

 

536

 

 

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0