From c51ccc69ed4039fac8ebfbd7c2fcaf0abb8341d0 Mon Sep 17 00:00:00 2001 From: Karen Arutyunov Date: Fri, 19 May 2017 19:39:21 +0300 Subject: Allow to enforce rebuild for building state --- mod/mod-build-task.cxx | 70 ++++++++++++++++++++++++++++---------------------- 1 file changed, 39 insertions(+), 31 deletions(-) (limited to 'mod/mod-build-task.cxx') diff --git a/mod/mod-build-task.cxx b/mod/mod-build-task.cxx index 911fb9b..e47ae60 100644 --- a/mod/mod-build-task.cxx +++ b/mod/mod-build-task.cxx @@ -149,7 +149,7 @@ handle (request& rq, response& rs) // collect the list of the built package configurations which it's time to // rebuilt. So if no unbuilt package is found, we will pickup one to // rebuild. The rebuild preference is given in the following order: the - // greater force flag, the greater overall status, the lower timestamp. + // greater force state, the greater overall status, the lower timestamp. // if (!cfg_machines.empty ()) { @@ -212,15 +212,18 @@ handle (request& rq, response& rs) expiration (timeout).time_since_epoch ()).count (); }; - uint64_t build_expiration_ns ( + uint64_t normal_result_expiration_ns ( expiration_ns (options_->build_result_timeout ())); - timestamp forced_rebuild_expiration ( - expiration (options_->build_forced_rebuild_timeout ())); + uint64_t forced_result_expiration_ns ( + expiration_ns (options_->build_forced_rebuild_timeout ())); timestamp normal_rebuild_expiration ( expiration (options_->build_normal_rebuild_timeout ())); + timestamp forced_rebuild_expiration ( + expiration (options_->build_forced_rebuild_timeout ())); + // Convert butl::standard_version type to brep::version. // brep::version toolchain_version (tqm.toolchain_version.string ()); @@ -309,7 +312,10 @@ handle (request& rq, response& rs) (bld_query::state == "built" || (bld_query::state == "building" && - bld_query::timestamp > build_expiration_ns))); + ((bld_query::force == "forcing" && + bld_query::timestamp > forced_result_expiration_ns) || + (bld_query::force != "forcing" && // Unforced or forced. + bld_query::timestamp > normal_result_expiration_ns))))); connection_ptr bld_conn (build_db_->connection ()); @@ -370,11 +376,15 @@ handle (request& rq, response& rs) assert (j != configs.end ()); configs.erase (j); - if (i->state == build_state::built && - i->timestamp <= (i->forced - ? forced_rebuild_expiration - : normal_rebuild_expiration)) - rebuilds.emplace_back (i.load ()); + if (i->state == build_state::built) + { + assert (i->force != force_state::forcing); + + if (i->timestamp <= (i->force == force_state::forced + ? forced_rebuild_expiration + : normal_rebuild_expiration)) + rebuilds.emplace_back (i.load ()); + } } if (!configs.empty ()) @@ -404,31 +414,29 @@ handle (request& rq, response& rs) else { // The package configuration can be in the building or unbuilt - // state, so the forced flag is false and the status is absent, - // unless in the building state (in which case they may or may - // not be set/exist), and there are no results. + // state, and there are no results. // - // Note that in the building state the status can be present if - // the rebuild task have been issued. In both cases we keep the - // status intact to be able to compare it with the final one in - // the result request handling in order to decide if to send the - // notification email. The same is true for the forced flag. We - // just assert that if the force flag is set, then the status - // exists. + // Note that in both cases we keep the status intact to be able + // to compare it with the final one in the result request + // handling in order to decide if to send the notification email. + // The same is true for the forced flag (in the sense that we + // don't set the force state to unforced). // // Load the section to assert the above statement. // build_db_->load (*b, b->results_section); - assert (b->state != build_state::built && + assert (b->state != build_state::built && b->results.empty ()); - ((!b->forced && !b->status) || - (b->state == build_state::building && - (!b->forced || b->status))) && + b->state = build_state::building; - b->results.empty ()); + // Switch the force state not to reissue the task after the + // forced rebuild timeout. Note that the result handler will + // still recognize that the rebuild was forced. + // + if (b->force == force_state::forcing) + b->force = force_state::forced; - b->state = build_state::building; b->toolchain_name = move (tqm.toolchain_name); b->machine = mh.name; b->machine_summary = move (mh.summary); @@ -476,15 +484,15 @@ handle (request& rq, response& rs) // Sort the package configuration rebuild list with the following sort // priority: // - // 1: forced flag + // 1: force state // 2: overall status // 3: timestamp (less is preferred) // auto cmp = [] (const shared_ptr& x, const shared_ptr& y) -> bool { - if (x->forced != y->forced) - return x->forced > y->forced; // Forced goes first. + if (x->force != y->force) + return x->force > y->force; // Forced goes first. assert (x->status && y->status); // Both built. @@ -502,7 +510,7 @@ handle (request& rq, response& rs) // anymore (as we have committed the database transactions that were // used to collect this data) so we recheck. If we find one that matches // then put it into the building state, refresh the timestamp and - // update. Note that we don't amend the status and the force flag to + // update. Note that we don't amend the status and the force state to // have them available in the result request handling (see above). // for (auto& b: rebuilds) @@ -514,7 +522,7 @@ handle (request& rq, response& rs) b = build_db_->find (b->id); if (b != nullptr && b->state == build_state::built && - b->timestamp <= (b->forced + b->timestamp <= (b->force == force_state::forced ? forced_rebuild_expiration : normal_rebuild_expiration)) { -- cgit v1.1