← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to baz_import.py

  • Committer: Robert Collins
  • Date: 2005-09-13 10:46:27 UTC
  • mto: (147.2.6) (364.1.3 bzrtools)
  • mto: This revision was merged to the branch mainline in revision 324.
  • Revision ID: robertc@robertcollins.net-20050913104627-51f938950a907475
handle inaccessible sibling archives somewhat - note version-0 is still not handled

Show diffs side-by-side

added added

removed removed

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