/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

More tests for sha maps, fix cache misses in tdb.

Show diffs side-by-side

added added

removed removed

Lines of Context:
push.py
17
17
"""Push implementation that simply prints message saying push is not supported."""
18
18
 
19
19
from bzrlib import (
20
 
    errors,
21
20
    ui,
22
21
    )
23
22
from bzrlib.repository import (
30
29
from bzrlib.plugins.git.errors import (
31
30
    NoPushSupport,
32
31
    )
33
 
from bzrlib.plugins.git.mapping import (
34
 
    extract_unusual_modes,
35
 
    )
36
32
from bzrlib.plugins.git.object_store import (
37
33
    BazaarObjectStore,
38
34
    )
51
47
 
52
48
    """
53
49
 
54
 
    def __init__(self, store, source, pb=None):
 
50
    def __init__(self, source, mapping, pb=None):
55
51
        """Create a new missing objects iterator.
56
52
 
57
53
        """
58
54
        self.source = source
59
 
        self._object_store = store
 
55
        self._object_store = BazaarObjectStore(self.source, mapping)
60
56
        self._revids = set()
61
57
        self._sent_shas = set()
62
58
        self._pending = []
71
67
            yield (revid, git_commit)
72
68
 
73
69
    def need_sha(self, sha):
74
 
        if sha is None or sha in self._sent_shas:
 
70
        if sha in self._sent_shas:
75
71
            return False
76
72
        (type, (fileid, revid)) = self._object_store._idmap.lookup_git_sha(sha)
77
73
        assert type in ("blob", "tree")
82
78
        # or already present remotely (as git doesn't do ghosts)
83
79
        return False
84
80
 
85
 
    def queue(self, sha, obj, path, ie=None, inv=None, unusual_modes=None):
 
81
    def queue(self, sha, obj, path, ie=None, inv=None):
86
82
        if obj is None:
87
 
            # Can't lazy-evaluate directories, since they might be eliminated
88
 
            if ie.kind == "directory":
89
 
                obj = self._object_store._get_ie_object(ie, inv, unusual_modes)
90
 
                if obj is None:
91
 
                    return
92
 
            else:
93
 
                obj = (ie, inv, unusual_modes)
 
83
            obj = (ie, inv)
94
84
        self._pending.append((obj, path))
95
85
        self._sent_shas.add(sha)
96
86
 
99
89
 
100
90
        """
101
91
        inv = self.source.get_inventory(revid)
102
 
        rev = self.source.get_revision(revid)
103
 
        unusual_modes = extract_unusual_modes(rev)
104
92
        todo = [inv.root]
105
93
        tree_sha = None
106
94
        while todo:
107
95
            ie = todo.pop()
108
 
            (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)
109
97
            if ie.parent_id is None:
110
98
                tree_sha = sha
111
99
            if not self.need_sha(sha):
112
100
                continue
113
 
            self.queue(sha, object, inv.id2path(ie.file_id), ie, inv, unusual_modes)
 
101
            self.queue(sha, object, inv.id2path(ie.file_id), ie, inv)
114
102
            if ie.kind == "directory":
115
103
                todo.extend(ie.children.values())
116
104
        assert tree_sha is not None
117
 
        commit = self._object_store._get_commit(rev, tree_sha)
118
 
        self.queue(commit.id, commit, None, None)
 
105
        commit = self._object_store._get_commit(revid, tree_sha)
 
106
        self.queue(commit.id, commit, None)
119
107
        return commit.id
120
108
 
121
109
    def __len__(self):
127
115
                self.pb.update("writing pack objects", i, len(self))
128
116
            if isinstance(object, tuple):
129
117
                object = self._object_store._get_ie_object(*object)
130
 
            yield (object, path)
 
118
            yield (object, path)   
131
119
 
132
120
 
133
121
class InterToGitRepository(InterRepository):
138
126
    def __init__(self, source, target):
139
127
        super(InterToGitRepository, self).__init__(source, target)
140
128
        self.mapping = self.target.get_mapping()
141
 
        self.source_store = BazaarObjectStore(self.source, self.mapping)
142
129
 
143
130
    @staticmethod
144
131
    def _get_repo_format_to_test():
148
135
        """See InterRepository.copy_content."""
149
136
        self.fetch(revision_id, pb, find_ghosts=False)
150
137
 
151
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False,
 
138
    def fetch(self, revision_id=None, pb=None, find_ghosts=False, 
152
139
            fetch_spec=None):
153
140
        raise NoPushSupport()
154
141
 
155
142
 
156
143
class InterToLocalGitRepository(InterToGitRepository):
157
144
 
158
 
    def missing_revisions(self, stop_revisions, check_revid):
 
145
    def missing_revisions(self, stop_revision):
 
146
        if stop_revision is None:
 
147
            raise NotImplementedError
159
148
        missing = []
160
149
        pb = ui.ui_factory.nested_progress_bar()
161
150
        try:
162
151
            graph = self.source.get_graph()
163
 
            for revid, _ in graph.iter_ancestry(stop_revisions):
 
152
            for revid, _ in graph.iter_ancestry([stop_revision]):
164
153
                pb.update("determining revisions to fetch", len(missing))
165
 
                if not check_revid(revid):
 
154
                if not self.target.has_revision(revid):
166
155
                    missing.append(revid)
167
156
            return graph.iter_topo_order(missing)
168
157
        finally:
169
158
            pb.finished()
170
159
 
171
160
    def dfetch_refs(self, refs):
 
161
        revidmap = {}
172
162
        new_refs = {}
173
 
        revidmap, gitidmap = self.dfetch(refs.values())
174
163
        for name, revid in refs.iteritems():
175
 
            if revid in gitidmap:
176
 
                gitid = gitidmap[revid]
 
164
            newrevidmap, newgitidmap = self.dfetch(revid)
 
165
            revidmap.update(newrevidmap)
 
166
            if revid in newgitidmap:
 
167
                gitid = newgitidmap[revid]
177
168
            else:
178
 
                gitid = self.source_store._lookup_revision_sha1(revid)
179
 
            self.target._git.refs[name] = gitid
 
169
                gitid, _ = self.mapping.revision_id_bzr_to_foreign(revid)
 
170
            self.target._git.set_ref(name, gitid)
180
171
            new_refs[name] = gitid
181
172
        return revidmap, new_refs
182
173
 
183
 
    def dfetch(self, stop_revisions):
 
174
    def dfetch(self, stop_revision=None):
184
175
        """Import the gist of the ancestry of a particular revision."""
185
176
        gitidmap = {}
186
177
        revidmap = {}
187
178
        self.source.lock_read()
188
179
        try:
189
 
            target_store = self.target._git.object_store
190
 
            def check_revid(revid):
191
 
                if revid == NULL_REVISION:
192
 
                    return True
193
 
                try:
194
 
                    return (self.source_store._lookup_revision_sha1(revid) in target_store)
195
 
                except errors.NoSuchRevision:
196
 
                    # Ghost, can't dpush
197
 
                    return True
198
 
            todo = list(self.missing_revisions(stop_revisions, check_revid))
 
180
            todo = [revid for revid in self.missing_revisions(stop_revision) if revid != NULL_REVISION]
199
181
            pb = ui.ui_factory.nested_progress_bar()
200
182
            try:
201
 
                object_generator = MissingObjectsIterator(self.source_store, self.source, pb)
 
183
                object_generator = MissingObjectsIterator(self.source, self.mapping, pb)
202
184
                for old_bzr_revid, git_commit in object_generator.import_revisions(
203
185
                    todo):
204
186
                    new_bzr_revid = self.mapping.revision_id_foreign_to_bzr(git_commit)
205
187
                    revidmap[old_bzr_revid] = new_bzr_revid
206
188
                    gitidmap[old_bzr_revid] = git_commit
207
 
                target_store.add_objects(object_generator)
 
189
                self.target._git.object_store.add_objects(object_generator) 
208
190
            finally:
209
191
                pb.finished()
210
192
        finally:
214
196
    @staticmethod
215
197
    def is_compatible(source, target):
216
198
        """Be compatible with GitRepository."""
217
 
        return (not isinstance(source, GitRepository) and
 
199
        return (not isinstance(source, GitRepository) and 
218
200
                isinstance(target, LocalGitRepository))
219
201
 
220
202
 
226
208
        def determine_wants(refs):
227
209
            ret = {}
228
210
            for name, revid in new_refs.iteritems():
229
 
                ret[name] = self.source_store._lookup_revision_sha1(revid)
 
211
                ret[name] = store._lookup_revision_sha1(revid)
230
212
            return ret
231
213
        self.source.lock_read()
232
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))
233
218
            new_refs = self.target.send_pack(determine_wants,
234
 
                    self.source_store.generate_pack_contents)
 
219
                    generate_blob_contents)
235
220
        finally:
236
221
            self.source.unlock()
237
222
        return revidmap, new_refs
239
224
    @staticmethod
240
225
    def is_compatible(source, target):
241
226
        """Be compatible with GitRepository."""
242
 
        return (not isinstance(source, GitRepository) and
 
227
        return (not isinstance(source, GitRepository) and 
243
228
                isinstance(target, RemoteGitRepository))