/brz/remove-bazaar : revision 0.239.10

1

2

3

#

4

# This program is free software; you can redistribute it and/or modify

5

# it under the terms of the GNU General Public License as published by

40

mutter,

41

)

42

43

from bzrlib.plugins.git import (

44

get_rich_root_format,

45

)

43

46

from bzrlib.plugins.git.config import (

44

47

GitBranchConfig,

45

48

)

47

50

NoPushSupport,

48

51

NoSuchRef,

49

52

)

50

from bzrlib.plugins.git.refs import (

51

branch_name_to_ref,

52

ref_to_branch_name,

53

extract_tags,

54

tag_name_to_ref,

55

)

56

53

57

54

from bzrlib.foreign import ForeignBranch

58

55

59

56

57

def extract_tags(refs, mapping):

58

ret = {}

59

for k,v in refs.iteritems():

60

if k.startswith("refs/tags/") and not k.endswith("^{}"):

61

v = refs.get(k+"^{}", v)

62

ret[k[len("refs/tags/"):]] = mapping.revision_id_foreign_to_bzr(v)

63

return ret

64

65

60

66

class GitPullResult(branch.PullResult):

61

67

62

68

def _lookup_revno(self, revid):

82

88

83

89

def get_tag_dict(self):

84

90

ret = {}

85

for k,v in extract_tags(self.repository._git.get_refs()).iteritems():

86

try:

87

obj = self.repository._git[v]

88

except KeyError:

89

mutter("Tag %s points at unknown object %s, ignoring", v, obj)

90

continue

91

for k,v in self.repository._git.refs.as_dict("refs/tags").iteritems():

92

obj = self.repository._git.get_object(v)

91

93

while isinstance(obj, Tag):

92

94

v = obj.object[1]

93

obj = self.repository._git[v]

95

obj = self.repository._git.get_object(v)

94

96

if not isinstance(obj, Commit):

95

97

mutter("Tag %s points at object %r that is not a commit, "

96

98

"ignoring", k, obj)

97

99

continue

98

ret[k] = self.branch.lookup_foreign_revision_id(v)

100

ret[k] = self.branch.mapping.revision_id_foreign_to_bzr(v)

99

101

return ret

100

102

101

def _set_tag_dict(self, to_dict):

102

extra = set(self.repository._git.get_refs().keys())

103

for k, revid in to_dict.iteritems():

104

name = tag_name_to_ref(k)

105

if name in extra:

106

extra.remove(name)

107

self.set_tag(k, revid)

108

for name in extra:

109

if name.startswith("refs/tags/"):

110

del self.repository._git[name]

111

112

103

def set_tag(self, name, revid):

113

self.repository._git.refs[tag_name_to_ref(name)], _ = \

104

self.repository._git.refs["refs/tags/%s" % name], _ = \

114

105

self.branch.mapping.revision_id_bzr_to_foreign(revid)

115

106

116

107

117

108

class DictTagDict(LocalGitTagDict):

118

109

110

119

111

def __init__(self, branch, tags):

120

112

super(DictTagDict, self).__init__(branch)

121

113

self._tags = tags

124

116

return self._tags

125

117

126

118

119

127

120

class GitBranchFormat(branch.BranchFormat):

128

121

129

122

def get_format_description(self):

130

123

return 'Git Branch'

131

124

132

def network_name(self):

133

return "git"

134

135

125

def supports_tags(self):

136

126

return True

137

127

138

def get_foreign_tests_branch_factory(self):

139

from bzrlib.plugins.git.tests.test_branch import ForeignTestsBranchFactory

140

return ForeignTestsBranchFactory()

141

142

128

def make_tags(self, branch):

143

129

if getattr(branch.repository, "get_refs", None) is not None:

144

130

from bzrlib.plugins.git.remote import RemoteGitTagDict

147

133

return LocalGitTagDict(branch)

148

134

149

135

150

class GitReadLock(object):

151

152

def __init__(self, unlock):

153

self.unlock = unlock

154

155

156

class GitWriteLock(object):

157

158

def __init__(self, unlock):

159

self.unlock = unlock

160

161

162

136

class GitBranch(ForeignBranch):

163

137

"""An adapter to git repositories for bzr Branch objects."""

164

138

165

def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):

139

def __init__(self, bzrdir, repository, name, lockfiles, tagsdict=None):

166

140

self.repository = repository

167

141

self._format = GitBranchFormat()

168

142

self.control_files = lockfiles

170

144

super(GitBranch, self).__init__(repository.get_mapping())

171

145

if tagsdict is not None:

172

146

self.tags = DictTagDict(self, tagsdict)

173

self.ref = ref

174

self.name = ref_to_branch_name(ref)

147

self.name = name

175

148

self._head = None

176

self.base = bzrdir.root_transport.base

149

self.base = bzrdir.transport.base

177

150

178

151

def _get_checkout_format(self):

179

152

"""Return the most suitable metadir for a checkout of this branch.

180

153

Weaves are used if this branch's repository uses weaves.

181

154

"""

182

return bzrdir.format_registry.make_bzrdir("default")

155

return get_rich_root_format()

183

156

184

157

def get_child_submit_format(self):

185

158

"""Return the preferred format of submissions to this branch."""

193

166

194

167

:return: Branch nick

195

168

"""

196

return self.name or "HEAD"

169

return self.name

197

170

198

171

def _set_nick(self, nick):

199

172

raise NotImplementedError

201

174

nick = property(_get_nick, _set_nick)

202

175

203

176

def __repr__(self):

204

return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,

205

self.ref or "HEAD")

177

return "%s(%r, %r)" % (self.__class__.__name__, self.repository.base, self.name)

206

178

207

179

def generate_revision_history(self, revid, old_revid=None):

208

180

# FIXME: Check that old_revid is in the ancestry of revid

211

183

212

184

def lock_write(self):

213

185

self.control_files.lock_write()

214

return GitWriteLock(self.unlock)

215

186

216

187

def get_stacked_on_url(self):

217

188

# Git doesn't do stacking (yet...)

218

raise errors.UnstackableBranchFormat(self._format, self.base)

189

return None

219

190

220

191

def get_parent(self):

221

192

"""See Branch.get_parent()."""

228

199

229

200

def lock_read(self):

230

201

self.control_files.lock_read()

231

return GitReadLock(self.unlock)

232

202

233

203

def is_locked(self):

234

204

return self.control_files.is_locked()

244

214

# perhaps should escape this ?

245

215

if self.head is None:

246

216

return revision.NULL_REVISION

247

return self.lookup_foreign_revision_id(self.head)

217

return self.mapping.revision_id_foreign_to_bzr(self.head)

248

218

249

219

def _basic_push(self, target, overwrite=False, stop_revision=None):

250

220

return branch.InterBranch.get(self, target)._basic_push(

251

221

overwrite, stop_revision)

252

222

253

def lookup_foreign_revision_id(self, foreign_revid):

254

return self.repository.lookup_foreign_revision_id(foreign_revid,

255

self.mapping)

256

257

223

258

224

class LocalGitBranch(GitBranch):

259

225

"""A local Git branch."""

260

226

261

def __init__(self, bzrdir, repository, name, lockfiles, tagsdict=None):

262

super(LocalGitBranch, self).__init__(bzrdir, repository, name,

263

lockfiles, tagsdict)

264

refs = repository._git.get_refs()

265

if not (name in refs.keys() or "HEAD" in refs.keys()):

266

raise errors.NotBranchError(self.base)

267

268

227

def create_checkout(self, to_location, revision_id=None, lightweight=False,

269

228

accelerator_tree=None, hardlink=False):

270

229

if lightweight:

272

231

t.ensure_base()

273

232

format = self._get_checkout_format()

274

233

checkout = format.initialize_on_transport(t)

275

from_branch = branch.BranchReferenceFormat().initialize(checkout,

234

from_branch = branch.BranchReferenceFormat().initialize(checkout,

276

235

self)

277

236

tree = checkout.create_workingtree(revision_id,

278

237

from_branch=from_branch, hardlink=hardlink)

281

240

return self._create_heavyweight_checkout(to_location, revision_id,

282

241

hardlink)

283

242

284

def _create_heavyweight_checkout(self, to_location, revision_id=None,

243

def _create_heavyweight_checkout(self, to_location, revision_id=None,

285

244

hardlink=False):

286

245

"""Create a new heavyweight checkout of this branch.

287

246

291

250

:return: WorkingTree object of checkout.

292

251

"""

293

252

checkout_branch = bzrdir.BzrDir.create_branch_convenience(

294

to_location, force_new_tree=False)

253

to_location, force_new_tree=False, format=get_rich_root_format())

295

254

checkout = checkout_branch.bzrdir

296

255

checkout_branch.bind(self)

297

# pull up to the specified revision_id to set the initial

256

# pull up to the specified revision_id to set the initial

298

257

# branch tip correctly, and seed it with history.

299

258

checkout_branch.pull(self, stop_revision=revision_id)

300

259

return checkout.create_workingtree(revision_id, hardlink=hardlink)

309

268

310

269

def _get_head(self):

311

270

try:

312

return self.repository._git.ref(self.ref or "HEAD")

271

return self.repository._git.ref(self.name)

313

272

except KeyError:

314

273

return None

315

274

317

276

self.set_last_revision(revid)

318

277

319

278

def set_last_revision(self, revid):

320

(newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)

279

(newhead, self.mapping) = self.mapping.revision_id_bzr_to_foreign(

280

revid)

321

281

self.head = newhead

322

282

323

283

def _set_head(self, value):

324

284

self._head = value

325

self.repository._git.refs[self.ref or "HEAD"] = self._head

285

self.repository._git.refs[self.name] = self._head

326

286

self._clear_cached_state()

327

287

328

288

head = property(_get_head, _set_head)

342

302

343

303

def supports_tags(self):

344

304

return True

345

305

346

306

347

307

class GitBranchPullResult(branch.PullResult):

348

308

349

def __init__(self):

350

super(GitBranchPullResult, self).__init__()

351

self.new_git_head = None

352

self._old_revno = None

353

self._new_revno = None

354

355

309

def report(self, to_file):

356

310

if not is_quiet():

357

311

if self.old_revid == self.new_revid:

358

312

to_file.write('No revisions to pull.\n')

359

elif self.new_git_head is not None:

360

to_file.write('Now on revision %d (git sha: %s).\n' %

313

else:

314

to_file.write('Now on revision %d (git sha: %s).\n' %

361

315

(self.new_revno, self.new_git_head))

362

else:

363

to_file.write('Now on revision %d.\n' % (self.new_revno,))

364

316

self._show_tag_conficts(to_file)

365

317

366

def _lookup_revno(self, revid):

367

assert isinstance(revid, str), "was %r" % revid

368

# Try in source branch first, it'll be faster

369

try:

370

return self.source_branch.revision_id_to_revno(revid)

371

except errors.NoSuchRevision:

372

# FIXME: Check using graph.find_distance_to_null() ?

373

return self.target_branch.revision_id_to_revno(revid)

374

375

def _get_old_revno(self):

376

if self._old_revno is not None:

377

return self._old_revno

378

return self._lookup_revno(self.old_revid)

379

380

def _set_old_revno(self, revno):

381

self._old_revno = revno

382

383

old_revno = property(_get_old_revno, _set_old_revno)

384

385

def _get_new_revno(self):

386

if self._new_revno is not None:

387

return self._new_revno

388

return self._lookup_revno(self.new_revid)

389

390

def _set_new_revno(self, revno):

391

self._new_revno = revno

392

393

new_revno = property(_get_new_revno, _set_new_revno)

394

395

318

396

319

class GitBranchPushResult(branch.BranchPushResult):

397

320

417

340

"""InterBranch implementation that pulls from Git into bzr."""

418

341

419

342

@classmethod

420

def _get_interrepo(self, source, target):

421

return repository.InterRepository.get(source.repository,

422

target.repository)

423

424

@classmethod

425

def is_compatible(cls, source, target):

426

return (isinstance(source, GitBranch) and

427

not isinstance(target, GitBranch) and

428

(getattr(cls._get_interrepo(source, target), "fetch_objects", None) is not None))

429

430

def _update_revisions(self, stop_revision=None, overwrite=False,

431

graph=None, limit=None):

432

"""Like InterBranch.update_revisions(), but with additions.

433

434

Compared to the `update_revisions()` below, this function takes a

435

`limit` argument that limits how many git commits will be converted

436

and returns the new git head.

437

"""

438

interrepo = self._get_interrepo(self.source, self.target)

343

def is_compatible(self, source, target):

344

return (isinstance(source, GitBranch) and

345

not isinstance(target, GitBranch))

346

347

def update_revisions(self, stop_revision=None, overwrite=False,

348

graph=None):

349

"""See InterBranch.update_revisions()."""

350

interrepo = repository.InterRepository.get(self.source.repository,

351

self.target.repository)

352

self._head = None

353

self._last_revid = None

439

354

def determine_wants(heads):

440

if self.source.ref is not None and not self.source.ref in heads:

441

raise NoSuchRef(self.source.ref, heads.keys())

355

if not self.source.name in heads:

356

raise NoSuchRef(self.source.name, heads.keys())

442

357

if stop_revision is not None:

443

358

self._last_revid = stop_revision

444

head, mapping = self.source.repository.lookup_bzr_revision_id(

359

self._head, mapping = self.source.repository.lookup_git_revid(

445

360

stop_revision)

446

361

else:

447

if self.source.ref is not None:

448

head = heads[self.source.ref]

449

else:

450

head = heads["HEAD"]

451

self._last_revid = self.source.lookup_foreign_revision_id(head)

362

self._head = heads[self.source.name]

363

self._last_revid = \

364

self.source.mapping.revision_id_foreign_to_bzr(self._head)

452

365

if self.target.repository.has_revision(self._last_revid):

453

366

return []

454

return [head]

455

pack_hint, head = interrepo.fetch_objects(

456

determine_wants, self.source.mapping, limit=limit)

457

if (pack_hint is not None and

458

self.target.repository._format.pack_compresses):

459

self.target.repository.pack(hint=pack_hint)

460

if head is not None:

461

self._last_revid = self.source.lookup_foreign_revision_id(head)

367

return [self._head]

368

interrepo.fetch_objects(determine_wants, self.source.mapping)

462

369

if overwrite:

463

370

prev_last_revid = None

464

371

else:

465

372

prev_last_revid = self.target.last_revision()

466

self.target.generate_revision_history(self._last_revid,

467

prev_last_revid)

468

return head

469

470

def update_revisions(self, stop_revision=None, overwrite=False,

471

graph=None):

472

"""See InterBranch.update_revisions()."""

473

self._update_revisions(stop_revision, overwrite, graph)

373

self.target.generate_revision_history(self._last_revid, prev_last_revid)

474

374

475

375

def pull(self, overwrite=False, stop_revision=None,

476

376

possible_transports=None, _hook_master=None, run_hooks=True,

477

_override_hook_target=None, local=False, limit=None):

377

_override_hook_target=None, local=False):

478

378

"""See Branch.pull.

479

379

480

380

:param _hook_master: Private parameter - set the branch to

484

384

so it should not run its hooks.

485

385

:param _override_hook_target: Private parameter - set the branch to be

486

386

supplied as the target_branch to pull hooks.

487

:param limit: Only import this many revisons. `None`, the default,

488

means import all revisions.

489

387

"""

490

388

# This type of branch can't be bound.

491

389

if local:

501

399

# We assume that during 'pull' the target repository is closer than

502

400

# the source one.

503

401

graph = self.target.repository.get_graph(self.source.repository)

504

(result.old_revno, result.old_revid) = \

402

result.old_revno, result.old_revid = \

505

403

self.target.last_revision_info()

506

result.new_git_head = self._update_revisions(

507

stop_revision, overwrite=overwrite, graph=graph, limit=limit)

404

self.update_revisions(stop_revision, overwrite=overwrite,

405

graph=graph)

406

result.new_git_head = self._head

508

407

result.tag_conflicts = self.source.tags.merge_to(self.target.tags,

509

408

overwrite)

510

(result.new_revno, result.new_revid) = \

511

self.target.last_revision_info()

409

result.new_revno, result.new_revid = self.target.last_revision_info()

512

410

if _hook_master:

513

411

result.master_branch = _hook_master

514

412

result.local_branch = result.target_branch

528

426

result.target_branch = self.target

529

427

graph = self.target.repository.get_graph(self.source.repository)

530

428

result.old_revno, result.old_revid = self.target.last_revision_info()

531

result.new_git_head = self._update_revisions(

532

stop_revision, overwrite=overwrite, graph=graph)

429

self.update_revisions(stop_revision, overwrite=overwrite,

430

graph=graph)

431

result.new_git_head = self._head

533

432

result.tag_conflicts = self.source.tags.merge_to(self.target.tags,

534

433

overwrite)

535

434

result.new_revno, result.new_revid = self.target.last_revision_info()

546

445

@classmethod

547

446

def is_compatible(self, source, target):

548

447

from bzrlib.plugins.git.remote import RemoteGitBranch

549

return (isinstance(source, LocalGitBranch) and

448

return (isinstance(source, LocalGitBranch) and

550

449

isinstance(target, RemoteGitBranch))

551

450

552

451

def _basic_push(self, overwrite=False, stop_revision=None):

553

from dulwich.protocol import ZERO_SHA

554

452

result = GitBranchPushResult()

555

453

result.source_branch = self.source

556

454

result.target_branch = self.target

558

456

stop_revision = self.source.last_revision()

559

457

# FIXME: Check for diverged branches

560

458

def get_changed_refs(old_refs):

561

result.old_revid = self.target.lookup_foreign_revision_id(old_refs.get(self.target.ref, ZERO_SHA))

562

refs = { self.target.ref: self.source.repository.lookup_bzr_revision_id(stop_revision)[0] }

459

result.old_revid = self.target.mapping.revision_id_foreign_to_bzr(old_refs.get("refs/heads/master", "0" * 40))

460

refs = { "refs/heads/master": self.source.repository.lookup_git_revid(stop_revision)[0] }

563

461

result.new_revid = stop_revision

564

462

for name, sha in self.source.repository._git.refs.as_dict("refs/tags").iteritems():

565

refs[tag_name_to_ref(name)] = sha

463

refs["refs/tags/%s" % name] = sha

566

464

return refs

567

self.target.repository.send_pack(get_changed_refs,

568

self.source.repository._git.object_store.generate_pack_contents)

465

self.target.repository.send_pack(get_changed_refs,

466

self.source.repository._git.object_store.generate_pack_contents)

569

467

return result

570

468

571

469

575

473

@classmethod

576

474

def is_compatible(self, source, target):

577

475

from bzrlib.plugins.git.remote import RemoteGitBranch

578

return (isinstance(source, RemoteGitBranch) and

476

return (isinstance(source, RemoteGitBranch) and

579

477

isinstance(target, LocalGitBranch))

580

478

581

479

def _basic_push(self, overwrite=False, stop_revision=None):

590

488

return result

591

489

592

490

def update_tags(self, refs):

593

for name, v in extract_tags(refs).iteritems():

594

revid = self.target.lookup_foreign_revision_id(v)

491

for name, revid in extract_tags(refs, self.target.mapping).iteritems():

595

492

self.target.tags.set_tag(name, revid)

596

493

597

494

def update_refs(self, stop_revision=None):

598

interrepo = repository.InterRepository.get(self.source.repository,

495

interrepo = repository.InterRepository.get(self.source.repository,

599

496

self.target.repository)

600

497

if stop_revision is None:

601

refs = interrepo.fetch(branches=["HEAD"])

602

stop_revision = self.target.lookup_foreign_revision_id(refs["HEAD"])

498

refs = interrepo.fetch_refs(branches=["HEAD"])

499

stop_revision = self.target.mapping.revision_id_foreign_to_bzr(refs["HEAD"])

603

500

else:

604

refs = interrepo.fetch(revision_id=stop_revision)

501

refs = interrepo.fetch_refs(revision_id=stop_revision)

605

502

return refs, stop_revision

606

503

607

def pull(self, stop_revision=None, overwrite=False,

608

possible_transports=None, run_hooks=True,local=False):

504

def pull(self, stop_revision=None, overwrite=False,

505

possible_transports=None, local=False):

609

506

# This type of branch can't be bound.

610

507

if local:

611

508

raise errors.LocalRequiresBoundBranch()

619

516

result.new_revid = self.target.last_revision()

620

517

return result

621

518

622

519

623

520

class InterToGitBranch(branch.InterBranch):

624

521

"""InterBranch implementation that pulls from Git into bzr."""

625

522

626

def __init__(self, source, target):

627

super(InterToGitBranch, self).__init__(source, target)

628

self.interrepo = repository.InterRepository.get(source.repository,

629

target.repository)

630

631

@staticmethod

632

def _get_branch_formats_to_test():

633

return None, None

634

635

523

@classmethod

636

524

def is_compatible(self, source, target):

637

return (not isinstance(source, GitBranch) and

525

return (not isinstance(source, GitBranch) and

638

526

isinstance(target, GitBranch))

639

527

640

528

def update_revisions(self, *args, **kwargs):

641

529

raise NoPushSupport()

642

530

643

def _get_new_refs(self, stop_revision=None):

531

def push(self, overwrite=True, stop_revision=None,

532

_override_hook_source_branch=None):

533

raise NoPushSupport()

534

535

def lossy_push(self, stop_revision=None):

536

result = GitBranchPushResult()

537

result.source_branch = self.source

538

result.target_branch = self.target

539

result.old_revid = self.target.last_revision()

644

540

if stop_revision is None:

645

541

stop_revision = self.source.last_revision()

646

main_ref = self.target.ref or "refs/heads/master"

647

refs = { main_ref: stop_revision }

542

# FIXME: Check for diverged branches

543

refs = { "refs/heads/master": stop_revision }

648

544

for name, revid in self.source.tags.get_tag_dict().iteritems():

649

545

if self.source.repository.has_revision(revid):

650

refs[tag_name_to_ref(name)] = revid

651

return refs, main_ref

652

653

def pull(self, overwrite=False, stop_revision=None, local=False,

654

possible_transports=None):

655

from dulwich.protocol import ZERO_SHA

656

result = GitBranchPullResult()

657

result.source_branch = self.source

658

result.target_branch = self.target

659

new_refs, main_ref = self._get_new_refs(stop_revision)

660

def update_refs(old_refs):

661

refs = dict(old_refs)

662

# FIXME: Check for diverged branches

663

refs.update(new_refs)

664

return refs

665

old_refs, new_refs = self.interrepo.fetch_refs(update_refs)

666

result.old_revid = self.target.lookup_foreign_revision_id(

667

old_refs.get(main_ref, ZERO_SHA))

668

result.new_revid = new_refs[main_ref]

669

return result

670

671

def push(self, overwrite=False, stop_revision=None,

672

_override_hook_source_branch=None):

673

from dulwich.protocol import ZERO_SHA

674

result = GitBranchPushResult()

675

result.source_branch = self.source

676

result.target_branch = self.target

677

new_refs, main_ref = self._get_new_refs(stop_revision)

678

def update_refs(old_refs):

679

refs = dict(old_refs)

680

# FIXME: Check for diverged branches

681

refs.update(new_refs)

682

return refs

683

old_refs, new_refs = self.interrepo.fetch_refs(update_refs)

684

result.old_revid = self.target.lookup_foreign_revision_id(

685

old_refs.get(main_ref, ZERO_SHA))

686

result.new_revid = new_refs[main_ref]

687

return result

688

689

def lossy_push(self, stop_revision=None):

690

from dulwich.protocol import ZERO_SHA

691

result = GitBranchPushResult()

692

result.source_branch = self.source

693

result.target_branch = self.target

694

new_refs, main_ref = self._get_new_refs(stop_revision)

695

def update_refs(old_refs):

696

refs = dict(old_refs)

697

# FIXME: Check for diverged branches

698

refs.update(new_refs)

699

return refs

700

result.revidmap, old_refs, new_refs = self.interrepo.dfetch_refs(

701

update_refs)

702

result.old_revid = self.target.lookup_foreign_revision_id(

703

old_refs.get(self.target.ref, ZERO_SHA))

704

result.new_revid = self.target.lookup_foreign_revision_id(

705

new_refs[main_ref])

546

refs["refs/tags/%s" % name] = revid

547

revidmap, new_refs = self.target.repository.dfetch_refs(

548

self.source.repository, refs)

549

if revidmap != {}:

550

self.target.generate_revision_history(revidmap[stop_revision])

551

result.new_revid = revidmap[stop_revision]

552

else:

553

result.new_revid = result.old_revid

554

result.revidmap = revidmap

706

555

return result

707

556

708

557