From 9c1830f9548270d0c65ceb9fe9ef3675224dec5c Mon Sep 17 00:00:00 2001 From: Alaa Eddine Elamri Date: Fri, 25 Mar 2022 10:22:25 +0100 Subject: [PATCH 1/5] Updated CHANGELOG.md --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 8146d0a49b8..b5678e340fc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -54,6 +54,8 @@ and since Bareos version 20 this project adheres to [Semantic Versioning](https: - Fix `always-incremental-consolidate` systemtest sporadic fails, and rename it. [PR #1154] - packaging: FreeBSD place all scripts into "normal" location /usr/local/lib/bareos/scripts [PR #1163] - [BUG #1445] adding quotes to director name when using `configure export`. [PR #1171] +- FreeBSD packages: add missing ddl/update 2171_2192 and 2192_2210 files [PR #1147] +- Fix director connects to client while `Connection From Director To Client` is disabled. [PR #1099] ### Changed - contrib: rename Python modules to satisfy PEP8 [PR #768] From 2f88976a873d9cd91e265c681348412e6b9735fa Mon Sep 17 00:00:00 2001 From: Andreas Rogge Date: Mon, 11 Apr 2022 15:51:43 +0200 Subject: [PATCH 2/5] cats: make db_list_ctx funcs const where possible --- core/src/cats/cats.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/src/cats/cats.h b/core/src/cats/cats.h index 140d3cbe872..3794fba12b2 100644 --- a/core/src/cats/cats.h +++ b/core/src/cats/cats.h @@ -432,8 +432,8 @@ class db_list_ctx : public BStringList { void add(const char* str) { Append(str); } void add(JobId_t id) { push_back(std::to_string(id)); } - std::string GetAsString() { return Join(','); } - uint64_t GetFrontAsInteger() + std::string GetAsString() const { return Join(','); } + uint64_t GetFrontAsInteger() const { try { return std::stoull(at(0)); From c7b6d45f98d88b0d73224f2fff9c4645cecad586 Mon Sep 17 00:00:00 2001 From: Andreas Rogge Date: Mon, 11 Apr 2022 15:52:19 +0200 Subject: [PATCH 3/5] dir: fix AlwaysIncrementalKeepNumber This fixes a bug where the number of incrementals was miscalculated during consolidation leading to no consolidation when "Keep Number" was set. The patch also makes a lot of the variables `const` and tries to avoid re-use of existing variables to improve readability. --- core/src/dird/consolidate.cc | 58 ++++++++++++++++++------------------ 1 file changed, 29 insertions(+), 29 deletions(-) diff --git a/core/src/dird/consolidate.cc b/core/src/dird/consolidate.cc index c5bac3e886d..74e2034a8ba 100644 --- a/core/src/dird/consolidate.cc +++ b/core/src/dird/consolidate.cc @@ -119,11 +119,6 @@ bool DoConsolidate(JobControlRecord* jcr) foreach_res (job, R_JOB) { if (job->AlwaysIncremental) { - db_list_ctx jobids_ctx; - int32_t incrementals_total; - int32_t incrementals_to_consolidate; - int32_t max_incrementals_to_consolidate; - Jmsg(jcr, M_INFO, 0, _("Looking at always incremental job %s\n"), job->resource_name_); @@ -148,10 +143,10 @@ bool DoConsolidate(JobControlRecord* jcr) } // First determine the number of total incrementals - jcr->db->AccurateGetJobids(jcr, &jcr->impl->jr, &jobids_ctx); - incrementals_total = jobids_ctx.size() - 1; + db_list_ctx all_jobids_ctx; + jcr->db->AccurateGetJobids(jcr, &jcr->impl->jr, &all_jobids_ctx); Dmsg1(10, "unlimited jobids list: %s.\n", - jobids_ctx.GetAsString().c_str()); + all_jobids_ctx.GetAsString().c_str()); /* * If we are doing always incremental, we need to limit the search to @@ -173,17 +168,22 @@ bool DoConsolidate(JobControlRecord* jcr) jcr->impl->jr.FileSetId, sdt); } + db_list_ctx jobids_ctx; jcr->db->AccurateGetJobids(jcr, &jcr->impl->jr, &jobids_ctx); Dmsg1(10, "consolidate candidates: %s.\n", jobids_ctx.GetAsString().c_str()); - db_list_ctx zero_file_jobs = jcr->db->FilterZeroFileJobs(jobids_ctx); + const db_list_ctx zero_file_jobs + = jcr->db->FilterZeroFileJobs(jobids_ctx); if (zero_file_jobs.size() > 0) { Jmsg(jcr, M_INFO, 0, "%s: purging empty jobids %s\n", job->resource_name_, zero_file_jobs.Join(", ").c_str()); jcr->db->PurgeJobs(zero_file_jobs.GetAsString().c_str()); } - incrementals_total = jobids_ctx.size() - 1; + + // all jobs - any empty jobs - the full backup + const int32_t incrementals_total + = all_jobids_ctx.size() - zero_file_jobs.size() - 1; /** * Consolidation of zero or one job does not make sense, we leave it * like it is @@ -200,35 +200,35 @@ bool DoConsolidate(JobControlRecord* jcr) * Calculate limit for query. We specify how many incrementals should be * left. the limit is total number of incrementals - number required - 1 */ - max_incrementals_to_consolidate + const int32_t max_incrementals_to_consolidate = incrementals_total - job->AlwaysIncrementalKeepNumber; Dmsg2(10, "Incrementals found/required. (%d/%d).\n", incrementals_total, job->AlwaysIncrementalKeepNumber); - if ((max_incrementals_to_consolidate + 1) > 1) { - jcr->impl->jr.limit = max_incrementals_to_consolidate + 1; - Dmsg3(10, "total: %d, to_consolidate: %d, limit: %d.\n", - incrementals_total, max_incrementals_to_consolidate, - jcr->impl->jr.limit); - jobids_ctx.clear(); - jcr->db->AccurateGetJobids(jcr, &jcr->impl->jr, &jobids_ctx); - incrementals_to_consolidate = jobids_ctx.size() - 1; - Dmsg2(10, "%d consolidate ids after limit: %s.\n", jobids_ctx.size(), - jobids_ctx.GetAsString().c_str()); - if (incrementals_to_consolidate < 1) { - Jmsg(jcr, M_INFO, 0, - _("%s: After limited query: less incrementals than required, " - "not consolidating\n"), - job->resource_name_); - continue; - } - } else { + if (max_incrementals_to_consolidate == 0) { Jmsg(jcr, M_INFO, 0, _("%s: less incrementals than required, not consolidating\n"), job->resource_name_); continue; } + jcr->impl->jr.limit = max_incrementals_to_consolidate + 1; + Dmsg3(10, "total: %d, to_consolidate: %d, limit: %d.\n", + incrementals_total, max_incrementals_to_consolidate, + jcr->impl->jr.limit); + jobids_ctx.clear(); + jcr->db->AccurateGetJobids(jcr, &jcr->impl->jr, &jobids_ctx); + const int32_t incrementals_to_consolidate = jobids_ctx.size() - 1; + Dmsg2(10, "%d consolidate ids after limit: %s.\n", jobids_ctx.size(), + jobids_ctx.GetAsString().c_str()); + if (incrementals_to_consolidate < 1) { + Jmsg(jcr, M_INFO, 0, + _("%s: After limited query: less incrementals than required, " + "not consolidating\n"), + job->resource_name_); + continue; + } + if (jobids) { free(jobids); jobids = NULL; From 64f14a1fceca363a87d67b3b2c2a5a07146be13a Mon Sep 17 00:00:00 2001 From: Andreas Rogge Date: Tue, 12 Apr 2022 14:54:33 +0200 Subject: [PATCH 4/5] Update CHANGELOG.md --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index b5678e340fc..57b8c3fdeea 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -56,6 +56,7 @@ and since Bareos version 20 this project adheres to [Semantic Versioning](https: - [BUG #1445] adding quotes to director name when using `configure export`. [PR #1171] - FreeBSD packages: add missing ddl/update 2171_2192 and 2192_2210 files [PR #1147] - Fix director connects to client while `Connection From Director To Client` is disabled. [PR #1099] +- dir: miscalculation when using `always incremental keep number` [PR #1159] ### Changed - contrib: rename Python modules to satisfy PEP8 [PR #768] From e9341db434eaaff024e71bcd046b2bfb65e40d64 Mon Sep 17 00:00:00 2001 From: Andreas Rogge Date: Tue, 12 Apr 2022 19:14:40 +0200 Subject: [PATCH 5/5] [fixup] fix a broken refactoring ... and try to improve readability even more. --- core/src/dird/consolidate.cc | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/core/src/dird/consolidate.cc b/core/src/dird/consolidate.cc index 74e2034a8ba..eb91d833c9d 100644 --- a/core/src/dird/consolidate.cc +++ b/core/src/dird/consolidate.cc @@ -200,18 +200,18 @@ bool DoConsolidate(JobControlRecord* jcr) * Calculate limit for query. We specify how many incrementals should be * left. the limit is total number of incrementals - number required - 1 */ - const int32_t max_incrementals_to_consolidate - = incrementals_total - job->AlwaysIncrementalKeepNumber; - Dmsg2(10, "Incrementals found/required. (%d/%d).\n", incrementals_total, job->AlwaysIncrementalKeepNumber); - if (max_incrementals_to_consolidate == 0) { + if (incrementals_total <= job->AlwaysIncrementalKeepNumber) { Jmsg(jcr, M_INFO, 0, _("%s: less incrementals than required, not consolidating\n"), job->resource_name_); continue; } + const int32_t max_incrementals_to_consolidate + = incrementals_total - job->AlwaysIncrementalKeepNumber; + jcr->impl->jr.limit = max_incrementals_to_consolidate + 1; Dmsg3(10, "total: %d, to_consolidate: %d, limit: %d.\n", incrementals_total, max_incrementals_to_consolidate,