/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 breezy/foreign.py

  • Committer: Jelmer Vernooij
  • Date: 2018-11-23 01:35:56 UTC
  • mto: (7211.10.3 git-empty-dirs)
  • mto: This revision was merged to the branch mainline in revision 7215.
  • Revision ID: jelmer@jelmer.uk-20181123013556-mu7ct9ovl7fozjc2
Update comment about ssl.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/foreign.py
 
1
# Copyright (C) 2008-2012 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""Foreign branch utilities."""
 
18
 
 
19
from __future__ import absolute_import
 
20
 
 
21
 
 
22
from .branch import (
 
23
    Branch,
 
24
    )
 
25
from .repository import Repository
 
26
from .revision import Revision
 
27
from .lazy_import import lazy_import
 
28
lazy_import(globals(), """
 
29
from breezy import (
 
30
    errors,
 
31
    registry,
 
32
    )
 
33
""")
 
34
 
 
35
 
 
36
class VcsMapping(object):
 
37
    """Describes the mapping between the semantics of Bazaar and a foreign VCS.
 
38
 
 
39
    """
 
40
    # Whether this is an experimental mapping that is still open to changes.
 
41
    experimental = False
 
42
 
 
43
    # Whether this mapping supports exporting and importing all bzr semantics.
 
44
    roundtripping = False
 
45
 
 
46
    # Prefix used when importing revisions native to the foreign VCS (as
 
47
    # opposed to roundtripping bzr-native revisions) using this mapping.
 
48
    revid_prefix = None
 
49
 
 
50
    def __init__(self, vcs):
 
51
        """Create a new VcsMapping.
 
52
 
 
53
        :param vcs: VCS that this mapping maps to Bazaar
 
54
        """
 
55
        self.vcs = vcs
 
56
 
 
57
    def revision_id_bzr_to_foreign(self, bzr_revid):
 
58
        """Parse a bzr revision id and convert it to a foreign revid.
 
59
 
 
60
        :param bzr_revid: The bzr revision id (a string).
 
61
        :return: A foreign revision id, can be any sort of object.
 
62
        """
 
63
        raise NotImplementedError(self.revision_id_bzr_to_foreign)
 
64
 
 
65
    def revision_id_foreign_to_bzr(self, foreign_revid):
 
66
        """Parse a foreign revision id and convert it to a bzr revid.
 
67
 
 
68
        :param foreign_revid: Foreign revision id, can be any sort of object.
 
69
        :return: A bzr revision id.
 
70
        """
 
71
        raise NotImplementedError(self.revision_id_foreign_to_bzr)
 
72
 
 
73
 
 
74
class VcsMappingRegistry(registry.Registry):
 
75
    """Registry for Bazaar<->foreign VCS mappings.
 
76
 
 
77
    There should be one instance of this registry for every foreign VCS.
 
78
    """
 
79
 
 
80
    def register(self, key, factory, help):
 
81
        """Register a mapping between Bazaar and foreign VCS semantics.
 
82
 
 
83
        The factory must be a callable that takes one parameter: the key.
 
84
        It must produce an instance of VcsMapping when called.
 
85
        """
 
86
        if b":" in key:
 
87
            raise ValueError("mapping name can not contain colon (:)")
 
88
        registry.Registry.register(self, key, factory, help)
 
89
 
 
90
    def set_default(self, key):
 
91
        """Set the 'default' key to be a clone of the supplied key.
 
92
 
 
93
        This method must be called once and only once.
 
94
        """
 
95
        self._set_default_key(key)
 
96
 
 
97
    def get_default(self):
 
98
        """Convenience function for obtaining the default mapping to use."""
 
99
        return self.get(self._get_default_key())
 
100
 
 
101
    def revision_id_bzr_to_foreign(self, revid):
 
102
        """Convert a bzr revision id to a foreign revid."""
 
103
        raise NotImplementedError(self.revision_id_bzr_to_foreign)
 
104
 
 
105
 
 
106
class ForeignRevision(Revision):
 
107
    """A Revision from a Foreign repository. Remembers
 
108
    information about foreign revision id and mapping.
 
109
 
 
110
    """
 
111
 
 
112
    def __init__(self, foreign_revid, mapping, *args, **kwargs):
 
113
        if "inventory_sha1" not in kwargs:
 
114
            kwargs["inventory_sha1"] = b""
 
115
        super(ForeignRevision, self).__init__(*args, **kwargs)
 
116
        self.foreign_revid = foreign_revid
 
117
        self.mapping = mapping
 
118
 
 
119
 
 
120
class ForeignVcs(object):
 
121
    """A foreign version control system."""
 
122
 
 
123
    branch_format = None
 
124
 
 
125
    repository_format = None
 
126
 
 
127
    def __init__(self, mapping_registry, abbreviation=None):
 
128
        """Create a new foreign vcs instance.
 
129
 
 
130
        :param mapping_registry: Registry with mappings for this VCS.
 
131
        :param abbreviation: Optional abbreviation ('bzr', 'svn', 'git', etc)
 
132
        """
 
133
        self.abbreviation = abbreviation
 
134
        self.mapping_registry = mapping_registry
 
135
 
 
136
    def show_foreign_revid(self, foreign_revid):
 
137
        """Prepare a foreign revision id for formatting using bzr log.
 
138
 
 
139
        :param foreign_revid: Foreign revision id.
 
140
        :return: Dictionary mapping string keys to string values.
 
141
        """
 
142
        return {}
 
143
 
 
144
    def serialize_foreign_revid(self, foreign_revid):
 
145
        """Serialize a foreign revision id for this VCS.
 
146
 
 
147
        :param foreign_revid: Foreign revision id
 
148
        :return: Bytestring with serialized revid, will not contain any
 
149
            newlines.
 
150
        """
 
151
        raise NotImplementedError(self.serialize_foreign_revid)
 
152
 
 
153
 
 
154
class ForeignVcsRegistry(registry.Registry):
 
155
    """Registry for Foreign VCSes.
 
156
 
 
157
    There should be one entry per foreign VCS. Example entries would be
 
158
    "git", "svn", "hg", "darcs", etc.
 
159
 
 
160
    """
 
161
 
 
162
    def register(self, key, foreign_vcs, help):
 
163
        """Register a foreign VCS.
 
164
 
 
165
        :param key: Prefix of the foreign VCS in revision ids
 
166
        :param foreign_vcs: ForeignVCS instance
 
167
        :param help: Description of the foreign VCS
 
168
        """
 
169
        if ":" in key or "-" in key:
 
170
            raise ValueError("vcs name can not contain : or -")
 
171
        registry.Registry.register(self, key, foreign_vcs, help)
 
172
 
 
173
    def parse_revision_id(self, revid):
 
174
        """Parse a bzr revision and return the matching mapping and foreign
 
175
        revid.
 
176
 
 
177
        :param revid: The bzr revision id
 
178
        :return: tuple with foreign revid and vcs mapping
 
179
        """
 
180
        if b":" not in revid or b"-" not in revid:
 
181
            raise errors.InvalidRevisionId(revid, None)
 
182
        try:
 
183
            foreign_vcs = self.get(revid.split(b"-")[0].decode('ascii'))
 
184
        except KeyError:
 
185
            raise errors.InvalidRevisionId(revid, None)
 
186
        return foreign_vcs.mapping_registry.revision_id_bzr_to_foreign(revid)
 
187
 
 
188
 
 
189
foreign_vcs_registry = ForeignVcsRegistry()
 
190
 
 
191
 
 
192
class ForeignRepository(Repository):
 
193
    """A Repository that exists in a foreign version control system.
 
194
 
 
195
    The data in this repository can not be represented natively using
 
196
    Bazaars internal datastructures, but have to converted using a VcsMapping.
 
197
    """
 
198
 
 
199
    # This repository's native version control system
 
200
    vcs = None
 
201
 
 
202
    def has_foreign_revision(self, foreign_revid):
 
203
        """Check whether the specified foreign revision is present.
 
204
 
 
205
        :param foreign_revid: A foreign revision id, in the format used
 
206
                              by this Repository's VCS.
 
207
        """
 
208
        raise NotImplementedError(self.has_foreign_revision)
 
209
 
 
210
    def lookup_bzr_revision_id(self, revid):
 
211
        """Lookup a mapped or roundtripped revision by revision id.
 
212
 
 
213
        :param revid: Bazaar revision id
 
214
        :return: Tuple with foreign revision id and mapping.
 
215
        """
 
216
        raise NotImplementedError(self.lookup_revision_id)
 
217
 
 
218
    def all_revision_ids(self, mapping=None):
 
219
        """See Repository.all_revision_ids()."""
 
220
        raise NotImplementedError(self.all_revision_ids)
 
221
 
 
222
    def get_default_mapping(self):
 
223
        """Get the default mapping for this repository."""
 
224
        raise NotImplementedError(self.get_default_mapping)
 
225
 
 
226
 
 
227
class ForeignBranch(Branch):
 
228
    """Branch that exists in a foreign version control system."""
 
229
 
 
230
    def __init__(self, mapping):
 
231
        self.mapping = mapping
 
232
        super(ForeignBranch, self).__init__()