← 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: 2005-09-23 23:51:13 UTC
  • mto: This revision was merged to the branch mainline in revision 200.
  • Revision ID: aaron.bentley@utoronto.ca-20050923235113-2a97a0590cbca8c9
Added more file exclusions

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
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
 
 
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
16
from bzrlib.branch import Branch
29
 
from bzrlib.commit import Commit, NullCommitReporter
30
17
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
18
from errors import NoPyBaz
39
19
try:
40
20
    import pybaz
41
21
    import pybaz.errors
42
 
    from pybaz import NameParser as NameParser
43
22
    from pybaz.backends.baz import null_cmd
44
23
except ImportError:
45
24
    raise NoPyBaz
46
 
from fai import iter_new_merges, direct_merges
47
25
import tempfile
48
26
import os
49
27
import os.path
50
28
import shutil
51
29
import bzrlib
 
30
from bzrlib.errors import BzrError
52
31
import bzrlib.trace
53
32
import bzrlib.merge
54
33
import bzrlib.inventory
57
36
import email.Utils
58
37
from progress import *
59
38
 
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
39
def add_id(files, id=None):
67
40
    """Adds an explicit id to a list of files.
68
41
 
77
50
    args.extend(files)
78
51
    return null_cmd(args)
79
52
 
80
 
saved_dir = None
81
 
 
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
53
def test_environ():
88
54
    """
89
55
    >>> q = test_environ()
95
61
    >>> os.path.exists(q)
96
62
    False
97
63
    """
98
 
    global saved_dir
99
 
    saved_dir = os.getcwdu()
100
64
    tdir = tempfile.mkdtemp(prefix="testdir-")
101
65
    os.environ["HOME"] = os.path.join(tdir, "home")
102
66
    os.mkdir(os.environ["HOME"])
103
67
    arch_dir = os.path.join(tdir, "archive_dir")
104
 
    make_archive("test@example.com", arch_dir)
 
68
    pybaz.make_archive("test@example.com", arch_dir)
105
69
    work_dir = os.path.join(tdir, "work_dir")
106
70
    os.mkdir(work_dir)
107
71
    os.chdir(work_dir)
140
104
    add_id([path], id)
141
105
 
142
106
def teardown_environ(tdir):
143
 
    os.chdir(saved_dir)
 
107
    os.chdir("/")
144
108
    shutil.rmtree(tdir)
145
109
 
146
110
def timport(tree, summary):
232
196
    """
233
197
    try:
234
198
        revision = version.iter_revisions(reverse=True).next()
235
 
    except StopIteration:
236
 
        return ()
237
199
    except:
238
 
        print version
239
200
        if not version.exists():
240
201
            raise NoSuchVersion(version)
241
202
        else:
245
206
    return ancestors
246
207
 
247
208
def get_last_revision(branch):
248
 
    last_patch = branch.last_revision()
 
209
    last_patch = branch.last_patch()
249
210
    try:
250
211
        return arch_revision(last_patch)
251
212
    except NotArchRevision:
252
213
        raise UserError(
253
214
            "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=[]):
 
215
            " an Arch revision (%s)" % (output_dir, last_patch))
 
216
 
 
217
 
 
218
def get_remaining_revisions(output_dir, version):
282
219
    last_patch = None
283
220
    old_revno = None
284
 
    output_exists = os.path.exists(output_dir)
285
 
    if output_exists:
 
221
    if os.path.exists(output_dir):
286
222
        # We are starting from an existing directory, figure out what
287
223
        # the current version is
288
 
        branch = Branch.open(output_dir)
 
224
        branch = find_branch(output_dir)
289
225
        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:
 
226
        if version is None:
294
227
            version = last_patch.version
295
228
    elif version is None:
296
229
        raise UserError("No version specified, and directory does not exist.")
297
230
 
298
231
    try:
299
232
        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
233
    except NoSuchVersion, e:
322
 
        raise UserError(str(e))
 
234
        raise UserError(e)
323
235
 
324
236
    if last_patch:
325
237
        for i in range(len(ancestors)):
332
244
        # Strip off all of the ancestors which are already present
333
245
        # And get a directory starting with the latest ancestor
334
246
        latest_ancestor = ancestors[i]
335
 
        old_revno = Branch.open(output_dir).revno()
 
247
        old_revno = find_branch(output_dir).revno()
336
248
        ancestors = ancestors[i+1:]
337
249
    return ancestors, old_revno
338
250
 
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):
 
251
def import_version(output_dir, version, fancy=True, fast=False, verbose=False, 
 
252
                   dry_run=False, max_count=None, skip_symlinks=False):
358
253
    """
359
254
    >>> 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
255
    >>> result_path = os.path.join(q, "result")
367
256
    >>> commit_test_revisions()
368
257
    >>> 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)
 
258
    >>> import_version('/', version, fancy=False, dry_run=True)
374
259
    Traceback (most recent call last):
375
 
    NotPreviousImport: / is not the location of a previous import.
376
 
    >>> import_version(result_path, version, dry_run=True)
 
260
    UserError: / exists, but is not a bzr branch.
 
261
    >>> import_version(result_path, version, fancy=False, dry_run=True)
377
262
    Traceback (most recent call last):
378
263
    UserError: The version test@example.com/test--test--0.1 does not exist.
379
264
    >>> 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: ..........................................
 
265
    >>> import_version(result_path, version, fancy=False, dry_run=True)
 
266
    not fancy
 
267
    ....
384
268
    Dry run, not modifying output_dir
385
269
    Cleaning up
386
 
    >>> import_version(result_path, version) #doctest: +ELLIPSIS
387
 
    importing test@example.com/test--test--0 into ...
388
 
    ...
389
 
    revisions: .....................................................................
 
270
    >>> import_version(result_path, version, fancy=False)
 
271
    not fancy
 
272
    ....
390
273
    Cleaning up
391
274
    Import complete.
392
 
    >>> import_version(result_path, version) #doctest: +ELLIPSIS
 
275
    >>> import_version(result_path, version, fancy=False)
393
276
    Tree is up-to-date with test@example.com/test--test--0--patch-2
394
277
    >>> commit_more_test_revisions()
395
 
    >>> import_version(result_path, version) #doctest: +ELLIPSIS
396
 
    importing test@example.com/test--test--0 into ...
397
 
    revisions: ....................................................
 
278
    >>> import_version(result_path, version, fancy=False)
 
279
    not fancy
 
280
    ..
398
281
    Cleaning up
399
282
    Import complete.
400
 
    >>> bzrlib.ui.ui_factory = old_ui
401
 
    >>> sys.stderr = old_stderr
402
283
    >>> teardown_environ(q)
403
284
    """
404
 
    progress_bar = bzrlib.ui.ui_factory.nested_progress_bar()
405
285
    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
 
286
        ancestors, old_revno = get_remaining_revisions(output_dir, version)
 
287
    except NotInABranch, e:
 
288
        raise UserError("%s exists, but is not a bzr branch." % e.path)
 
289
    if len(ancestors) == 0:
 
290
        last_revision = get_last_revision(find_branch(output_dir))
 
291
        print 'Tree is up-to-date with %s' % last_revision
 
292
        return
418
293
 
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()
 
294
    progress_bar = ProgressBar()
 
295
    tempdir = tempfile.mkdtemp(prefix="baz2bzr-",
 
296
                               dir=os.path.dirname(output_dir))
 
297
    try:
 
298
        if not fancy:
 
299
            print "not fancy"
431
300
        try:
432
301
            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
 
302
                    fast=fast, verbose=verbose, dry_run=dry_run, 
 
303
                    max_count=max_count, skip_symlinks=skip_symlinks):
 
304
                if fancy:
 
305
                    show_progress(progress_bar, result)
 
306
                else:
 
307
                    sys.stdout.write('.')
 
308
        finally:
 
309
            if fancy:
 
310
                progress_bar.clear()
 
311
            else:
 
312
                sys.stdout.write('\n')
 
313
 
 
314
        if dry_run:
 
315
            print 'Dry run, not modifying output_dir'
 
316
            return
 
317
        if os.path.exists(output_dir):
 
318
            # Move the bzr control directory back, and update the working tree
 
319
            tmp_bzr_dir = os.path.join(tempdir, '.bzr')
 
320
            
 
321
            bzr_dir = os.path.join(output_dir, '.bzr')
 
322
            new_bzr_dir = os.path.join(tempdir, "rd", '.bzr')
 
323
 
 
324
            os.rename(bzr_dir, tmp_bzr_dir) # Move the original bzr out of the way
 
325
            os.rename(new_bzr_dir, bzr_dir)
442
326
            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.")
 
327
                bzrlib.merge.merge((output_dir, -1), (output_dir, old_revno), 
 
328
                                   check_clean=False, this_dir=output_dir, 
 
329
                                   ignore_zero=True)
 
330
            except:
 
331
                # If something failed, move back the original bzr directory
 
332
                os.rename(bzr_dir, new_bzr_dir)
 
333
                os.rename(tmp_bzr_dir, bzr_dir)
 
334
                raise
 
335
        else:
 
336
            revdir = os.path.join(tempdir, "rd")
 
337
            os.rename(revdir, output_dir)
 
338
 
457
339
    finally:
458
 
        progress_bar.finished()
 
340
        print 'Cleaning up'
 
341
        shutil.rmtree(tempdir)
 
342
    print "Import complete."
459
343
            
460
 
class UserError(BzrCommandError):
 
344
class UserError(Exception):
461
345
    def __init__(self, message):
462
346
        """Exception to throw when a user makes an impossible request
463
347
        :param message: The message to emit when printing this exception
464
348
        :type message: string
465
349
        """
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
 
 
 
350
        Exception.__init__(self, message)
473
351
 
474
352
def revision_id(arch_revision):
475
353
    """
480
358
    :param arch_revision: The Arch revision to generate an ID for.
481
359
 
482
360
    >>> revision_id(pybaz.Revision("you@example.com/cat--br--0--base-0"))
483
 
    'Arch-1:you@example.com%cat--br--0--base-0'
 
361
    'Arch-x:you@example.com%cat--br--0--base-0'
484
362
    """
485
 
    return "Arch-1:%s" % str(arch_revision).replace('/', '%')
 
363
    return "Arch-x:%s" % str(arch_revision).replace('/', '%')
486
364
 
487
365
class NotArchRevision(Exception):
488
366
    def __init__(self, revision_id):
492
370
 
493
371
def arch_revision(revision_id):
494
372
    """
495
 
    >>> str(arch_revision("Arch-1:jrandom@example.com%test--test--0"))
496
 
    Traceback (most recent call last):
497
 
    NotArchRevision: The revision id Arch-1:jrandom@example.com%test--test--0 does not look like it came from Arch.
498
 
    >>> str(arch_revision("Arch-1:jrandom@example.com%test--test--0--base-5"))
499
 
    Traceback (most recent call last):
500
 
    NotArchRevision: The revision id Arch-1:jrandom@example.com%test--test--0--base-5 does not look like it came from Arch.
501
 
    >>> str(arch_revision("Arch-1:jrandom@example.com%test--test--0--patch-5"))
 
373
    >>> str(arch_revision("Arch-x:jrandom@example.com%test--test--0"))
 
374
    Traceback (most recent call last):
 
375
    NotArchRevision: The revision id Arch-x:jrandom@example.com%test--test--0 does not look like it came from Arch.
 
376
    >>> str(arch_revision("Arch-x:jrandom@example.com%test--test--0--base-5"))
 
377
    Traceback (most recent call last):
 
378
    NotArchRevision: The revision id Arch-x:jrandom@example.com%test--test--0--base-5 does not look like it came from Arch.
 
379
    >>> str(arch_revision("Arch-x:jrandom@example.com%test--test--0--patch-5"))
502
380
    'jrandom@example.com/test--test--0--patch-5'
503
381
    """
504
382
    if revision_id is None:
505
383
        return None
506
 
    if revision_id[:7] != 'Arch-1:':
 
384
    if revision_id[:7] != 'Arch-x:':
507
385
        raise NotArchRevision(revision_id)
508
386
    else:
509
387
        try:
510
388
            return pybaz.Revision(revision_id[7:].replace('%', '/'))
511
389
        except pybaz.errors.NamespaceError, e:
512
390
            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,
 
391
            
 
392
def iter_import_version(output_dir, ancestors, tempdir, fast=False,
541
393
                        verbose=False, dry_run=False, max_count=None,
542
 
                        standalone=False):
 
394
                        skip_symlinks=False):
543
395
    revdir = None
544
396
 
545
397
    # Uncomment this for testing, it basically just has baz2bzr only update
557
409
    #        print '\t%s' % a
558
410
 
559
411
    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
412
 
576
413
    for i in range(len(ancestors)):
577
414
        revision = ancestors[i]
578
 
        rev_id = revision_id(revision)
579
 
        direct_merges = []
580
415
        if verbose:
581
416
            version = str(revision.version)
582
417
            if version != previous_version:
583
 
                pb.note('On version: %s' % version)
 
418
                clear_progress_bar()
 
419
                print '\rOn version: %s' % version
584
420
            yield Progress(str(revision.patchlevel), i, len(ancestors))
585
421
            previous_version = version
586
422
        else:
587
423
            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
424
        if revdir is None:
593
425
            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
 
426
            baz_inv, log = get_revision(revdir, revision, 
 
427
                                        skip_symlinks=skip_symlinks)
 
428
            if os.path.exists(output_dir):
 
429
                bzr_dir = os.path.join(output_dir, '.bzr')
 
430
                new_bzr_dir = os.path.join(tempdir, "rd", '.bzr')
 
431
                # This would be much faster with a simple os.rename(), but if
 
432
                # we fail, we have corrupted the original .bzr directory.  Is
 
433
                # that a big problem, as we can just back out the last
 
434
                # revisions in .bzr/revision_history I don't really know
 
435
                shutil.copytree(bzr_dir, new_bzr_dir)
 
436
                # Now revdir should have a tree with the latest .bzr, and the
 
437
                # next revision of the baz tree
 
438
                branch = find_branch(revdir)
 
439
            else:
 
440
                branch = Branch.initialize(revdir)
606
441
        else:
607
442
            old = os.path.join(revdir, ".bzr")
608
443
            new = os.path.join(tempdir, ".bzr")
609
444
            os.rename(old, new)
610
 
            baz_inv, log = apply_revision(tree, revision)
 
445
            baz_inv, log = apply_revision(revdir, revision, 
 
446
                                          skip_symlinks=skip_symlinks)
611
447
            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
 
 
622
 
        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()
 
448
            branch = find_branch(revdir)
 
449
        timestamp = email.Utils.mktime_tz(log.date + (0,))
 
450
        rev_id = revision_id(revision)
631
451
        branch.lock_write()
632
452
        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={})
 
453
            branch.set_inventory(baz_inv)
 
454
            bzrlib.trace.silent = True
 
455
            branch.commit(log.summary, verbose=False, committer=log.creator,
 
456
                          timestamp=timestamp, timezone=0, rev_id=rev_id)
646
457
        finally:
647
 
            target_tree.unlock()
 
458
            bzrlib.trace.silent = False   
648
459
            branch.unlock()
649
460
    yield Progress("revisions", len(ancestors), len(ancestors))
650
 
 
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)
656
 
    log_path = "%s/{arch}/%s/%s/%s/%s/patch-log/%s" % (revdir, 
657
 
        revision.category.nonarch, revision.branch.nonarch, 
658
 
        revision.version.nonarch, revision.archive, revision.patchlevel)
659
 
    temp_path = tempfile.mktemp(dir=os.path.dirname(revdir))
660
 
    os.rename(log_path, temp_path)
661
 
    merges = list(iter_new_merges(revdir, revision.version))
662
 
    direct = direct_merges(merges, [continuation])
663
 
    os.rename(temp_path, log_path)
664
 
    return direct
665
 
 
666
 
def unlink_unversioned(wt):
667
 
    for unversioned in wt.extras():
668
 
        path = wt.abspath(unversioned)
 
461
    unlink_unversioned(branch, revdir)
 
462
 
 
463
def unlink_unversioned(branch, revdir):
 
464
    for unversioned in branch.working_tree().extras():
 
465
        path = os.path.join(revdir, unversioned)
669
466
        if os.path.isdir(path):
670
467
            shutil.rmtree(path)
671
468
        else:
672
469
            os.unlink(path)
673
470
 
674
471
def get_log(tree, revision):
675
 
    log = pybaz.Patchlog(revision, tree=tree)
 
472
    log = tree.iter_logs(version=revision.version, reverse=True).next()
676
473
    assert str(log.revision) == str(revision), (log.revision, revision)
677
474
    return log
678
475
 
679
 
def get_revision(revdir, revision):
680
 
    tree = revision.get(revdir)
 
476
def get_revision(revdir, revision, skip_symlinks=False):
 
477
    revision.get(revdir)
 
478
    tree = pybaz.tree_root(revdir)
681
479
    log = get_log(tree, revision)
682
480
    try:
683
 
        return tree, bzr_inventory_data(tree), log 
 
481
        return bzr_inventory_data(tree, skip_symlinks=skip_symlinks), log 
684
482
    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):
 
483
        raise UserError("Cannot convert %s because %s is a %s" % (revision,e.path, e.kind) )
 
484
 
 
485
 
 
486
def apply_revision(revdir, revision, skip_symlinks=False):
 
487
    tree = pybaz.tree_root(revdir)
690
488
    revision.apply(tree)
691
489
    log = get_log(tree, revision)
692
490
    try:
693
 
        return bzr_inventory_data(tree), log
 
491
        return bzr_inventory_data(tree, skip_symlinks=skip_symlinks), log
694
492
    except BadFileKind, e:
695
 
        raise UserError("Cannot convert %s because %s is a %s" % 
696
 
                        (revision,e.path, e.kind))
 
493
        raise UserError("Cannot convert %s because %s is a %s" % (revision,e.path, e.kind) )
 
494
 
 
495
 
697
496
 
698
497
 
699
498
class BadFileKind(Exception):
705
504
        Exception.__init__(self, "File %s is of forbidden type %s" %
706
505
                           (os.path.join(tree_root, path), kind))
707
506
 
708
 
 
709
 
def bzr_inventory_data(tree):
 
507
def bzr_inventory_data(tree, skip_symlinks=False):
710
508
    inv_iter = tree.iter_inventory_ids(source=True, both=True)
711
509
    inv_map = {}
712
510
    for arch_id, path in inv_iter:
713
 
        bzr_file_id = map_file_id(arch_id)
 
511
        bzr_file_id = arch_id.replace('%', '%25').replace('/', '%2f')
714
512
        inv_map[path] = bzr_file_id 
715
513
 
716
514
    bzr_inv = []
717
515
    for path, file_id in inv_map.iteritems():
718
516
        full_path = os.path.join(tree, path)
719
517
        kind = bzrlib.osutils.file_kind(full_path)
720
 
        if kind not in ("file", "directory", "symlink"):
 
518
        if skip_symlinks and kind == "symlink":
 
519
            continue
 
520
        if kind not in ("file", "directory"):
721
521
            raise BadFileKind(tree, path, kind)
722
522
        parent_dir = os.path.dirname(path)
723
523
        if parent_dir != "":
728
528
    bzr_inv.sort()
729
529
    return bzr_inv
730
530
 
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."""
734
 
    takes_args = ['to_location', 'from_branch?', 'reuse_history*']
735
 
    takes_options = ['verbose', 'max-count']
736
 
 
737
 
    def run(self, to_location, from_branch=None, fast=False, max_count=None,
738
 
            verbose=False, dry_run=False, reuse_history_list=[]):
 
531
class NotInABranch(Exception):
 
532
    def __init__(self, path):
 
533
        Exception.__init__(self, "%s is not in a branch." % path)
 
534
        self.path = path
 
535
 
 
536
 
 
537
def find_branch(path):
 
538
    """
 
539
    >>> find_branch('/')
 
540
    Traceback (most recent call last):
 
541
    NotInABranch: / is not in a branch.
 
542
    >>> sb = bzrlib.ScratchBranch()
 
543
    >>> isinstance(find_branch(sb.base), Branch)
 
544
    True
 
545
    """
 
546
    try:
 
547
        return Branch.open(path)
 
548
    except BzrError, e:
 
549
        if e.args[0].endswith("' is not in a branch"):
 
550
            raise NotInABranch(path)
 
551
 
 
552
class cmd_baz_import(Command):
 
553
    """Import an Arch or Baz branch into a bzr branch"""
 
554
    takes_args = ['to_location', 'from_branch?']
 
555
    takes_options = ['verbose']
 
556
 
 
557
    def run(self, to_location, from_branch=None, skip_symlinks=False, 
 
558
            fast=False, max_count=None, verbose=False, dry_run=False):
739
559
        to_location = os.path.realpath(str(to_location))
740
560
        if from_branch is not None:
741
561
            try:
743
563
            except pybaz.errors.NamespaceError:
744
564
                print "%s is not a valid Arch branch." % from_branch
745
565
                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.
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')
 
566
        import_version(to_location, from_branch)