~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

• browse files at revision 4797.33.16
• compare with another revision
• compare with revision 2694.2.1
• download diff
• download tarball
• view history from revision 4797.33.16

Show diffs side-by-side

added

removed

bzrlib/repository.py

1027

1027

 

1028

1028

        :seealso: add_inventory, for the contract.

1029

1029

        """

1030

 

        inv_lines = self._serialise_inventory_to_lines(inv)

 

1030

        inv_lines = self._serializer.write_inventory_to_lines(inv)

1031

1031

        return self._inventory_add_lines(revision_id, parents,

1032

1032

            inv_lines, check_content=False)

1033

1033

 

1240

1240

        """Check a single text from this repository."""

1241

1241

        if kind == 'inventories':

1242

1242

            rev_id = record.key[0]

1243

 

            inv = self.deserialise_inventory(rev_id,

 

1243

            inv = self._deserialise_inventory(rev_id,

1244

1244

                record.get_bytes_as('fulltext'))

1245

1245

            if last_object is not None:

1246

1246

                delta = inv._make_delta(last_object)

1484

1484

        :param using: If True, list only branches using this repository.

1485

1485

        """

1486

1486

        if using and not self.is_shared():

1487

 

            try:

1488

 

                return [self.bzrdir.open_branch()]

1489

 

            except errors.NotBranchError:

1490

 

                return []

 

1487

            return self.bzrdir.list_branches()

1491

1488

        class Evaluator(object):

1492

1489

 

1493

1490

            def __init__(self):

1502

1499

                    except errors.NoRepositoryPresent:

1503

1500

                        pass

1504

1501

                    else:

1505

 

                        return False, (None, repository)

 

1502

                        return False, ([], repository)

1506

1503

                self.first_call = False

1507

 

                try:

1508

 

                    value = (bzrdir.open_branch(), None)

1509

 

                except errors.NotBranchError:

1510

 

                    value = (None, None)

 

1504

                value = (bzrdir.list_branches(), None)

1511

1505

                return True, value

1512

1506

 

1513

 

        branches = []

1514

 

        for branch, repository in bzrdir.BzrDir.find_bzrdirs(

 

1507

        ret = []

 

1508

        for branches, repository in bzrdir.BzrDir.find_bzrdirs(

1515

1509

                self.bzrdir.root_transport, evaluate=Evaluator()):

1516

 

            if branch is not None:

1517

 

                branches.append(branch)

 

1510

            if branches is not None:

 

1511

                ret.extend(branches)

1518

1512

            if not using and repository is not None:

1519

 

                branches.extend(repository.find_branches())

1520

 

        return branches

 

1513

                ret.extend(repository.find_branches())

 

1514

        return ret

1521

1515

 

1522

1516

    @needs_read_lock

1523

1517

    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):

1901

1895

                rev = self._serializer.read_revision_from_string(text)

1902

1896

                yield (revid, rev)

1903

1897

 

1904

 

    @needs_read_lock

1905

 

    def get_revision_xml(self, revision_id):

1906

 

        # TODO: jam 20070210 This shouldn't be necessary since get_revision

1907

 

        #       would have already do it.

1908

 

        # TODO: jam 20070210 Just use _serializer.write_revision_to_string()

1909

 

        # TODO: this can't just be replaced by:

1910

 

        # return self._serializer.write_revision_to_string(

1911

 

        #     self.get_revision(revision_id))

1912

 

        # as cStringIO preservers the encoding unlike write_revision_to_string

1913

 

        # or some other call down the path.

1914

 

        rev = self.get_revision(revision_id)

1915

 

        rev_tmp = cStringIO.StringIO()

1916

 

        # the current serializer..

1917

 

        self._serializer.write_revision(rev, rev_tmp)

1918

 

        rev_tmp.seek(0)

1919

 

        return rev_tmp.getvalue()

1920

 

 

1921

1898

    def get_deltas_for_revisions(self, revisions, specific_fileids=None):

1922

1899

        """Produce a generator of revision deltas.

1923

1900

 

2165

2142

        """

2166

2143

        selected_keys = set((revid,) for revid in revision_ids)

2167

2144

        w = _inv_weave or self.inventories

2168

 

        pb = ui.ui_factory.nested_progress_bar()

2169

 

        try:

2170

 

            return self._find_file_ids_from_xml_inventory_lines(

2171

 

                w.iter_lines_added_or_present_in_keys(

2172

 

                    selected_keys, pb=pb),

2173

 

                selected_keys)

2174

 

        finally:

2175

 

            pb.finished()

 

2145

        return self._find_file_ids_from_xml_inventory_lines(

 

2146

            w.iter_lines_added_or_present_in_keys(

 

2147

                selected_keys, pb=None),

 

2148

            selected_keys)

2176

2149

 

2177

2150

    def iter_files_bytes(self, desired_files):

2178

2151

        """Iterate through file versions.

2388

2361

        """single-document based inventory iteration."""

2389

2362

        inv_xmls = self._iter_inventory_xmls(revision_ids, ordering)

2390

2363

        for text, revision_id in inv_xmls:

2391

 

            yield self.deserialise_inventory(revision_id, text)

 

2364

            yield self._deserialise_inventory(revision_id, text)

2392

2365

 

2393

2366

    def _iter_inventory_xmls(self, revision_ids, ordering):

2394

2367

        if ordering is None:

2426

2399

                        next_key = None

2427

2400

                        break

2428

2401

 

2429

 

    def deserialise_inventory(self, revision_id, xml):

 

2402

    def _deserialise_inventory(self, revision_id, xml):

2430

2403

        """Transform the xml into an inventory object.

2431

2404

 

2432

2405

        :param revision_id: The expected revision id of the inventory.

2440

2413

                result.revision_id, revision_id))

2441

2414

        return result

2442

2415

 

2443

 

    def serialise_inventory(self, inv):

2444

 

        return self._serializer.write_inventory_to_string(inv)

2445

 

 

2446

 

    def _serialise_inventory_to_lines(self, inv):

2447

 

        return self._serializer.write_inventory_to_lines(inv)

2448

 

 

2449

2416

    def get_serializer_format(self):

2450

2417

        return self._serializer.format_num

2451

2418

 

2452

2419

    @needs_read_lock

2453

 

    def get_inventory_xml(self, revision_id):

2454

 

        """Get inventory XML as a file object."""

 

2420

    def _get_inventory_xml(self, revision_id):

 

2421

        """Get serialized inventory as a string."""

2455

2422

        texts = self._iter_inventory_xmls([revision_id], 'unordered')

2456

2423

        try:

2457

2424

            text, revision_id = texts.next()

2459

2426

            raise errors.HistoryMissing(self, 'inventory', revision_id)

2460

2427

        return text

2461

2428

 

2462

 

    @needs_read_lock

2463

 

    def get_inventory_sha1(self, revision_id):

2464

 

        """Return the sha1 hash of the inventory entry

2465

 

        """

2466

 

        return self.get_revision(revision_id).inventory_sha1

2467

 

 

2468

2429

    def get_rev_id_for_revno(self, revno, known_pair):

2469

2430

        """Return the revision id of a revno, given a later (revno, revid)

2470

2431

        pair in the same history.

2521

2482

            else:

2522

2483

                next_id = parents[0]

2523

2484

 

2524

 

    @needs_read_lock

2525

 

    def get_revision_inventory(self, revision_id):

2526

 

        """Return inventory of a past revision."""

2527

 

        # TODO: Unify this with get_inventory()

2528

 

        # bzr 0.0.6 and later imposes the constraint that the inventory_id

2529

 

        # must be the same as its revision, so this is trivial.

2530

 

        if revision_id is None:

2531

 

            # This does not make sense: if there is no revision,

2532

 

            # then it is the current tree inventory surely ?!

2533

 

            # and thus get_root_id() is something that looks at the last

2534

 

            # commit on the branch, and the get_root_id is an inventory check.

2535

 

            raise NotImplementedError

2536

 

            # return Inventory(self.get_root_id())

2537

 

        else:

2538

 

            return self.get_inventory(revision_id)

2539

 

 

2540

2485

    def is_shared(self):

2541

2486

        """Return True if this repository is flagged as a shared repository."""

2542

2487

        raise NotImplementedError(self.is_shared)

2576

2521

            return RevisionTree(self, Inventory(root_id=None),

2577

2522

                                _mod_revision.NULL_REVISION)

2578

2523

        else:

2579

 

            inv = self.get_revision_inventory(revision_id)

 

2524

            inv = self.get_inventory(revision_id)

2580

2525

            return RevisionTree(self, inv, revision_id)

2581

2526

 

2582

2527

    def revision_trees(self, revision_ids):

3085

3030

    pack_compresses = False

3086

3031

    # Does the repository inventory storage understand references to trees?

3087

3032

    supports_tree_reference = None

 

3033

    # Is the format experimental ?

 

3034

    experimental = False

3088

3035

 

3089

3036

    def __repr__(self):

3090

3037

        return "%s()" % self.__class__.__name__

3421

3368

 

3422

3369

        :param revision_id: if None all content is copied, if NULL_REVISION no

3423

3370

                            content is copied.

3424

 

        :param pb: optional progress bar to use for progress reports. If not

3425

 

                   provided a default one will be created.

 

3371

        :param pb: ignored.

3426

3372

        :return: None.

3427

3373

        """

 

3374

        ui.ui_factory.warn_experimental_format_fetch(self)

3428

3375

        from bzrlib.fetch import RepoFetcher

3429

3376

        # See <https://launchpad.net/bugs/456077> asking for a warning here

3430

3377

        if self.source._format.network_name() != self.target._format.network_name():

3435

3382

                               from_repository=self.source,

3436

3383

                               last_revision=revision_id,

3437

3384

                               fetch_spec=fetch_spec,

3438

 

                               pb=pb, find_ghosts=find_ghosts)

 

3385

                               find_ghosts=find_ghosts)

3439

3386

 

3440

3387

    def _walk_to_common_revisions(self, revision_ids):

3441

3388

        """Walk out from revision_ids in source to revisions target has.

4015

3962

        """See InterRepository.fetch()."""

4016

3963

        if fetch_spec is not None:

4017

3964

            raise AssertionError("Not implemented yet...")

 

3965

        ui.ui_factory.warn_experimental_format_fetch(self)

4018

3966

        if (not self.source.supports_rich_root()

4019

3967

            and self.target.supports_rich_root()):

4020

3968

            self._converting_to_rich_root = True

4100

4048

        :param to_convert: The disk object to convert.

4101

4049

        :param pb: a progress bar to use for progress information.

4102

4050

        """

4103

 

        self.pb = pb

 

4051

        pb = ui.ui_factory.nested_progress_bar()

4104

4052

        self.count = 0

4105

4053

        self.total = 4

4106

4054

        # this is only useful with metadir layouts - separated repo content.

4107

4055

        # trigger an assertion if not such

4108

4056

        repo._format.get_format_string()

4109

4057

        self.repo_dir = repo.bzrdir

4110

 

        self.step('Moving repository to repository.backup')

 

4058

        pb.update('Moving repository to repository.backup')

4111

4059

        self.repo_dir.transport.move('repository', 'repository.backup')

4112

4060

        backup_transport =  self.repo_dir.transport.clone('repository.backup')

4113

4061

        repo._format.check_conversion_target(self.target_format)

4114

4062

        self.source_repo = repo._format.open(self.repo_dir,

4115

4063

            _found=True,

4116

4064

            _override_transport=backup_transport)

4117

 

        self.step('Creating new repository')

 

4065

        pb.update('Creating new repository')

4118

4066

        converted = self.target_format.initialize(self.repo_dir,

4119

4067

                                                  self.source_repo.is_shared())

4120

4068

        converted.lock_write()

4121

4069

        try:

4122

 

            self.step('Copying content')

 

4070

            pb.update('Copying content')

4123

4071

            self.source_repo.copy_content_into(converted)

4124

4072

        finally:

4125

4073

            converted.unlock()

4126

 

        self.step('Deleting old repository content')

 

4074

        pb.update('Deleting old repository content')

4127

4075

        self.repo_dir.transport.delete_tree('repository.backup')

4128

4076

        ui.ui_factory.note('repository converted')

4129

 

 

4130

 

    def step(self, message):

4131

 

        """Update the pb by a step."""

4132

 

        self.count +=1

4133

 

        self.pb.update(message, self.count, self.total)

 

4077

        pb.finished()

4134

4078

 

4135

4079

 

4136

4080

_unescape_map = {

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1