← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/info.py

  • Committer: Robert Collins
  • Date: 2007-07-25 00:52:21 UTC
  • mfrom: (2650 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2651.
  • Revision ID: robertc@robertcollins.net-20070725005221-0ysm6il5mqnme3wz
Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/info.py
1
 
# Copyright (C) 2004, 2005 by Martin Pool
2
 
# Copyright (C) 2005 by Canonical Ltd
3
 
 
4
 
 
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
2
# 
5
3
# This program is free software; you can redistribute it and/or modify
6
4
# it under the terms of the GNU General Public License as published by
7
5
# the Free Software Foundation; either version 2 of the License, or
8
6
# (at your option) any later version.
9
 
 
 
7
#
10
8
# This program is distributed in the hope that it will be useful,
11
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
11
# GNU General Public License for more details.
14
 
 
 
12
#
15
13
# You should have received a copy of the GNU General Public License
16
14
# along with this program; if not, write to the Free Software
17
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
16
 
 
17
__all__ = ['show_bzrdir_info']
 
18
 
 
19
import os
19
20
import time
20
 
 
21
 
from osutils import format_date
22
 
 
23
 
 
24
 
def _countiter(it):
25
 
    # surely there's a builtin for this?
26
 
    i = 0
27
 
    for j in it:
28
 
        i += 1
29
 
    return i        
30
 
 
31
 
 
32
 
 
33
 
def show_info(b):
34
 
    import diff
35
 
    
36
 
    print 'branch format:', b.controlfile('branch-format', 'r').readline().rstrip('\n')
37
 
 
38
 
    def plural(n, base='', pl=None):
39
 
        if n == 1:
40
 
            return base
41
 
        elif pl != None:
42
 
            return pl
43
 
        else:
44
 
            return 's'
45
 
 
46
 
    count_version_dirs = 0
47
 
 
48
 
    basis = b.basis_tree()
49
 
    working = b.working_tree()
50
 
    work_inv = working.inventory
51
 
    delta = diff.compare_trees(basis, working, want_unchanged=True)
52
 
    
53
 
    print
54
 
    print 'in the working tree:'
 
21
import sys
 
22
 
 
23
from bzrlib import (
 
24
    bzrdir,
 
25
    diff,
 
26
    errors,
 
27
    osutils,
 
28
    urlutils,
 
29
    )
 
30
from bzrlib.errors import (NoWorkingTree, NotBranchError,
 
31
                           NoRepositoryPresent, NotLocalUrl)
 
32
from bzrlib.missing import find_unmerged
 
33
from bzrlib.symbol_versioning import (deprecated_function,
 
34
        zero_eight, zero_eighteen)
 
35
 
 
36
 
 
37
def plural(n, base='', pl=None):
 
38
    if n == 1:
 
39
        return base
 
40
    elif pl is not None:
 
41
        return pl
 
42
    else:
 
43
        return 's'
 
44
 
 
45
 
 
46
class LocationList(object):
 
47
 
 
48
    def __init__(self, base_path):
 
49
        self.locs = []
 
50
        self.base_path = base_path
 
51
 
 
52
    def add_url(self, label, url):
 
53
        """Add a URL to the list, converting it to a path if possible"""
 
54
        if url is None:
 
55
            return
 
56
        try:
 
57
            path = urlutils.local_path_from_url(url)
 
58
        except errors.InvalidURL:
 
59
            self.locs.append((label, url))
 
60
        else:
 
61
            self.add_path(label, path)
 
62
 
 
63
    def add_path(self, label, path):
 
64
        """Add a path, converting it to a relative path if possible"""
 
65
        try:
 
66
            path = osutils.relpath(self.base_path, path)
 
67
        except errors.PathNotChild:
 
68
            pass
 
69
        else:
 
70
            if path == '':
 
71
                path = '.'
 
72
        if path != '/':
 
73
            path = path.rstrip('/')
 
74
        self.locs.append((label, path))
 
75
 
 
76
    def get_lines(self):
 
77
        max_len = max(len(l) for l, u in self.locs)
 
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):
 
82
    locs = {}
 
83
    repository_path = repository.bzrdir.root_transport.base
 
84
    if branch is not None:
 
85
        branch_path = branch.bzrdir.root_transport.base
 
86
        master_path = branch.get_bound_location()
 
87
        if master_path is None:
 
88
            master_path = branch_path
 
89
    else:
 
90
        branch_path = None
 
91
        master_path = None
 
92
    if working:
 
93
        working_path = working.bzrdir.root_transport.base
 
94
        if working_path != branch_path:
 
95
            locs['light checkout root'] = working_path
 
96
        if master_path != branch_path:
 
97
            if repository.is_shared():
 
98
                locs['repository checkout root'] = branch_path
 
99
            else:
 
100
                locs['checkout root'] = branch_path
 
101
        if working_path != master_path:
 
102
            locs['checkout of branch'] = master_path
 
103
        elif repository.is_shared():
 
104
            locs['repository branch'] = branch_path
 
105
        elif branch_path is not None:
 
106
            # standalone
 
107
            locs['branch root'] = branch_path
 
108
    else:
 
109
        working_path = None
 
110
        if repository.is_shared():
 
111
            # lightweight checkout of branch in shared repository
 
112
            if branch_path is not None:
 
113
                locs['repository branch'] = branch_path
 
114
        elif branch_path is not None:
 
115
            # standalone
 
116
            locs['branch root'] = branch_path
 
117
            if master_path != branch_path:
 
118
                locs['bound to branch'] = master_path
 
119
        else:
 
120
            locs['repository'] = repository_path
 
121
    if repository.is_shared():
 
122
        # lightweight checkout of branch in shared repository
 
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']
 
128
    return [(n, locs[n]) for n in order if n in locs]
 
129
 
 
130
 
 
131
def _show_location_info(locs):
 
132
    """Show known locations for working, branch and repository."""
 
133
    print 'Location:'
 
134
    path_list = LocationList(os.getcwd())
 
135
    for name, loc in locs:
 
136
        path_list.add_url(name, loc)
 
137
    sys.stdout.writelines(path_list.get_lines())
 
138
 
 
139
def _gather_related_branches(branch):
 
140
    locs = LocationList(os.getcwd())
 
141
    locs.add_url('public branch', branch.get_public_branch())
 
142
    locs.add_url('push branch', branch.get_push_location())
 
143
    locs.add_url('parent branch', branch.get_parent())
 
144
    locs.add_url('submit branch', branch.get_submit_branch())
 
145
    return locs
 
146
 
 
147
def _show_related_info(branch, outfile):
 
148
    """Show parent and push location of branch."""
 
149
    locs = _gather_related_branches(branch)
 
150
    if len(locs.locs) > 0:
 
151
        print >> outfile
 
152
        print >> outfile, 'Related branches:'
 
153
        outfile.writelines(locs.get_lines())
 
154
 
 
155
 
 
156
def _show_format_info(control=None, repository=None, branch=None, working=None):
 
157
    """Show known formats for control, working, branch and repository."""
 
158
    print
 
159
    print 'Format:'
 
160
    if control:
 
161
        print '       control: %s' % control._format.get_format_description()
 
162
    if working:
 
163
        print '  working tree: %s' % working._format.get_format_description()
 
164
    if branch:
 
165
        print '        branch: %s' % branch._format.get_format_description()
 
166
    if repository:
 
167
        print '    repository: %s' % repository._format.get_format_description()
 
168
 
 
169
 
 
170
def _show_locking_info(repository, branch=None, working=None):
 
171
    """Show locking status of working, branch and repository."""
 
172
    if (repository.get_physical_lock_status() or
 
173
        (branch and branch.get_physical_lock_status()) or
 
174
        (working and working.get_physical_lock_status())):
 
175
        print
 
176
        print 'Lock status:'
 
177
        if working:
 
178
            if working.get_physical_lock_status():
 
179
                status = 'locked'
 
180
            else:
 
181
                status = 'unlocked'
 
182
            print '  working tree: %s' % status
 
183
        if branch:
 
184
            if branch.get_physical_lock_status():
 
185
                status = 'locked'
 
186
            else:
 
187
                status = 'unlocked'
 
188
            print '        branch: %s' % status
 
189
        if repository:
 
190
            if repository.get_physical_lock_status():
 
191
                status = 'locked'
 
192
            else:
 
193
                status = 'unlocked'
 
194
            print '    repository: %s' % status
 
195
 
 
196
 
 
197
def _show_missing_revisions_branch(branch):
 
198
    """Show missing master revisions in branch."""
 
199
    # Try with inaccessible branch ?
 
200
    master = branch.get_master_branch()
 
201
    if master:
 
202
        local_extra, remote_extra = find_unmerged(branch, master)
 
203
        if remote_extra:
 
204
            print
 
205
            print 'Branch is out of date: missing %d revision%s.' % (
 
206
                len(remote_extra), plural(len(remote_extra)))
 
207
 
 
208
 
 
209
def _show_missing_revisions_working(working):
 
210
    """Show missing revisions in working tree."""
 
211
    branch = working.branch
 
212
    basis = working.basis_tree()
 
213
    work_inv = working.inventory
 
214
    branch_revno, branch_last_revision = branch.last_revision_info()
 
215
    try:
 
216
        tree_last_id = working.get_parent_ids()[0]
 
217
    except IndexError:
 
218
        tree_last_id = None
 
219
 
 
220
    if branch_revno and tree_last_id != branch_last_revision:
 
221
        tree_last_revno = branch.revision_id_to_revno(tree_last_id)
 
222
        missing_count = branch_revno - tree_last_revno
 
223
        print
 
224
        print 'Working tree is out of date: missing %d revision%s.' % (
 
225
            missing_count, plural(missing_count))
 
226
 
 
227
 
 
228
def _show_working_stats(working):
 
229
    """Show statistics about a working tree."""
 
230
    basis = working.basis_tree()
 
231
    work_inv = working.inventory
 
232
    delta = working.changes_from(basis, want_unchanged=True)
 
233
 
 
234
    print
 
235
    print 'In the working tree:'
55
236
    print '  %8s unchanged' % len(delta.unchanged)
56
237
    print '  %8d modified' % len(delta.modified)
57
238
    print '  %8d added' % len(delta.added)
64
245
            ignore_cnt += 1
65
246
        else:
66
247
            unknown_cnt += 1
67
 
 
68
248
    print '  %8d unknown' % unknown_cnt
69
249
    print '  %8d ignored' % ignore_cnt
70
250
 
71
251
    dir_cnt = 0
72
252
    for file_id in work_inv:
73
 
        if work_inv.get_file_kind(file_id) == 'directory':
 
253
        if (work_inv.get_file_kind(file_id) == 'directory' and 
 
254
            not work_inv.is_root(file_id)):
74
255
            dir_cnt += 1
75
256
    print '  %8d versioned %s' \
76
257
          % (dir_cnt,
77
258
             plural(dir_cnt, 'subdirectory', 'subdirectories'))
78
259
 
 
260
 
 
261
def _show_branch_stats(branch, verbose):
 
262
    """Show statistics about a branch."""
 
263
    revno, head = branch.last_revision_info()
79
264
    print
80
 
    print 'branch history:'
81
 
    history = b.revision_history()
82
 
    revno = len(history)
 
265
    print 'Branch history:'
83
266
    print '  %8d revision%s' % (revno, plural(revno))
84
 
    committers = {}
85
 
    for rev in history:
86
 
        committers[b.get_revision(rev).committer] = True
87
 
    print '  %8d committer%s' % (len(committers), plural(len(committers)))
88
 
    if revno > 0:
89
 
        firstrev = b.get_revision(history[0])
90
 
        age = int((time.time() - firstrev.timestamp) / 3600 / 24)
 
267
    stats = branch.repository.gather_stats(head, committers=verbose)
 
268
    if verbose:
 
269
        committers = stats['committers']
 
270
        print '  %8d committer%s' % (committers, plural(committers))
 
271
    if revno:
 
272
        timestamp, timezone = stats['firstrev']
 
273
        age = int((time.time() - timestamp) / 3600 / 24)
91
274
        print '  %8d day%s old' % (age, plural(age))
92
 
        print '   first revision: %s' % format_date(firstrev.timestamp,
93
 
                                                    firstrev.timezone)
94
 
 
95
 
        lastrev = b.get_revision(history[-1])
96
 
        print '  latest revision: %s' % format_date(lastrev.timestamp,
97
 
                                                    lastrev.timezone)
98
 
 
99
 
    print
100
 
    print 'text store:'
101
 
    c, t = b.text_store.total_size()
102
 
    print '  %8d file texts' % c
103
 
    print '  %8d kB' % (t/1024)
104
 
 
105
 
    print
106
 
    print 'revision store:'
107
 
    c, t = b.revision_store.total_size()
108
 
    print '  %8d revisions' % c
109
 
    print '  %8d kB' % (t/1024)
110
 
 
111
 
 
112
 
    print
113
 
    print 'inventory store:'
114
 
    c, t = b.inventory_store.total_size()
115
 
    print '  %8d inventories' % c
116
 
    print '  %8d kB' % (t/1024)
117
 
 
 
275
        print '   first revision: %s' % osutils.format_date(timestamp,
 
276
            timezone)
 
277
        timestamp, timezone = stats['latestrev']
 
278
        print '  latest revision: %s' % osutils.format_date(timestamp,
 
279
            timezone)
 
280
    return stats
 
281
 
 
282
 
 
283
def _show_repository_info(repository):
 
284
    """Show settings of a repository."""
 
285
    if repository.make_working_trees():
 
286
        print
 
287
        print 'Create working tree for new branches inside the repository.'
 
288
 
 
289
 
 
290
def _show_repository_stats(stats):
 
291
    """Show statistics about a repository."""
 
292
    if 'revisions' in stats or 'size' in stats:
 
293
        print
 
294
        print 'Repository:'
 
295
    if 'revisions' in stats:
 
296
        revisions = stats['revisions']
 
297
        print '  %8d revision%s' % (revisions, plural(revisions))
 
298
    if 'size' in stats:
 
299
        print '  %8d KiB' % (stats['size']/1024)
 
300
 
 
301
def show_bzrdir_info(a_bzrdir, verbose=False):
 
302
    """Output to stdout the 'info' for a_bzrdir."""
 
303
    try:
 
304
        tree = a_bzrdir.open_workingtree(
 
305
            recommend_upgrade=False)
 
306
    except (NoWorkingTree, NotLocalUrl):
 
307
        tree = None
 
308
        try:
 
309
            branch = a_bzrdir.open_branch()
 
310
        except NotBranchError:
 
311
            branch = None
 
312
            try:
 
313
                repository = a_bzrdir.open_repository()
 
314
            except NoRepositoryPresent:
 
315
                # Return silently; cmd_info already returned NotBranchError
 
316
                # if no bzrdir could be opened.
 
317
                return
 
318
            else:
 
319
                lockable = repository
 
320
        else:
 
321
            repository = branch.repository
 
322
            lockable = branch
 
323
    else:
 
324
        branch = tree.branch
 
325
        repository = branch.repository
 
326
        lockable = tree
 
327
 
 
328
    lockable.lock_read()
 
329
    try:
 
330
        show_component_info(a_bzrdir, repository, branch, tree, verbose)
 
331
    finally:
 
332
        lockable.unlock()
 
333
 
 
334
 
 
335
def show_component_info(control, repository, branch=None, working=None,
 
336
    verbose=1):
 
337
    """Write info about all bzrdir components to stdout"""
 
338
    if verbose is False:
 
339
        verbose = 1
 
340
    if verbose is True:
 
341
        verbose = 2
 
342
    layout = describe_layout(repository, branch, working)
 
343
    format = describe_format(control, repository, branch, working)
 
344
    print "%s (format: %s)" % (layout, format)
 
345
    _show_location_info(gather_location_info(repository, branch, working))
 
346
    if branch is not None:
 
347
        _show_related_info(branch, sys.stdout)
 
348
    if verbose == 0:
 
349
        return
 
350
    _show_format_info(control, repository, branch, working)
 
351
    _show_locking_info(repository, branch, working)
 
352
    if branch is not None:
 
353
        _show_missing_revisions_branch(branch)
 
354
    if working is not None:
 
355
        _show_missing_revisions_working(working)
 
356
        _show_working_stats(working)
 
357
    elif branch is not None:
 
358
        _show_missing_revisions_branch(branch)
 
359
    if branch is not None:
 
360
        stats = _show_branch_stats(branch, verbose==2)
 
361
    else:
 
362
        stats = repository.gather_stats()
 
363
    if branch is None and working is None:
 
364
        _show_repository_info(repository)
 
365
    _show_repository_stats(stats)
 
366
 
 
367
 
 
368
def describe_layout(repository=None, branch=None, tree=None):
 
369
    """Convert a control directory layout into a user-understandable term
 
370
 
 
371
    Common outputs include "Standalone tree", "Repository branch" and
 
372
    "Checkout".  Uncommon outputs include "Unshared repository with trees"
 
373
    and "Empty control directory"
 
374
    """
 
375
    if repository is None:
 
376
        return 'Empty control directory'
 
377
    if branch is None and tree is None:
 
378
        if repository.is_shared():
 
379
            phrase = 'Shared repository'
 
380
        else:
 
381
            phrase = 'Unshared repository'
 
382
        if repository.make_working_trees():
 
383
            phrase += ' with trees'
 
384
        return phrase
 
385
    else:
 
386
        if repository.is_shared():
 
387
            independence = "Repository "
 
388
        else:
 
389
            independence = "Standalone "
 
390
        if tree is not None:
 
391
            phrase = "tree"
 
392
        else:
 
393
            phrase = "branch"
 
394
        if branch is None and tree is not None:
 
395
            phrase = "branchless tree"
 
396
        else:
 
397
            if (tree is not None and tree.bzrdir.root_transport.base !=
 
398
                branch.bzrdir.root_transport.base):
 
399
                independence = ''
 
400
                phrase = "Lightweight checkout"
 
401
            elif branch.get_bound_location() is not None:
 
402
                if independence == 'Standalone ':
 
403
                    independence = ''
 
404
                if tree is None:
 
405
                    phrase = "Bound branch"
 
406
                else:
 
407
                    phrase = "Checkout"
 
408
        if independence != "":
 
409
            phrase = phrase.lower()
 
410
        return "%s%s" % (independence, phrase)
 
411
 
 
412
 
 
413
def describe_format(control, repository, branch, tree):
 
414
    """Determine the format of an existing control directory
 
415
 
 
416
    Several candidates may be found.  If so, the names are returned as a
 
417
    single string, separated by ' or '.
 
418
 
 
419
    If no matching candidate is found, "unnamed" is returned.
 
420
    """
 
421
    candidates  = []
 
422
    if (branch is not None and tree is not None and
 
423
        branch.bzrdir.root_transport.base !=
 
424
        tree.bzrdir.root_transport.base):
 
425
        branch = None
 
426
        repository = None
 
427
    for key in bzrdir.format_registry.keys():
 
428
        format = bzrdir.format_registry.make_bzrdir(key)
 
429
        if isinstance(format, bzrdir.BzrDirMetaFormat1):
 
430
            if (tree and format.workingtree_format !=
 
431
                tree._format):
 
432
                continue
 
433
            if (branch and format.get_branch_format() !=
 
434
                branch._format):
 
435
                continue
 
436
            if (repository and format.repository_format !=
 
437
                repository._format):
 
438
                continue
 
439
        if format.__class__ is not control._format.__class__:
 
440
            continue
 
441
        candidates.append(key)
 
442
    if len(candidates) == 0:
 
443
        return 'unnamed'
 
444
    new_candidates = [c for c in candidates if c != 'default']
 
445
    if len(new_candidates) > 0:
 
446
        candidates = new_candidates
 
447
    new_candidates = [c for c in candidates if not
 
448
        bzrdir.format_registry.get_info(c).hidden]
 
449
    if len(new_candidates) > 0:
 
450
        candidates = new_candidates
 
451
    return ' or '.join(candidates)
 
452
 
 
453
@deprecated_function(zero_eight)
 
454
def show_info(b):
 
455
    """Please see show_bzrdir_info."""
 
456
    return show_bzrdir_info(b.bzrdir)
 
457
 
 
458
 
 
459
@deprecated_function(zero_eighteen)
 
460
def show_tree_info(working, verbose):
 
461
    """Output to stdout the 'info' for working."""
 
462
    branch = working.branch
 
463
    repository = branch.repository
 
464
    control = working.bzrdir
 
465
    show_component_info(control, repository, branch, working, verbose)
 
466
 
 
467
 
 
468
@deprecated_function(zero_eighteen)
 
469
def show_branch_info(branch, verbose):
 
470
    """Output to stdout the 'info' for branch."""
 
471
    repository = branch.repository
 
472
    control = branch.bzrdir
 
473
    show_component_info(control, repository, branch, verbose=verbose)
 
474
 
 
475
 
 
476
@deprecated_function(zero_eighteen)
 
477
def show_repository_info(repository, verbose):
 
478
    """Output to stdout the 'info' for repository."""
 
479
    control = repository.bzrdir
 
480
    show_component_info(control, repository, verbose=verbose)