/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/plugins/fastimport/cmds.py

  • Committer: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-07-04 12:50:55 UTC
  • mfrom: (7027.2.8 git-fixes)
  • Revision ID: breezy.the.bot@gmail.com-20180704125055-8nni25pn2439p48v
Fix eol handling in knits on Python 3, port fastimport plugin to Python 3.

Merged from https://code.launchpad.net/~jelmer/brz/fastimport-fixes/+merge/348924

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/plugins/fastimport/cmds.py
 
1
# Copyright (C) 2008 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, see <http://www.gnu.org/licenses/>.
 
15
 
 
16
"""Fastimport/fastexport commands."""
 
17
 
 
18
from __future__ import absolute_import
 
19
 
 
20
from ... import controldir
 
21
from ...commands import Command
 
22
from ...option import Option, ListOption, RegistryOption
 
23
from ...sixish import (
 
24
    text_type,
 
25
    )
 
26
 
 
27
 
 
28
from . import (
 
29
    helpers,
 
30
    load_fastimport,
 
31
    )
 
32
 
 
33
 
 
34
def _run(source, processor_factory, verbose=False, user_map=None, **kwargs):
 
35
    """Create and run a processor.
 
36
 
 
37
    :param source: a filename or '-' for standard input. If the
 
38
      filename ends in .gz, it will be opened as a gzip file and
 
39
      the stream will be implicitly uncompressed
 
40
    :param processor_factory: a callable for creating a processor
 
41
    :param user_map: if not None, the file containing the user map.
 
42
    """
 
43
    from fastimport.errors import ParsingError
 
44
    from ...errors import BzrCommandError
 
45
    from fastimport import parser
 
46
    stream = _get_source_stream(source)
 
47
    user_mapper = _get_user_mapper(user_map)
 
48
    proc = processor_factory(verbose=verbose, **kwargs)
 
49
    p = parser.ImportParser(stream, verbose=verbose, user_mapper=user_mapper)
 
50
    try:
 
51
        return proc.process(p.iter_commands)
 
52
    except ParsingError as e:
 
53
        raise BzrCommandError("%d: Parse error: %s" % (e.lineno, e))
 
54
 
 
55
 
 
56
def _get_source_stream(source):
 
57
    if source == '-' or source is None:
 
58
        import sys
 
59
        stream = helpers.binary_stream(sys.stdin)
 
60
    elif source.endswith('.gz'):
 
61
        import gzip
 
62
        stream = gzip.open(source, "rb")
 
63
    else:
 
64
        stream = open(source, "rb")
 
65
    return stream
 
66
 
 
67
 
 
68
def _get_user_mapper(filename):
 
69
    from . import user_mapper
 
70
    if filename is None:
 
71
        return None
 
72
    f = open(filename)
 
73
    lines = f.readlines()
 
74
    f.close()
 
75
    return user_mapper.UserMapper(lines)
 
76
 
 
77
 
 
78
class cmd_fast_import(Command):
 
79
    """Backend for fast Bazaar data importers.
 
80
 
 
81
    This command reads a mixed command/data stream and creates
 
82
    branches in a Bazaar repository accordingly. The preferred
 
83
    recipe is::
 
84
 
 
85
      bzr fast-import project.fi project.bzr
 
86
 
 
87
    Numerous commands are provided for generating a fast-import file
 
88
    to use as input. 
 
89
    To specify standard input as the input stream, use a
 
90
    source name of '-' (instead of project.fi). If the source name
 
91
    ends in '.gz', it is assumed to be compressed in gzip format.
 
92
 
 
93
    project.bzr will be created if it doesn't exist. If it exists
 
94
    already, it should be empty or be an existing Bazaar repository
 
95
    or branch. If not specified, the current directory is assumed.
 
96
 
 
97
    fast-import will intelligently select the format to use when
 
98
    creating a repository or branch. If you are running Bazaar 1.17
 
99
    up to Bazaar 2.0, the default format for Bazaar 2.x ("2a") is used.
 
100
    Otherwise, the current default format ("pack-0.92" for Bazaar 1.x)
 
101
    is used. If you wish to specify a custom format, use the `--format`
 
102
    option.
 
103
 
 
104
     .. note::
 
105
 
 
106
        To maintain backwards compatibility, fast-import lets you
 
107
        create the target repository or standalone branch yourself.
 
108
        It is recommended though that you let fast-import create
 
109
        these for you instead.
 
110
 
 
111
    :Branch mapping rules:
 
112
 
 
113
     Git reference names are mapped to Bazaar branch names as follows:
 
114
 
 
115
     * refs/heads/foo is mapped to foo
 
116
     * refs/remotes/origin/foo is mapped to foo.remote
 
117
     * refs/tags/foo is mapped to foo.tag
 
118
     * */master is mapped to trunk, trunk.remote, etc.
 
119
     * */trunk is mapped to git-trunk, git-trunk.remote, etc.
 
120
 
 
121
    :Branch creation rules:
 
122
 
 
123
     When a shared repository is created or found at the destination,
 
124
     branches are created inside it. In the simple case of a single
 
125
     branch (refs/heads/master) inside the input file, the branch is
 
126
     project.bzr/trunk.
 
127
 
 
128
     When a standalone branch is found at the destination, the trunk
 
129
     is imported there and warnings are output about any other branches
 
130
     found in the input file.
 
131
 
 
132
     When a branch in a shared repository is found at the destination,
 
133
     that branch is made the trunk and other branches, if any, are
 
134
     created in sister directories.
 
135
 
 
136
    :Working tree updates:
 
137
 
 
138
     The working tree is generated for the trunk branch. If multiple
 
139
     branches are created, a message is output on completion explaining
 
140
     how to create the working trees for other branches.
 
141
 
 
142
    :Custom exporters:
 
143
 
 
144
     The fast-export-from-xxx commands typically call more advanced
 
145
     xxx-fast-export scripts. You are welcome to use the advanced
 
146
     scripts if you prefer.
 
147
 
 
148
     If you wish to write a custom exporter for your project, see
 
149
     http://bazaar-vcs.org/BzrFastImport for the detailed protocol
 
150
     specification. In many cases, exporters can be written quite
 
151
     quickly using whatever scripting/programming language you like.
 
152
 
 
153
    :User mapping:
 
154
 
 
155
     Some source repositories store just the user name while Bazaar
 
156
     prefers a full email address. You can adjust user-ids while
 
157
     importing by using the --user-map option. The argument is a
 
158
     text file with lines in the format::
 
159
 
 
160
       old-id = new-id
 
161
 
 
162
     Blank lines and lines beginning with # are ignored.
 
163
     If old-id has the special value '@', then users without an
 
164
     email address will get one created by using the matching new-id
 
165
     as the domain, unless a more explicit address is given for them.
 
166
     For example, given the user-map of::
 
167
 
 
168
       @ = example.com
 
169
       bill = William Jones <bill@example.com>
 
170
 
 
171
     then user-ids are mapped as follows::
 
172
 
 
173
      maria => maria <maria@example.com>
 
174
      bill => William Jones <bill@example.com>
 
175
 
 
176
     .. note::
 
177
 
 
178
        User mapping is supported by both the fast-import and
 
179
        fast-import-filter commands.
 
180
 
 
181
    :Blob tracking:
 
182
 
 
183
     As some exporters (like git-fast-export) reuse blob data across
 
184
     commits, fast-import makes two passes over the input file by
 
185
     default. In the first pass, it collects data about what blobs are
 
186
     used when, along with some other statistics (e.g. total number of
 
187
     commits). In the second pass, it generates the repository and
 
188
     branches.
 
189
 
 
190
     .. note::
 
191
 
 
192
        The initial pass isn't done if the --info option is used
 
193
        to explicitly pass in information about the input stream.
 
194
        It also isn't done if the source is standard input. In the
 
195
        latter case, memory consumption may be higher than otherwise
 
196
        because some blobs may be kept in memory longer than necessary.
 
197
 
 
198
    :Restarting an import:
 
199
 
 
200
     At checkpoints and on completion, the commit-id -> revision-id
 
201
     map is saved to a file called 'fastimport-id-map' in the control
 
202
     directory for the repository (e.g. .bzr/repository). If the import
 
203
     is interrupted or unexpectedly crashes, it can be started again
 
204
     and this file will be used to skip over already loaded revisions.
 
205
     As long as subsequent exports from the original source begin
 
206
     with exactly the same revisions, you can use this feature to
 
207
     maintain a mirror of a repository managed by a foreign tool.
 
208
     If and when Bazaar is used to manage the repository, this file
 
209
     can be safely deleted.
 
210
 
 
211
    :Examples:
 
212
 
 
213
     Import a Subversion repository into Bazaar::
 
214
 
 
215
       svn-fast-export /svn/repo/path > project.fi
 
216
       bzr fast-import project.fi project.bzr
 
217
 
 
218
     Import a CVS repository into Bazaar::
 
219
 
 
220
       cvs2git /cvs/repo/path > project.fi
 
221
       bzr fast-import project.fi project.bzr
 
222
 
 
223
     Import a Git repository into Bazaar::
 
224
 
 
225
       cd /git/repo/path
 
226
       git fast-export --all > project.fi
 
227
       bzr fast-import project.fi project.bzr
 
228
 
 
229
     Import a Mercurial repository into Bazaar::
 
230
 
 
231
       cd /hg/repo/path
 
232
       hg fast-export > project.fi
 
233
       bzr fast-import project.fi project.bzr
 
234
 
 
235
     Import a Darcs repository into Bazaar::
 
236
 
 
237
       cd /darcs/repo/path
 
238
       darcs-fast-export > project.fi
 
239
       bzr fast-import project.fi project.bzr
 
240
    """
 
241
    hidden = False
 
242
    _see_also = ['fast-export', 'fast-import-filter', 'fast-import-info']
 
243
    takes_args = ['source', 'destination?']
 
244
    takes_options = ['verbose',
 
245
                    Option('user-map', type=text_type,
 
246
                        help="Path to file containing a map of user-ids.",
 
247
                        ),
 
248
                    Option('info', type=text_type,
 
249
                        help="Path to file containing caching hints.",
 
250
                        ),
 
251
                    Option('trees',
 
252
                        help="Update all working trees, not just trunk's.",
 
253
                        ),
 
254
                    Option('count', type=int,
 
255
                        help="Import this many revisions then exit.",
 
256
                        ),
 
257
                    Option('checkpoint', type=int,
 
258
                        help="Checkpoint automatically every N revisions."
 
259
                             " The default is 10000.",
 
260
                        ),
 
261
                    Option('autopack', type=int,
 
262
                        help="Pack every N checkpoints. The default is 4.",
 
263
                        ),
 
264
                    Option('inv-cache', type=int,
 
265
                        help="Number of inventories to cache.",
 
266
                        ),
 
267
                    RegistryOption.from_kwargs('mode',
 
268
                        'The import algorithm to use.',
 
269
                        title='Import Algorithm',
 
270
                        default='Use the preferred algorithm (inventory deltas).',
 
271
                        experimental="Enable experimental features.",
 
272
                        value_switches=True, enum_switch=False,
 
273
                        ),
 
274
                    Option('import-marks', type=text_type,
 
275
                        help="Import marks from file."
 
276
                        ),
 
277
                    Option('export-marks', type=text_type,
 
278
                        help="Export marks to file."
 
279
                        ),
 
280
                    RegistryOption('format',
 
281
                            help='Specify a format for the created repository. See'
 
282
                                 ' "bzr help formats" for details.',
 
283
                            lazy_registry=('breezy.controldir', 'format_registry'),
 
284
                            converter=lambda name: controldir.format_registry.make_controldir(name),
 
285
                            value_switches=False, title='Repository format'),
 
286
                     ]
 
287
    def run(self, source, destination='.', verbose=False, info=None,
 
288
        trees=False, count=-1, checkpoint=10000, autopack=4, inv_cache=-1,
 
289
        mode=None, import_marks=None, export_marks=None, format=None,
 
290
        user_map=None):
 
291
        load_fastimport()
 
292
        from .processors import generic_processor
 
293
        from .helpers import (
 
294
            open_destination_directory,
 
295
            )
 
296
        control = open_destination_directory(destination, format=format)
 
297
 
 
298
        # If an information file was given and the source isn't stdin,
 
299
        # generate the information by reading the source file as a first pass
 
300
        if info is None and source != '-':
 
301
            info = self._generate_info(source)
 
302
 
 
303
        # Do the work
 
304
        if mode is None:
 
305
            mode = 'default'
 
306
        params = {
 
307
            'info': info,
 
308
            'trees': trees,
 
309
            'count': count,
 
310
            'checkpoint': checkpoint,
 
311
            'autopack': autopack,
 
312
            'inv-cache': inv_cache,
 
313
            'mode': mode,
 
314
            'import-marks': import_marks,
 
315
            'export-marks': export_marks,
 
316
            }
 
317
        return _run(source, generic_processor.GenericProcessor,
 
318
                bzrdir=control, params=params, verbose=verbose,
 
319
                user_map=user_map)
 
320
 
 
321
    def _generate_info(self, source):
 
322
        from ...sixish import StringIO
 
323
        from fastimport import parser
 
324
        from fastimport.errors import ParsingError
 
325
        from ...errors import BzrCommandError
 
326
        from fastimport.processors import info_processor
 
327
        stream = _get_source_stream(source)
 
328
        output = StringIO()
 
329
        try:
 
330
            proc = info_processor.InfoProcessor(verbose=True, outf=output)
 
331
            p = parser.ImportParser(stream)
 
332
            try:
 
333
                return_code = proc.process(p.iter_commands)
 
334
            except ParsingError as e:
 
335
                raise BzrCommandError("%d: Parse error: %s" % (e.lineno, e))
 
336
            lines = output.getvalue().splitlines()
 
337
        finally:
 
338
            output.close()
 
339
            stream.seek(0)
 
340
        return lines
 
341
 
 
342
 
 
343
class cmd_fast_export(Command):
 
344
    """Generate a fast-import stream from a Bazaar branch.
 
345
 
 
346
    This program generates a stream from a Bazaar branch in fast-import
 
347
    format used by tools such as bzr fast-import, git-fast-import and
 
348
    hg-fast-import.
 
349
 
 
350
    It takes two optional arguments: the source bzr branch to export and
 
351
    the destination to write the file to write the fastimport stream to.
 
352
 
 
353
    If no source is specified, it will search for a branch in the
 
354
    current directory.
 
355
 
 
356
    If no destination is given or the destination is '-', standard output
 
357
    is used. Otherwise, the destination is the name of a file. If the
 
358
    destination ends in '.gz', the output will be compressed into gzip
 
359
    format.
 
360
 
 
361
    :Round-tripping:
 
362
 
 
363
     Recent versions of the fast-import specification support features
 
364
     that allow effective round-tripping most of the metadata in Bazaar
 
365
     branches. As such, fast-exporting a branch and fast-importing the data
 
366
     produced will create a new repository with roughly equivalent history, i.e.
 
367
     "bzr log -v -p --include-merges --forward" on the old branch and
 
368
     new branch should produce similar, if not identical, results.
 
369
 
 
370
     .. note::
 
371
 
 
372
        Be aware that the new repository may appear to have similar history
 
373
        but internally it is quite different with new revision-ids and
 
374
        file-ids assigned. As a consequence, the ability to easily merge
 
375
        with branches based on the old repository is lost. Depending on your
 
376
        reasons for producing a new repository, this may or may not be an
 
377
        issue.
 
378
 
 
379
    :Interoperability:
 
380
 
 
381
     fast-export can use the following "extended features" to
 
382
     produce a richer data stream:
 
383
 
 
384
     * *multiple-authors* - if a commit has multiple authors (as commonly
 
385
       occurs in pair-programming), all authors will be included in the
 
386
       output, not just the first author
 
387
 
 
388
     * *commit-properties* - custom metadata per commit that Bazaar stores
 
389
       in revision properties (e.g. branch-nick and bugs fixed by this
 
390
       change) will be included in the output.
 
391
 
 
392
     * *empty-directories* - directories, even the empty ones, will be
 
393
       included in the output.
 
394
 
 
395
     To disable these features and produce output acceptable to git 1.6,
 
396
     use the --plain option. To enable these features, use --no-plain.
 
397
     Currently, --plain is the default but that will change in the near
 
398
     future once the feature names and definitions are formally agreed
 
399
     to by the broader fast-import developer community.
 
400
 
 
401
     Git has stricter naming rules for tags and fast-export --plain
 
402
     will skip tags which can't be imported into git. To replace characters
 
403
     unsupported in git with an underscore instead, specify
 
404
     --rewrite-tag-names.
 
405
 
 
406
    :History truncation:
 
407
 
 
408
     It is sometimes convenient to simply truncate the revision history at a
 
409
     certain point.  The --baseline option, to be used in conjunction with -r,
 
410
     emits a baseline commit containing the state of the entire source tree at
 
411
     the first requested revision.  This allows a user to produce a tree
 
412
     identical to the original without munging multiple exports.
 
413
 
 
414
    :Examples:
 
415
 
 
416
     To produce data destined for import into Bazaar::
 
417
 
 
418
       bzr fast-export --no-plain my-bzr-branch my.fi.gz
 
419
 
 
420
     To produce data destined for Git 1.6::
 
421
 
 
422
       bzr fast-export --plain my-bzr-branch my.fi
 
423
 
 
424
     To import several unmerged but related branches into the same repository,
 
425
     use the --{export,import}-marks options, and specify a name for the git
 
426
     branch like this::
 
427
 
 
428
       bzr fast-export --export-marks=marks.bzr project.dev |
 
429
              GIT_DIR=project/.git git-fast-import --export-marks=marks.git
 
430
 
 
431
       bzr fast-export --import-marks=marks.bzr -b other project.other |
 
432
              GIT_DIR=project/.git git-fast-import --import-marks=marks.git
 
433
 
 
434
     If you get a "Missing space after source" error from git-fast-import,
 
435
     see the top of the commands.py module for a work-around.
 
436
 
 
437
     Since bzr uses per-branch tags and git/hg use per-repo tags, the
 
438
     way bzr fast-export presently emits tags (unconditional reset &
 
439
     new ref) may result in clashes when several different branches
 
440
     are imported into single git/hg repo.  If this occurs, use the
 
441
     bzr fast-export option --no-tags during the export of one or more
 
442
     branches to avoid the issue.
 
443
    """
 
444
    hidden = False
 
445
    _see_also = ['fast-import', 'fast-import-filter']
 
446
    takes_args = ['source?', 'destination?']
 
447
    takes_options = ['verbose', 'revision',
 
448
                    Option('git-branch', short_name='b', type=text_type,
 
449
                        argname='FILE',
 
450
                        help='Name of the git branch to create (default=master).'
 
451
                        ),
 
452
                    Option('checkpoint', type=int, argname='N',
 
453
                        help="Checkpoint every N revisions (default=10000)."
 
454
                        ),
 
455
                    Option('marks', type=text_type, argname='FILE',
 
456
                        help="Import marks from and export marks to file."
 
457
                        ),
 
458
                    Option('import-marks', type=text_type, argname='FILE',
 
459
                        help="Import marks from file."
 
460
                        ),
 
461
                    Option('export-marks', type=text_type, argname='FILE',
 
462
                        help="Export marks to file."
 
463
                        ),
 
464
                    Option('plain',
 
465
                        help="Exclude metadata to maximise interoperability."
 
466
                        ),
 
467
                    Option('rewrite-tag-names',
 
468
                        help="Replace characters invalid in git with '_'"
 
469
                             " (plain mode only).",
 
470
                        ),
 
471
                    Option('baseline',
 
472
                        help="Export an 'absolute' baseline commit prior to"
 
473
                             "the first relative commit",
 
474
                        ),
 
475
                    Option('no-tags',
 
476
                        help="Don't export tags"
 
477
                        ),
 
478
                     ]
 
479
    encoding_type = 'exact'
 
480
    def run(self, source=None, destination=None, verbose=False,
 
481
        git_branch="master", checkpoint=10000, marks=None,
 
482
        import_marks=None, export_marks=None, revision=None,
 
483
        plain=True, rewrite_tag_names=False, no_tags=False, baseline=False):
 
484
        load_fastimport()
 
485
        from ...branch import Branch
 
486
        from . import exporter
 
487
 
 
488
        if marks:
 
489
            import_marks = export_marks = marks
 
490
 
 
491
        # Open the source
 
492
        if source is None:
 
493
            source = "."
 
494
        branch = Branch.open_containing(source)[0]
 
495
        outf = exporter._get_output_stream(destination)
 
496
        exporter = exporter.BzrFastExporter(branch,
 
497
            outf=outf, ref=b"refs/heads/%s" % git_branch.encode('utf-8'), checkpoint=checkpoint,
 
498
            import_marks_file=import_marks, export_marks_file=export_marks,
 
499
            revision=revision, verbose=verbose, plain_format=plain,
 
500
            rewrite_tags=rewrite_tag_names, no_tags=no_tags, baseline=baseline)
 
501
        return exporter.run()