← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/check.py

  • Committer: Vincent Ladeuil
  • Date: 2009-05-05 15:31:34 UTC
  • mto: (4343.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4344.
  • Revision ID: v.ladeuil+lp@free.fr-20090505153134-q4bp4is9gywsmzrv
Clean up test for log formats.

* bzrlib/tests/blackbox/test_logformats.py:
Update tests to actual style.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/check.py
32
32
# raising them.  If there's more than one exception it'd be good to see them
33
33
# all.
34
34
 
35
 
"""Checking of bzr objects.
36
 
 
37
 
check_refs is a concept used for optimising check. Objects that depend on other
38
 
objects (e.g. tree on repository) can list the objects they would be requesting
39
 
so that when the dependent object is checked, matches can be pulled out and
40
 
evaluated in-line rather than re-reading the same data many times.
41
 
check_refs are tuples (kind, value). Currently defined kinds are:
42
 
* 'trees', where value is a revid and the looked up objects are revision trees.
43
 
* 'lefthand-distance', where value is a revid and the looked up objects are the
44
 
  distance along the lefthand path to NULL for that revid.
45
 
* 'revision-existence', where value is a revid, and the result is True or False
46
 
  indicating that the revision was found/not found.
47
 
"""
48
 
 
49
35
from bzrlib import errors, osutils
50
36
from bzrlib import repository as _mod_repository
51
37
from bzrlib import revision
53
39
from bzrlib.bzrdir import BzrDir
54
40
from bzrlib.errors import BzrCheckError
55
41
from bzrlib.repository import Repository
56
 
from bzrlib.revision import NULL_REVISION
57
42
from bzrlib.symbol_versioning import deprecated_function, deprecated_in
58
43
from bzrlib.trace import log_error, note
59
44
import bzrlib.ui
64
49
 
65
50
    # The Check object interacts with InventoryEntry.check, etc.
66
51
 
67
 
    def __init__(self, repository, check_repo=True):
 
52
    def __init__(self, repository):
68
53
        self.repository = repository
 
54
        self.checked_text_cnt = 0
69
55
        self.checked_rev_cnt = 0
70
 
        self.ghosts = set()
 
56
        self.ghosts = []
 
57
        self.repeated_text_cnt = 0
71
58
        self.missing_parent_links = {}
72
59
        self.missing_inventory_sha_cnt = 0
73
60
        self.missing_revision_cnt = 0
 
61
        # maps (file-id, version) -> sha1; used by InventoryFile._check
 
62
        self.checked_texts = {}
74
63
        self.checked_weaves = set()
75
64
        self.unreferenced_versions = set()
76
65
        self.inconsistent_parents = []
77
66
        self.rich_roots = repository.supports_rich_root()
78
67
        self.text_key_references = {}
79
 
        self.check_repo = check_repo
80
 
        self.other_results = []
81
 
        # Plain text lines to include in the report
82
 
        self._report_items = []
83
 
        # Keys we are looking for; may be large and need spilling to disk.
84
 
        # key->(type(revision/inventory/text/signature/map), sha1, first-referer)
85
 
        self.pending_keys = {}
86
 
        # Ancestors map for all of revisions being checked; while large helper
87
 
        # functions we call would create it anyway, so better to have once and
88
 
        # keep.
89
 
        self.ancestors = {}
90
68
 
91
 
    def check(self, callback_refs=None, check_repo=True):
92
 
        if callback_refs is None:
93
 
            callback_refs = {}
 
69
    def check(self):
94
70
        self.repository.lock_read()
95
71
        self.progress = bzrlib.ui.ui_factory.nested_progress_bar()
96
72
        try:
97
 
            self.progress.update('check', 0, 4)
98
 
            if self.check_repo:
99
 
                self.progress.update('checking revisions', 0)
100
 
                self.check_revisions()
101
 
                self.progress.update('checking commit contents', 1)
102
 
                self.repository._check_inventories(self)
103
 
                self.progress.update('checking file graphs', 2)
104
 
                # check_weaves is done after the revision scan so that
105
 
                # revision index is known to be valid.
106
 
                self.check_weaves()
107
 
            self.progress.update('checking branches and trees', 3)
108
 
            if callback_refs:
109
 
                repo = self.repository
110
 
                # calculate all refs, and callback the objects requesting them.
111
 
                refs = {}
112
 
                wanting_items = set()
113
 
                # Current crude version calculates everything and calls
114
 
                # everything at once. Doing a queue and popping as things are
115
 
                # satisfied would be cheaper on memory [but few people have
116
 
                # huge numbers of working trees today. TODO: fix before
117
 
                # landing].
118
 
                distances = set()
119
 
                existences = set()
120
 
                for ref, wantlist in callback_refs.iteritems():
121
 
                    wanting_items.update(wantlist)
122
 
                    kind, value = ref
123
 
                    if kind == 'trees':
124
 
                        refs[ref] = repo.revision_tree(value)
125
 
                    elif kind == 'lefthand-distance':
126
 
                        distances.add(value)
127
 
                    elif kind == 'revision-existence':
128
 
                        existences.add(value)
129
 
                    else:
130
 
                        raise AssertionError(
131
 
                            'unknown ref kind for ref %s' % ref)
132
 
                node_distances = repo.get_graph().find_lefthand_distances(distances)
133
 
                for key, distance in node_distances.iteritems():
134
 
                    refs[('lefthand-distance', key)] = distance
135
 
                    if key in existences and distance > 0:
136
 
                        refs[('revision-existence', key)] = True
137
 
                        existences.remove(key)
138
 
                parent_map = repo.get_graph().get_parent_map(existences)
139
 
                for key in parent_map:
140
 
                    refs[('revision-existence', key)] = True
141
 
                    existences.remove(key)
142
 
                for key in existences:
143
 
                    refs[('revision-existence', key)] = False
144
 
                for item in wanting_items:
145
 
                    if isinstance(item, WorkingTree):
146
 
                        item._check(refs)
147
 
                    if isinstance(item, Branch):
148
 
                        self.other_results.append(item.check(refs))
 
73
            self.progress.update('retrieving inventory', 0, 2)
 
74
            # do not put in init, as it should be done with progess,
 
75
            # and inside the lock.
 
76
            self.inventory_weave = self.repository.inventories
 
77
            self.progress.update('checking revision graph', 1)
 
78
            self.check_revision_graph()
 
79
            self.plan_revisions()
 
80
            revno = 0
 
81
            while revno < len(self.planned_revisions):
 
82
                rev_id = self.planned_revisions[revno]
 
83
                self.progress.update('checking revision', revno,
 
84
                                     len(self.planned_revisions))
 
85
                revno += 1
 
86
                self.check_one_rev(rev_id)
 
87
            # check_weaves is done after the revision scan so that
 
88
            # revision index is known to be valid.
 
89
            self.check_weaves()
149
90
        finally:
150
91
            self.progress.finished()
151
92
            self.repository.unlock()
152
93
 
153
 
    def _check_revisions(self, revisions_iterator):
154
 
        """Check revision objects by decorating a generator.
155
 
 
156
 
        :param revisions_iterator: An iterator of(revid, Revision-or-None).
157
 
        :return: A generator of the contents of revisions_iterator.
158
 
        """
159
 
        self.planned_revisions = set()
160
 
        for revid, revision in revisions_iterator:
161
 
            yield revid, revision
162
 
            self._check_one_rev(revid, revision)
163
 
        # Flatten the revisions we found to guarantee consistent later
164
 
        # iteration.
165
 
        self.planned_revisions = list(self.planned_revisions)
166
 
        # TODO: extract digital signatures as items to callback on too.
167
 
 
168
 
    def check_revisions(self):
169
 
        """Scan revisions, checking data directly available as we go."""
170
 
        revision_iterator = self.repository._iter_revisions(None)
171
 
        revision_iterator = self._check_revisions(revision_iterator)
172
 
        # We read the all revisions here:
173
 
        # - doing this allows later code to depend on the revision index.
174
 
        # - we can fill out existence flags at this point
175
 
        # - we can read the revision inventory sha at this point
176
 
        # - we can check properties and serialisers etc.
 
94
    def check_revision_graph(self):
177
95
        if not self.repository.revision_graph_can_have_wrong_parents():
178
 
            # The check against the index isn't needed.
 
96
            # This check is not necessary.
179
97
            self.revs_with_bad_parents_in_index = None
180
 
            for thing in revision_iterator:
181
 
                pass
182
 
        else:
183
 
            bad_revisions = self.repository._find_inconsistent_revision_parents(
184
 
                revision_iterator)
185
 
            self.revs_with_bad_parents_in_index = list(bad_revisions)
 
98
            return
 
99
        bad_revisions = self.repository._find_inconsistent_revision_parents()
 
100
        self.revs_with_bad_parents_in_index = list(bad_revisions)
 
101
 
 
102
    def plan_revisions(self):
 
103
        repository = self.repository
 
104
        self.planned_revisions = repository.all_revision_ids()
 
105
        self.progress.clear()
 
106
        inventoried = set(key[-1] for key in self.inventory_weave.keys())
 
107
        awol = set(self.planned_revisions) - inventoried
 
108
        if len(awol) > 0:
 
109
            raise BzrCheckError('Stored revisions missing from inventory'
 
110
                '{%s}' % ','.join([f for f in awol]))
186
111
 
187
112
    def report_results(self, verbose):
188
 
        if self.check_repo:
189
 
            self._report_repo_results(verbose)
190
 
        for result in self.other_results:
191
 
            result.report_results(verbose)
192
 
 
193
 
    def _report_repo_results(self, verbose):
194
113
        note('checked repository %s format %s',
195
114
             self.repository.bzrdir.root_transport,
196
115
             self.repository._format)
197
116
        note('%6d revisions', self.checked_rev_cnt)
198
117
        note('%6d file-ids', len(self.checked_weaves))
199
 
        if verbose:
200
 
            note('%6d unreferenced text versions',
201
 
                len(self.unreferenced_versions))
202
 
        if verbose and len(self.unreferenced_versions):
203
 
                for file_id, revision_id in self.unreferenced_versions:
204
 
                    log_error('unreferenced version: {%s} in %s', revision_id,
205
 
                        file_id)
 
118
        note('%6d unique file texts', self.checked_text_cnt)
 
119
        note('%6d repeated file texts', self.repeated_text_cnt)
 
120
        note('%6d unreferenced text versions',
 
121
             len(self.unreferenced_versions))
206
122
        if self.missing_inventory_sha_cnt:
207
123
            note('%6d revisions are missing inventory_sha1',
208
124
                 self.missing_inventory_sha_cnt)
222
138
                    note('      %s should be in the ancestry for:', link)
223
139
                    for linker in linkers:
224
140
                        note('       * %s', linker)
 
141
            if verbose:
 
142
                for file_id, revision_id in self.unreferenced_versions:
 
143
                    log_error('unreferenced version: {%s} in %s', revision_id,
 
144
                        file_id)
225
145
        if len(self.inconsistent_parents):
226
146
            note('%6d inconsistent parents', len(self.inconsistent_parents))
227
147
            if verbose:
241
161
                        '       %s has wrong parents in index: '
242
162
                        '%r should be %r',
243
163
                        revision_id, index_parents, actual_parents)
244
 
        for item in self._report_items:
245
 
            note(item)
246
 
 
247
 
    def _check_one_rev(self, rev_id, rev):
248
 
        """Cross-check one revision.
249
 
 
250
 
        :param rev_id: A revision id to check.
251
 
        :param rev: A revision or None to indicate a missing revision.
 
164
 
 
165
    def check_one_rev(self, rev_id):
 
166
        """Check one revision.
 
167
 
 
168
        rev_id - the one to check
252
169
        """
 
170
        rev = self.repository.get_revision(rev_id)
 
171
 
253
172
        if rev.revision_id != rev_id:
254
 
            self._report_items.append(
255
 
                'Mismatched internal revid {%s} and index revid {%s}' % (
256
 
                rev.revision_id, rev_id))
257
 
            rev_id = rev.revision_id
258
 
        # Check this revision tree etc, and count as seen when we encounter a
259
 
        # reference to it.
260
 
        self.planned_revisions.add(rev_id)
261
 
        # It is not a ghost
262
 
        self.ghosts.discard(rev_id)
263
 
        # Count all parents as ghosts if we haven't seen them yet.
 
173
            raise BzrCheckError('wrong internal revision id in revision {%s}'
 
174
                                % rev_id)
 
175
 
264
176
        for parent in rev.parent_ids:
265
177
            if not parent in self.planned_revisions:
266
 
                self.ghosts.add(parent)
267
 
        
268
 
        self.ancestors[rev_id] = tuple(rev.parent_ids) or (NULL_REVISION,)
269
 
        self.add_pending_item(rev_id, ('inventories', rev_id), 'inventory',
270
 
            rev.inventory_sha1)
 
178
                # rev has a parent we didn't know about.
 
179
                missing_links = self.missing_parent_links.get(parent, [])
 
180
                missing_links.append(rev_id)
 
181
                self.missing_parent_links[parent] = missing_links
 
182
                # list based so somewhat slow,
 
183
                # TODO have a planned_revisions list and set.
 
184
                if self.repository.has_revision(parent):
 
185
                    missing_ancestry = self.repository.get_ancestry(parent)
 
186
                    for missing in missing_ancestry:
 
187
                        if (missing is not None
 
188
                            and missing not in self.planned_revisions):
 
189
                            self.planned_revisions.append(missing)
 
190
                else:
 
191
                    self.ghosts.append(rev_id)
 
192
 
 
193
        if rev.inventory_sha1:
 
194
            # Loopback - this is currently circular logic as the
 
195
            # knit get_inventory_sha1 call returns rev.inventory_sha1.
 
196
            # Repository.py's get_inventory_sha1 should instead return
 
197
            # inventories.get_record_stream([(revid,)]).next().sha1 or
 
198
            # similar.
 
199
            inv_sha1 = self.repository.get_inventory_sha1(rev_id)
 
200
            if inv_sha1 != rev.inventory_sha1:
 
201
                raise BzrCheckError('Inventory sha1 hash doesn\'t match'
 
202
                    ' value in revision {%s}' % rev_id)
 
203
        self._check_revision_tree(rev_id)
271
204
        self.checked_rev_cnt += 1
272
205
 
273
 
    def add_pending_item(self, referer, key, kind, sha1):
274
 
        """Add a reference to a sha1 to be cross checked against a key.
275
 
 
276
 
        :param referer: The referer that expects key to have sha1.
277
 
        :param key: A storage key e.g. ('texts', 'foo@bar-20040504-1234')
278
 
        :param kind: revision/inventory/text/map/signature
279
 
        :param sha1: A hex sha1 or None if no sha1 is known.
280
 
        """
281
 
        existing = self.pending_keys.get(key)
282
 
        if existing:
283
 
            if sha1 != existing[1]:
284
 
                self._report_items.append('Multiple expected sha1s for %s. {%s}'
285
 
                    ' expects {%s}, {%s} expects {%s}', (
286
 
                    key, referer, sha1, existing[1], existing[0]))
287
 
        else:
288
 
            self.pending_keys[key] = (kind, sha1, referer)
289
 
 
290
206
    def check_weaves(self):
291
207
        """Check all the weaves we can get our hands on.
292
208
        """
293
209
        weave_ids = []
294
 
        storebar = bzrlib.ui.ui_factory.nested_progress_bar()
295
 
        try:
296
 
            self._check_weaves(storebar)
297
 
        finally:
298
 
            storebar.finished()
299
 
 
300
 
    def _check_weaves(self, storebar):
301
 
        storebar.update('text-index', 0, 2)
302
 
        if self.repository._format.fast_deltas:
303
 
            # We haven't considered every fileid instance so far.
304
 
            weave_checker = self.repository._get_versioned_file_checker(
305
 
                ancestors=self.ancestors)
306
 
        else:
307
 
            weave_checker = self.repository._get_versioned_file_checker(
308
 
                text_key_references=self.text_key_references,
309
 
                ancestors=self.ancestors)
310
 
        storebar.update('file-graph', 1)
 
210
        self.progress.update('checking inventory', 0, 2)
 
211
        self.inventory_weave.check(progress_bar=self.progress)
 
212
        self.progress.update('checking text storage', 1, 2)
 
213
        self.repository.texts.check(progress_bar=self.progress)
 
214
        weave_checker = self.repository._get_versioned_file_checker(
 
215
            text_key_references=self.text_key_references)
311
216
        result = weave_checker.check_file_version_parents(
312
 
            self.repository.texts)
 
217
            self.repository.texts, progress_bar=self.progress)
313
218
        self.checked_weaves = weave_checker.file_ids
314
219
        bad_parents, unused_versions = result
315
220
        bad_parents = bad_parents.items()
323
228
                (revision_id, weave_id, weave_parents, correct_parents))
324
229
        self.unreferenced_versions.update(unused_versions)
325
230
 
 
231
    def _check_revision_tree(self, rev_id):
 
232
        tree = self.repository.revision_tree(rev_id)
 
233
        inv = tree.inventory
 
234
        seen_ids = set()
 
235
        seen_names = set()
 
236
        for path, ie in inv.iter_entries():
 
237
            self._add_entry_to_text_key_references(inv, ie)
 
238
            file_id = ie.file_id
 
239
            if file_id in seen_ids:
 
240
                raise BzrCheckError('duplicated file_id {%s} '
 
241
                                    'in inventory for revision {%s}'
 
242
                                    % (file_id, rev_id))
 
243
            seen_ids.add(file_id)
 
244
            ie.check(self, rev_id, inv, tree)
 
245
            if path in seen_names:
 
246
                raise BzrCheckError('duplicated path %s '
 
247
                                    'in inventory for revision {%s}'
 
248
                                    % (path, rev_id))
 
249
            seen_names.add(path)
 
250
 
326
251
    def _add_entry_to_text_key_references(self, inv, entry):
327
 
        if not self.rich_roots and entry.name == '':
 
252
        if not self.rich_roots and entry == inv.root:
328
253
            return
329
254
        key = (entry.file_id, entry.revision)
330
255
        self.text_key_references.setdefault(key, False)
338
263
 
339
264
    Results are reported through logging.
340
265
 
341
 
    Deprecated in 1.6.  Please use check_dwim instead.
 
266
    Deprecated in 1.6.  Please use check_branch instead.
342
267
 
343
268
    :raise BzrCheckError: if there's a consistency error.
344
269
    """
345
270
    check_branch(branch, verbose)
346
271
 
347
272
 
348
 
@deprecated_function(deprecated_in((1,16,0)))
349
273
def check_branch(branch, verbose):
350
274
    """Run consistency checks on a branch.
351
275
 
355
279
    """
356
280
    branch.lock_read()
357
281
    try:
358
 
        needed_refs = {}
359
 
        for ref in branch._get_check_refs():
360
 
            needed_refs.setdefault(ref, []).append(branch)
361
 
        result = branch.repository.check([branch.last_revision()], needed_refs)
362
 
        branch_result = result.other_results[0]
 
282
        branch_result = branch.check()
363
283
    finally:
364
284
        branch.unlock()
365
285
    branch_result.report_results(verbose)
366
286
 
367
287
 
368
 
def scan_branch(branch, needed_refs, to_unlock):
369
 
    """Scan a branch for refs.
370
 
 
371
 
    :param branch:  The branch to schedule for checking.
372
 
    :param needed_refs: Refs we are accumulating.
373
 
    :param to_unlock: The unlock list accumulating.
374
 
    """
375
 
    note("Checking branch at '%s'." % (branch.base,))
376
 
    branch.lock_read()
377
 
    to_unlock.append(branch)
378
 
    branch_refs = branch._get_check_refs()
379
 
    for ref in branch_refs:
380
 
        reflist = needed_refs.setdefault(ref, [])
381
 
        reflist.append(branch)
382
 
 
383
 
 
384
 
def scan_tree(base_tree, tree, needed_refs, to_unlock):
385
 
    """Scan a tree for refs.
386
 
 
387
 
    :param base_tree: The original tree check opened, used to detect duplicate
388
 
        tree checks.
389
 
    :param tree:  The tree to schedule for checking.
390
 
    :param needed_refs: Refs we are accumulating.
391
 
    :param to_unlock: The unlock list accumulating.
392
 
    """
393
 
    if base_tree is not None and tree.basedir == base_tree.basedir:
394
 
        return
395
 
    note("Checking working tree at '%s'." % (tree.basedir,))
396
 
    tree.lock_read()
397
 
    to_unlock.append(tree)
398
 
    tree_refs = tree._get_check_refs()
399
 
    for ref in tree_refs:
400
 
        reflist = needed_refs.setdefault(ref, [])
401
 
        reflist.append(tree)
402
 
 
403
 
 
404
288
def check_dwim(path, verbose, do_branch=False, do_repo=False, do_tree=False):
405
 
    """Check multiple objects.
406
 
 
407
 
    If errors occur they are accumulated and reported as far as possible, and
408
 
    an exception raised at the end of the process.
409
 
    """
410
289
    try:
411
 
        base_tree, branch, repo, relpath = \
 
290
        tree, branch, repo, relpath = \
412
291
                        BzrDir.open_containing_tree_branch_or_repository(path)
413
292
    except errors.NotBranchError:
414
 
        base_tree = branch = repo = None
415
 
 
416
 
    to_unlock = []
417
 
    needed_refs= {}
418
 
    try:
419
 
        if base_tree is not None:
420
 
            # If the tree is a lightweight checkout we won't see it in
421
 
            # repo.find_branches - add now.
422
 
            if do_tree:
423
 
                scan_tree(None, base_tree, needed_refs, to_unlock)
424
 
            branch = base_tree.branch
425
 
        if branch is not None:
426
 
            # We have a branch
427
 
            if repo is None:
428
 
                # The branch is in a shared repository
429
 
                repo = branch.repository
430
 
        if repo is not None:
431
 
            repo.lock_read()
432
 
            to_unlock.append(repo)
433
 
            branches = repo.find_branches(using=True)
434
 
            saw_tree = False
435
 
            if do_branch or do_tree:
436
 
                for branch in branches:
437
 
                    if do_tree:
438
 
                        try:
439
 
                            tree = branch.bzrdir.open_workingtree()
440
 
                            saw_tree = True
441
 
                        except (errors.NotLocalUrl, errors.NoWorkingTree):
442
 
                            pass
443
 
                        else:
444
 
                            scan_tree(base_tree, tree, needed_refs, to_unlock)
445
 
                    if do_branch:
446
 
                        scan_branch(branch, needed_refs, to_unlock)
447
 
            if do_branch and not branches:
448
 
                log_error("No branch found at specified location.")
449
 
            if do_tree and base_tree is None and not saw_tree:
450
 
                log_error("No working tree found at specified location.")
451
 
            if do_repo or do_branch or do_tree:
452
 
                if do_repo:
453
 
                    note("Checking repository at '%s'."
454
 
                         % (repo.bzrdir.root_transport.base,))
455
 
                result = repo.check(None, callback_refs=needed_refs,
456
 
                    check_repo=do_repo)
 
293
        tree = branch = repo = None
 
294
 
 
295
    if do_tree:
 
296
        if tree is not None:
 
297
            note("Checking working tree at '%s'."
 
298
                 % (tree.bzrdir.root_transport.base,))
 
299
            tree._check()
 
300
        else:
 
301
            log_error("No working tree found at specified location.")
 
302
 
 
303
    if branch is not None:
 
304
        # We have a branch
 
305
        if repo is None:
 
306
            # The branch is in a shared repository
 
307
            repo = branch.repository
 
308
        branches = [branch]
 
309
    elif repo is not None:
 
310
        branches = repo.find_branches(using=True)
 
311
 
 
312
    if repo is not None:
 
313
        repo.lock_read()
 
314
        try:
 
315
            if do_repo:
 
316
                note("Checking repository at '%s'."
 
317
                     % (repo.bzrdir.root_transport.base,))
 
318
                result = repo.check()
457
319
                result.report_results(verbose)
458
 
        else:
459
 
            if do_tree:
460
 
                log_error("No working tree found at specified location.")
461
320
            if do_branch:
462
 
                log_error("No branch found at specified location.")
463
 
            if do_repo:
464
 
                log_error("No repository found at specified location.")
465
 
    finally:
466
 
        for thing in to_unlock:
467
 
            thing.unlock()
 
321
                if branches == []:
 
322
                    log_error("No branch found at specified location.")
 
323
                else:
 
324
                    for branch in branches:
 
325
                        note("Checking branch at '%s'."
 
326
                             % (branch.bzrdir.root_transport.base,))
 
327
                        check_branch(branch, verbose)
 
328
        finally:
 
329
            repo.unlock()
 
330
    else:
 
331
        if do_branch:
 
332
            log_error("No branch found at specified location.")
 
333
        if do_repo:
 
334
            log_error("No repository found at specified location.")