osaf/services/saf/smfsv/smfd/SmfExecControl.cc | 121 +++++++------------
osaf/services/saf/smfsv/smfd/SmfExecControl.h | 11 +-
osaf/services/saf/smfsv/smfd/SmfProcState.cc | 5 +-
osaf/services/saf/smfsv/smfd/SmfUpgradeProcedure.cc | 39 ++++-
osaf/services/saf/smfsv/smfd/SmfUpgradeProcedure.hh | 2 +
osaf/services/saf/smfsv/smfd/SmfUpgradeStep.cc | 45 -------
6 files changed, 84 insertions(+), 139 deletions(-)
diff --git a/osaf/services/saf/smfsv/smfd/SmfExecControl.cc
b/osaf/services/saf/smfsv/smfd/SmfExecControl.cc
--- a/osaf/services/saf/smfsv/smfd/SmfExecControl.cc
+++ b/osaf/services/saf/smfsv/smfd/SmfExecControl.cc
@@ -29,17 +29,14 @@
namespace execctrl {
-static std::vector<SmfUpgradeStep*>
getStepsMatchingBalancedGroup(SmfUpgradeProcedure* procedure);
-
-static void addInitAndWrapupActionsToProcedure(SmfUpgradeProcedure* procedure,
- const std::vector<SmfUpgradeAction*>& initactions,
- const std::vector<SmfUpgradeAction*>& wrapupactions);
+static std::vector<SmfUpgradeStep*>
getStepsMatchingBalancedGroup(SmfUpgradeProcedure* procedure,
+
SmfUpgradeCampaign* ucamp);
static SmfUpgradeStep* mergeStep(SmfUpgradeProcedure* procedure,
- const std::vector<SmfUpgradeStep*>& steps);
+ const std::vector<SmfUpgradeStep*>& steps);
static bool removeDuplicateActivationUnits(SmfUpgradeProcedure * i_newproc,
- SmfUpgradeStep *newStep);
+ SmfUpgradeStep *newStep);
static bool isNodeInGroup(const std::string& node,
@@ -50,17 +47,18 @@ static bool isNodeInGroup(const std::str
bool createBalancedProcs() {
// Creates new procedures based on the ExecControl configuration
TRACE_ENTER();
- auto ucamp = SmfCampaignThread::instance()->campaign()->getUpgradeCampaign();
- auto exechdl = ucamp->getExecControlHdl();
+ SmfCampaign* camp = SmfCampaignThread::instance()->campaign();
+ SmfUpgradeCampaign* ucamp = camp->getUpgradeCampaign();
+ SmfExecControlObjHandler* exechdl = ucamp->getExecControlHdl();
bool errinfo = false;
- auto numberofss = exechdl->numberOfSingleSteps(&errinfo);
+ SaUint32T numberofss = exechdl->numberOfSingleSteps(&errinfo);
if (errinfo == false) {
TRACE("Failed reading attribute from ExecControlHdl");
return false;
}
// Assume that nodesForSingleStep only contains nodes used by the campaign.
- auto nodesforss = exechdl->nodesForSingleStep(&errinfo);
+ std::vector<std::string> nodesforss = exechdl->nodesForSingleStep(&errinfo);
if (errinfo == false) {
TRACE("Failed reading attribute from ExecControlHdl");
return false;
@@ -102,43 +100,47 @@ bool createBalancedProcs() {
bool createStepForBalancedProc(SmfUpgradeProcedure* procedure) {
TRACE_ENTER();
+ SmfCampaign* camp = SmfCampaignThread::instance()->campaign();
+ SmfUpgradeCampaign* ucamp = camp->getUpgradeCampaign();
+
std::vector<SmfUpgradeStep*> steps;
- std::vector<SmfUpgradeAction*> initactions;
- std::vector<SmfUpgradeAction*> wrapupactions;
- for (auto step : getStepsMatchingBalancedGroup(procedure)) {
- // copy the steps together with actions and callbacks
- auto oproc = step->getProcedure();
+ for (auto step : getStepsMatchingBalancedGroup(procedure, ucamp)) {
+ // copy steps and callbacks
+ SmfUpgradeProcedure* oproc = step->getProcedure();
steps.insert(steps.end(),
oproc->getProcSteps().begin(),
oproc->getProcSteps().end());
- initactions.insert(initactions.end(),
- oproc->getInitActions().begin(),
- oproc->getInitActions().end());
- wrapupactions.insert(wrapupactions.end(),
- oproc->getWrapupActions().begin(),
- oproc->getWrapupActions().end());
procedure->getCallbackList(oproc->getUpgradeMethod());
}
if (!steps.empty()) {
SmfUpgradeStep* newstep = mergeStep(procedure, steps);
- addInitAndWrapupActionsToProcedure(procedure, initactions, wrapupactions);
removeDuplicateActivationUnits(procedure, newstep);
procedure->addProcStep(newstep);
}
+ const std::vector<SmfUpgradeProcedure*>& allprocs = ucamp->getProcedures();
+ if (procedure == (*--allprocs.end())) {
+ // This is the last balanced procedure configure the wrapup actions.
+ for (auto wac : procedure->getWrapupActions()) {
+ const SmfCallbackAction* cba = dynamic_cast<const
SmfCallbackAction*>(wac);
+ if (cba != nullptr) {
+ const_cast<SmfCallbackAction*>(cba)->setCallbackProcedure(procedure);
+ }
+ }
+ }
TRACE_LEAVE();
return true;
}
-bool allStepsMerged(SmfUpgradeProcedure* procedure) {
+void disableMergeSteps(SmfUpgradeProcedure* procedure) {
TRACE_ENTER();
if (!procedure->getBalancedGroup().empty()) {
TRACE("not an original proc");
- return false;
+ return;
}
- auto camp = SmfCampaignThread::instance()->campaign();
- auto allprocs = camp->getUpgradeCampaign()->getProcedures();
-
- auto nodesforss =
camp->getUpgradeCampaign()->getExecControlHdl()->nodesForSingleStep(NULL);
+ SmfCampaign* camp = SmfCampaignThread::instance()->campaign();
+ SmfUpgradeCampaign* ucamp = camp->getUpgradeCampaign();
+ SmfExecControlObjHandler* exechdl = ucamp->getExecControlHdl();
+ std::vector<std::string> nodesforss = exechdl->nodesForSingleStep(NULL);
for (auto& node : nodesforss) {
node = "safAmfNode=" + std::string(node) + ",safAmfCluster=myAmfCluster";
}
@@ -150,40 +152,32 @@ bool allStepsMerged(SmfUpgradeProcedure*
allmerged = false;
} else {
TRACE("node in group stepNode:%s", step->getSwNode().c_str());
+ // disable this step, it will be executed in a balanced step
step->setStepState(SA_SMF_STEP_COMPLETED);
}
}
- TRACE("allStepsMerged returns:%d", allmerged);
+
+ if (allmerged) {
+ // All steps in this procedure are merged to balanced steps therefore we
+ // move the wrapup actions to the last balanced procedure.
+ const std::vector<SmfUpgradeProcedure*>& allprocs = ucamp->getProcedures();
+ auto lastproc = --allprocs.end();
+ for (auto& wact : procedure->getWrapupActions()) {
+ (*lastproc)->addProcWrapupAction(wact);
+ }
+ procedure->clearWrapupActions();
+ }
+
TRACE_LEAVE();
- return allmerged;
-}
-
-void trace(const std::string& message) {
- TRACE("-tracing procedures in UpgradeCampaign:%s", message.c_str());
- auto camp = SmfCampaignThread::instance()->campaign();
- for (auto proc : camp->getUpgradeCampaign()->getProcedures()) {
- TRACE("-procedure: name:%s dn:%s", proc->getName().c_str(),
proc->getDn().c_str());
- for (auto step : proc->getProcSteps()) {
- TRACE(" -step : %s, state %i", step->getDn().c_str(),
step->getState());
- }
- for (auto node : proc->getBalancedGroup()) {
- TRACE(" balanced node : %s", node.c_str());
- }
- for (auto iact : proc->getInitActions()) {
- auto cba = dynamic_cast<SmfCallbackAction*>(iact);
- TRACE(" iact cb label : %s",
cba->getCallback().getCallbackLabel().c_str());
- }
- }
}
std::vector<SmfUpgradeStep*> getStepsMatchingBalancedGroup(
- SmfUpgradeProcedure* procedure) {
+ SmfUpgradeProcedure* procedure, SmfUpgradeCampaign* ucamp) {
TRACE_ENTER();
// For all original procedures check if the steps are in the balanced group
// of the procedure. Return the matching steps.
std::vector<SmfUpgradeStep*> steps;
- auto camp = SmfCampaignThread::instance()->campaign();
- for (auto proc : camp->getUpgradeCampaign()->getProcedures()) {
+ for (auto proc : ucamp->getProcedures()) {
if (proc->getBalancedGroup().empty()) {
for (auto ostep : proc->getProcSteps()) {
if (isNodeInGroup(ostep->getSwNode(), procedure->getBalancedGroup())) {
@@ -199,29 +193,6 @@ std::vector<SmfUpgradeStep*> getStepsMat
return steps;
}
-void addInitAndWrapupActionsToProcedure(SmfUpgradeProcedure* procedure,
- const std::vector<SmfUpgradeAction*>& initactions,
- const std::vector<SmfUpgradeAction*>& wrapupactions) {
- // Add Init/WrapupActions to the procedure. The Actions themself contain a
- // pointer to the procedure.
- TRACE_ENTER();
- procedure->addInitActions(initactions);
- procedure->addWrapupActions(wrapupactions);
- for (auto iac : initactions) {
- const SmfCallbackAction* cba = dynamic_cast<const SmfCallbackAction*>(iac);
- if (cba != nullptr) {
- const_cast<SmfCallbackAction*>(cba)->setCallbackProcedure(procedure);
- }
- }
- for (auto wac : wrapupactions) {
- const SmfCallbackAction* cba = dynamic_cast<const SmfCallbackAction*>(wac);
- if (cba != nullptr) {
- const_cast<SmfCallbackAction*>(cba)->setCallbackProcedure(procedure);
- }
- }
- TRACE_LEAVE();
-}
-
SmfUpgradeStep* mergeStep(SmfUpgradeProcedure* procedure,
const std::vector<SmfUpgradeStep*>& steps) {
// Create a merged step based on the upgrade step passed in. The in/out
diff --git a/osaf/services/saf/smfsv/smfd/SmfExecControl.h
b/osaf/services/saf/smfsv/smfd/SmfExecControl.h
--- a/osaf/services/saf/smfsv/smfd/SmfExecControl.h
+++ b/osaf/services/saf/smfsv/smfd/SmfExecControl.h
@@ -46,14 +46,13 @@ namespace execctrl {
*/
bool createStepForBalancedProc(SmfUpgradeProcedure* procedure);
/*
- * Check if an original procedure will have all its steps merged to balanced
- * procedures. Set the step that will be merged to completed state.
- *
- * Return: true, if all steps will be merged
+ * Set the steps that will be merged to completed state and move the wrapup
+ * actions to the last procedure if all steps are to be merged. This is
+ * because we don't want to call the wrapup actions twice if it is not
+ * needed.
*/
- bool allStepsMerged(SmfUpgradeProcedure* procedure);
+ void disableMergeSteps(SmfUpgradeProcedure* procedure);
- void trace(const std::string& message);
} // namespace execctrl
#endif // OPENSAF_STAGING_OSAF_SERVICES_SAF_SMFSV_SMFD_SMFEXECCONTROL_H_
diff --git a/osaf/services/saf/smfsv/smfd/SmfProcState.cc
b/osaf/services/saf/smfsv/smfd/SmfProcState.cc
--- a/osaf/services/saf/smfsv/smfd/SmfProcState.cc
+++ b/osaf/services/saf/smfsv/smfd/SmfProcState.cc
@@ -259,9 +259,7 @@ SmfProcStateInitial::executeInit(SmfUpgr
LOG_NO("SmfProcStateExecuting::Step
calculation failed");
return SMF_PROC_FAILED;
}
- // Some steps will be merged, mark them as completed
- execctrl::allStepsMerged(i_proc);
- execctrl::trace("after procStateInit allStepsMerged");
+ execctrl::disableMergeSteps(i_proc);
} else {
LOG_NO("SmfProcStateInitial::executeInit, create step
for balanced procedure");
if (!execctrl::createStepForBalancedProc(i_proc)) {
@@ -270,7 +268,6 @@ SmfProcStateInitial::executeInit(SmfUpgr
TRACE_LEAVE();
return SMF_PROC_FAILED;
}
- execctrl::trace("after procStateInit
createStepsForBalancedProc");
}
} else {
TRACE("SmfProcStateInitial::executeInit, Calculate steps");
diff --git a/osaf/services/saf/smfsv/smfd/SmfUpgradeProcedure.cc
b/osaf/services/saf/smfsv/smfd/SmfUpgradeProcedure.cc
--- a/osaf/services/saf/smfsv/smfd/SmfUpgradeProcedure.cc
+++ b/osaf/services/saf/smfsv/smfd/SmfUpgradeProcedure.cc
@@ -20,6 +20,7 @@
* ========================================================================
*/
#include <string>
+#include <algorithm>
#include <vector>
#include <sstream>
@@ -433,7 +434,9 @@ SmfUpgradeProcedure::getUpgradeMethod(vo
void
SmfUpgradeProcedure::addProcInitAction(SmfUpgradeAction * i_action)
{
- m_procInitAction.push_back(i_action);
+ if (std::find(m_procInitAction.begin(), m_procInitAction.end(),
i_action) == m_procInitAction.end()) {
+ m_procInitAction.push_back(i_action);
+ }
}
//------------------------------------------------------------------------------
@@ -442,7 +445,9 @@ SmfUpgradeProcedure::addProcInitAction(S
void
SmfUpgradeProcedure::addProcWrapupAction(SmfUpgradeAction * i_action)
{
- m_procWrapupAction.push_back(i_action);
+ if (std::find(m_procWrapupAction.begin(), m_procWrapupAction.end(),
i_action) == m_procWrapupAction.end()) {
+ m_procWrapupAction.push_back(i_action);
+ }
}
//------------------------------------------------------------------------------
@@ -470,6 +475,13 @@ void
SmfUpgradeProcedure::switchOver()
{
TRACE_ENTER();
+ // If this assert triggers nodesForSingleStep was configured to
+ // contain controllers which is not possible for now.
+ if (!getBalancedGroup().empty()) {
+ LOG_ER("Unexpected SI-swap for balanced procedure.
nodesForSingleStep possibly contains controller node");
+ osafassert(0);
+ }
+
TRACE("SmfUpgradeProcedure::switchOver: Create the restart indicator");
SmfCampaignThread::instance()->campaign()->getUpgradeCampaign()->createSmfRestartIndicator();
@@ -810,28 +822,37 @@ void SmfUpgradeProcedure::getCallbackLis
switch((*cbkiter)->getAtAction()) {
case SmfCallback::beforeLock:
{
- /*Add this callback ptr to the beforeLock list
*/
- m_beforeLock.push_back(*cbkiter);
+ if (std::find(m_beforeLock.begin(),
m_beforeLock.end(), (*cbkiter)) == m_beforeLock.end()){
+ m_beforeLock.push_back(*cbkiter);
+ }
break;
}
case SmfCallback::beforeTermination:
{
- m_beforeTerm.push_back(*cbkiter);
+ if (std::find(m_beforeTerm.begin(),
m_beforeTerm.end(), (*cbkiter)) == m_beforeTerm.end()){
+ m_beforeTerm.push_back(*cbkiter);
+ }
break;
}
case SmfCallback::afterImmModification:
{
- m_afterImmModify.push_back(*cbkiter);
+ if (std::find(m_afterImmModify.begin(),
m_afterImmModify.end(), (*cbkiter)) == m_afterImmModify.end()){
+ m_afterImmModify.push_back(*cbkiter);
+ }
break;
}
case SmfCallback::afterInstantiation:
{
- m_afterInstantiate.push_back(*cbkiter);
+ if (std::find(m_afterInstantiate.begin(),
m_afterInstantiate.end(), (*cbkiter)) == m_afterInstantiate.end()){
+ m_afterInstantiate.push_back(*cbkiter);
+ }
break;
}
case SmfCallback::afterUnlock:
{
- m_afterUnlock.push_back(*cbkiter);
+ if (std::find(m_afterUnlock.begin(),
m_afterUnlock.end(), (*cbkiter)) == m_afterUnlock.end()){
+ m_afterUnlock.push_back(*cbkiter);
+ }
break;
}
default:
@@ -2790,7 +2811,7 @@ SmfUpgradeProcedure::getImmSteps()
rc = getImmStepsRolling();
if (execMode == SMF_BALANCED_MODE) {
// We get here after a SI SWAP, some steps will be
merged, mark them as completed
- execctrl::allStepsMerged(this);
+ execctrl::disableMergeSteps(this);
}
} else if (upgradeMethod->getUpgradeMethod() == SA_SMF_SINGLE_STEP) {
if (execMode == SMF_MERGE_TO_SINGLE_STEP) { //This is a
merged single step
diff --git a/osaf/services/saf/smfsv/smfd/SmfUpgradeProcedure.hh
b/osaf/services/saf/smfsv/smfd/SmfUpgradeProcedure.hh
--- a/osaf/services/saf/smfsv/smfd/SmfUpgradeProcedure.hh
+++ b/osaf/services/saf/smfsv/smfd/SmfUpgradeProcedure.hh
@@ -586,6 +586,8 @@ class SmfUpgradeProcedure {
///
const std::vector < SmfUpgradeAction * >& getWrapupActions() { return
m_procWrapupAction; }
+ void clearWrapupActions() { m_procWrapupAction.clear(); }
+
///
/// Purpose: Add the list of wrapup actions
/// @param The list of wrapup actions to add
diff --git a/osaf/services/saf/smfsv/smfd/SmfUpgradeStep.cc
b/osaf/services/saf/smfsv/smfd/SmfUpgradeStep.cc
--- a/osaf/services/saf/smfsv/smfd/SmfUpgradeStep.cc
+++ b/osaf/services/saf/smfsv/smfd/SmfUpgradeStep.cc
@@ -682,51 +682,6 @@ SmfUpgradeStep::lockDeactivationUnits()
SmfAdminOperation units(&m_deactivationUnit.m_actedOn);
bool rc = units.lock();
-#if 0
- /*LLDTEST*/
- bool errinfo = true;
- SmfExecControlObjHandler *lldtest_p = new SmfExecControlObjHandler;
- lldtest_p->install();
- TRACE("LLDTEST 1 %s: procExecMode=%d", __FUNCTION__,
- lldtest_p->procExecMode(errinfo));
- TRACE("LLDTEST 1 %s: numberOfSingleSteps=%d", __FUNCTION__,
- lldtest_p->numberOfSingleSteps(errinfo));
- TRACE("LLDTEST 1 %s: errinfo = %s", __FUNCTION__,
- lldtest_p? "true": "false");
-
- //nodesForSingleStep
- std::vector <std::string> tst_nodes;
- tst_nodes = lldtest_p->nodesForSingleStep(errinfo);
-
- for(auto& tst_node : tst_nodes ) {
- TRACE("LLDTEST 1 %s: nodesForSingleStep='%s'", __FUNCTION__,
- tst_node.c_str());
- }
-
- // Check what happens if we remove the exec control object copy!
- //lldtest_p->uninstall();
-
- delete lldtest_p;
-
-
- /* Try to create an object again and read attributes */
- SmfExecControlObjHandler lldtest;
- TRACE("LLDTEST 2 %s: procExecMode=%d", __FUNCTION__,
- lldtest.procExecMode(errinfo));
- TRACE("LLDTEST 2 %s: numberOfSingleSteps=%d", __FUNCTION__,
- lldtest.numberOfSingleSteps(errinfo));
- TRACE("LLDTEST 2 %s: errinfo = %s", __FUNCTION__,
- errinfo? "true": "false");
-
- //nodesForSingleStep
- tst_nodes = lldtest.nodesForSingleStep(errinfo);
-
- for(auto& tst_node : tst_nodes ) {
- TRACE("LLDTEST 2 %s: nodesForSingleStep='%s'", __FUNCTION__,
- tst_node.c_str());
- }
-#endif
-
return rc;
}
------------------------------------------------------------------------------
_______________________________________________
Opensaf-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/opensaf-devel
