Merge pull request #1159

fix miscalculation when using Always Incremental Keep Number

CHANGELOG.md

@@ -54,6 +54,9 @@ 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]
+- dir: miscalculation when using `always incremental keep number` [PR #1159]
 
 ### Changed
 - contrib: rename Python modules to satisfy PEP8 [PR #768]

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));

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
-          = 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 (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,
+            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;