/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 mapping.py

Fix locking.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mapping.py
1
 
# Copyright (C) 2007-2008 Canonical Ltd
 
1
# Copyright (C) 2007 Canonical Ltd
 
2
# Copyright (C) 2008-2009 Jelmer Vernooij <jelmer@samba.org>
 
3
# Copyright (C) 2008 John Carr
2
4
#
3
5
# This program is free software; you can redistribute it and/or modify
4
6
# it under the terms of the GNU General Public License as published by
16
18
 
17
19
"""Converters, etc for going between Bazaar and Git ids."""
18
20
 
19
 
from bzrlib import errors, foreign, urlutils
20
 
from bzrlib.inventory import ROOT_ID
 
21
import base64
 
22
import stat
 
23
 
 
24
from bzrlib import (
 
25
    errors,
 
26
    foreign,
 
27
    trace,
 
28
    )
 
29
try:
 
30
    from bzrlib import bencode
 
31
except ImportError:
 
32
    from bzrlib.util import bencode
 
33
from bzrlib.inventory import (
 
34
    ROOT_ID,
 
35
    )
21
36
from bzrlib.foreign import (
22
 
        ForeignVcs, 
23
 
        VcsMappingRegistry, 
24
 
        ForeignRevision,
25
 
        )
 
37
    ForeignVcs,
 
38
    VcsMappingRegistry,
 
39
    ForeignRevision,
 
40
    )
 
41
from bzrlib.revision import (
 
42
    NULL_REVISION,
 
43
    )
 
44
from bzrlib.plugins.git.hg import (
 
45
    format_hg_metadata,
 
46
    extract_hg_metadata,
 
47
    )
 
48
 
 
49
DEFAULT_FILE_MODE = stat.S_IFREG | 0644
 
50
 
26
51
 
27
52
def escape_file_id(file_id):
28
53
    return file_id.replace('_', '__').replace(' ', '_s')
29
54
 
30
55
 
31
56
def unescape_file_id(file_id):
32
 
    return file_id.replace("_s", " ").replace("__", "_")
 
57
    ret = []
 
58
    i = 0
 
59
    while i < len(file_id):
 
60
        if file_id[i] != '_':
 
61
            ret.append(file_id[i])
 
62
        else:
 
63
            if file_id[i+1] == '_':
 
64
                ret.append("_")
 
65
            elif file_id[i+1] == 's':
 
66
                ret.append(" ")
 
67
            else:
 
68
                raise AssertionError("unknown escape character %s" %
 
69
                    file_id[i+1])
 
70
            i += 1
 
71
        i += 1
 
72
    return "".join(ret)
 
73
 
 
74
 
 
75
def fix_person_identifier(text):
 
76
    if "<" in text and ">" in text:
 
77
        return text
 
78
    return "%s <%s>" % (text, text)
 
79
 
 
80
 
 
81
def warn_escaped(commit, num_escaped):
 
82
    trace.warning("Escaped %d XML-invalid characters in %s. Will be unable "
 
83
                  "to regenerate the SHA map.", num_escaped, commit)
 
84
 
 
85
 
 
86
def warn_unusual_mode(commit, path, mode):
 
87
    trace.mutter("Unusual file mode %o for %s in %s. Storing as revision "
 
88
                 "property. ", mode, path, commit)
 
89
 
 
90
 
 
91
def squash_revision(target_repo, rev):
 
92
    """Remove characters that can't be stored from a revision, if necessary.
 
93
 
 
94
    :param target_repo: Repository in which the revision will be stored
 
95
    :param rev: Revision object, will be modified in-place
 
96
    """
 
97
    if not getattr(target_repo._serializer, "squashes_xml_invalid_characters", True):
 
98
        return
 
99
    from bzrlib.xml_serializer import escape_invalid_chars
 
100
    rev.message, num_escaped = escape_invalid_chars(rev.message)
 
101
    if num_escaped:
 
102
        warn_escaped(rev.foreign_revid, num_escaped)
 
103
    if 'author' in rev.properties:
 
104
        rev.properties['author'], num_escaped = escape_invalid_chars(
 
105
            rev.properties['author'])
 
106
        if num_escaped:
 
107
            warn_escaped(rev.foreign_revid, num_escaped)
 
108
    rev.committer, num_escaped = escape_invalid_chars(rev.committer)
 
109
    if num_escaped:
 
110
        warn_escaped(rev.foreign_revid, num_escaped)
33
111
 
34
112
 
35
113
class BzrGitMapping(foreign.VcsMapping):
40
118
        super(BzrGitMapping, self).__init__(foreign_git)
41
119
 
42
120
    def __eq__(self, other):
43
 
        return type(self) == type(other) and self.revid_prefix == other.revid_prefix
 
121
        return (type(self) == type(other) and 
 
122
                self.revid_prefix == other.revid_prefix)
44
123
 
45
124
    @classmethod
46
125
    def revision_id_foreign_to_bzr(cls, git_rev_id):
47
126
        """Convert a git revision id handle to a Bazaar revision id."""
 
127
        from dulwich.protocol import ZERO_SHA
 
128
        if git_rev_id == ZERO_SHA:
 
129
            return NULL_REVISION
48
130
        return "%s:%s" % (cls.revid_prefix, git_rev_id)
49
131
 
50
132
    @classmethod
55
137
        return bzr_rev_id[len(cls.revid_prefix)+1:], cls()
56
138
 
57
139
    def generate_file_id(self, path):
 
140
        # Git paths are just bytestrings
 
141
        # We must just hope they are valid UTF-8..
58
142
        if path == "":
59
143
            return ROOT_ID
60
 
        return escape_file_id(path.encode('utf-8'))
 
144
        return escape_file_id(path)
 
145
 
 
146
    def parse_file_id(self, file_id):
 
147
        if file_id == ROOT_ID:
 
148
            return ""
 
149
        return unescape_file_id(file_id)
 
150
 
 
151
    def import_unusual_file_modes(self, rev, unusual_file_modes):
 
152
        if unusual_file_modes:
 
153
            ret = [(path, unusual_file_modes[path])
 
154
                   for path in sorted(unusual_file_modes.keys())]
 
155
            rev.properties['file-modes'] = bencode.bencode(ret)
 
156
 
 
157
    def export_unusual_file_modes(self, rev):
 
158
        try:
 
159
            return dict([(self.generate_file_id(path), mode) for (path, mode) in bencode.bdecode(rev.properties['file-modes'].encode("utf-8"))])
 
160
        except KeyError:
 
161
            return {}
 
162
 
 
163
    def _generate_git_svn_metadata(self, rev, encoding):
 
164
        try:
 
165
            return "\ngit-svn-id: %s\n" % rev.properties["git-svn-id"].encode(
 
166
                encoding)
 
167
        except KeyError:
 
168
            return ""
 
169
 
 
170
    def _generate_hg_message_tail(self, rev):
 
171
        extra = {}
 
172
        renames = []
 
173
        branch = 'default'
 
174
        for name in rev.properties:
 
175
            if name == 'hg:extra:branch':
 
176
                branch = rev.properties['hg:extra:branch']
 
177
            elif name.startswith('hg:extra'):
 
178
                extra[name[len('hg:extra:'):]] = base64.b64decode(
 
179
                    rev.properties[name])
 
180
            elif name == 'hg:renames':
 
181
                renames = bencode.bdecode(base64.b64decode(
 
182
                    rev.properties['hg:renames']))
 
183
            # TODO: Export other properties as 'bzr:' extras?
 
184
        ret = format_hg_metadata(renames, branch, extra)
 
185
        assert isinstance(ret, str)
 
186
        return ret
 
187
 
 
188
    def _extract_git_svn_metadata(self, rev, message):
 
189
        lines = message.split("\n")
 
190
        if not (lines[-1] == "" and lines[-2].startswith("git-svn-id:")):
 
191
            return message
 
192
        git_svn_id = lines[-2].split(": ", 1)[1]
 
193
        rev.properties['git-svn-id'] = git_svn_id
 
194
        (url, rev, uuid) = parse_git_svn_id(git_svn_id)
 
195
        # FIXME: Convert this to converted-from property somehow..
 
196
        ret = "\n".join(lines[:-2])
 
197
        assert isinstance(ret, str)
 
198
        return ret
 
199
 
 
200
    def _extract_hg_metadata(self, rev, message):
 
201
        (message, renames, branch, extra) = extract_hg_metadata(message)
 
202
        if branch is not None:
 
203
            rev.properties['hg:extra:branch'] = branch
 
204
        for name, value in extra.iteritems():
 
205
            rev.properties['hg:extra:' + name] = base64.b64encode(value)
 
206
        if renames:
 
207
            rev.properties['hg:renames'] = base64.b64encode(bencode.bencode(
 
208
                [(new, old) for (old, new) in renames.iteritems()]))
 
209
        return message
 
210
 
 
211
    def _decode_commit_message(self, rev, message, encoding):
 
212
        return message.decode(encoding)
 
213
 
 
214
    def _encode_commit_message(self, rev, message, encoding):
 
215
        return message.encode(encoding)
 
216
 
 
217
    def export_commit(self, rev, tree_sha, parent_lookup):
 
218
        """Turn a Bazaar revision in to a Git commit
 
219
 
 
220
        :param tree_sha: Tree sha for the commit
 
221
        :param parent_lookup: Function for looking up the GIT sha equiv of a
 
222
            bzr revision
 
223
        :return dulwich.objects.Commit represent the revision:
 
224
        """
 
225
        from dulwich.objects import Commit
 
226
        commit = Commit()
 
227
        commit.tree = tree_sha
 
228
        for p in rev.parent_ids:
 
229
            try:
 
230
                git_p = parent_lookup(p)
 
231
            except KeyError:
 
232
                git_p = None
 
233
            if git_p is not None:
 
234
                assert len(git_p) == 40, "unexpected length for %r" % git_p
 
235
                commit.parents.append(git_p)
 
236
        try:
 
237
            encoding = rev.properties['git-explicit-encoding']
 
238
        except KeyError:
 
239
            encoding = rev.properties.get('git-implicit-encoding', 'utf-8')
 
240
        commit.encoding = rev.properties.get('git-explicit-encoding')
 
241
        commit.committer = fix_person_identifier(rev.committer.encode(
 
242
            encoding))
 
243
        commit.author = fix_person_identifier(
 
244
            rev.get_apparent_authors()[0].encode(encoding))
 
245
        commit.commit_time = long(rev.timestamp)
 
246
        if 'author-timestamp' in rev.properties:
 
247
            commit.author_time = long(rev.properties['author-timestamp'])
 
248
        else:
 
249
            commit.author_time = commit.commit_time
 
250
        commit._commit_timezone_neg_utc = "commit-timezone-neg-utc" in rev.properties
 
251
        commit.commit_timezone = rev.timezone
 
252
        commit._author_timezone_neg_utc = "author-timezone-neg-utc" in rev.properties
 
253
        if 'author-timezone' in rev.properties:
 
254
            commit.author_timezone = int(rev.properties['author-timezone'])
 
255
        else:
 
256
            commit.author_timezone = commit.commit_timezone
 
257
        commit.message = self._encode_commit_message(rev, rev.message, 
 
258
            encoding)
 
259
        return commit
61
260
 
62
261
    def import_commit(self, commit):
63
262
        """Convert a git commit to a bzr revision.
66
265
        """
67
266
        if commit is None:
68
267
            raise AssertionError("Commit object can't be None")
69
 
        rev = ForeignRevision(commit.id, self, self.revision_id_foreign_to_bzr(commit.id))
 
268
        rev = ForeignRevision(commit.id, self,
 
269
                self.revision_id_foreign_to_bzr(commit.id))
70
270
        rev.parent_ids = tuple([self.revision_id_foreign_to_bzr(p) for p in commit.parents])
71
 
        rev.message = commit.message.decode("utf-8", "replace")
72
 
        rev.committer = str(commit.committer).decode("utf-8", "replace")
73
 
        if commit.committer != commit.author:
74
 
            rev.properties['author'] = str(commit.author).decode("utf-8", "replace")
 
271
        def decode_using_encoding(rev, commit, encoding):
 
272
            rev.committer = str(commit.committer).decode(encoding)
 
273
            if commit.committer != commit.author:
 
274
                rev.properties['author'] = str(commit.author).decode(encoding)
 
275
            rev.message = self._decode_commit_message(rev, commit.message, 
 
276
                encoding)
 
277
        if commit.encoding is not None:
 
278
            rev.properties['git-explicit-encoding'] = commit.encoding
 
279
            decode_using_encoding(rev, commit, commit.encoding)
 
280
        else:
 
281
            for encoding in ('utf-8', 'latin1'):
 
282
                try:
 
283
                    decode_using_encoding(rev, commit, encoding)
 
284
                except UnicodeDecodeError:
 
285
                    pass
 
286
                else:
 
287
                    if encoding != 'utf-8':
 
288
                        rev.properties['git-implicit-encoding'] = encoding
 
289
                    break
 
290
        if commit.commit_time != commit.author_time:
 
291
            rev.properties['author-timestamp'] = str(commit.author_time)
 
292
        if commit.commit_timezone != commit.author_timezone:
 
293
            rev.properties['author-timezone'] = "%d" % commit.author_timezone
 
294
        if commit._author_timezone_neg_utc:
 
295
            rev.properties['author-timezone-neg-utc'] = ""
 
296
        if commit._commit_timezone_neg_utc:
 
297
            rev.properties['commit-timezone-neg-utc'] = ""
75
298
        rev.timestamp = commit.commit_time
76
 
        rev.timezone = 0
 
299
        rev.timezone = commit.commit_timezone
77
300
        return rev
78
301
 
79
302
 
81
304
    revid_prefix = 'git-v1'
82
305
    experimental = False
83
306
 
 
307
    def __str__(self):
 
308
        return self.revid_prefix
 
309
 
84
310
 
85
311
class BzrGitMappingExperimental(BzrGitMappingv1):
86
312
    revid_prefix = 'git-experimental'
87
313
    experimental = True
88
314
 
 
315
    def _decode_commit_message(self, rev, message, encoding):
 
316
        message = self._extract_hg_metadata(rev, message)
 
317
        message = self._extract_git_svn_metadata(rev, message)
 
318
        return message.decode(encoding)
 
319
 
 
320
    def _encode_commit_message(self, rev, message, encoding):
 
321
        ret = message.encode(encoding)
 
322
        ret += self._generate_hg_message_tail(rev)
 
323
        ret += self._generate_git_svn_metadata(rev, encoding)
 
324
        return ret
 
325
 
 
326
    def import_commit(self, commit):
 
327
        rev = super(BzrGitMappingExperimental, self).import_commit(commit)
 
328
        rev.properties['converted_revision'] = "git %s\n" % commit.id
 
329
        return rev
 
330
 
89
331
 
90
332
class GitMappingRegistry(VcsMappingRegistry):
 
333
    """Registry with available git mappings."""
91
334
 
92
335
    def revision_id_bzr_to_foreign(self, bzr_revid):
 
336
        if bzr_revid == NULL_REVISION:
 
337
            from dulwich.protocol import ZERO_SHA
 
338
            return ZERO_SHA, None
93
339
        if not bzr_revid.startswith("git-"):
94
340
            raise errors.InvalidRevisionId(bzr_revid, None)
95
341
        (mapping_version, git_sha) = bzr_revid.split(":", 1)
101
347
 
102
348
mapping_registry = GitMappingRegistry()
103
349
mapping_registry.register_lazy('git-v1', "bzrlib.plugins.git.mapping",
104
 
                                   "BzrGitMappingv1")
105
 
mapping_registry.register_lazy('git-experimental', "bzrlib.plugins.git.mapping",
106
 
                                   "BzrGitMappingExperimental")
 
350
    "BzrGitMappingv1")
 
351
mapping_registry.register_lazy('git-experimental',
 
352
    "bzrlib.plugins.git.mapping", "BzrGitMappingExperimental")
 
353
mapping_registry.set_default('git-v1')
107
354
 
108
355
 
109
356
class ForeignGit(ForeignVcs):
110
 
    """Foreign Git."""
 
357
    """The Git Stupid Content Tracker"""
 
358
 
 
359
    @property
 
360
    def branch_format(self):
 
361
        from bzrlib.plugins.git.branch import GitBranchFormat
 
362
        return GitBranchFormat()
 
363
 
 
364
    @property
 
365
    def repository_format(self):
 
366
        from bzrlib.plugins.git.repository import GitRepositoryFormat
 
367
        return GitRepositoryFormat()
111
368
 
112
369
    def __init__(self):
113
370
        super(ForeignGit, self).__init__(mapping_registry)
 
371
        self.abbreviation = "git"
 
372
 
 
373
    @classmethod
 
374
    def serialize_foreign_revid(self, foreign_revid):
 
375
        return foreign_revid
114
376
 
115
377
    @classmethod
116
378
    def show_foreign_revid(cls, foreign_revid):
118
380
 
119
381
 
120
382
foreign_git = ForeignGit()
121
 
default_mapping = BzrGitMappingv1()
122
 
 
123
 
 
124
 
def inventory_to_tree_and_blobs(repo, mapping, revision_id):
125
 
    from dulwich.objects import Tree, Blob
126
 
    from bzrlib.inventory import InventoryDirectory, InventoryFile
127
 
    import stat
128
 
    stack = []
129
 
    cur = ""
 
383
default_mapping = mapping_registry.get_default()()
 
384
 
 
385
 
 
386
def symlink_to_blob(entry):
 
387
    from dulwich.objects import Blob
 
388
    blob = Blob()
 
389
    symlink_target = entry.symlink_target
 
390
    if type(symlink_target) == unicode:
 
391
        symlink_target = symlink_target.encode('utf-8')
 
392
    blob.data = symlink_target
 
393
    return blob
 
394
 
 
395
 
 
396
def mode_is_executable(mode):
 
397
    """Check if mode should be considered executable."""
 
398
    return bool(mode & 0111)
 
399
 
 
400
 
 
401
def mode_kind(mode):
 
402
    """Determine the Bazaar inventory kind based on Unix file mode."""
 
403
    entry_kind = (mode & 0700000) / 0100000
 
404
    if entry_kind == 0:
 
405
        return 'directory'
 
406
    elif entry_kind == 1:
 
407
        file_kind = (mode & 070000) / 010000
 
408
        if file_kind == 0:
 
409
            return 'file'
 
410
        elif file_kind == 2:
 
411
            return 'symlink'
 
412
        elif file_kind == 6:
 
413
            return 'tree-reference'
 
414
        else:
 
415
            raise AssertionError(
 
416
                "Unknown file kind %d, perms=%o." % (file_kind, mode,))
 
417
    else:
 
418
        raise AssertionError(
 
419
            "Unknown kind, perms=%r." % (mode,))
 
420
 
 
421
 
 
422
def object_mode(kind, executable):
 
423
    if kind == 'directory':
 
424
        return stat.S_IFDIR
 
425
    elif kind == 'symlink':
 
426
        mode = stat.S_IFLNK
 
427
        if executable:
 
428
            mode |= 0111
 
429
        return mode
 
430
    elif kind == 'file':
 
431
        mode = stat.S_IFREG | 0644
 
432
        if executable:
 
433
            mode |= 0111
 
434
        return mode
 
435
    elif kind == 'tree-reference':
 
436
        from dulwich.objects import S_IFGITLINK
 
437
        return S_IFGITLINK
 
438
    else:
 
439
        raise AssertionError
 
440
 
 
441
 
 
442
def entry_mode(entry):
 
443
    """Determine the git file mode for an inventory entry."""
 
444
    return object_mode(entry.kind, entry.executable)
 
445
 
 
446
 
 
447
def directory_to_tree(entry, lookup_ie_sha1, unusual_modes):
 
448
    from dulwich.objects import Tree
130
449
    tree = Tree()
131
 
 
132
 
    inv = repo.get_inventory(revision_id)
133
 
 
134
 
    # stack contains the set of trees that we haven't 
135
 
    # finished constructing
136
 
 
137
 
    for path, entry in inv.iter_entries():
138
 
        while stack and not path.startswith(cur):
139
 
            tree.serialize()
140
 
            sha = tree.sha().hexdigest()
141
 
            yield sha, tree, cur
142
 
            t = (stat.S_IFDIR, urlutils.basename(cur).encode('UTF-8'), sha)
143
 
            cur, tree = stack.pop()
144
 
            tree.add(*t)
145
 
 
146
 
        if type(entry) == InventoryDirectory:
147
 
            stack.append((cur, tree))
148
 
            cur = path
149
 
            tree = Tree()
150
 
 
151
 
        if type(entry) == InventoryFile:
152
 
            #FIXME: We can make potentially make this Lazy to avoid shaing lots of stuff
153
 
            # and having all these objects in memory at once
154
 
            blob = Blob()
155
 
            _, blob._text = repo.iter_files_bytes([(entry.file_id, entry.revision, path)]).next()
156
 
            sha = blob.sha().hexdigest()
157
 
            yield sha, blob, path
158
 
 
159
 
            name = urlutils.basename(path).encode("utf-8")
160
 
            mode = stat.S_IFREG | 0644
161
 
            if entry.executable:
162
 
                mode |= 0111
163
 
            tree.add(mode, name, sha)
164
 
 
165
 
    while len(stack) > 1:
166
 
        tree.serialize()
167
 
        sha = tree.sha().hexdigest()
168
 
        yield sha, tree, cur
169
 
        t = (stat.S_IFDIR, urlutils.basename(cur).encode('UTF-8'), sha)
170
 
        cur, tree = stack.pop()
171
 
        tree.add(*t)
172
 
 
173
 
    tree.serialize()
174
 
    yield tree.sha().hexdigest(), tree, cur
175
 
 
176
 
 
177
 
def revision_to_commit(rev, tree_sha, parent_lookup):
178
 
    """Turn a Bazaar revision in to a Git commit
179
 
 
180
 
    :param tree_sha: Tree sha for the commit
181
 
    :param parent_lookup: Function for looking up the GIT sha equiv of a bzr revision
182
 
    :return dulwich.objects.Commit represent the revision:
183
 
    """
184
 
    from dulwich.objects import Commit
185
 
    commit = Commit()
186
 
    commit._tree = tree_sha
187
 
    for p in rev.parent_ids:
188
 
        git_p = parent_lookup(p)
189
 
        if git_p is not None:
190
 
            commit._parents.append(git_p)
191
 
    commit._message = rev.message.encode("utf-8")
192
 
    commit._committer = rev.committer.encode("utf-8")
193
 
    commit._author = rev.get_apparent_author().encode("utf-8")
194
 
    commit._commit_time = long(rev.timestamp)
195
 
    commit.serialize()
196
 
    return commit
 
450
    for name, value in entry.children.iteritems():
 
451
        ie = entry.children[name]
 
452
        try:
 
453
            mode = unusual_modes[ie.file_id]
 
454
        except KeyError:
 
455
            mode = entry_mode(ie)
 
456
        hexsha = lookup_ie_sha1(ie)
 
457
        if hexsha is not None:
 
458
            tree.add(mode, name.encode("utf-8"), hexsha)
 
459
    if entry.parent_id is not None and len(tree) == 0:
 
460
        # Only the root can be an empty tree
 
461
        return None
 
462
    return tree
 
463
 
 
464
 
 
465
def extract_unusual_modes(rev):
 
466
    try:
 
467
        foreign_revid, mapping = mapping_registry.parse_revision_id(
 
468
            rev.revision_id)
 
469
    except errors.InvalidRevisionId:
 
470
        return {}
 
471
    else:
 
472
        return mapping.export_unusual_file_modes(rev)
 
473
 
 
474
 
 
475
def parse_git_svn_id(text):
 
476
    (head, uuid) = text.rsplit(" ", 1)
 
477
    (full_url, rev) = head.rsplit("@", 1)
 
478
    return (full_url, int(rev), uuid)