/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to push.py

Update docs.

Show diffs side-by-side

added added

removed removed

Lines of Context:
push.py
29
29
from bzrlib.plugins.git.errors import (
30
30
    NoPushSupport,
31
31
    )
32
 
from bzrlib.plugins.git.mapping import (
33
 
    extract_unusual_modes,
34
 
    )
35
32
from bzrlib.plugins.git.object_store import (
36
33
    BazaarObjectStore,
37
34
    )
50
47
 
51
48
    """
52
49
 
53
 
    def __init__(self, store, source, pb=None):
 
50
    def __init__(self, source, mapping, pb=None):
54
51
        """Create a new missing objects iterator.
55
52
 
56
53
        """
57
54
        self.source = source
58
 
        self._object_store = store
 
55
        self._object_store = BazaarObjectStore(self.source, mapping)
59
56
        self._revids = set()
60
57
        self._sent_shas = set()
61
58
        self._pending = []
92
89
 
93
90
        """
94
91
        inv = self.source.get_inventory(revid)
95
 
        rev = self.source.get_revision(revid)
96
 
        unusual_modes = extract_unusual_modes(rev)
97
92
        todo = [inv.root]
98
93
        tree_sha = None
99
94
        while todo:
100
95
            ie = todo.pop()
101
 
            (sha, object) = self._object_store._get_ie_object_or_sha1(ie, inv, unusual_modes)
 
96
            (sha, object) = self._object_store._get_ie_object_or_sha1(ie, inv)
102
97
            if ie.parent_id is None:
103
98
                tree_sha = sha
104
99
            if not self.need_sha(sha):
107
102
            if ie.kind == "directory":
108
103
                todo.extend(ie.children.values())
109
104
        assert tree_sha is not None
110
 
        commit = self._object_store._get_commit(rev, tree_sha)
 
105
        commit = self._object_store._get_commit(revid, tree_sha)
111
106
        self.queue(commit.id, commit, None)
112
107
        return commit.id
113
108
 
131
126
    def __init__(self, source, target):
132
127
        super(InterToGitRepository, self).__init__(source, target)
133
128
        self.mapping = self.target.get_mapping()
134
 
        self.source_store = BazaarObjectStore(self.source, self.mapping)
135
129
 
136
130
    @staticmethod
137
131
    def _get_repo_format_to_test():
148
142
 
149
143
class InterToLocalGitRepository(InterToGitRepository):
150
144
 
151
 
    def missing_revisions(self, stop_revisions, check_revid):
 
145
    def missing_revisions(self, stop_revision):
 
146
        if stop_revision is None:
 
147
            raise NotImplementedError
152
148
        missing = []
153
149
        pb = ui.ui_factory.nested_progress_bar()
154
150
        try:
155
151
            graph = self.source.get_graph()
156
 
            for revid, _ in graph.iter_ancestry(stop_revisions):
 
152
            for revid, _ in graph.iter_ancestry([stop_revision]):
157
153
                pb.update("determining revisions to fetch", len(missing))
158
 
                if not check_revid(revid):
 
154
                if not self.target.has_revision(revid):
159
155
                    missing.append(revid)
160
156
            return graph.iter_topo_order(missing)
161
157
        finally:
162
158
            pb.finished()
163
159
 
164
160
    def dfetch_refs(self, refs):
 
161
        revidmap = {}
165
162
        new_refs = {}
166
 
        revidmap, gitidmap = self.dfetch(refs.values())
167
163
        for name, revid in refs.iteritems():
168
 
            if revid in gitidmap:
169
 
                gitid = gitidmap[revid]
 
164
            newrevidmap, newgitidmap = self.dfetch(revid)
 
165
            revidmap.update(newrevidmap)
 
166
            if revid in newgitidmap:
 
167
                gitid = newgitidmap[revid]
170
168
            else:
171
 
                gitid = self.source_store._lookup_revision_sha1(revid)
172
 
            self.target._git.refs[name] = gitid
 
169
                gitid, _ = self.mapping.revision_id_bzr_to_foreign(revid)
 
170
            self.target._git.set_ref(name, gitid)
173
171
            new_refs[name] = gitid
174
172
        return revidmap, new_refs
175
173
 
176
 
    def dfetch(self, stop_revisions):
 
174
    def dfetch(self, stop_revision=None):
177
175
        """Import the gist of the ancestry of a particular revision."""
178
176
        gitidmap = {}
179
177
        revidmap = {}
180
178
        self.source.lock_read()
181
179
        try:
182
 
            target_store = self.target._git.object_store
183
 
            def check_revid(revid):
184
 
                if revid == NULL_REVISION:
185
 
                    return True
186
 
                return (self.source_store._lookup_revision_sha1(revid) in target_store)
187
 
            todo = list(self.missing_revisions(stop_revisions, check_revid))
 
180
            todo = [revid for revid in self.missing_revisions(stop_revision) if revid != NULL_REVISION]
188
181
            pb = ui.ui_factory.nested_progress_bar()
189
182
            try:
190
 
                object_generator = MissingObjectsIterator(self.source_store, self.source, pb)
 
183
                object_generator = MissingObjectsIterator(self.source, self.mapping, pb)
191
184
                for old_bzr_revid, git_commit in object_generator.import_revisions(
192
185
                    todo):
193
186
                    new_bzr_revid = self.mapping.revision_id_foreign_to_bzr(git_commit)
194
187
                    revidmap[old_bzr_revid] = new_bzr_revid
195
188
                    gitidmap[old_bzr_revid] = git_commit
196
 
                target_store.add_objects(object_generator) 
 
189
                self.target._git.object_store.add_objects(object_generator) 
197
190
            finally:
198
191
                pb.finished()
199
192
        finally:
215
208
        def determine_wants(refs):
216
209
            ret = {}
217
210
            for name, revid in new_refs.iteritems():
218
 
                ret[name] = self.source_store._lookup_revision_sha1(revid)
 
211
                ret[name] = store._lookup_revision_sha1(revid)
219
212
            return ret
220
213
        self.source.lock_read()
221
214
        try:
 
215
            store = BazaarObjectStore(self.source, self.mapping)
 
216
            def generate_blob_contents(have, want):
 
217
                return store.iter_shas(store.find_missing_objects(have, want))
222
218
            new_refs = self.target.send_pack(determine_wants,
223
 
                    self.source_store.generate_pack_contents)
 
219
                    generate_blob_contents)
224
220
        finally:
225
221
            self.source.unlock()
226
222
        return revidmap, new_refs