← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to baz_import.py

  • Committer: Aaron Bentley
  • Date: 2006-03-24 19:51:54 UTC
  • Revision ID: abentley@panoramicfeedback.com-20060324195154-e183244265faeb50
Handled more hrefs

Show diffs side-by-side

added added

removed removed

Lines of Context:
baz_import.py
1
 
# Copyright (C) 2005 by Aaron Bentley
 
1
# Copyright (C) 2005, 2006 by Aaron Bentley
2
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
from bzrlib import Branch
 
16
 
 
17
import errno
 
18
 
 
19
from bzrlib.bzrdir import BzrDir
 
20
import bzrlib.bzrdir as bzrdir
 
21
from bzrlib.errors import (BzrError,
 
22
                           NotBranchError,
 
23
                           NoWorkingTree,
 
24
                           BzrCommandError, 
 
25
                           NoSuchRevision,
 
26
                           NoRepositoryPresent,
 
27
                          )
 
28
from bzrlib.branch import Branch
 
29
from bzrlib.commit import Commit, NullCommitReporter
17
30
from bzrlib.commands import Command
 
31
from bzrlib.option import _global_option, Option
 
32
from bzrlib.merge import merge_inner
 
33
from bzrlib.revision import NULL_REVISION
 
34
from bzrlib.tree import EmptyTree
 
35
import bzrlib.ui
 
36
from bzrlib.workingtree import WorkingTree
 
37
from errors import NoPyBaz
18
38
try:
19
39
    import pybaz
20
40
    import pybaz.errors
 
41
    from pybaz import NameParser as NameParser
 
42
    from pybaz.backends.baz import null_cmd
21
43
except ImportError:
22
 
    print "This command requires PyBaz.  Please ensure that it is installed."
23
 
    import sys
24
 
    sys.exit(1)
25
 
from pybaz.backends.baz import null_cmd
 
44
    raise NoPyBaz
 
45
from fai import iter_new_merges, direct_merges
26
46
import tempfile
27
47
import os
28
48
import os.path
29
49
import shutil
30
50
import bzrlib
31
 
from bzrlib.errors import BzrError
32
51
import bzrlib.trace
33
52
import bzrlib.merge
 
53
import bzrlib.inventory
 
54
import bzrlib.osutils
34
55
import sys
35
56
import email.Utils
36
57
from progress import *
37
58
 
 
59
class ImportCommitReporter(NullCommitReporter):
 
60
    def __init__(self, pb):
 
61
        self.pb = pb
 
62
 
 
63
    def escaped(self, escape_count, message):
 
64
        self.pb.clear()
 
65
        bzrlib.trace.warning("replaced %d control characters in message" %
 
66
                             escape_count)
 
67
 
38
68
def add_id(files, id=None):
39
69
    """Adds an explicit id to a list of files.
40
70
 
49
79
    args.extend(files)
50
80
    return null_cmd(args)
51
81
 
 
82
saved_dir = None
 
83
 
 
84
def make_archive(name, location):
 
85
    pb_location = pybaz.ArchiveLocation(location)
 
86
    pb_location.create_master(pybaz.Archive(name), 
 
87
                              pybaz.ArchiveLocationParams())
 
88
 
52
89
def test_environ():
53
90
    """
54
91
    >>> q = test_environ()
60
97
    >>> os.path.exists(q)
61
98
    False
62
99
    """
 
100
    global saved_dir
 
101
    saved_dir = os.getcwdu()
63
102
    tdir = tempfile.mkdtemp(prefix="testdir-")
64
103
    os.environ["HOME"] = os.path.join(tdir, "home")
65
104
    os.mkdir(os.environ["HOME"])
66
105
    arch_dir = os.path.join(tdir, "archive_dir")
67
 
    pybaz.make_archive("test@example.com", arch_dir)
 
106
    make_archive("test@example.com", arch_dir)
68
107
    work_dir = os.path.join(tdir, "work_dir")
69
108
    os.mkdir(work_dir)
70
109
    os.chdir(work_dir)
103
142
    add_id([path], id)
104
143
 
105
144
def teardown_environ(tdir):
106
 
    os.chdir("/")
 
145
    os.chdir(saved_dir)
107
146
    shutil.rmtree(tdir)
108
147
 
109
148
def timport(tree, summary):
195
234
    """
196
235
    try:
197
236
        revision = version.iter_revisions(reverse=True).next()
 
237
    except StopIteration:
 
238
        return ()
198
239
    except:
 
240
        print version
199
241
        if not version.exists():
200
242
            raise NoSuchVersion(version)
201
243
        else:
205
247
    return ancestors
206
248
 
207
249
def get_last_revision(branch):
208
 
    last_patch = branch.last_patch()
 
250
    last_patch = branch.last_revision()
209
251
    try:
210
252
        return arch_revision(last_patch)
211
253
    except NotArchRevision:
212
254
        raise UserError(
213
255
            "Directory \"%s\" already exists, and the last revision is not"
214
 
            " an Arch revision (%s)" % (output_dir, last_patch))
215
 
 
216
 
 
217
 
def get_remaining_revisions(output_dir, version):
 
256
            " an Arch revision (%s)" % (branch.base, last_patch))
 
257
 
 
258
def do_branch(br_from, to_location, revision_id):
 
259
    """Derived from branch in builtins."""
 
260
    br_from.lock_read()
 
261
    try:
 
262
        try:
 
263
            os.mkdir(to_location)
 
264
        except OSError, e:
 
265
            if e.errno == errno.EEXIST:
 
266
                raise UserError('Target directory "%s" already'
 
267
                                      ' exists.' % to_location)
 
268
            if e.errno == errno.ENOENT:
 
269
                raise UserError('Parent of "%s" does not exist.' %
 
270
                                      to_location)
 
271
            else:
 
272
                raise
 
273
        try:
 
274
            br_from.bzrdir.clone(to_location, revision_id)
 
275
        except NoSuchRevision:
 
276
            rmtree(to_location)
 
277
            msg = "The branch %s has no revision %s." % (from_location, 
 
278
                                                         revision_id)
 
279
            raise UserError(msg)
 
280
    finally:
 
281
        br_from.unlock()
 
282
 
 
283
def get_remaining_revisions(output_dir, version, reuse_history_from=[]):
218
284
    last_patch = None
219
285
    old_revno = None
220
 
    if os.path.exists(output_dir):
 
286
    output_exists = os.path.exists(output_dir)
 
287
    if output_exists:
221
288
        # We are starting from an existing directory, figure out what
222
289
        # the current version is
223
 
        branch = find_branch(output_dir)
 
290
        branch = Branch.open(output_dir)
224
291
        last_patch = get_last_revision(branch)
 
292
        if last_patch is None:
 
293
            raise NotPreviousImport(branch.base)
225
294
        if version is None:
226
295
            version = last_patch.version
227
296
    elif version is None:
229
298
 
230
299
    try:
231
300
        ancestors = version_ancestry(version)
 
301
        if not output_exists and reuse_history_from != []:
 
302
            for ancestor in reversed(ancestors):
 
303
                if last_patch is not None:
 
304
                    # found something to copy
 
305
                    break
 
306
                # try to grab a copy of ancestor
 
307
                # note that is not optimised: we could look for namespace
 
308
                # transitions and only look for the past after the 
 
309
                # transition.
 
310
                for history_root in reuse_history_from:
 
311
                    possible_source = os.path.join(history_root,
 
312
                        map_namespace(ancestor.version))
 
313
                    try:
 
314
                        source = Branch.open(possible_source)
 
315
                        rev_id = revision_id(ancestor)
 
316
                        if rev_id in source.revision_history():
 
317
                            do_branch(source, output_dir, rev_id)
 
318
                            last_patch = ancestor
 
319
                            break
 
320
                    except NotBranchError:
 
321
                        pass
232
322
    except NoSuchVersion, e:
233
 
        raise UserError(e)
 
323
        raise UserError(str(e))
234
324
 
235
325
    if last_patch:
236
326
        for i in range(len(ancestors)):
243
333
        # Strip off all of the ancestors which are already present
244
334
        # And get a directory starting with the latest ancestor
245
335
        latest_ancestor = ancestors[i]
246
 
        old_revno = find_branch(output_dir).revno()
 
336
        old_revno = Branch.open(output_dir).revno()
247
337
        ancestors = ancestors[i+1:]
248
338
    return ancestors, old_revno
249
339
 
250
 
def import_version(output_dir, version, fancy=True, fast=False, verbose=False, 
251
 
                   dry_run=False, max_count=None, skip_symlinks=False):
 
340
 
 
341
###class Importer(object):
 
342
###    """An importer.
 
343
###    
 
344
###    Currently this is used as a parameter object, though more behaviour is
 
345
###    possible later.
 
346
###    """
 
347
###
 
348
###    def __init__(self, output_dir, version, printer, fancy=True, fast=False,
 
349
###                 verbose=False, dry_run=False, max_count=None, 
 
350
###                   reuse_history_from=[]):
 
351
###        self.output_dir = output_dir
 
352
###        self.version = version
 
353
###        self.
 
354
 
 
355
 
 
356
def import_version(output_dir, version, printer, fancy=True, fast=False,
 
357
                   verbose=False, dry_run=False, max_count=None,
 
358
                   reuse_history_from=[], standalone=True):
252
359
    """
253
360
    >>> q = test_environ()
254
361
    >>> result_path = os.path.join(q, "result")
255
362
    >>> commit_test_revisions()
256
363
    >>> version = pybaz.Version("test@example.com/test--test--0.1")
257
 
    >>> import_version('/', version, fancy=False, dry_run=True)
 
364
    >>> def printer(message): print message
 
365
    >>> import_version('/', version, printer, fancy=False, dry_run=True)
258
366
    Traceback (most recent call last):
259
 
    UserError: / exists, but is not a bzr branch.
260
 
    >>> import_version(result_path, version, fancy=False, dry_run=True)
 
367
    NotPreviousImport: / is not the location of a previous import.
 
368
    >>> import_version(result_path, version, printer, fancy=False, dry_run=True)
261
369
    Traceback (most recent call last):
262
370
    UserError: The version test@example.com/test--test--0.1 does not exist.
263
371
    >>> version = pybaz.Version("test@example.com/test--test--0")
264
 
    >>> import_version(result_path, version, fancy=False, dry_run=True)
 
372
    >>> import_version(result_path, version, printer, fancy=False, dry_run=True)
265
373
    not fancy
266
374
    ....
267
375
    Dry run, not modifying output_dir
268
376
    Cleaning up
269
 
    >>> import_version(result_path, version, fancy=False)
 
377
    >>> import_version(result_path, version, printer, fancy=False)
270
378
    not fancy
271
379
    ....
272
380
    Cleaning up
273
381
    Import complete.
274
 
    >>> import_version(result_path, version, fancy=False)
 
382
    >>> import_version(result_path, version, printer, fancy=False)
275
383
    Tree is up-to-date with test@example.com/test--test--0--patch-2
276
384
    >>> commit_more_test_revisions()
277
 
    >>> import_version(result_path, version, fancy=False)
 
385
    >>> import_version(result_path, version, printer, fancy=False)
278
386
    not fancy
279
387
    ..
280
388
    Cleaning up
282
390
    >>> teardown_environ(q)
283
391
    """
284
392
    try:
285
 
        ancestors, old_revno = get_remaining_revisions(output_dir, version)
286
 
    except NotInABranch, e:
287
 
        raise UserError("%s exists, but is not a bzr branch." % e.path)
 
393
        ancestors, old_revno = get_remaining_revisions(output_dir, version,
 
394
                                                       reuse_history_from)
 
395
    except NotBranchError, e:
 
396
        raise NotPreviousImport(e.path)
 
397
    if old_revno is None and len(ancestors) == 0:
 
398
        print 'Version %s has no revisions.' % version
 
399
        return
288
400
    if len(ancestors) == 0:
289
 
        last_revision = get_last_revision(find_branch(output_dir))
 
401
        last_revision = get_last_revision(Branch.open(output_dir))
290
402
        print 'Tree is up-to-date with %s' % last_revision
291
403
        return
292
404
 
293
 
    progress_bar = ProgressBar()
 
405
    progress_bar = bzrlib.ui.ui_factory.nested_progress_bar()
294
406
    tempdir = tempfile.mkdtemp(prefix="baz2bzr-",
295
407
                               dir=os.path.dirname(output_dir))
296
408
    try:
 
409
        wt = WorkingTree.open(output_dir)
 
410
    except (NotBranchError, NoWorkingTree):
 
411
        wt = None
 
412
    if wt is None:
 
413
        old_basis = EmptyTree()
 
414
    else:
 
415
        old_basis = wt.basis_tree()
 
416
    try:
297
417
        if not fancy:
298
418
            print "not fancy"
299
419
        try:
300
420
            for result in iter_import_version(output_dir, ancestors, tempdir,
301
 
                    fast=fast, verbose=verbose, dry_run=dry_run, 
302
 
                    max_count=max_count, skip_symlinks=skip_symlinks):
 
421
                    progress_bar, fast=fast, verbose=verbose, dry_run=dry_run,
 
422
                    max_count=max_count, standalone=standalone):
303
423
                if fancy:
304
 
                    progress_bar(result)
 
424
                    show_progress(progress_bar, result)
305
425
                else:
306
426
                    sys.stdout.write('.')
307
427
        finally:
308
428
            if fancy:
309
 
                progress_bar.clear()
 
429
                progress_bar.finished()
310
430
            else:
311
431
                sys.stdout.write('\n')
312
432
 
313
433
        if dry_run:
314
434
            print 'Dry run, not modifying output_dir'
315
435
            return
316
 
        if os.path.exists(output_dir):
317
 
            # Move the bzr control directory back, and update the working tree
318
 
            tmp_bzr_dir = os.path.join(tempdir, '.bzr')
319
 
            
320
 
            bzr_dir = os.path.join(output_dir, '.bzr')
321
 
            new_bzr_dir = os.path.join(tempdir, "rd", '.bzr')
322
436
 
323
 
            os.rename(bzr_dir, tmp_bzr_dir) # Move the original bzr out of the way
324
 
            os.rename(new_bzr_dir, bzr_dir)
325
 
            try:
326
 
                bzrlib.merge.merge((output_dir, -1), (output_dir, old_revno), 
327
 
                                   check_clean=False, this_dir=output_dir, 
328
 
                                   ignore_zero=True)
329
 
            except:
330
 
                # If something failed, move back the original bzr directory
331
 
                os.rename(bzr_dir, new_bzr_dir)
332
 
                os.rename(tmp_bzr_dir, bzr_dir)
333
 
                raise
334
 
        else:
335
 
            revdir = os.path.join(tempdir, "rd")
336
 
            os.rename(revdir, output_dir)
 
437
        # Update the working tree of the branch
 
438
        try:
 
439
            wt = WorkingTree.open(output_dir)
 
440
        except NoWorkingTree:
 
441
            wt = None
 
442
        if wt is not None:
 
443
            wt.set_last_revision(wt.branch.last_revision())
 
444
            merge_inner(wt.branch, wt.basis_tree(), old_basis, 
 
445
                        ignore_zero=True, this_tree=wt)
 
446
            wt.revert([])
337
447
 
338
448
    finally:
339
 
        print 'Cleaning up'
 
449
        printer('Cleaning up')
340
450
        shutil.rmtree(tempdir)
341
 
    print "Import complete."
 
451
    printer("Import complete.")
342
452
            
343
 
class UserError(Exception):
 
453
class UserError(BzrCommandError):
344
454
    def __init__(self, message):
345
455
        """Exception to throw when a user makes an impossible request
346
456
        :param message: The message to emit when printing this exception
347
457
        :type message: string
348
458
        """
349
 
        Exception.__init__(self, message)
 
459
        BzrCommandError.__init__(self, message)
 
460
 
 
461
class NotPreviousImport(UserError):
 
462
    def __init__(self, path):
 
463
        UserError.__init__(self, "%s is not the location of a previous import."
 
464
                           % path)
 
465
 
350
466
 
351
467
def revision_id(arch_revision):
352
468
    """
357
473
    :param arch_revision: The Arch revision to generate an ID for.
358
474
 
359
475
    >>> revision_id(pybaz.Revision("you@example.com/cat--br--0--base-0"))
360
 
    'Arch-x:you@example.com%cat--br--0--base-0'
 
476
    'Arch-1:you@example.com%cat--br--0--base-0'
361
477
    """
362
 
    return "Arch-x:%s" % str(arch_revision).replace('/', '%')
 
478
    return "Arch-1:%s" % str(arch_revision).replace('/', '%')
363
479
 
364
480
class NotArchRevision(Exception):
365
481
    def __init__(self, revision_id):
369
485
 
370
486
def arch_revision(revision_id):
371
487
    """
372
 
    >>> str(arch_revision("Arch-x:jrandom@example.com%test--test--0"))
373
 
    Traceback (most recent call last):
374
 
    NotArchRevision: The revision id Arch-x:jrandom@example.com%test--test--0 does not look like it came from Arch.
375
 
    >>> str(arch_revision("Arch-x:jrandom@example.com%test--test--0--base-5"))
376
 
    Traceback (most recent call last):
377
 
    NotArchRevision: The revision id Arch-x:jrandom@example.com%test--test--0--base-5 does not look like it came from Arch.
378
 
    >>> str(arch_revision("Arch-x:jrandom@example.com%test--test--0--patch-5"))
 
488
    >>> str(arch_revision("Arch-1:jrandom@example.com%test--test--0"))
 
489
    Traceback (most recent call last):
 
490
    NotArchRevision: The revision id Arch-1:jrandom@example.com%test--test--0 does not look like it came from Arch.
 
491
    >>> str(arch_revision("Arch-1:jrandom@example.com%test--test--0--base-5"))
 
492
    Traceback (most recent call last):
 
493
    NotArchRevision: The revision id Arch-1:jrandom@example.com%test--test--0--base-5 does not look like it came from Arch.
 
494
    >>> str(arch_revision("Arch-1:jrandom@example.com%test--test--0--patch-5"))
379
495
    'jrandom@example.com/test--test--0--patch-5'
380
496
    """
381
497
    if revision_id is None:
382
498
        return None
383
 
    if revision_id[:7] != 'Arch-x:':
 
499
    if revision_id[:7] != 'Arch-1:':
384
500
        raise NotArchRevision(revision_id)
385
501
    else:
386
502
        try:
387
503
            return pybaz.Revision(revision_id[7:].replace('%', '/'))
388
504
        except pybaz.errors.NamespaceError, e:
389
505
            raise NotArchRevision(revision_id)
390
 
            
391
 
def iter_import_version(output_dir, ancestors, tempdir, fast=False,
 
506
 
 
507
 
 
508
def create_shared_repository(output_dir):
 
509
    bd = bzrdir.BzrDirMetaFormat1().initialize(output_dir)
 
510
    bd.create_repository(shared=True)
 
511
 
 
512
def create_branch(output_dir):
 
513
    os.mkdir(output_dir)
 
514
    bd = bzrdir.BzrDirMetaFormat1().initialize(output_dir)
 
515
    return bd.create_branch()
 
516
 
 
517
 
 
518
def create_checkout(source, to_location, revision_id=None):
 
519
    checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
 
520
    bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
 
521
    return checkout.create_workingtree(revision_id)
 
522
 
 
523
 
 
524
def create_checkout_metadata(source, to_location, revision_id=None):
 
525
    if revision_id is None:
 
526
        revision_id = source.last_revision()
 
527
    wt = create_checkout(source, to_location, NULL_REVISION)
 
528
    wt.set_last_revision(revision_id)
 
529
    wt._write_inventory(wt.basis_tree().inventory)
 
530
    return wt
 
531
 
 
532
 
 
533
def iter_import_version(output_dir, ancestors, tempdir, pb, fast=False,
392
534
                        verbose=False, dry_run=False, max_count=None,
393
 
                        skip_symlinks=False):
 
535
                        standalone=False):
394
536
    revdir = None
395
537
 
396
538
    # Uncomment this for testing, it basically just has baz2bzr only update
408
550
    #        print '\t%s' % a
409
551
 
410
552
    previous_version=None
 
553
    missing_ancestor = None
 
554
    if dry_run:
 
555
        dry_output_dir = os.path.join(tempdir, 'od')
 
556
        if os.path.exists(output_dir):
 
557
            shutil.copytree(output_dir, dry_output_dir)
 
558
        output_dir = dry_output_dir
 
559
 
 
560
    if os.path.exists(output_dir):
 
561
        target_branch = Branch.open(output_dir)
 
562
    else:
 
563
        if standalone:
 
564
            wt = BzrDir.create_standalone_workingtree(output_dir)
 
565
            target_branch = wt.branch
 
566
        else:
 
567
            target_branch = create_branch(output_dir)
411
568
 
412
569
    for i in range(len(ancestors)):
413
570
        revision = ancestors[i]
 
571
        rev_id = revision_id(revision)
 
572
        direct_merges = []
414
573
        if verbose:
415
574
            version = str(revision.version)
416
575
            if version != previous_version:
420
579
            previous_version = version
421
580
        else:
422
581
            yield Progress("revisions", i, len(ancestors))
 
582
 
 
583
        if target_branch.repository.has_revision(rev_id):
 
584
            target_branch.append_revision(rev_id)
 
585
            continue
423
586
        if revdir is None:
424
587
            revdir = os.path.join(tempdir, "rd")
425
 
            baz_inv, log = get_revision(revdir, revision, 
426
 
                                        skip_symlinks=skip_symlinks)
427
 
            if os.path.exists(output_dir):
428
 
                bzr_dir = os.path.join(output_dir, '.bzr')
429
 
                new_bzr_dir = os.path.join(tempdir, "rd", '.bzr')
430
 
                # This would be much faster with a simple os.rename(), but if
431
 
                # we fail, we have corrupted the original .bzr directory.  Is
432
 
                # that a big problem, as we can just back out the last
433
 
                # revisions in .bzr/revision_history I don't really know
434
 
                shutil.copytree(bzr_dir, new_bzr_dir)
435
 
                # Now revdir should have a tree with the latest .bzr, and the
436
 
                # next revision of the baz tree
437
 
                branch = find_branch(revdir)
438
 
            else:
439
 
                branch = bzrlib.Branch(revdir, init=True)
 
588
            try:
 
589
                tree, baz_inv, log = get_revision(revdir, revision)
 
590
            except pybaz.errors.ExecProblem, e:
 
591
                if ("%s" % e.args).find('could not connect') == -1:
 
592
                    raise
 
593
                missing_ancestor = revision
 
594
                revdir = None
 
595
                print ("unable to access ancestor %s, making into a merge."
 
596
                       % missing_ancestor)
 
597
                continue
 
598
            target_tree = create_checkout_metadata(target_branch, revdir)
 
599
            branch = target_tree.branch
440
600
        else:
441
601
            old = os.path.join(revdir, ".bzr")
442
602
            new = os.path.join(tempdir, ".bzr")
443
603
            os.rename(old, new)
444
 
            baz_inv, log = apply_revision(revdir, revision, 
445
 
                                          skip_symlinks=skip_symlinks)
 
604
            baz_inv, log = apply_revision(tree, revision)
446
605
            os.rename(new, old)
447
 
            branch = find_branch(revdir)
448
 
        timestamp = email.Utils.mktime_tz(log.date + (0,))
449
 
        rev_id = revision_id(revision)
 
606
            target_tree = WorkingTree.open(revdir)
 
607
            branch = target_tree.branch
 
608
        # cached so we can delete the log
 
609
        log_date = log.date
 
610
        log_summary = log.summary
 
611
        log_description = log.description
 
612
        is_continuation = log.continuation_of is not None
 
613
        log_creator = log.creator
 
614
        direct_merges = get_direct_merges(revdir, revision, log)
 
615
 
 
616
        timestamp = email.Utils.mktime_tz(log_date + (0,))
 
617
        if log_summary is None:
 
618
            log_summary = ""
 
619
        # log_descriptions of None and "" are ignored.
 
620
        if not is_continuation and log_description:
 
621
            log_message = "\n".join((log_summary, log_description))
 
622
        else:
 
623
            log_message = log_summary
 
624
        target_tree.lock_write()
450
625
        branch.lock_write()
451
626
        try:
452
 
            branch.set_inventory(baz_inv)
453
 
            bzrlib.trace.silent = True
454
 
            branch.commit(log.summary, verbose=False, committer=log.creator,
455
 
                          timestamp=timestamp, timezone=0, rev_id=rev_id)
 
627
            if missing_ancestor:
 
628
                # if we want it to be in revision-history, do that here.
 
629
                target_tree.add_pending_merge(revision_id(missing_ancestor))
 
630
                missing_ancestor = None
 
631
            for merged_rev in direct_merges:
 
632
                target_tree.add_pending_merge(revision_id(merged_rev))
 
633
            target_tree.set_inventory(baz_inv)
 
634
            commitobj = Commit(reporter=ImportCommitReporter(pb))
 
635
            commitobj.commit(working_tree=target_tree,
 
636
                             message=log_message.decode('ascii', 'replace'), 
 
637
                             verbose=False, committer=log_creator,
 
638
                             timestamp=timestamp, timezone=0, rev_id=rev_id,
 
639
                             revprops={})
456
640
        finally:
457
 
            bzrlib.trace.silent = False   
 
641
            target_tree.unlock()
458
642
            branch.unlock()
459
643
    yield Progress("revisions", len(ancestors), len(ancestors))
460
 
    unlink_unversioned(branch, revdir)
461
 
 
462
 
def unlink_unversioned(branch, revdir):
463
 
    for unversioned in branch.working_tree().extras():
464
 
        path = os.path.join(revdir, unversioned)
 
644
 
 
645
def get_direct_merges(revdir, revision, log):
 
646
    continuation = log.continuation_of
 
647
    previous_version = revision.version
 
648
    if pybaz.WorkingTree(revdir).tree_version != previous_version:
 
649
        pybaz.WorkingTree(revdir).set_tree_version(previous_version)
 
650
    log_path = "%s/{arch}/%s/%s/%s/%s/patch-log/%s" % (revdir, 
 
651
        revision.category.nonarch, revision.branch.nonarch, 
 
652
        revision.version.nonarch, revision.archive, revision.patchlevel)
 
653
    temp_path = tempfile.mktemp(dir=os.path.dirname(revdir))
 
654
    os.rename(log_path, temp_path)
 
655
    merges = list(iter_new_merges(revdir, revision.version))
 
656
    direct = direct_merges(merges, [continuation])
 
657
    os.rename(temp_path, log_path)
 
658
    return direct
 
659
 
 
660
def unlink_unversioned(wt):
 
661
    for unversioned in wt.extras():
 
662
        path = wt.abspath(unversioned)
465
663
        if os.path.isdir(path):
466
664
            shutil.rmtree(path)
467
665
        else:
468
666
            os.unlink(path)
469
667
 
470
668
def get_log(tree, revision):
471
 
    log = tree.iter_logs(version=revision.version, reverse=True).next()
472
 
    assert log.revision == revision
 
669
    log = pybaz.Patchlog(revision, tree=tree)
 
670
    assert str(log.revision) == str(revision), (log.revision, revision)
473
671
    return log
474
672
 
475
 
def get_revision(revdir, revision, skip_symlinks=False):
476
 
    revision.get(revdir)
477
 
    tree = pybaz.tree_root(revdir)
 
673
def get_revision(revdir, revision):
 
674
    tree = revision.get(revdir)
478
675
    log = get_log(tree, revision)
479
676
    try:
480
 
        return bzr_inventory_data(tree, skip_symlinks=skip_symlinks), log 
 
677
        return tree, bzr_inventory_data(tree), log 
481
678
    except BadFileKind, e:
482
 
        raise UserError("Cannot convert %s because %s is a %s" % (revision,e.path, e.kind) )
483
 
 
484
 
 
485
 
def apply_revision(revdir, revision, skip_symlinks=False):
486
 
    tree = pybaz.tree_root(revdir)
 
679
        raise UserError("Cannot convert %s because %s is a %s" % 
 
680
                        (revision,e.path, e.kind))
 
681
 
 
682
 
 
683
def apply_revision(tree, revision):
487
684
    revision.apply(tree)
488
685
    log = get_log(tree, revision)
489
686
    try:
490
 
        return bzr_inventory_data(tree, skip_symlinks=skip_symlinks), log
 
687
        return bzr_inventory_data(tree), log
491
688
    except BadFileKind, e:
492
 
        raise UserError("Cannot convert %s because %s is a %s" % (revision,e.path, e.kind) )
493
 
 
494
 
 
 
689
        raise UserError("Cannot convert %s because %s is a %s" % 
 
690
                        (revision,e.path, e.kind))
495
691
 
496
692
 
497
693
class BadFileKind(Exception):
503
699
        Exception.__init__(self, "File %s is of forbidden type %s" %
504
700
                           (os.path.join(tree_root, path), kind))
505
701
 
506
 
def bzr_inventory_data(tree, skip_symlinks=False):
 
702
 
 
703
def bzr_inventory_data(tree):
507
704
    inv_iter = tree.iter_inventory_ids(source=True, both=True)
508
705
    inv_map = {}
509
 
    for file_id, path in inv_iter:
510
 
        inv_map[path] = file_id 
 
706
    for arch_id, path in inv_iter:
 
707
        bzr_file_id = map_file_id(arch_id)
 
708
        inv_map[path] = bzr_file_id 
511
709
 
512
710
    bzr_inv = []
513
711
    for path, file_id in inv_map.iteritems():
514
712
        full_path = os.path.join(tree, path)
515
713
        kind = bzrlib.osutils.file_kind(full_path)
516
 
        if skip_symlinks and kind == "symlink":
517
 
            continue
518
 
        if kind not in ("file", "directory"):
 
714
        if kind not in ("file", "directory", "symlink"):
519
715
            raise BadFileKind(tree, path, kind)
520
716
        parent_dir = os.path.dirname(path)
521
717
        if parent_dir != "":
526
722
    bzr_inv.sort()
527
723
    return bzr_inv
528
724
 
529
 
class NotInABranch(Exception):
530
 
    def __init__(self, path):
531
 
        Exception.__init__(self, "%s is not in a branch." % path)
532
 
        self.path = path
533
 
 
534
 
 
535
 
def find_branch(path):
536
 
    """
537
 
    >>> find_branch('/')
538
 
    Traceback (most recent call last):
539
 
    NotInABranch: / is not in a branch.
540
 
    >>> sb = bzrlib.ScratchBranch()
541
 
    >>> isinstance(find_branch(sb.base), bzrlib.Branch)
542
 
    True
543
 
    """
544
 
    try:
545
 
        return bzrlib.Branch(path)
546
 
    except BzrError, e:
547
 
        if e.args[0].endswith("' is not in a branch"):
548
 
            raise NotInABranch(path)
549
 
 
550
 
class cmd_baz_import(Command):
551
 
    """Import an Arch or Baz branch into a bzr branch"""
552
 
    takes_args = ['to_location', 'from_branch?']
553
 
    takes_options = ['verbose']
554
 
 
555
 
    def run(self, to_location, from_branch=None, skip_symlinks=False, 
556
 
            fast=False, max_count=None, verbose=False, dry_run=False):
 
725
_global_option('max-count', type = int)
 
726
class cmd_baz_import_branch(Command):
 
727
    """Import an Arch or Baz branch into a bzr branch.  <BZRTOOLS>"""
 
728
    takes_args = ['to_location', 'from_branch?', 'reuse_history*']
 
729
    takes_options = ['verbose', 'max-count']
 
730
 
 
731
    def printer(self, name):
 
732
        print name
 
733
 
 
734
    def run(self, to_location, from_branch=None, fast=False, max_count=None,
 
735
            verbose=False, dry_run=False, reuse_history_list=[]):
557
736
        to_location = os.path.realpath(str(to_location))
558
737
        if from_branch is not None:
559
738
            try:
560
 
                from_branch = pybaz.Version(version)
 
739
                from_branch = pybaz.Version(from_branch)
561
740
            except pybaz.errors.NamespaceError:
562
741
                print "%s is not a valid Arch branch." % from_branch
563
742
                return 1
564
 
        import_version(to_location, from_branch)
 
743
        if reuse_history_list is None:
 
744
            reuse_history_list = []
 
745
        import_version(to_location, from_branch, self.printer, 
 
746
                       max_count=max_count, 
 
747
                       reuse_history_from=reuse_history_list)
 
748
 
 
749
 
 
750
class NotInABranch(Exception):
 
751
    def __init__(self, path):
 
752
        Exception.__init__(self, "%s is not in a branch." % path)
 
753
        self.path = path
 
754
 
 
755
 
 
756
class cmd_baz_import(Command):
 
757
    """Import an Arch or Baz archive into bzr branches.  <BZRTOOLS>
 
758
 
 
759
    This command should be used on local archives (or mirrors) only.  It is
 
760
    quite slow on remote archives.
 
761
    
 
762
    reuse_history allows you to specify any previous imports you 
 
763
    have done of different archives, which this archive has branches
 
764
    tagged from. This will dramatically reduce the time to convert 
 
765
    the archive as it will not have to convert the history already
 
766
    converted in that other branch.
 
767
 
 
768
    If you specify prefixes, only branches whose names start with that prefix
 
769
    will be imported.  Skipped branches will be listed, so you can import any
 
770
    branches you missed by accident.  Here's an example of doing a partial
 
771
    import from thelove@canonical.com:
 
772
    bzr baz-import thelove thelove@canonical.com --prefixes dists:talloc-except
 
773
    """
 
774
    takes_args = ['to_root_dir', 'from_archive', 'reuse_history*']
 
775
    takes_options = ['verbose', Option('prefixes', type=str,
 
776
                     help="Prefixes of branches to import, colon-separated")]
 
777
 
 
778
    def printer(self, name):
 
779
        print name
 
780
 
 
781
    def run(self, to_root_dir, from_archive, verbose=False,
 
782
            reuse_history_list=[], prefixes=None):
 
783
        if reuse_history_list is None:
 
784
            reuse_history_list = []
 
785
        to_root = str(os.path.realpath(to_root_dir))
 
786
        if not os.path.exists(to_root):
 
787
            os.mkdir(to_root)
 
788
        if prefixes is not None:
 
789
            prefixes = prefixes.split(':')
 
790
        import_archive(to_root, from_archive, verbose, self.printer, 
 
791
                       reuse_history_list, prefixes=prefixes)
 
792
 
 
793
 
 
794
def import_archive(to_root, from_archive, verbose, printer,
 
795
                   reuse_history_from=[], standalone=False,
 
796
                   prefixes=None):
 
797
    def selected(version):
 
798
        if prefixes is None:
 
799
            return True
 
800
        else:
 
801
            for prefix in prefixes:
 
802
                if version.nonarch.startswith(prefix):
 
803
                    return True
 
804
            return False
 
805
    real_to = os.path.realpath(to_root)
 
806
    history_locations = [real_to] + reuse_history_from
 
807
    if standalone is False:
 
808
        try:
 
809
            bd = BzrDir.open(to_root)
 
810
            bd.find_repository()
 
811
        except NotBranchError:
 
812
            create_shared_repository(to_root)
 
813
        except NoRepositoryPresent:
 
814
            raise BzrCommandError("Can't create repository at existing branch.")
 
815
    versions = list(pybaz.Archive(str(from_archive)).iter_versions())
 
816
#    progress_bar = bzrlib.ui.ui_factory.nested_progress_bar()
 
817
    try:
 
818
        for num, version in enumerate(versions):
 
819
#            progress_bar.update("Branch", num, len(versions))
 
820
            if not selected(version):
 
821
                print "Skipping %s" % version
 
822
                continue
 
823
            target = os.path.join(to_root, map_namespace(version))
 
824
            printer("importing %s into %s" % (version, target))
 
825
            if not os.path.exists(os.path.dirname(target)):
 
826
                os.makedirs(os.path.dirname(target))
 
827
            try:
 
828
                import_version(target, version, printer,
 
829
                               reuse_history_from=reuse_history_from, 
 
830
                               standalone=standalone)
 
831
            except pybaz.errors.ExecProblem,e:
 
832
                if str(e).find('The requested revision cannot be built.') != -1:
 
833
                    printer("Skipping version %s as it cannot be built due"
 
834
                            " to a missing parent archive." % version)
 
835
                else:
 
836
                    raise
 
837
            except UserError, e:
 
838
                if str(e).find('already exists, and the last revision ') != -1:
 
839
                    printer("Skipping version %s as it has had commits made"
 
840
                            " since it was converted to bzr." % version)
 
841
                else:
 
842
                    raise
 
843
    finally:
 
844
        pass
 
845
#        progress_bar.finished()
 
846
 
 
847
def map_namespace(a_version):
 
848
    a_version = pybaz.Version("%s" % a_version)
 
849
    parser = NameParser(a_version)
 
850
    version = parser.get_version()
 
851
    branch = parser.get_branch()
 
852
    category = parser.get_category()
 
853
    if branch is None or branch == '':
 
854
        branch = "+trunk"
 
855
    if version == '0':
 
856
        return "%s/%s" % (category, branch)
 
857
    return "%s/%s/%s" % (category, version, branch)
 
858
 
 
859
def map_file_id(file_id):
 
860
    """Convert a baz file id to a bzr one."""
 
861
    return file_id.replace('%', '%25').replace('/', '%2f')