/brz/remove-bazaar : revision 0.200.56

16

17

"""An adapter between a Git Repository and a Bazaar Branch"""

18

19

import git

19

20

import os

20

import time

21

22

import bzrlib

23

from bzrlib import (

24

deprecated_graph,

24

25

errors,

25

graph,

26

inventory,

27

osutils,

28

repository,

29

revision,

30

revisiontree,

31

ui,

32

31

urlutils,

33

32

)

34

from bzrlib.foreign import (

35

ForeignRepository,

36

)

37

from bzrlib.trace import mutter

38

33

from bzrlib.transport import get_transport

39

34

40

from bzrlib.plugins.git.foreign import (

41

versionedfiles,

35

from bzrlib.plugins.git import (

36

cache,

37

ids,

42

38

)

43

from bzrlib.plugins.git.mapping import default_mapping, mapping_registry

44

from bzrlib.plugins.git.versionedfiles import GitTexts

45

46

import dulwich as git

47

48

49

class GitTags(object):

50

51

def __init__(self, tags):

52

self._tags = tags

53

54

def __iter__(self):

55

return iter(self._tags)

56

57

58

class GitRepository(ForeignRepository):

39

40

41

cachedbs = {}

42

43

44

class GitRepository(repository.Repository):

59

45

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

60

46

61

47

_serializer = None

62

48

63

49

def __init__(self, gitdir, lockfiles):

64

ForeignRepository.__init__(self, GitFormat(), gitdir, lockfiles)

65

from bzrlib.plugins.git import fetch

66

repository.InterRepository.register_optimiser(fetch.InterGitRepository)

67

repository.InterRepository.register_optimiser(fetch.InterGitNonGitRepository)

50

self.bzrdir = gitdir

51

self.control_files = lockfiles

52

self._git = git.repo.Repo(gitdir.root_transport.local_abspath("."))

53

self._revision_cache = {}

54

self._blob_cache = {}

55

self._blob_info_cache = {}

56

cache_dir = cache.create_cache_dir()

57

cachedir_transport = get_transport(cache_dir)

58

cache_file = os.path.join(cache_dir, 'cache-%s' % ids.NAMESPACE)

59

if not cachedbs.has_key(cache_file):

60

cachedbs[cache_file] = cache.sqlite3.connect(cache_file)

61

self.cachedb = cachedbs[cache_file]

62

self._init_cachedb()

63

self.texts = None

64

self.signatures = None

65

self.revisions = None

66

self._format = GitFormat()

67

68

def _init_cachedb(self):

69

self.cachedb.executescript("""

70

create table if not exists inventory (

71

revid blob);

72

create unique index if not exists inventory_revid

73

on inventory (revid);

74

create table if not exists entry_revision (

75

inventory blob,

76

path blob,

77

gitid blob,

78

executable integer,

79

revision blob);

80

create unique index if not exists entry_revision_revid_path

81

on entry_revision (inventory, path);

82

""")

83

self.cachedb.commit()

84

85

def _ancestor_revisions(self, revision_ids):

86

if revision_ids is not None:

87

git_revisions = [gitrevid_from_bzr(r) for r in revision_ids]

88

else:

89

git_revisions = None

90

for lines in self._git.ancestor_lines(git_revisions):

91

yield self._parse_rev(lines)

92

# print "fetched ancestors:", git_revisions

68

93

69

94

def is_shared(self):

70

95

return True

71

96

72

97

def supports_rich_root(self):

73

return True

74

75

def _warn_if_deprecated(self):

76

# This class isn't deprecated

77

pass

78

79

def get_mapping(self):

80

return default_mapping

81

82

def make_working_trees(self):

83

return True

84

85

86

class LocalGitRepository(GitRepository):

87

88

def __init__(self, gitdir, lockfiles):

89

# FIXME: This also caches negatives. Need to be more careful

90

# about this once we start writing to git

91

self._parents_provider = graph.CachingParentsProvider(self)

92

GitRepository.__init__(self, gitdir, lockfiles)

93

self.base = gitdir.root_transport.base

94

self._git = gitdir._git

95

self.texts = None

96

self.signatures = versionedfiles.VirtualSignatureTexts(self)

97

self.revisions = versionedfiles.VirtualRevisionTexts(self)

98

self.inventories = versionedfiles.VirtualInventoryTexts(self)

99

self.texts = GitTexts(self)

100

self.tags = GitTags(self._git.get_tags())

101

102

def all_revision_ids(self):

103

ret = set([revision.NULL_REVISION])

104

if self._git.heads() == []:

105

return ret

106

bzr_heads = [self.get_mapping().revision_id_foreign_to_bzr(h) for h in self._git.heads()]

107

ret = set(bzr_heads)

108

graph = self.get_graph()

109

for rev, parents in graph.iter_ancestry(bzr_heads):

110

ret.add(rev)

111

return ret

112

113

#def get_revision_delta(self, revision_id):

114

# parent_revid = self.get_revision(revision_id).parent_ids[0]

115

# diff = self._git.diff(ids.convert_revision_id_bzr_to_git(parent_revid),

116

# ids.convert_revision_id_bzr_to_git(revision_id))

117

118

def _make_parents_provider(self):

119

"""See Repository._make_parents_provider()."""

120

return self._parents_provider

121

122

def get_parent_map(self, revids):

123

parent_map = {}

124

mutter("get_parent_map(%r)", revids)

125

for revision_id in revids:

126

assert isinstance(revision_id, str)

127

if revision_id == revision.NULL_REVISION:

128

parent_map[revision_id] = ()

129

continue

130

hexsha, mapping = self.lookup_git_revid(revision_id)

131

commit = self._git.commit(hexsha)

132

if commit is None:

133

continue

134

else:

135

parent_map[revision_id] = [mapping.revision_id_foreign_to_bzr(p) for p in commit.parents]

136

return parent_map

137

138

def get_ancestry(self, revision_id, topo_sorted=True):

139

"""See Repository.get_ancestry().

140

"""

141

if revision_id is None:

142

return self._all_revision_ids()

143

assert isinstance(revision_id, str)

144

ancestry = []

145

graph = self.get_graph()

146

for rev, parents in graph.iter_ancestry([revision_id]):

147

if rev == revision.NULL_REVISION:

148

rev = None

149

ancestry.append(rev)

150

ancestry.reverse()

151

return ancestry

152

153

def import_revision_gist(self, source, revid):

154

pass

155

156

def dfetch(self, source, stop_revision):

157

if stop_revision is None:

158

raise NotImplementedError

159

revidmap = {}

160

todo = []

161

source.lock_read()

162

try:

163

graph = source.get_graph()

164

for revid, parents in graph.iter_ancestry([stop_revision]):

165

if not self.has_revision(revid):

166

todo.append(revid)

167

pb = ui.ui_factory.nested_progress_bar()

168

try:

169

for i, revid in enumerate(reversed(todo)):

170

pb.update("pushing revisions", i, len(todo))

171

revidmap[revid] = self.import_revision_gist(source, revid)

172

finally:

173

pb.finished()

174

finally:

175

source.unlock()

176

return revidmap

98

return False

99

100

def get_revision_graph(self, revision_id=None):

101

result = {}

102

if revision_id is not None:

103

param = [ids.convert_revision_id_bzr_to_git(revision_id)]

104

else:

105

param = None

106

git_graph = self._git.get_revision_graph(param)

107

# print "fetched revision graph:", param

108

for node, parents in git_graph.iteritems():

109

bzr_node = ids.convert_revision_id_git_to_bzr(node)

110

bzr_parents = [ids.convert_revision_id_git_to_bzr(n)

111

for n in parents]

112

result[bzr_node] = bzr_parents

113

return result

114

115

def get_revision_graph_with_ghosts(self, revision_ids=None):

116

graph = deprecated_graph.Graph()

117

if revision_ids is not None:

118

revision_ids = [ids.convert_revision_id_bzr_to_git(r)

119

for r in revision_ids]

120

git_graph = self._git.get_revision_graph(revision_ids)

121

# print "fetched revision graph (ghosts):", revision_ids

122

for node, parents in git_graph.iteritems():

123

bzr_node = ids.convert_revision_id_git_to_bzr(node)

124

bzr_parents = [ids.convert_revision_id_git_to_bzr(n)

125

for n in parents]

126

127

graph.add_node(bzr_node, bzr_parents)

128

return graph

129

130

def get_ancestry(self, revision_id):

131

param = [ids.convert_revision_id_bzr_to_git(revision_id)]

132

git_ancestry = self._git.get_ancestry(param)

133

# print "fetched ancestry:", param

134

return [None] + [

135

ids.convert_revision_id_git_to_bzr(git_id)

136

for git_id in git_ancestry]

177

137

178

138

def get_signature_text(self, revision_id):

179

139

raise errors.NoSuchRevision(self, revision_id)

180

140

181

def lookup_revision_id(self, revid):

182

"""Lookup a revision id.

183

184

:param revid: Bazaar revision id.

185

:return: Tuple with git revisionid and mapping.

186

"""

187

# Yes, this doesn't really work, but good enough as a stub

188

return osutils.sha(rev_id).hexdigest(), self.get_mapping()

189

190

def has_signature_for_revision_id(self, revision_id):

191

return False

192

193

def lookup_git_revid(self, bzr_revid):

194

try:

195

return mapping_registry.revision_id_bzr_to_foreign(bzr_revid)

196

except errors.InvalidRevisionId:

197

raise errors.NoSuchRevision(self, bzr_revid)

198

141

199

142

def get_revision(self, revision_id):

200

git_commit_id, mapping = self.lookup_git_revid(revision_id)

201

try:

202

commit = self._git.commit(git_commit_id)

203

except KeyError:

204

raise errors.NoSuchRevision(self, revision_id)

143

if revision_id in self._revision_cache:

144

return self._revision_cache[revision_id]

145

git_commit_id = ids.convert_revision_id_bzr_to_git(revision_id)

146

raw = self._git.rev_list([git_commit_id], max_count=1, header=True)

205

147

# print "fetched revision:", git_commit_id

206

revision = mapping.import_commit(commit)

207

assert revision is not None

148

revision = self._parse_rev(raw)

149

self._revision_cache[revision_id] = revision

208

150

return revision

209

151

210

152

def has_revision(self, revision_id):

211

153

try:

212

154

self.get_revision(revision_id)

213

except errors.NoSuchRevision:

155

except NoSuchRevision:

214

156

return False

215

157

else:

216

158

return True

217

159

218

def get_revisions(self, revids):

219

return [self.get_revision(r) for r in revids]

160

def get_revisions(self, revisions):

161

return [self.get_revision(r) for r in revisions]

162

163

@classmethod

164

def _parse_rev(klass, raw):

165

"""Parse a single git revision.

166

167

* The first line is the git commit id.

168

* Following lines conform to the 'name value' structure, until the

169

first blank line.

170

* All lines after the first blank line and until the NULL line have 4

171

leading spaces and constitute the commit message.

172

173

:param raw: sequence of newline-terminated strings, its last item is a

174

single NULL character.

175

:return: a `bzrlib.revision.Revision` object.

176

"""

177

parents = []

178

message_lines = []

179

in_message = False

180

committer_was_set = False

181

revision_id = ids.convert_revision_id_git_to_bzr(raw[0][:-1])

182

rev = revision.Revision(revision_id)

183

rev.inventory_sha1 = ""

184

assert raw[-1] == '\x00', (

185

"Last item of raw was not a single NULL character.")

186

for line in raw[1:-1]:

187

if in_message:

188

assert line[:4] == ' ', (

189

"Unexpected line format in commit message: %r" % line)

190

message_lines.append(line[4:])

191

continue

192

if line == '\n':

193

in_message = True

194

continue

195

name, value = line[:-1].split(' ', 1)

196

if name == 'parent':

197

rev.parent_ids.append(

198

ids.convert_revision_id_git_to_bzr(value))

199

continue

200

if name == 'author':

201

author, timestamp, timezone = value.rsplit(' ', 2)

202

rev.properties['author'] = author

203

rev.properties['git-author-timestamp'] = timestamp

204

rev.properties['git-author-timezone'] = timezone

205

if not committer_was_set:

206

rev.committer = author

207

rev.timestamp = float(timestamp)

208

rev.timezone = klass._parse_tz(timezone)

209

continue

210

if name == 'committer':

211

committer_was_set = True

212

committer, timestamp, timezone = value.rsplit(' ', 2)

213

rev.committer = committer

214

rev.timestamp = float(timestamp)

215

rev.timezone = klass._parse_tz(timezone)

216

continue

217

if name == 'tree':

218

rev.properties['git-tree-id'] = value

219

continue

220

221

rev.message = ''.join(message_lines)

222

223

# XXX: That should not be needed, but current revision serializers do

224

# not know how how to handle text that is illegal in xml. Note: when

225

# this is fixed, we will need to rev up the revision namespace when

226

# removing the escaping code. -- David Allouche 2007-12-30

227

rev.message = escape_for_xml(rev.message)

228

rev.committer = escape_for_xml(rev.committer)

229

rev.properties['author'] = escape_for_xml(rev.properties['author'])

230

231

return rev

232

233

@classmethod

234

def _parse_tz(klass, tz):

235

"""Parse a timezone specification in the [+|-]HHMM format.

236

237

:return: the timezone offset in seconds.

238

"""

239

assert len(tz) == 5

240

sign = {'+': +1, '-': -1}[tz[0]]

241

hours = int(tz[1:3])

242

minutes = int(tz[3:])

243

return sign * 60 * (60 * hours + minutes)

220

244

221

245

def revision_trees(self, revids):

222

246

for revid in revids:

223

247

yield self.revision_tree(revid)

224

248

225

249

def revision_tree(self, revision_id):

226

revision_id = revision.ensure_null(revision_id)

227

228

if revision_id == revision.NULL_REVISION:

229

inv = inventory.Inventory(root_id=None)

230

inv.revision_id = revision_id

231

return revisiontree.RevisionTree(self, inv, revision_id)

232

233

250

return GitRevisionTree(self, revision_id)

234

251

252

def _fetch_blob(self, git_id):

253

lines = self._git.cat_file('blob', git_id)

254

# print "fetched blob:", git_id

255

if self._building_inventory is not None:

256

self._building_inventory.git_file_data[git_id] = lines

257

return lines

258

259

def _get_blob(self, git_id):

260

try:

261

return self._blob_cache[git_id]

262

except KeyError:

263

return self._fetch_blob(git_id)

264

265

def _get_blob_caching(self, git_id):

266

try:

267

return self._blob_cache[git_id]

268

except KeyError:

269

lines = self._fetch_blob(git_id)

270

self._blob_cache[git_id] = lines

271

return lines

272

273

def _get_blob_info(self, git_id):

274

try:

275

return self._blob_info_cache[git_id]

276

except KeyError:

277

lines = self._get_blob(git_id)

278

size = sum(len(line) for line in lines)

279

sha1 = osutils.sha_strings(lines)

280

self._blob_info_cache[git_id] = (size, sha1)

281

return size, sha1

282

235

283

def get_inventory(self, revision_id):

236

assert revision_id != None

237

return self.revision_tree(revision_id).inventory

238

239

def set_make_working_trees(self, trees):

240

pass

241

242

def fetch_objects(self, determine_wants, graph_walker, progress=None):

243

return self._git.fetch_objects(determine_wants, graph_walker, progress)

284

if revision_id is None:

285

revision_id = revision.NULL_REVISION

286

if revision_id == revision.NULL_REVISION:

287

return inventory.Inventory(

288

revision_id=revision_id, root_id=None)

289

290

# First pass at building the inventory. We need this one to get the

291

# git ids, so we do not have to cache the entire tree text. Ideally,

292

# this should be all we need to do.

293

git_commit = ids.convert_revision_id_bzr_to_git(revision_id)

294

git_inventory = self._git.get_inventory(git_commit)

295

# print "fetched inventory:", git_commit

296

inv = self._parse_inventory(revision_id, git_inventory)

297

298

# Second pass at building the inventory. There we retrieve additional

299

# data that bzrlib requires: text sizes, sha1s, symlink targets and

300

# revisions that introduced inventory entries

301

self._building_inventory = inv

302

self._building_inventory.git_file_data = {}

303

for file_id in sorted(inv.git_ids.iterkeys()):

304

git_id = inv.git_ids[file_id]

305

entry = inv[file_id]

306

self._set_entry_text_info(inv, entry, git_id)

307

for file_id in sorted(inv.git_ids.iterkeys()):

308

git_id = inv.git_ids[file_id]

309

entry = inv[file_id]

310

path = inv.id2path(file_id)

311

self._set_entry_revision(entry, revision_id, path, git_id)

312

313

# At this point the entry_revision table is fully populated for this

314

# revision. So record that we have inventory data for this revision.

315

self.cachedb.execute(

316

"insert or ignore into inventory (revid) values (?)",

317

(revision_id,))

318

self.cachedb.commit()

319

self._building_inventory = None

320

return inv

321

322

@classmethod

323

def _parse_inventory(klass, revid, git_inv):

324

# For now, git inventory do not have root ids. It is not clear that we

325

# can reliably support root ids. -- David Allouche 2007-12-28

326

inv = inventory.Inventory(revision_id=revid)

327

inv.git_ids = {}

328

for perms, git_kind, git_id, path in git_inv:

329

text_sha1 = None

330

executable = False

331

if git_kind == 'blob':

332

if perms[1] == '0':

333

kind = 'file'

334

executable = bool(int(perms[-3:], 8) & 0111)

335

elif perms[1] == '2':

336

kind = 'symlink'

337

else:

338

raise AssertionError(

339

"Unknown blob kind, perms=%r." % (perms,))

340

elif git_kind == 'tree':

341

kind = 'directory'

342

else:

343

raise AssertionError(

344

"Unknown git entry kind: %r" % (git_kind,))

345

# XXX: Maybe the file id should be prefixed by file kind, so when

346

# the kind of path changes, the id changes too.

347

# -- David Allouche 2007-12-28.

348

file_id = escape_file_id(path.encode('utf-8'))

349

entry = inv.add_path(path, kind, file_id=file_id)

350

entry.executable = executable

351

inv.git_ids[file_id] = git_id

352

inv.root.revision = revid

353

return inv

354

355

def _set_entry_text_info(self, inv, entry, git_id):

356

if entry.kind == 'directory':

357

return

358

size, sha1 = self._get_blob_info(git_id)

359

entry.text_size = size

360

entry.text_sha1 = sha1

361

if entry.kind == 'symlink':

362

lines = self._get_blob_caching(git_id)

363

entry.symlink_target = ''.join(lines)

364

365

def _get_file_revision(self, revision_id, path):

366

lines = self._git.rev_list(

367

[ids.convert_revision_id_bzr_to_git(revision_id)],

368

max_count=1, topo_order=True, paths=[path])

369

[line] = lines

370

result = ids.convert_revision_id_git_to_bzr(line[:-1])

371

# print "fetched file revision", line[:-1], path

372

return result

373

374

def _get_entry_revision_from_db(self, revid, path, git_id, executable):

375

result = self.cachedb.execute(

376

"select revision from entry_revision where"

377

" inventory=? and path=? and gitid=? and executable=?",

378

(revid, path, git_id, executable)).fetchone()

379

if result is None:

380

return None

381

[revision] = result

382

return revision

383

384

def _set_entry_revision_in_db(self, revid, path, git_id, executable, revision):

385

self.cachedb.execute(

386

"insert into entry_revision"

387

" (inventory, path, gitid, executable, revision)"

388

" values (?, ?, ?, ?, ?)",

389

(revid, path, git_id, executable, revision))

390

391

def _all_inventories_in_db(self, revids):

392

for revid in revids:

393

result = self.cachedb.execute(

394

"select count(*) from inventory where revid = ?",

395

(revid,)).fetchone()

396

if result is None:

397

return False

398

return True

399

400

def _set_entry_revision(self, entry, revid, path, git_id):

401

# If a revision is in the cache, we assume it contains entries for the

402

# whole inventory. So if all parent revisions are in the cache, but no

403

# parent entry is present, then the entry revision is the current

404

# revision. That amortizes the number of _get_file_revision calls for

405

# large pulls to a "small number".

406

entry_rev = self._get_entry_revision_from_db(

407

revid, path, git_id, entry.executable)

408

if entry_rev is not None:

409

entry.revision = entry_rev

410

return

411

412

revision = self.get_revision(revid)

413

for parent_id in revision.parent_ids:

414

entry_rev = self._get_entry_revision_from_db(

415

parent_id, path, git_id, entry.executable)

416

if entry_rev is not None:

417

break

418

else:

419

if self._all_inventories_in_db(revision.parent_ids):

420

entry_rev = revid

421

else:

422

entry_rev = self._get_file_revision(revid, path)

423

self._set_entry_revision_in_db(

424

revid, path, git_id, entry.executable, entry_rev)

425

#self.cachedb.commit()

426

entry.revision = entry_rev

427

428

429

def escape_file_id(file_id):

430

return file_id.replace('_', '__').replace(' ', '_s')

431

432

433

def escape_for_xml(message):

434

"""Replace xml-incompatible control characters."""

435

# Copied from _escape_commit_message from bzr-svn.

436

# -- David Allouche 2007-12-29.

437

if message is None:

438

return None

439

import re

440

# FIXME: RBC 20060419 this should be done by the revision

441

# serialiser not by commit. Then we can also add an unescaper

442

# in the deserializer and start roundtripping revision messages

443

# precisely. See repository_implementations/test_repository.py

444

445

# Python strings can include characters that can't be

446

# represented in well-formed XML; escape characters that

447

# aren't listed in the XML specification

448

# (http://www.w3.org/TR/REC-xml/#NT-Char).

449

message, _ = re.subn(

450

u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]+',

451

lambda match: match.group(0).encode('unicode_escape'),

452

message)

453

return message

244

454

245

455

246

456

class GitRevisionTree(revisiontree.RevisionTree):

247

457

248

458

def __init__(self, repository, revision_id):

459

if revision_id is None:

460

revision_id = revision.NULL_REVISION

461

self._inventory = repository.get_inventory(revision_id)

249

462

self._repository = repository

250

self.revision_id = revision_id

251

assert isinstance(revision_id, str)

252

git_id, self.mapping = repository.lookup_git_revid(revision_id)

253

try:

254

commit = repository._git.commit(git_id)

255

except KeyError, r:

256

raise errors.NoSuchRevision(repository, revision_id)

257

self.tree = commit.tree

258

self._inventory = inventory.Inventory(revision_id=revision_id)

259

self._inventory.root.revision = revision_id

260

self._build_inventory(self.tree, self._inventory.root, "")

261

262

def get_revision_id(self):

263

return self.revision_id

264

265

def get_file_text(self, file_id):

463

self._revision_id = revision_id

464

465

def get_file_lines(self, file_id):

266

466

entry = self._inventory[file_id]

267

if entry.kind == 'directory': return ""

268

return self._repository._git.get_blob(entry.text_id).data

269

270

def _build_inventory(self, tree_id, ie, path):

271

assert isinstance(path, str)

272

tree = self._repository._git.tree(tree_id)

273

for mode, name, hexsha in tree.entries():

274

basename = name.decode("utf-8")

275

if path == "":

276

child_path = name

277

else:

278

child_path = urlutils.join(path, name)

279

file_id = self.mapping.generate_file_id(child_path)

280

entry_kind = (mode & 0700000) / 0100000

281

if entry_kind == 0:

282

child_ie = inventory.InventoryDirectory(file_id, basename, ie.file_id)

283

elif entry_kind == 1:

284

file_kind = (mode & 070000) / 010000

285

b = self._repository._git.get_blob(hexsha)

286

if file_kind == 0:

287

child_ie = inventory.InventoryFile(file_id, basename, ie.file_id)

288

child_ie.text_sha1 = osutils.sha_string(b.data)

289

elif file_kind == 2:

290

child_ie = inventory.InventoryLink(file_id, basename, ie.file_id)

291

child_ie.text_sha1 = osutils.sha_string("")

292

else:

293

raise AssertionError(

294

"Unknown file kind, perms=%o." % (mode,))

295

child_ie.text_id = b.id

296

child_ie.text_size = len(b.data)

297

else:

298

raise AssertionError(

299

"Unknown blob kind, perms=%r." % (mode,))

300

fs_mode = mode & 0777

301

child_ie.executable = bool(fs_mode & 0111)

302

child_ie.revision = self.revision_id

303

self._inventory.add(child_ie)

304

if entry_kind == 0:

305

self._build_inventory(hexsha, child_ie, child_path)

467

if entry.kind == 'directory': return []

468

git_id = self._inventory.git_ids[file_id]

469

if git_id in self._inventory.git_file_data:

470

return self._inventory.git_file_data[git_id]

471

return self._repository._get_blob(git_id)

306

472

307

473

308

474

class GitFormat(object):

309

475

310

476

supports_tree_reference = False

311

rich_root_data = True

312

313

def get_format_description(self):

314

return "Git Repository"

315

316

def initialize(self, url, shared=False, _internal=False):

317

raise bzr_errors.UninitializableFormat(self)

318

319

def check_conversion_target(self, target_repo_format):

320

return target_repo_format.rich_root_data