/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 breezy/info.py

  • Committer: Jelmer Vernooij
  • Date: 2017-07-23 15:59:57 UTC
  • mto: This revision was merged to the branch mainline in revision 6740.
  • Revision ID: jelmer@jelmer.uk-20170723155957-rw4kqurf44fqx4x0
Move AlreadyBuilding/NotBuilding errors.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/info.py
 
1
# Copyright (C) 2005-2010 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
from __future__ import absolute_import
 
18
 
 
19
__all__ = ['show_bzrdir_info']
 
20
 
 
21
import time
 
22
import sys
 
23
 
 
24
from . import (
 
25
    controldir,
 
26
    errors,
 
27
    hooks as _mod_hooks,
 
28
    osutils,
 
29
    urlutils,
 
30
    )
 
31
from .bzr import (
 
32
    bzrdir,
 
33
    )
 
34
from .errors import (NoWorkingTree, NotBranchError,
 
35
                           NoRepositoryPresent, NotLocalUrl)
 
36
from .missing import find_unmerged
 
37
from .sixish import (
 
38
    BytesIO,
 
39
    )
 
40
 
 
41
 
 
42
def plural(n, base='', pl=None):
 
43
    if n == 1:
 
44
        return base
 
45
    elif pl is not None:
 
46
        return pl
 
47
    else:
 
48
        return 's'
 
49
 
 
50
 
 
51
class LocationList(object):
 
52
 
 
53
    def __init__(self, base_path):
 
54
        self.locs = []
 
55
        self.base_path = base_path
 
56
 
 
57
    def add_url(self, label, url):
 
58
        """Add a URL to the list, converting it to a path if possible"""
 
59
        if url is None:
 
60
            return
 
61
        try:
 
62
            path = urlutils.local_path_from_url(url)
 
63
        except errors.InvalidURL:
 
64
            self.locs.append((label, url))
 
65
        else:
 
66
            self.add_path(label, path)
 
67
 
 
68
    def add_path(self, label, path):
 
69
        """Add a path, converting it to a relative path if possible"""
 
70
        try:
 
71
            path = osutils.relpath(self.base_path, path)
 
72
        except errors.PathNotChild:
 
73
            pass
 
74
        else:
 
75
            if path == '':
 
76
                path = '.'
 
77
        if path != '/':
 
78
            path = path.rstrip('/')
 
79
        self.locs.append((label, path))
 
80
 
 
81
    def get_lines(self):
 
82
        max_len = max(len(l) for l, u in self.locs)
 
83
        return ["  %*s: %s\n" % (max_len, l, u) for l, u in self.locs ]
 
84
 
 
85
 
 
86
def gather_location_info(repository=None, branch=None, working=None,
 
87
        control=None):
 
88
    locs = {}
 
89
    if branch is not None:
 
90
        branch_path = branch.user_url
 
91
        master_path = branch.get_bound_location()
 
92
        if master_path is None:
 
93
            master_path = branch_path
 
94
    else:
 
95
        branch_path = None
 
96
        master_path = None
 
97
        try:
 
98
            if control is not None and control.get_branch_reference():
 
99
                locs['checkout of branch'] = control.get_branch_reference()
 
100
        except NotBranchError:
 
101
            pass
 
102
    if working:
 
103
        working_path = working.user_url
 
104
        if working_path != branch_path:
 
105
            locs['light checkout root'] = working_path
 
106
        if master_path != branch_path:
 
107
            if repository.is_shared():
 
108
                locs['repository checkout root'] = branch_path
 
109
            else:
 
110
                locs['checkout root'] = branch_path
 
111
        if working_path != master_path:
 
112
            locs['checkout of branch'] = master_path
 
113
        elif repository.is_shared():
 
114
            locs['repository branch'] = branch_path
 
115
        elif branch_path is not None:
 
116
            # standalone
 
117
            locs['branch root'] = branch_path
 
118
    else:
 
119
        working_path = None
 
120
        if repository is not None and repository.is_shared():
 
121
            # lightweight checkout of branch in shared repository
 
122
            if branch_path is not None:
 
123
                locs['repository branch'] = branch_path
 
124
        elif branch_path is not None:
 
125
            # standalone
 
126
            locs['branch root'] = branch_path
 
127
        elif repository is not None:
 
128
            locs['repository'] = repository.user_url
 
129
        elif control is not None:
 
130
            locs['control directory'] = control.user_url
 
131
        else:
 
132
            # Really, at least a control directory should be
 
133
            # passed in for this method to be useful.
 
134
            pass
 
135
        if master_path != branch_path:
 
136
            locs['bound to branch'] = master_path
 
137
    if repository is not None and repository.is_shared():
 
138
        # lightweight checkout of branch in shared repository
 
139
        locs['shared repository'] = repository.user_url
 
140
    order = ['control directory', 'light checkout root',
 
141
             'repository checkout root', 'checkout root',
 
142
             'checkout of branch', 'shared repository',
 
143
             'repository', 'repository branch', 'branch root',
 
144
             'bound to branch']
 
145
    return [(n, locs[n]) for n in order if n in locs]
 
146
 
 
147
 
 
148
def _show_location_info(locs, outfile):
 
149
    """Show known locations for working, branch and repository."""
 
150
    outfile.write('Location:\n')
 
151
    path_list = LocationList(osutils.getcwd())
 
152
    for name, loc in locs:
 
153
        path_list.add_url(name, loc)
 
154
    outfile.writelines(path_list.get_lines())
 
155
 
 
156
 
 
157
def _gather_related_branches(branch):
 
158
    locs = LocationList(osutils.getcwd())
 
159
    locs.add_url('public branch', branch.get_public_branch())
 
160
    locs.add_url('push branch', branch.get_push_location())
 
161
    locs.add_url('parent branch', branch.get_parent())
 
162
    locs.add_url('submit branch', branch.get_submit_branch())
 
163
    try:
 
164
        locs.add_url('stacked on', branch.get_stacked_on_url())
 
165
    except (errors.UnstackableBranchFormat, errors.UnstackableRepositoryFormat,
 
166
        errors.NotStacked):
 
167
        pass
 
168
    return locs
 
169
 
 
170
 
 
171
def _show_related_info(branch, outfile):
 
172
    """Show parent and push location of branch."""
 
173
    locs = _gather_related_branches(branch)
 
174
    if len(locs.locs) > 0:
 
175
        outfile.write('\n')
 
176
        outfile.write('Related branches:\n')
 
177
        outfile.writelines(locs.get_lines())
 
178
 
 
179
 
 
180
def _show_control_dir_info(control, outfile):
 
181
    """Show control dir information."""
 
182
    if control._format.colocated_branches:
 
183
        outfile.write('\n')
 
184
        outfile.write('Control directory:\n')
 
185
        outfile.write('         %d branches\n' % len(control.list_branches()))
 
186
 
 
187
 
 
188
def _show_format_info(control=None, repository=None, branch=None,
 
189
                      working=None, outfile=None):
 
190
    """Show known formats for control, working, branch and repository."""
 
191
    outfile.write('\n')
 
192
    outfile.write('Format:\n')
 
193
    if control:
 
194
        outfile.write('       control: %s\n' %
 
195
            control._format.get_format_description())
 
196
    if working:
 
197
        outfile.write('  working tree: %s\n' %
 
198
            working._format.get_format_description())
 
199
    if branch:
 
200
        outfile.write('        branch: %s\n' %
 
201
            branch._format.get_format_description())
 
202
    if repository:
 
203
        outfile.write('    repository: %s\n' %
 
204
            repository._format.get_format_description())
 
205
 
 
206
 
 
207
def _show_locking_info(repository=None, branch=None, working=None,
 
208
        outfile=None):
 
209
    """Show locking status of working, branch and repository."""
 
210
    if (repository and repository.get_physical_lock_status() or
 
211
        (branch and branch.get_physical_lock_status()) or
 
212
        (working and working.get_physical_lock_status())):
 
213
        outfile.write('\n')
 
214
        outfile.write('Lock status:\n')
 
215
        if working:
 
216
            if working.get_physical_lock_status():
 
217
                status = 'locked'
 
218
            else:
 
219
                status = 'unlocked'
 
220
            outfile.write('  working tree: %s\n' % status)
 
221
        if branch:
 
222
            if branch.get_physical_lock_status():
 
223
                status = 'locked'
 
224
            else:
 
225
                status = 'unlocked'
 
226
            outfile.write('        branch: %s\n' % status)
 
227
        if repository:
 
228
            if repository.get_physical_lock_status():
 
229
                status = 'locked'
 
230
            else:
 
231
                status = 'unlocked'
 
232
            outfile.write('    repository: %s\n' % status)
 
233
 
 
234
 
 
235
def _show_missing_revisions_branch(branch, outfile):
 
236
    """Show missing master revisions in branch."""
 
237
    # Try with inaccessible branch ?
 
238
    master = branch.get_master_branch()
 
239
    if master:
 
240
        local_extra, remote_extra = find_unmerged(branch, master)
 
241
        if remote_extra:
 
242
            outfile.write('\n')
 
243
            outfile.write(('Branch is out of date: missing %d '
 
244
                'revision%s.\n') % (len(remote_extra),
 
245
                plural(len(remote_extra))))
 
246
 
 
247
 
 
248
def _show_missing_revisions_working(working, outfile):
 
249
    """Show missing revisions in working tree."""
 
250
    branch = working.branch
 
251
    basis = working.basis_tree()
 
252
    try:
 
253
        branch_revno, branch_last_revision = branch.last_revision_info()
 
254
    except errors.UnsupportedOperation:
 
255
        return
 
256
    try:
 
257
        tree_last_id = working.get_parent_ids()[0]
 
258
    except IndexError:
 
259
        tree_last_id = None
 
260
 
 
261
    if branch_revno and tree_last_id != branch_last_revision:
 
262
        tree_last_revno = branch.revision_id_to_revno(tree_last_id)
 
263
        missing_count = branch_revno - tree_last_revno
 
264
        outfile.write('\n')
 
265
        outfile.write(('Working tree is out of date: missing %d '
 
266
            'revision%s.\n') % (missing_count, plural(missing_count)))
 
267
 
 
268
 
 
269
def _show_working_stats(working, outfile):
 
270
    """Show statistics about a working tree."""
 
271
    basis = working.basis_tree()
 
272
    delta = working.changes_from(basis, want_unchanged=True)
 
273
 
 
274
    outfile.write('\n')
 
275
    outfile.write('In the working tree:\n')
 
276
    outfile.write('  %8s unchanged\n' % len(delta.unchanged))
 
277
    outfile.write('  %8d modified\n' % len(delta.modified))
 
278
    outfile.write('  %8d added\n' % len(delta.added))
 
279
    outfile.write('  %8d removed\n' % len(delta.removed))
 
280
    outfile.write('  %8d renamed\n' % len(delta.renamed))
 
281
 
 
282
    ignore_cnt = unknown_cnt = 0
 
283
    for path in working.extras():
 
284
        if working.is_ignored(path):
 
285
            ignore_cnt += 1
 
286
        else:
 
287
            unknown_cnt += 1
 
288
    outfile.write('  %8d unknown\n' % unknown_cnt)
 
289
    outfile.write('  %8d ignored\n' % ignore_cnt)
 
290
 
 
291
    dir_cnt = 0
 
292
    root_id = working.get_root_id()
 
293
    for path, entry in working.iter_entries_by_dir():
 
294
        if entry.kind == 'directory' and entry.file_id != root_id:
 
295
            dir_cnt += 1
 
296
    outfile.write('  %8d versioned %s\n' % (dir_cnt,
 
297
        plural(dir_cnt, 'subdirectory', 'subdirectories')))
 
298
 
 
299
 
 
300
def _show_branch_stats(branch, verbose, outfile):
 
301
    """Show statistics about a branch."""
 
302
    try:
 
303
        revno, head = branch.last_revision_info()
 
304
    except errors.UnsupportedOperation:
 
305
        return {}
 
306
    outfile.write('\n')
 
307
    outfile.write('Branch history:\n')
 
308
    outfile.write('  %8d revision%s\n' % (revno, plural(revno)))
 
309
    stats = branch.repository.gather_stats(head, committers=verbose)
 
310
    if verbose:
 
311
        committers = stats['committers']
 
312
        outfile.write('  %8d committer%s\n' % (committers,
 
313
            plural(committers)))
 
314
    if revno:
 
315
        timestamp, timezone = stats['firstrev']
 
316
        age = int((time.time() - timestamp) / 3600 / 24)
 
317
        outfile.write('  %8d day%s old\n' % (age, plural(age)))
 
318
        outfile.write('   first revision: %s\n' %
 
319
            osutils.format_date(timestamp, timezone))
 
320
        timestamp, timezone = stats['latestrev']
 
321
        outfile.write('  latest revision: %s\n' %
 
322
            osutils.format_date(timestamp, timezone))
 
323
    return stats
 
324
 
 
325
 
 
326
def _show_repository_info(repository, outfile):
 
327
    """Show settings of a repository."""
 
328
    if repository.make_working_trees():
 
329
        outfile.write('\n')
 
330
        outfile.write('Create working tree for new branches inside '
 
331
            'the repository.\n')
 
332
 
 
333
 
 
334
def _show_repository_stats(repository, stats, outfile):
 
335
    """Show statistics about a repository."""
 
336
    f = BytesIO()
 
337
    if 'revisions' in stats:
 
338
        revisions = stats['revisions']
 
339
        f.write('  %8d revision%s\n' % (revisions, plural(revisions)))
 
340
    if 'size' in stats:
 
341
        f.write('  %8d KiB\n' % (stats['size']/1024))
 
342
    for hook in hooks['repository']:
 
343
        hook(repository, stats, f)
 
344
    if f.getvalue() != "":
 
345
        outfile.write('\n')
 
346
        outfile.write('Repository:\n')
 
347
        outfile.write(f.getvalue())
 
348
 
 
349
 
 
350
def show_bzrdir_info(a_controldir, verbose=False, outfile=None):
 
351
    """Output to stdout the 'info' for a_controldir."""
 
352
    if outfile is None:
 
353
        outfile = sys.stdout
 
354
    try:
 
355
        tree = a_controldir.open_workingtree(
 
356
            recommend_upgrade=False)
 
357
    except (NoWorkingTree, NotLocalUrl, NotBranchError):
 
358
        tree = None
 
359
        try:
 
360
            branch = a_controldir.open_branch(name="")
 
361
        except NotBranchError:
 
362
            branch = None
 
363
            try:
 
364
                repository = a_controldir.open_repository()
 
365
            except NoRepositoryPresent:
 
366
                lockable = None
 
367
                repository = None
 
368
            else:
 
369
                lockable = repository
 
370
        else:
 
371
            repository = branch.repository
 
372
            lockable = branch
 
373
    else:
 
374
        branch = tree.branch
 
375
        repository = branch.repository
 
376
        lockable = tree
 
377
 
 
378
    if lockable is not None:
 
379
        lockable.lock_read()
 
380
    try:
 
381
        show_component_info(a_controldir, repository, branch, tree, verbose,
 
382
                            outfile)
 
383
    finally:
 
384
        if lockable is not None:
 
385
            lockable.unlock()
 
386
 
 
387
 
 
388
def show_component_info(control, repository, branch=None, working=None,
 
389
    verbose=1, outfile=None):
 
390
    """Write info about all bzrdir components to stdout"""
 
391
    if outfile is None:
 
392
        outfile = sys.stdout
 
393
    if verbose is False:
 
394
        verbose = 1
 
395
    if verbose is True:
 
396
        verbose = 2
 
397
    layout = describe_layout(repository, branch, working, control)
 
398
    format = describe_format(control, repository, branch, working)
 
399
    outfile.write("%s (format: %s)\n" % (layout, format))
 
400
    _show_location_info(
 
401
        gather_location_info(control=control, repository=repository,
 
402
            branch=branch, working=working),
 
403
        outfile)
 
404
    if branch is not None:
 
405
        _show_related_info(branch, outfile)
 
406
    if verbose == 0:
 
407
        return
 
408
    _show_format_info(control, repository, branch, working, outfile)
 
409
    _show_locking_info(repository, branch, working, outfile)
 
410
    _show_control_dir_info(control, outfile)
 
411
    if branch is not None:
 
412
        _show_missing_revisions_branch(branch, outfile)
 
413
    if working is not None:
 
414
        _show_missing_revisions_working(working, outfile)
 
415
        _show_working_stats(working, outfile)
 
416
    elif branch is not None:
 
417
        _show_missing_revisions_branch(branch, outfile)
 
418
    if branch is not None:
 
419
        show_committers = verbose >= 2
 
420
        stats = _show_branch_stats(branch, show_committers, outfile)
 
421
    elif repository is not None:
 
422
        stats = repository.gather_stats()
 
423
    if branch is None and working is None and repository is not None:
 
424
        _show_repository_info(repository, outfile)
 
425
    if repository is not None:
 
426
        _show_repository_stats(repository, stats, outfile)
 
427
 
 
428
 
 
429
def describe_layout(repository=None, branch=None, tree=None, control=None):
 
430
    """Convert a control directory layout into a user-understandable term
 
431
 
 
432
    Common outputs include "Standalone tree", "Repository branch" and
 
433
    "Checkout".  Uncommon outputs include "Unshared repository with trees"
 
434
    and "Empty control directory"
 
435
    """
 
436
    if branch is None and control is not None:
 
437
        try:
 
438
            branch_reference = control.get_branch_reference()
 
439
        except NotBranchError:
 
440
            pass
 
441
        else:
 
442
            if branch_reference is not None:
 
443
                return "Dangling branch reference"
 
444
    if repository is None:
 
445
        return 'Empty control directory'
 
446
    if branch is None and tree is None:
 
447
        if repository.is_shared():
 
448
            phrase = 'Shared repository'
 
449
        else:
 
450
            phrase = 'Unshared repository'
 
451
        extra = []
 
452
        if repository.make_working_trees():
 
453
            extra.append('trees')
 
454
        if len(control.get_branches()) > 0:
 
455
            extra.append('colocated branches')
 
456
        if extra:
 
457
            phrase += ' with ' + " and ".join(extra)
 
458
        return phrase
 
459
    else:
 
460
        if repository.is_shared():
 
461
            independence = "Repository "
 
462
        else:
 
463
            independence = "Standalone "
 
464
        if tree is not None:
 
465
            phrase = "tree"
 
466
        else:
 
467
            phrase = "branch"
 
468
        if branch is None and tree is not None:
 
469
            phrase = "branchless tree"
 
470
        else:
 
471
            if (tree is not None and tree.user_url !=
 
472
                branch.user_url):
 
473
                independence = ''
 
474
                phrase = "Lightweight checkout"
 
475
            elif branch.get_bound_location() is not None:
 
476
                if independence == 'Standalone ':
 
477
                    independence = ''
 
478
                if tree is None:
 
479
                    phrase = "Bound branch"
 
480
                else:
 
481
                    phrase = "Checkout"
 
482
        if independence != "":
 
483
            phrase = phrase.lower()
 
484
        return "%s%s" % (independence, phrase)
 
485
 
 
486
 
 
487
def describe_format(control, repository, branch, tree):
 
488
    """Determine the format of an existing control directory
 
489
 
 
490
    Several candidates may be found.  If so, the names are returned as a
 
491
    single string, separated by ' or '.
 
492
 
 
493
    If no matching candidate is found, "unnamed" is returned.
 
494
    """
 
495
    candidates  = []
 
496
    if (branch is not None and tree is not None and
 
497
        branch.user_url != tree.user_url):
 
498
        branch = None
 
499
        repository = None
 
500
    non_aliases = set(controldir.format_registry.keys())
 
501
    non_aliases.difference_update(controldir.format_registry.aliases())
 
502
    for key in non_aliases:
 
503
        format = controldir.format_registry.make_controldir(key)
 
504
        if isinstance(format, bzrdir.BzrDirMetaFormat1):
 
505
            if (tree and format.workingtree_format !=
 
506
                tree._format):
 
507
                continue
 
508
            if (branch and format.get_branch_format() !=
 
509
                branch._format):
 
510
                continue
 
511
            if (repository and format.repository_format !=
 
512
                repository._format):
 
513
                continue
 
514
        if format.__class__ is not control._format.__class__:
 
515
            continue
 
516
        candidates.append(key)
 
517
    if len(candidates) == 0:
 
518
        return 'unnamed'
 
519
    candidates.sort()
 
520
    new_candidates = [c for c in candidates if not
 
521
        controldir.format_registry.get_info(c).hidden]
 
522
    if len(new_candidates) > 0:
 
523
        # If there are any non-hidden formats that match, only return those to
 
524
        # avoid listing hidden formats except when only a hidden format will
 
525
        # do.
 
526
        candidates = new_candidates
 
527
    return ' or '.join(candidates)
 
528
 
 
529
 
 
530
class InfoHooks(_mod_hooks.Hooks):
 
531
    """Hooks for the info command."""
 
532
 
 
533
    def __init__(self):
 
534
        super(InfoHooks, self).__init__("breezy.info", "hooks")
 
535
        self.add_hook('repository',
 
536
            "Invoked when displaying the statistics for a repository. "
 
537
            "repository is called with a statistics dictionary as returned "
 
538
            "by the repository and a file-like object to write to.", (1, 15))
 
539
 
 
540
 
 
541
hooks = InfoHooks()