~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

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

• reverse the comparison (5532 to 5549.1.25)
• stop comparing with revision 5549.1.25

Show diffs side-by-side

added

removed

bzrlib/fetch.py

1

 

# Copyright (C) 2005-2011 Canonical Ltd

 

1

# Copyright (C) 2005-2010 Canonical Ltd

2

2

#

3

3

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

4

4

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

28

28

from bzrlib.lazy_import import lazy_import

29

29

lazy_import(globals(), """

30

30

from bzrlib import (

31

 

    graph,

32

31

    tsort,

33

32

    versionedfile,

34

33

    )

55

54

 

56

55

        :param last_revision: If set, try to limit to the data this revision

57

56

            references.

58

 

        :param fetch_spec: A SearchResult specifying which revisions to fetch.

59

 

            If set, this overrides last_revision.

60

57

        :param find_ghosts: If True search the entire history for ghosts.

61

58

        """

62

59

        # repository.fetch has the responsibility for short-circuiting

95

92

        pb.show_pct = pb.show_count = False

96

93

        try:

97

94

            pb.update("Finding revisions", 0, 2)

98

 

            search_result = self._revids_to_fetch()

99

 

            mutter('fetching: %s', search_result)

100

 

            if search_result.is_empty():

 

95

            search = self._revids_to_fetch()

 

96

            if search is None:

101

97

                return

102

98

            pb.update("Fetching revisions", 1, 2)

103

 

            self._fetch_everything_for_search(search_result)

 

99

            self._fetch_everything_for_search(search)

104

100

        finally:

105

101

            pb.finished()

106

102

 

129

125

            pb.update("Inserting stream")

130

126

            resume_tokens, missing_keys = self.sink.insert_stream(

131

127

                stream, from_format, [])

 

128

            if self.to_repository._fallback_repositories:

 

129

                missing_keys.update(

 

130

                    self._parent_inventories(search.get_keys()))

132

131

            if missing_keys:

133

132

                pb.update("Missing keys")

134

133

                stream = source.get_stream_for_missing_keys(missing_keys)

152

151

        """Determines the exact revisions needed from self.from_repository to

153

152

        install self._last_revision in self.to_repository.

154

153

 

155

 

        :returns: A SearchResult of some sort.  (Possibly a

156

 

            PendingAncestryResult, EmptySearchResult, etc.)

 

154

        If no revisions need to be fetched, then this just returns None.

157

155

        """

158

156

        if self._fetch_spec is not None:

159

 

            # The fetch spec is already a concrete search result.

160

157

            return self._fetch_spec

161

 

        elif self._last_revision == NULL_REVISION:

162

 

            # fetch_spec is None + last_revision is null => empty fetch.

 

158

        mutter('fetch up to rev {%s}', self._last_revision)

 

159

        if self._last_revision is NULL_REVISION:

163

160

            # explicit limit of no revisions needed

164

 

            return graph.EmptySearchResult()

165

 

        elif self._last_revision is not None:

166

 

            return graph.NotInOtherForRevs(self.to_repository,

167

 

                self.from_repository, [self._last_revision],

168

 

                find_ghosts=self.find_ghosts).execute()

169

 

        else: # self._last_revision is None:

170

 

            return graph.EverythingNotInOther(self.to_repository,

171

 

                self.from_repository,

172

 

                find_ghosts=self.find_ghosts).execute()

 

161

            return None

 

162

        return self.to_repository.search_missing_revision_ids(

 

163

            self.from_repository, self._last_revision,

 

164

            find_ghosts=self.find_ghosts)

 

165

 

 

166

    def _parent_inventories(self, revision_ids):

 

167

        # Find all the parent revisions referenced by the stream, but

 

168

        # not present in the stream, and make sure we send their

 

169

        # inventories.

 

170

        parent_maps = self.to_repository.get_parent_map(revision_ids)

 

171

        parents = set()

 

172

        map(parents.update, parent_maps.itervalues())

 

173

        parents.discard(NULL_REVISION)

 

174

        parents.difference_update(revision_ids)

 

175

        missing_keys = set(('inventories', rev_id) for rev_id in parents)

 

176

        return missing_keys

173

177

 

174

178

 

175

179

class Inter1and2Helper(object):

332

336

            selected_ids.append(parent_id)

333

337

    parent_keys = [(root_id, parent_id) for parent_id in selected_ids]

334

338

    return parent_keys

335

 

 

336

 

 

337

 

class TargetRepoKinds(object):

338

 

    """An enum-like set of constants.

339

 

    

340

 

    They are the possible values of FetchSpecFactory.target_repo_kinds.

341

 

    """

342

 

    

343

 

    PREEXISTING = 'preexisting'

344

 

    STACKED = 'stacked'

345

 

    EMPTY = 'empty'

346

 

 

347

 

 

348

 

class FetchSpecFactory(object):

349

 

    """A helper for building the best fetch spec for a sprout call.

350

 

 

351

 

    Factors that go into determining the sort of fetch to perform:

352

 

     * did the caller specify any revision IDs?

353

 

     * did the caller specify a source branch (need to fetch the tip + tags)

354

 

     * is there an existing target repo (don't need to refetch revs it

355

 

       already has)

356

 

     * target is stacked?  (similar to pre-existing target repo: even if

357

 

       the target itself is new don't want to refetch existing revs)

358

 

 

359

 

    :ivar source_branch: the source branch if one specified, else None.

360

 

    :ivar source_branch_stop_revision_id: fetch up to this revision of

361

 

        source_branch, rather than its tip.

362

 

    :ivar source_repo: the source repository if one found, else None.

363

 

    :ivar target_repo: the target repository acquired by sprout.

364

 

    :ivar target_repo_kind: one of the TargetRepoKinds constants.

365

 

    """

366

 

 

367

 

    def __init__(self):

368

 

        self._explicit_rev_ids = set()

369

 

        self.source_branch = None

370

 

        self.source_branch_stop_revision_id = None

371

 

        self.source_repo = None

372

 

        self.target_repo = None

373

 

        self.target_repo_kind = None

374

 

 

375

 

    def add_revision_ids(self, revision_ids):

376

 

        """Add revision_ids to the set of revision_ids to be fetched."""

377

 

        self._explicit_rev_ids.update(revision_ids)

378

 

        

379

 

    def make_fetch_spec(self):

380

 

        """Build a SearchResult or PendingAncestryResult or etc."""

381

 

        if self.target_repo_kind is None or self.source_repo is None:

382

 

            raise AssertionError(

383

 

                'Incomplete FetchSpecFactory: %r' % (self.__dict__,))

384

 

        if len(self._explicit_rev_ids) == 0 and self.source_branch is None:

385

 

            # Caller hasn't specified any revisions or source branch

386

 

            if self.target_repo_kind == TargetRepoKinds.EMPTY:

387

 

                return graph.EverythingResult(self.source_repo)

388

 

            else:

389

 

                # We want everything not already in the target (or target's

390

 

                # fallbacks).

391

 

                return graph.EverythingNotInOther(

392

 

                    self.target_repo, self.source_repo).execute()

393

 

        heads_to_fetch = set(self._explicit_rev_ids)

394

 

        tags_to_fetch = set()

395

 

        if self.source_branch is not None:

396

 

            try:

397

 

                tags_to_fetch.update(

398

 

                    self.source_branch.tags.get_reverse_tag_dict())

399

 

            except errors.TagsNotSupported:

400

 

                pass

401

 

            if self.source_branch_stop_revision_id is not None:

402

 

                heads_to_fetch.add(self.source_branch_stop_revision_id)

403

 

            else:

404

 

                heads_to_fetch.add(self.source_branch.last_revision())

405

 

        if self.target_repo_kind == TargetRepoKinds.EMPTY:

406

 

            # PendingAncestryResult does not raise errors if a requested head

407

 

            # is absent.  Ideally it would support the

408

 

            # required_ids/if_present_ids distinction, but in practice

409

 

            # heads_to_fetch will almost certainly be present so this doesn't

410

 

            # matter much.

411

 

            all_heads = heads_to_fetch.union(tags_to_fetch)

412

 

            return graph.PendingAncestryResult(all_heads, self.source_repo)

413

 

        return graph.NotInOtherForRevs(self.target_repo, self.source_repo,

414

 

            required_ids=heads_to_fetch, if_present_ids=tags_to_fetch

415

 

            ).execute()

416

 

 

417

 

 

• Older »

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