/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/info.py

  • Committer: John Ferlito
  • Date: 2009-09-02 04:31:45 UTC
  • mto: (4665.7.1 serve-init)
  • mto: This revision was merged to the branch mainline in revision 4913.
  • Revision ID: johnf@inodes.org-20090902043145-gxdsfw03ilcwbyn5
Add a debian init script for bzr --serve

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/info.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
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
16
16
 
17
17
__all__ = ['show_bzrdir_info']
18
18
 
19
 
from io import StringIO
 
19
from cStringIO import StringIO
 
20
import os
20
21
import time
21
22
import sys
22
23
 
23
 
from . import (
24
 
    branch as _mod_branch,
25
 
    controldir,
 
24
from bzrlib import (
 
25
    bzrdir,
 
26
    diff,
26
27
    errors,
27
28
    hooks as _mod_hooks,
28
29
    osutils,
29
30
    urlutils,
30
31
    )
31
 
from .bzr import (
32
 
    bzrdir,
33
 
    )
34
 
from .errors import (NoWorkingTree, NotBranchError,
35
 
                     NoRepositoryPresent, NotLocalUrl)
36
 
from .missing import find_unmerged
37
 
 
38
 
 
39
 
def plural(n, base=u'', pl=None):
 
32
from bzrlib.errors import (NoWorkingTree, NotBranchError,
 
33
                           NoRepositoryPresent, NotLocalUrl)
 
34
from bzrlib.missing import find_unmerged
 
35
 
 
36
 
 
37
def plural(n, base='', pl=None):
40
38
    if n == 1:
41
39
        return base
42
40
    elif pl is not None:
43
41
        return pl
44
42
    else:
45
 
        return u's'
 
43
        return 's'
46
44
 
47
45
 
48
46
class LocationList(object):
57
55
            return
58
56
        try:
59
57
            path = urlutils.local_path_from_url(url)
60
 
        except urlutils.InvalidURL:
 
58
        except errors.InvalidURL:
61
59
            self.locs.append((label, url))
62
60
        else:
63
61
            self.add_path(label, path)
77
75
 
78
76
    def get_lines(self):
79
77
        max_len = max(len(l) for l, u in self.locs)
80
 
        return ["  %*s: %s\n" % (max_len, l, u) for l, u in self.locs]
81
 
 
82
 
 
83
 
def gather_location_info(repository=None, branch=None, working=None,
84
 
                         control=None):
 
78
        return ["  %*s: %s\n" % (max_len, l, u) for l, u in self.locs ]
 
79
 
 
80
 
 
81
def gather_location_info(repository, branch=None, working=None):
85
82
    locs = {}
 
83
    repository_path = repository.bzrdir.root_transport.base
86
84
    if branch is not None:
87
 
        branch_path = branch.user_url
 
85
        branch_path = branch.bzrdir.root_transport.base
88
86
        master_path = branch.get_bound_location()
89
87
        if master_path is None:
90
88
            master_path = branch_path
91
89
    else:
92
90
        branch_path = None
93
91
        master_path = None
94
 
        try:
95
 
            if control is not None and control.get_branch_reference():
96
 
                locs['checkout of branch'] = control.get_branch_reference()
97
 
        except NotBranchError:
98
 
            pass
99
92
    if working:
100
 
        working_path = working.user_url
 
93
        working_path = working.bzrdir.root_transport.base
101
94
        if working_path != branch_path:
102
95
            locs['light checkout root'] = working_path
103
96
        if master_path != branch_path:
106
99
            else:
107
100
                locs['checkout root'] = branch_path
108
101
        if working_path != master_path:
109
 
            (master_path_base, params) = urlutils.split_segment_parameters(
110
 
                master_path)
111
 
            if working_path == master_path_base:
112
 
                locs['checkout of co-located branch'] = params['branch']
113
 
            elif 'branch' in params:
114
 
                locs['checkout of branch'] = "%s, branch %s" % (
115
 
                    master_path_base, params['branch'])
116
 
            else:
117
 
                locs['checkout of branch'] = master_path
 
102
            locs['checkout of branch'] = master_path
118
103
        elif repository.is_shared():
119
104
            locs['repository branch'] = branch_path
120
105
        elif branch_path is not None:
122
107
            locs['branch root'] = branch_path
123
108
    else:
124
109
        working_path = None
125
 
        if repository is not None and repository.is_shared():
 
110
        if repository.is_shared():
126
111
            # lightweight checkout of branch in shared repository
127
112
            if branch_path is not None:
128
113
                locs['repository branch'] = branch_path
129
114
        elif branch_path is not None:
130
115
            # standalone
131
116
            locs['branch root'] = branch_path
132
 
        elif repository is not None:
133
 
            locs['repository'] = repository.user_url
134
 
        elif control is not None:
135
 
            locs['control directory'] = control.user_url
 
117
            if master_path != branch_path:
 
118
                locs['bound to branch'] = master_path
136
119
        else:
137
 
            # Really, at least a control directory should be
138
 
            # passed in for this method to be useful.
139
 
            pass
140
 
        if master_path != branch_path:
141
 
            locs['bound to branch'] = master_path
142
 
    if repository is not None and repository.is_shared():
 
120
            locs['repository'] = repository_path
 
121
    if repository.is_shared():
143
122
        # lightweight checkout of branch in shared repository
144
 
        locs['shared repository'] = repository.user_url
145
 
    order = ['control directory', 'light checkout root',
146
 
             'repository checkout root', 'checkout root',
147
 
             'checkout of branch', 'checkout of co-located branch',
148
 
             'shared repository', 'repository', 'repository branch',
149
 
             'branch root', 'bound to branch']
 
123
        locs['shared repository'] = repository_path
 
124
    order = ['light checkout root', 'repository checkout root',
 
125
             'checkout root', 'checkout of branch', 'shared repository',
 
126
             'repository', 'repository branch', 'branch root',
 
127
             'bound to branch']
150
128
    return [(n, locs[n]) for n in order if n in locs]
151
129
 
152
130
 
167
145
    locs.add_url('submit branch', branch.get_submit_branch())
168
146
    try:
169
147
        locs.add_url('stacked on', branch.get_stacked_on_url())
170
 
    except (_mod_branch.UnstackableBranchFormat, errors.UnstackableRepositoryFormat,
171
 
            errors.NotStacked):
 
148
    except (errors.UnstackableBranchFormat, errors.UnstackableRepositoryFormat,
 
149
        errors.NotStacked):
172
150
        pass
173
151
    return locs
174
152
 
182
160
        outfile.writelines(locs.get_lines())
183
161
 
184
162
 
185
 
def _show_control_dir_info(control, outfile):
186
 
    """Show control dir information."""
187
 
    if control._format.colocated_branches:
188
 
        outfile.write('\n')
189
 
        outfile.write('Control directory:\n')
190
 
        outfile.write('         %d branches\n' % len(control.list_branches()))
191
 
 
192
 
 
193
163
def _show_format_info(control=None, repository=None, branch=None,
194
164
                      working=None, outfile=None):
195
165
    """Show known formats for control, working, branch and repository."""
197
167
    outfile.write('Format:\n')
198
168
    if control:
199
169
        outfile.write('       control: %s\n' %
200
 
                      control._format.get_format_description())
 
170
            control._format.get_format_description())
201
171
    if working:
202
172
        outfile.write('  working tree: %s\n' %
203
 
                      working._format.get_format_description())
 
173
            working._format.get_format_description())
204
174
    if branch:
205
175
        outfile.write('        branch: %s\n' %
206
 
                      branch._format.get_format_description())
 
176
            branch._format.get_format_description())
207
177
    if repository:
208
178
        outfile.write('    repository: %s\n' %
209
 
                      repository._format.get_format_description())
210
 
 
211
 
 
212
 
def _show_locking_info(repository=None, branch=None, working=None,
213
 
                       outfile=None):
 
179
            repository._format.get_format_description())
 
180
 
 
181
 
 
182
def _show_locking_info(repository, branch=None, working=None, outfile=None):
214
183
    """Show locking status of working, branch and repository."""
215
 
    if (repository and repository.get_physical_lock_status() or
 
184
    if (repository.get_physical_lock_status() or
216
185
        (branch and branch.get_physical_lock_status()) or
217
 
            (working and working.get_physical_lock_status())):
 
186
        (working and working.get_physical_lock_status())):
218
187
        outfile.write('\n')
219
188
        outfile.write('Lock status:\n')
220
189
        if working:
246
215
        if remote_extra:
247
216
            outfile.write('\n')
248
217
            outfile.write(('Branch is out of date: missing %d '
249
 
                           'revision%s.\n') % (len(remote_extra),
250
 
                                               plural(len(remote_extra))))
 
218
                'revision%s.\n') % (len(remote_extra),
 
219
                plural(len(remote_extra))))
251
220
 
252
221
 
253
222
def _show_missing_revisions_working(working, outfile):
254
223
    """Show missing revisions in working tree."""
255
224
    branch = working.branch
256
 
    try:
257
 
        branch_revno, branch_last_revision = branch.last_revision_info()
258
 
    except errors.UnsupportedOperation:
259
 
        return
 
225
    basis = working.basis_tree()
 
226
    work_inv = working.inventory
 
227
    branch_revno, branch_last_revision = branch.last_revision_info()
260
228
    try:
261
229
        tree_last_id = working.get_parent_ids()[0]
262
230
    except IndexError:
267
235
        missing_count = branch_revno - tree_last_revno
268
236
        outfile.write('\n')
269
237
        outfile.write(('Working tree is out of date: missing %d '
270
 
                       'revision%s.\n') % (missing_count, plural(missing_count)))
 
238
            'revision%s.\n') % (missing_count, plural(missing_count)))
271
239
 
272
240
 
273
241
def _show_working_stats(working, outfile):
274
242
    """Show statistics about a working tree."""
275
243
    basis = working.basis_tree()
 
244
    work_inv = working.inventory
276
245
    delta = working.changes_from(basis, want_unchanged=True)
277
246
 
278
247
    outfile.write('\n')
282
251
    outfile.write('  %8d added\n' % len(delta.added))
283
252
    outfile.write('  %8d removed\n' % len(delta.removed))
284
253
    outfile.write('  %8d renamed\n' % len(delta.renamed))
285
 
    outfile.write('  %8d copied\n' % len(delta.copied))
286
254
 
287
255
    ignore_cnt = unknown_cnt = 0
288
256
    for path in working.extras():
294
262
    outfile.write('  %8d ignored\n' % ignore_cnt)
295
263
 
296
264
    dir_cnt = 0
297
 
    for path, entry in working.iter_entries_by_dir():
298
 
        if entry.kind == 'directory' and path != '':
 
265
    for file_id in work_inv:
 
266
        if (work_inv.get_file_kind(file_id) == 'directory' and
 
267
            not work_inv.is_root(file_id)):
299
268
            dir_cnt += 1
300
269
    outfile.write('  %8d versioned %s\n' % (dir_cnt,
301
 
                                            plural(dir_cnt, 'subdirectory', 'subdirectories')))
 
270
        plural(dir_cnt, 'subdirectory', 'subdirectories')))
302
271
 
303
272
 
304
273
def _show_branch_stats(branch, verbose, outfile):
305
274
    """Show statistics about a branch."""
306
 
    try:
307
 
        revno, head = branch.last_revision_info()
308
 
    except errors.UnsupportedOperation:
309
 
        return {}
 
275
    revno, head = branch.last_revision_info()
310
276
    outfile.write('\n')
311
277
    outfile.write('Branch history:\n')
312
278
    outfile.write('  %8d revision%s\n' % (revno, plural(revno)))
314
280
    if verbose:
315
281
        committers = stats['committers']
316
282
        outfile.write('  %8d committer%s\n' % (committers,
317
 
                                               plural(committers)))
 
283
            plural(committers)))
318
284
    if revno:
319
285
        timestamp, timezone = stats['firstrev']
320
286
        age = int((time.time() - timestamp) / 3600 / 24)
321
287
        outfile.write('  %8d day%s old\n' % (age, plural(age)))
322
288
        outfile.write('   first revision: %s\n' %
323
 
                      osutils.format_date(timestamp, timezone))
 
289
            osutils.format_date(timestamp, timezone))
324
290
        timestamp, timezone = stats['latestrev']
325
291
        outfile.write('  latest revision: %s\n' %
326
 
                      osutils.format_date(timestamp, timezone))
 
292
            osutils.format_date(timestamp, timezone))
327
293
    return stats
328
294
 
329
295
 
332
298
    if repository.make_working_trees():
333
299
        outfile.write('\n')
334
300
        outfile.write('Create working tree for new branches inside '
335
 
                      'the repository.\n')
 
301
            'the repository.\n')
336
302
 
337
303
 
338
304
def _show_repository_stats(repository, stats, outfile):
342
308
        revisions = stats['revisions']
343
309
        f.write('  %8d revision%s\n' % (revisions, plural(revisions)))
344
310
    if 'size' in stats:
345
 
        f.write('  %8d KiB\n' % (stats['size'] / 1024))
 
311
        f.write('  %8d KiB\n' % (stats['size']/1024))
346
312
    for hook in hooks['repository']:
347
313
        hook(repository, stats, f)
348
314
    if f.getvalue() != "":
351
317
        outfile.write(f.getvalue())
352
318
 
353
319
 
354
 
def show_bzrdir_info(a_controldir, verbose=False, outfile=None):
355
 
    """Output to stdout the 'info' for a_controldir."""
 
320
def show_bzrdir_info(a_bzrdir, verbose=False, outfile=None):
 
321
    """Output to stdout the 'info' for a_bzrdir."""
356
322
    if outfile is None:
357
323
        outfile = sys.stdout
358
324
    try:
359
 
        tree = a_controldir.open_workingtree(
 
325
        tree = a_bzrdir.open_workingtree(
360
326
            recommend_upgrade=False)
361
 
    except (NoWorkingTree, NotLocalUrl, NotBranchError):
 
327
    except (NoWorkingTree, NotLocalUrl):
362
328
        tree = None
363
329
        try:
364
 
            branch = a_controldir.open_branch(name="")
 
330
            branch = a_bzrdir.open_branch()
365
331
        except NotBranchError:
366
332
            branch = None
367
333
            try:
368
 
                repository = a_controldir.open_repository()
 
334
                repository = a_bzrdir.open_repository()
369
335
            except NoRepositoryPresent:
370
 
                lockable = None
371
 
                repository = None
 
336
                # Return silently; cmd_info already returned NotBranchError
 
337
                # if no bzrdir could be opened.
 
338
                return
372
339
            else:
373
340
                lockable = repository
374
341
        else:
379
346
        repository = branch.repository
380
347
        lockable = tree
381
348
 
382
 
    if lockable is not None:
383
 
        lockable.lock_read()
 
349
    lockable.lock_read()
384
350
    try:
385
 
        show_component_info(a_controldir, repository, branch, tree, verbose,
 
351
        show_component_info(a_bzrdir, repository, branch, tree, verbose,
386
352
                            outfile)
387
353
    finally:
388
 
        if lockable is not None:
389
 
            lockable.unlock()
 
354
        lockable.unlock()
390
355
 
391
356
 
392
357
def show_component_info(control, repository, branch=None, working=None,
393
 
                        verbose=1, outfile=None):
 
358
    verbose=1, outfile=None):
394
359
    """Write info about all bzrdir components to stdout"""
395
360
    if outfile is None:
396
361
        outfile = sys.stdout
398
363
        verbose = 1
399
364
    if verbose is True:
400
365
        verbose = 2
401
 
    layout = describe_layout(repository, branch, working, control)
 
366
    layout = describe_layout(repository, branch, working)
402
367
    format = describe_format(control, repository, branch, working)
403
368
    outfile.write("%s (format: %s)\n" % (layout, format))
404
 
    _show_location_info(
405
 
        gather_location_info(control=control, repository=repository,
406
 
                             branch=branch, working=working),
407
 
        outfile)
 
369
    _show_location_info(gather_location_info(repository, branch, working),
 
370
                        outfile)
408
371
    if branch is not None:
409
372
        _show_related_info(branch, outfile)
410
373
    if verbose == 0:
411
374
        return
412
375
    _show_format_info(control, repository, branch, working, outfile)
413
376
    _show_locking_info(repository, branch, working, outfile)
414
 
    _show_control_dir_info(control, outfile)
415
377
    if branch is not None:
416
378
        _show_missing_revisions_branch(branch, outfile)
417
379
    if working is not None:
422
384
    if branch is not None:
423
385
        show_committers = verbose >= 2
424
386
        stats = _show_branch_stats(branch, show_committers, outfile)
425
 
    elif repository is not None:
 
387
    else:
426
388
        stats = repository.gather_stats()
427
 
    if branch is None and working is None and repository is not None:
 
389
    if branch is None and working is None:
428
390
        _show_repository_info(repository, outfile)
429
 
    if repository is not None:
430
 
        _show_repository_stats(repository, stats, outfile)
431
 
 
432
 
 
433
 
def describe_layout(repository=None, branch=None, tree=None, control=None):
 
391
    _show_repository_stats(repository, stats, outfile)
 
392
 
 
393
 
 
394
def describe_layout(repository=None, branch=None, tree=None):
434
395
    """Convert a control directory layout into a user-understandable term
435
396
 
436
397
    Common outputs include "Standalone tree", "Repository branch" and
437
398
    "Checkout".  Uncommon outputs include "Unshared repository with trees"
438
399
    and "Empty control directory"
439
400
    """
440
 
    if branch is None and control is not None:
441
 
        try:
442
 
            branch_reference = control.get_branch_reference()
443
 
        except NotBranchError:
444
 
            pass
445
 
        else:
446
 
            if branch_reference is not None:
447
 
                return "Dangling branch reference"
448
401
    if repository is None:
449
402
        return 'Empty control directory'
450
403
    if branch is None and tree is None:
452
405
            phrase = 'Shared repository'
453
406
        else:
454
407
            phrase = 'Unshared repository'
455
 
        extra = []
456
408
        if repository.make_working_trees():
457
 
            extra.append('trees')
458
 
        if len(control.branch_names()) > 0:
459
 
            extra.append('colocated branches')
460
 
        if extra:
461
 
            phrase += ' with ' + " and ".join(extra)
 
409
            phrase += ' with trees'
462
410
        return phrase
463
411
    else:
464
412
        if repository.is_shared():
472
420
        if branch is None and tree is not None:
473
421
            phrase = "branchless tree"
474
422
        else:
475
 
            if (tree is not None and tree.controldir.control_url !=
476
 
                    branch.controldir.control_url):
 
423
            if (tree is not None and tree.bzrdir.root_transport.base !=
 
424
                branch.bzrdir.root_transport.base):
477
425
                independence = ''
478
426
                phrase = "Lightweight checkout"
479
427
            elif branch.get_bound_location() is not None:
496
444
 
497
445
    If no matching candidate is found, "unnamed" is returned.
498
446
    """
499
 
    candidates = []
 
447
    candidates  = []
500
448
    if (branch is not None and tree is not None and
501
 
            branch.user_url != tree.user_url):
 
449
        branch.bzrdir.root_transport.base !=
 
450
        tree.bzrdir.root_transport.base):
502
451
        branch = None
503
452
        repository = None
504
 
    non_aliases = set(controldir.format_registry.keys())
505
 
    non_aliases.difference_update(controldir.format_registry.aliases())
 
453
    non_aliases = set(bzrdir.format_registry.keys())
 
454
    non_aliases.difference_update(bzrdir.format_registry.aliases())
506
455
    for key in non_aliases:
507
 
        format = controldir.format_registry.make_controldir(key)
 
456
        format = bzrdir.format_registry.make_bzrdir(key)
508
457
        if isinstance(format, bzrdir.BzrDirMetaFormat1):
509
458
            if (tree and format.workingtree_format !=
510
 
                    tree._format):
 
459
                tree._format):
511
460
                continue
512
461
            if (branch and format.get_branch_format() !=
513
 
                    branch._format):
 
462
                branch._format):
514
463
                continue
515
464
            if (repository and format.repository_format !=
516
 
                    repository._format):
 
465
                repository._format):
517
466
                continue
518
467
        if format.__class__ is not control._format.__class__:
519
468
            continue
522
471
        return 'unnamed'
523
472
    candidates.sort()
524
473
    new_candidates = [c for c in candidates if not
525
 
                      controldir.format_registry.get_info(c).hidden]
 
474
        bzrdir.format_registry.get_info(c).hidden]
526
475
    if len(new_candidates) > 0:
527
476
        # If there are any non-hidden formats that match, only return those to
528
477
        # avoid listing hidden formats except when only a hidden format will
535
484
    """Hooks for the info command."""
536
485
 
537
486
    def __init__(self):
538
 
        super(InfoHooks, self).__init__("breezy.info", "hooks")
539
 
        self.add_hook(
540
 
            'repository',
 
487
        self.create_hook(_mod_hooks.HookPoint('repository',
541
488
            "Invoked when displaying the statistics for a repository. "
542
489
            "repository is called with a statistics dictionary as returned "
543
 
            "by the repository and a file-like object to write to.", (1, 15))
 
490
            "by the repository and a file-like object to write to.", (1, 15), 
 
491
            None))
544
492
 
545
493
 
546
494
hooks = InfoHooks()