← 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-07-01 22:25:01 UTC
  • mfrom: (408.1.1 bzrtools)
  • Revision ID: aaron.bentley@utoronto.ca-20060701222501-a5dfbdeacbccd2da
Update colordiff to use wrapped versions of diff

Show diffs side-by-side

added added

removed removed

Lines of Context:
baz_import.py
33
33
from bzrlib.revision import NULL_REVISION
34
34
from bzrlib.tree import EmptyTree
35
35
import bzrlib.ui
 
36
import bzrlib.ui.text
36
37
from bzrlib.workingtree import WorkingTree
37
38
from errors import NoPyBaz
38
39
try:
57
58
from progress import *
58
59
 
59
60
class ImportCommitReporter(NullCommitReporter):
60
 
    def __init__(self, pb):
61
 
        self.pb = pb
62
61
 
63
62
    def escaped(self, escape_count, message):
64
 
        self.pb.clear()
65
63
        bzrlib.trace.warning("replaced %d control characters in message" %
66
64
                             escape_count)
67
65
 
290
288
        branch = Branch.open(output_dir)
291
289
        last_patch = get_last_revision(branch)
292
290
        if last_patch is None:
293
 
            raise NotPreviousImport(branch.base)
294
 
        if version is None:
 
291
            if branch.last_revision() != None:
 
292
                raise NotPreviousImport(branch.base)
 
293
        elif version is None:
295
294
            version = last_patch.version
296
295
    elif version is None:
297
296
        raise UserError("No version specified, and directory does not exist.")
345
344
###    possible later.
346
345
###    """
347
346
###
348
 
###    def __init__(self, output_dir, version, printer, fancy=True, fast=False,
 
347
###    def __init__(self, output_dir, version, fast=False,
349
348
###                 verbose=False, dry_run=False, max_count=None, 
350
349
###                   reuse_history_from=[]):
351
350
###        self.output_dir = output_dir
353
352
###        self.
354
353
 
355
354
 
356
 
def import_version(output_dir, version, printer, fancy=True, fast=False,
 
355
def import_version(output_dir, version, fast=False,
357
356
                   verbose=False, dry_run=False, max_count=None,
358
357
                   reuse_history_from=[], standalone=True):
359
358
    """
360
359
    >>> q = test_environ()
 
360
    
 
361
    Progress bars output to stderr, but doctest does not capture that.
 
362
 
 
363
    >>> old_stderr = sys.stderr
 
364
    >>> sys.stderr = sys.stdout
 
365
 
361
366
    >>> result_path = os.path.join(q, "result")
362
367
    >>> commit_test_revisions()
363
368
    >>> version = pybaz.Version("test@example.com/test--test--0.1")
364
 
    >>> def printer(message): print message
365
 
    >>> import_version('/', version, printer, fancy=False, dry_run=True)
 
369
    >>> old_ui = bzrlib.ui.ui_factory
 
370
    >>> bzrlib.ui.ui_factory = bzrlib.ui.text.TextUIFactory(
 
371
    ...     bar_type=bzrlib.progress.DotsProgressBar)
 
372
 
 
373
    >>> import_version('/', version, dry_run=True)
366
374
    Traceback (most recent call last):
367
375
    NotPreviousImport: / is not the location of a previous import.
368
 
    >>> import_version(result_path, version, printer, fancy=False, dry_run=True)
 
376
    >>> import_version(result_path, version, dry_run=True)
369
377
    Traceback (most recent call last):
370
378
    UserError: The version test@example.com/test--test--0.1 does not exist.
371
379
    >>> version = pybaz.Version("test@example.com/test--test--0")
372
 
    >>> import_version(result_path, version, printer, fancy=False, dry_run=True)
373
 
    not fancy
374
 
    ....
 
380
    >>> import_version(result_path, version, dry_run=True) #doctest: +ELLIPSIS
 
381
    importing test@example.com/test--test--0 into ...
 
382
    ...
 
383
    revisions: ..........................................
375
384
    Dry run, not modifying output_dir
376
385
    Cleaning up
377
 
    >>> import_version(result_path, version, printer, fancy=False)
378
 
    not fancy
379
 
    ....
 
386
    >>> import_version(result_path, version) #doctest: +ELLIPSIS
 
387
    importing test@example.com/test--test--0 into ...
 
388
    ...
 
389
    revisions: .....................................................................
380
390
    Cleaning up
381
391
    Import complete.
382
 
    >>> import_version(result_path, version, printer, fancy=False)
 
392
    >>> import_version(result_path, version) #doctest: +ELLIPSIS
383
393
    Tree is up-to-date with test@example.com/test--test--0--patch-2
384
394
    >>> commit_more_test_revisions()
385
 
    >>> import_version(result_path, version, printer, fancy=False)
386
 
    not fancy
387
 
    ..
 
395
    >>> import_version(result_path, version) #doctest: +ELLIPSIS
 
396
    importing test@example.com/test--test--0 into ...
 
397
    revisions: ....................................................
388
398
    Cleaning up
389
399
    Import complete.
 
400
    >>> bzrlib.ui.ui_factory = old_ui
 
401
    >>> sys.stderr = old_stderr
390
402
    >>> teardown_environ(q)
391
403
    """
 
404
    progress_bar = bzrlib.ui.ui_factory.nested_progress_bar()
392
405
    try:
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
400
 
    if len(ancestors) == 0:
401
 
        last_revision = get_last_revision(Branch.open(output_dir))
402
 
        print 'Tree is up-to-date with %s' % last_revision
403
 
        return
 
406
        try:
 
407
            ancestors, old_revno = get_remaining_revisions(output_dir, version,
 
408
                                                           reuse_history_from)
 
409
        except NotBranchError, e:
 
410
            raise NotPreviousImport(e.path)
 
411
        if old_revno is None and len(ancestors) == 0:
 
412
            progress_bar.note('Version %s has no revisions.' % version)
 
413
            return
 
414
        if len(ancestors) == 0:
 
415
            last_revision = get_last_revision(Branch.open(output_dir))
 
416
            progress_bar.note('Tree is up-to-date with %s' % last_revision)
 
417
            return
404
418
 
405
 
    progress_bar = bzrlib.ui.ui_factory.nested_progress_bar()
406
 
    tempdir = tempfile.mkdtemp(prefix="baz2bzr-",
407
 
                               dir=os.path.dirname(output_dir))
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:
417
 
        if not fancy:
418
 
            print "not fancy"
 
419
        progress_bar.note("importing %s into %s" % (version, output_dir))
 
420
    
 
421
        tempdir = tempfile.mkdtemp(prefix="baz2bzr-",
 
422
                                   dir=os.path.dirname(output_dir))
 
423
        try:
 
424
            wt = WorkingTree.open(output_dir)
 
425
        except (NotBranchError, NoWorkingTree):
 
426
            wt = None
 
427
        if wt is None:
 
428
            old_basis = EmptyTree()
 
429
        else:
 
430
            old_basis = wt.basis_tree()
419
431
        try:
420
432
            for result in iter_import_version(output_dir, ancestors, tempdir,
421
 
                    progress_bar, fast=fast, verbose=verbose, dry_run=dry_run,
 
433
                    pb=progress_bar,
 
434
                    fast=fast, verbose=verbose, dry_run=dry_run,
422
435
                    max_count=max_count, standalone=standalone):
423
 
                if fancy:
424
 
                    show_progress(progress_bar, result)
425
 
                else:
426
 
                    sys.stdout.write('.')
 
436
                show_progress(progress_bar, result)
 
437
            if dry_run:
 
438
                progress_bar.note('Dry run, not modifying output_dir')
 
439
                return
 
440
    
 
441
            # Update the working tree of the branch
 
442
            try:
 
443
                wt = WorkingTree.open(output_dir)
 
444
            except NoWorkingTree:
 
445
                wt = None
 
446
            if wt is not None:
 
447
                wt.set_last_revision(wt.branch.last_revision())
 
448
                merge_inner(wt.branch, wt.basis_tree(), old_basis, 
 
449
                            ignore_zero=True, this_tree=wt)
 
450
                wt.revert([])
 
451
    
427
452
        finally:
428
 
            if fancy:
429
 
                progress_bar.finished()
430
 
            else:
431
 
                sys.stdout.write('\n')
432
 
 
433
 
        if dry_run:
434
 
            print 'Dry run, not modifying output_dir'
435
 
            return
436
 
 
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([])
447
 
 
 
453
            
 
454
            progress_bar.note('Cleaning up')
 
455
            shutil.rmtree(tempdir)
 
456
        progress_bar.note("Import complete.")
448
457
    finally:
449
 
        printer('Cleaning up')
450
 
        shutil.rmtree(tempdir)
451
 
    printer("Import complete.")
 
458
        progress_bar.finished()
452
459
            
453
460
class UserError(BzrCommandError):
454
461
    def __init__(self, message):
573
580
        if verbose:
574
581
            version = str(revision.version)
575
582
            if version != previous_version:
576
 
                clear_progress_bar()
577
 
                print '\rOn version: %s' % version
 
583
                pb.note('On version: %s' % version)
578
584
            yield Progress(str(revision.patchlevel), i, len(ancestors))
579
585
            previous_version = version
580
586
        else:
592
598
                    raise
593
599
                missing_ancestor = revision
594
600
                revdir = None
595
 
                print ("unable to access ancestor %s, making into a merge."
 
601
                pb.note("unable to access ancestor %s, making into a merge."
596
602
                       % missing_ancestor)
597
603
                continue
598
604
            target_tree = create_checkout_metadata(target_branch, revdir)
631
637
            for merged_rev in direct_merges:
632
638
                target_tree.add_pending_merge(revision_id(merged_rev))
633
639
            target_tree.set_inventory(baz_inv)
634
 
            commitobj = Commit(reporter=ImportCommitReporter(pb))
 
640
            commitobj = Commit(reporter=ImportCommitReporter())
635
641
            commitobj.commit(working_tree=target_tree,
636
642
                             message=log_message.decode('ascii', 'replace'), 
637
643
                             verbose=False, committer=log_creator,
728
734
    takes_args = ['to_location', 'from_branch?', 'reuse_history*']
729
735
    takes_options = ['verbose', 'max-count']
730
736
 
731
 
    def printer(self, name):
732
 
        print name
733
 
 
734
737
    def run(self, to_location, from_branch=None, fast=False, max_count=None,
735
738
            verbose=False, dry_run=False, reuse_history_list=[]):
736
739
        to_location = os.path.realpath(str(to_location))
742
745
                return 1
743
746
        if reuse_history_list is None:
744
747
            reuse_history_list = []
745
 
        import_version(to_location, from_branch, self.printer, 
 
748
        import_version(to_location, from_branch, 
746
749
                       max_count=max_count, 
747
750
                       reuse_history_from=reuse_history_list)
748
751
 
754
757
 
755
758
 
756
759
class cmd_baz_import(Command):
757
 
    """Import an Arch or Baz archive into bzr branches.  <BZRTOOLS>
 
760
    """Import an Arch or Baz archive into a bzr repository.  <BZRTOOLS>
758
761
 
759
762
    This command should be used on local archives (or mirrors) only.  It is
760
763
    quite slow on remote archives.
775
778
    takes_options = ['verbose', Option('prefixes', type=str,
776
779
                     help="Prefixes of branches to import, colon-separated")]
777
780
 
778
 
    def printer(self, name):
779
 
        print name
780
 
 
781
781
    def run(self, to_root_dir, from_archive, verbose=False,
782
782
            reuse_history_list=[], prefixes=None):
783
783
        if reuse_history_list is None:
787
787
            os.mkdir(to_root)
788
788
        if prefixes is not None:
789
789
            prefixes = prefixes.split(':')
790
 
        import_archive(to_root, from_archive, verbose, self.printer, 
 
790
        import_archive(to_root, from_archive, verbose,
791
791
                       reuse_history_list, prefixes=prefixes)
792
792
 
793
793
 
794
 
def import_archive(to_root, from_archive, verbose, printer,
 
794
def import_archive(to_root, from_archive, verbose,
795
795
                   reuse_history_from=[], standalone=False,
796
796
                   prefixes=None):
797
797
    def selected(version):
813
813
        except NoRepositoryPresent:
814
814
            raise BzrCommandError("Can't create repository at existing branch.")
815
815
    versions = list(pybaz.Archive(str(from_archive)).iter_versions())
816
 
#    progress_bar = bzrlib.ui.ui_factory.nested_progress_bar()
 
816
    progress_bar = bzrlib.ui.ui_factory.nested_progress_bar()
817
817
    try:
818
818
        for num, version in enumerate(versions):
819
 
#            progress_bar.update("Branch", num, len(versions))
 
819
            progress_bar.update("Branch", num, len(versions))
820
820
            if not selected(version):
821
821
                print "Skipping %s" % version
822
822
                continue
823
823
            target = os.path.join(to_root, map_namespace(version))
824
 
            printer("importing %s into %s" % (version, target))
825
824
            if not os.path.exists(os.path.dirname(target)):
826
825
                os.makedirs(os.path.dirname(target))
827
826
            try:
828
 
                import_version(target, version, printer,
 
827
                import_version(target, version,
829
828
                               reuse_history_from=reuse_history_from, 
830
829
                               standalone=standalone)
831
830
            except pybaz.errors.ExecProblem,e:
832
831
                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)
 
832
                    progress_bar.note(
 
833
                        "Skipping version %s as it cannot be built due"
 
834
                        " to a missing parent archive." % version)
835
835
                else:
836
836
                    raise
837
837
            except UserError, e:
838
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)
 
839
                    progress_bar.note(
 
840
                        "Skipping version %s as it has had commits made"
 
841
                        " since it was converted to bzr." % version)
841
842
                else:
842
843
                    raise
843
844
    finally:
844
 
        pass
845
 
#        progress_bar.finished()
 
845
        progress_bar.finished()
 
846
 
846
847
 
847
848
def map_namespace(a_version):
848
849
    a_version = pybaz.Version("%s" % a_version)
856
857
        return "%s/%s" % (category, branch)
857
858
    return "%s/%s/%s" % (category, version, branch)
858
859
 
 
860
 
859
861
def map_file_id(file_id):
860
862
    """Convert a baz file id to a bzr one."""
861
863
    return file_id.replace('%', '%25').replace('/', '%2f')