# # patch "ChangeLog" # from [18cb62c01adbe50b42f90d5b77a066507658fbcd] # to [449de581b331a80859192326e5a8bc909496b2fa] # # patch "database_check.cc" # from [a4c657c1f544061cd11935dd18ef5fea43e9accb] # to [415b63b94a1150b3aff78b9e7fa512e0141577e8] # # patch "tests/t_database_check_normalized.at" # from [b56eaa874dc95e9f15a87b50997a11c8f85a71b5] # to [c282c8b5f282a61b35880dd25aee757eb3d3df95] # ======================================================================== --- ChangeLog 18cb62c01adbe50b42f90d5b77a066507658fbcd +++ ChangeLog 449de581b331a80859192326e5a8bc909496b2fa @@ -1,5 +1,13 @@ 2005-08-26 Nathaniel Smith + * database_check.cc: Track and report on manifest and revision + parseability. + * tests/t_database_check_normalized.at: Update to expect "not + parseable" messages rather than "not normalized" messages. + All tests pass. + +2005-08-26 Nathaniel Smith + * tests/t_unreadable_MT.at: This test was called "do not fail on unreadable MT/options". I do not know why we wanted such behavior. I am making it "fail cleanly on unreadable ======================================================================== --- database_check.cc a4c657c1f544061cd11935dd18ef5fea43e9accb +++ database_check.cc 415b63b94a1150b3aff78b9e7fa512e0141577e8 @@ -57,11 +57,12 @@ size_t revision_refs; // number of revision references to this manifest size_t missing_files; // number of missing files referenced by this manifest + bool parseable; // read_manifest_map does not throw bool normalized; // write_manifest_map( read_manifest_map(dat) ) == dat checked_manifest(): found(false), revision_refs(0), - missing_files(0), normalized(false) {} + missing_files(0), parseable(false), normalized(false) {} }; // the number of times a revision is referenced (revision_refs) @@ -84,6 +85,7 @@ size_t cert_refs; // number of references to this revision by revision certs; + bool parseable; // read_revision_set does not throw bool normalized; // write_revision_set( read_revision_set(dat) ) == dat std::string history_error; @@ -95,7 +97,7 @@ found(false), revision_refs(0), ancestry_parent_refs(0), ancestry_child_refs(0), missing_manifests(0), missing_revisions(0), incomplete_manifests(0), - cert_refs(0), normalized(false) {} + cert_refs(0), parseable(false), normalized(false) {} }; static void @@ -142,7 +144,17 @@ checked_manifests[*i].found = true; manifest_map man; - read_manifest_map(data, man); + try + { + read_manifest_map(data, man); + } + catch (std::logic_error & e) + { + L(F("error parsing manifest %s: %s") % *i % e.what()); + checked_manifests[*i].parseable = false; + continue; + } + checked_manifests[*i].parseable = true; // normalisation check manifest_id norm_ident; @@ -188,7 +200,17 @@ checked_revisions[*i].found = true; revision_set rev; - read_revision_set(data, rev); + try + { + read_revision_set(data, rev); + } + catch (std::logic_error & e) + { + L(F("error parsing revision %s: %s") % *i % e.what()); + checked_revisions[*i].parseable = false; + continue; + } + checked_revisions[*i].parseable = true; // normalisation check revision_id norm_ident; @@ -406,6 +428,7 @@ size_t & missing_manifests, size_t & unreferenced_manifests, size_t & incomplete_manifests, + size_t & non_parseable_manifests, size_t & non_normalized_manifests) { for (std::map::const_iterator @@ -433,8 +456,15 @@ % i->first % manifest.missing_files); } - if (!manifest.normalized) + if (!manifest.parseable) { + non_parseable_manifests++; + P(F("manifest %s is not parseable (perhaps with unnormalized paths?)\n") + % i->first); + } + + if (manifest.parseable && !manifest.normalized) + { non_normalized_manifests++; P(F("manifest %s is not in normalized form\n") % i->first); @@ -449,6 +479,7 @@ size_t & mismatched_parents, size_t & mismatched_children, size_t & bad_history, + size_t & non_parseable_revisions, size_t & non_normalized_revisions) { for (std::map::const_iterator @@ -512,8 +543,15 @@ % i->first % tmp); } - if (!revision.normalized) + if (!revision.parseable) { + non_parseable_revisions++; + P(F("revision %s is not parseable (perhaps with unnormalized paths?)\n") + % i->first); + } + + if (revision.parseable && !revision.normalized) + { non_normalized_revisions++; P(F("revision %s is not in normalized form\n") % i->first); @@ -628,6 +666,7 @@ size_t missing_manifests = 0; size_t unreferenced_manifests = 0; size_t incomplete_manifests = 0; + size_t non_parseable_manifests = 0; size_t non_normalized_manifests = 0; size_t missing_revisions = 0; @@ -635,6 +674,7 @@ size_t mismatched_parents = 0; size_t mismatched_children = 0; size_t bad_history = 0; + size_t non_parseable_revisions = 0; size_t non_normalized_revisions = 0; size_t missing_keys = 0; @@ -658,12 +698,14 @@ report_manifests(checked_manifests, missing_manifests, unreferenced_manifests, incomplete_manifests, + non_parseable_manifests, non_normalized_manifests); report_revisions(checked_revisions, missing_revisions, incomplete_revisions, mismatched_parents, mismatched_children, - bad_history, non_normalized_revisions); + bad_history, non_parseable_revisions, + non_normalized_revisions); report_keys(checked_keys, missing_keys); @@ -682,6 +724,9 @@ W(F("%d unreferenced manifests\n") % unreferenced_manifests); if (incomplete_manifests > 0) W(F("%d incomplete manifests\n") % incomplete_manifests); + if (non_parseable_manifests > 0) + W(F("%d manifests not parseable (perhaps with invalid paths)\n") + % non_parseable_manifests); if (non_normalized_manifests > 0) W(F("%d manifests not in normalized form\n") % non_normalized_manifests); @@ -695,6 +740,9 @@ W(F("%d mismatched children\n") % mismatched_children); if (bad_history > 0) W(F("%d revisions with bad history\n") % bad_history); + if (non_parseable_revisions > 0) + W(F("%d revisions not parseable (perhaps with invalid paths)\n") + % non_parseable_revisions); if (non_normalized_revisions > 0) W(F("%d revisions not in normalized form\n") % non_normalized_revisions); @@ -712,9 +760,9 @@ size_t total = missing_files + unreferenced_files + missing_manifests + unreferenced_manifests + incomplete_manifests + - non_normalized_manifests + + non_parseable_manifests + non_normalized_manifests + missing_revisions + incomplete_revisions + - non_normalized_revisions + + non_parseable_revisions + non_normalized_revisions + mismatched_parents + mismatched_children + bad_history + missing_certs + mismatched_certs + @@ -724,9 +772,9 @@ // serious errors; odd, but nothing will break. size_t serious = missing_files + missing_manifests + incomplete_manifests + - non_normalized_manifests + + non_parseable_manifests + non_normalized_manifests + missing_revisions + incomplete_revisions + - non_normalized_revisions + + non_parseable_revisions + non_normalized_revisions + mismatched_parents + mismatched_children + bad_history + missing_certs + ======================================================================== --- tests/t_database_check_normalized.at b56eaa874dc95e9f15a87b50997a11c8f85a71b5 +++ tests/t_database_check_normalized.at c282c8b5f282a61b35880dd25aee757eb3d3df95 @@ -101,7 +101,7 @@ AT_CHECK(MONOTONE db check -d bad.db, [1], [ignore], [stderr]) -AT_CHECK(grep 'revisions not in normalized form' stderr, [], [ignore], [ignore]) -AT_CHECK(grep 'manifests not in normalized form' stderr, [], [ignore], [ignore]) +AT_CHECK(grep 'revisions not parseable' stderr, [], [ignore], [ignore]) +AT_CHECK(grep 'manifests not parseable' stderr, [], [ignore], [ignore]) AT_CLEANUP