Hi Rafel,
Reviewed and tested the patch.
minor comments inline.
Questions:
1. For the new attribute "nodesForSingleStep" only PLs are allowed?
2. I tested giving controllers
immcfg -a numberOfSingleSteps=2 -a nodesForSingleStep=SC-1 -a
nodesForSingleStep=SC-2 openSafSmfExecControl=MergeCampToSS2
The steps created are "SmfBalancedProcedure" are created for PL and
normal "safSmfProc=proc2 " created for SCs
Thanks,
Neel.
On 2016/08/27 01:59 PM, Rafael Odzakow wrote:
> osaf/services/saf/smfsv/config/smfsv_classes.xml | 13 +
> osaf/services/saf/smfsv/smfd/Makefile.am | 6 +-
> osaf/services/saf/smfsv/smfd/SmfCampState.cc | 126 +----
> osaf/services/saf/smfsv/smfd/SmfCampaign.cc | 78 ++-
> osaf/services/saf/smfsv/smfd/SmfCampaign.hh | 1 +
> osaf/services/saf/smfsv/smfd/SmfExecControl.cc | 423
> ++++++++++++++++++++
> osaf/services/saf/smfsv/smfd/SmfExecControl.h | 64 +++
> osaf/services/saf/smfsv/smfd/SmfProcState.cc | 7 +-
> osaf/services/saf/smfsv/smfd/SmfUpgradeCampaign.cc | 32 +-
> osaf/services/saf/smfsv/smfd/SmfUpgradeCampaign.hh | 24 +-
> osaf/services/saf/smfsv/smfd/SmfUpgradeProcedure.cc | 14 +-
> osaf/services/saf/smfsv/smfd/SmfUpgradeProcedure.hh | 20 +-
> osaf/services/saf/smfsv/smfd/SmfUpgradeStep.hh | 13 +-
> osaf/services/saf/smfsv/smfd/smfd.h | 2 +-
> 14 files changed, 638 insertions(+), 185 deletions(-)
>
>
> diff --git a/osaf/services/saf/smfsv/config/smfsv_classes.xml
> b/osaf/services/saf/smfsv/config/smfsv_classes.xml
> --- a/osaf/services/saf/smfsv/config/smfsv_classes.xml
> +++ b/osaf/services/saf/smfsv/config/smfsv_classes.xml
> @@ -531,5 +531,18 @@
> <flag>SA_WRITABLE</flag>
> <default-value>0</default-value>
> </attr>
> + <attr>
> + <name>numberOfSingleSteps</name>
> + <type>SA_UINT32_T</type>
> + <category>SA_CONFIG</category>
> + <flag>SA_WRITABLE</flag>
> + </attr>
> + <attr>
> + <name>nodesForSingleStep</name>
> + <type>SA_STRING_T</type>
> + <category>SA_CONFIG</category>
> + <flag>SA_WRITABLE</flag>
> + <flag>SA_MULTI_VALUE</flag>
> + </attr>
> </class>
> </imm:IMM-contents>
> diff --git a/osaf/services/saf/smfsv/smfd/Makefile.am
> b/osaf/services/saf/smfsv/smfd/Makefile.am
> --- a/osaf/services/saf/smfsv/smfd/Makefile.am
> +++ b/osaf/services/saf/smfsv/smfd/Makefile.am
> @@ -49,7 +49,8 @@ noinst_HEADERS = \
> SmfCampaignWrapup.hh \
> SmfCampaignInit.hh \
> SmfCallback.hh \
> - SmfCbkUtil.hh
> + SmfCbkUtil.hh \
> + SmfExecControl.h
>
> osafsmfd_CXXFLAGS = $(AM_CXXFLAGS) @XML2_CFLAGS@
>
> @@ -87,7 +88,8 @@ osafsmfd_SOURCES = \
> SmfCampaignInit.cc \
> SmfCampaignWrapup.cc \
> SmfCallback.cc \
> - SmfCbkUtil.cc
> + SmfCbkUtil.cc \
> + SmfExecControl.cc
>
> osafsmfd_LDFLAGS = \
> $(AM_LDFLAGS) \
> diff --git a/osaf/services/saf/smfsv/smfd/SmfCampState.cc
> b/osaf/services/saf/smfsv/smfd/SmfCampState.cc
> --- a/osaf/services/saf/smfsv/smfd/SmfCampState.cc
> +++ b/osaf/services/saf/smfsv/smfd/SmfCampState.cc
> @@ -32,8 +32,10 @@
> #include "SmfCampaignThread.hh"
> #include "SmfCampaign.hh"
> #include "SmfProcedureThread.hh"
> +#include "smfsv_defs.h"
> #include <immutil.h>
> #include <sstream>
> +#include "SmfUpgradeAction.hh"
> /* ========================================================================
> * DEFINITIONS
> * ========================================================================
> @@ -764,12 +766,7 @@ SmfCampStateExecuting::execute(SmfUpgrad
> //must be restarted. The execution shall continue at step execution
> phase. The procedure initialization
> //and step calculation was performed before the move of control.
>
> - std::vector < SmfUpgradeProcedure * > procedures;
> - if (i_camp->getProcExecutionMode() == SMF_MERGE_TO_SINGLE_STEP) {
> - procedures.push_back(i_camp->getMergedProc());
> - } else {
> - procedures = i_camp->getProcedures();
> - }
> + std::vector<SmfUpgradeProcedure*> procedures =
> i_camp->getProcedures();
>
> std::vector < SmfUpgradeProcedure * >::iterator iter;
> bool execProcFound = false;
> @@ -817,13 +814,7 @@ SmfCampStateExecuting::executeProc(SmfUp
> //The procedure vector is sorted in execution level order (low -> high)
> //Lowest number shall be executed first.
>
> - std::vector < SmfUpgradeProcedure * > procedures;
> - if (i_camp->getProcExecutionMode() == SMF_MERGE_TO_SINGLE_STEP) {
> - procedures.push_back(i_camp->getMergedProc());
> - } else {
> - procedures = i_camp->getProcedures();
> - }
> -
> + std::vector<SmfUpgradeProcedure*> procedures =
> i_camp->getProcedures();
> std::vector < SmfUpgradeProcedure * >::iterator iter;
> int execLevel = -1;
>
> @@ -912,12 +903,7 @@ SmfCampStateExecuting::suspend(SmfUpgrad
> TRACE("SmfCampStateExecuting::suspend implementation");
>
> /* Send suspend message to all procedures */
> - std::vector < SmfUpgradeProcedure * > procedures;
> - if (i_camp->getProcExecutionMode() == SMF_MERGE_TO_SINGLE_STEP) {
> - procedures.push_back(i_camp->getMergedProc());
> - } else {
> - procedures = i_camp->getProcedures();
> - }
> + std::vector<SmfUpgradeProcedure*> procedures =
> i_camp->getProcedures();
>
> std::vector < SmfUpgradeProcedure * >::iterator iter;
>
> @@ -966,12 +952,7 @@ SmfCampStateExecuting::procResult(SmfUpg
> LOG_NO("CAMP: Procedure %s returned STEPUNDONE",
> i_procedure->getProcName().c_str());
>
> /* Send suspend message to all procedures */
> - std::vector < SmfUpgradeProcedure * > procedures;
> - if (i_camp->getProcExecutionMode() ==
> SMF_MERGE_TO_SINGLE_STEP) {
> - procedures.push_back(i_camp->getMergedProc());
> - } else {
> - procedures = i_camp->getProcedures();
> - }
> + std::vector<SmfUpgradeProcedure*> procedures =
> i_camp->getProcedures();
>
> std::vector < SmfUpgradeProcedure * >::iterator iter;
> for (iter = procedures.begin(); iter != procedures.end();
> ++iter) {
> @@ -1114,21 +1095,8 @@ SmfCampStateExecCompleted::commit(SmfUpg
> i_camp->resetMaintenanceState(); // No action if it fails
>
> //Remove the procedure runtime objects
> - if (i_camp->getProcExecutionMode() == SMF_MERGE_TO_SINGLE_STEP) {
> - i_camp->getMergedProc()->commit();
> -
> - } else {
> - std::vector < SmfUpgradeProcedure * > procedures;
> - if (i_camp->getProcExecutionMode() ==
> SMF_MERGE_TO_SINGLE_STEP) {
> - procedures.push_back(i_camp->getMergedProc());
> - } else {
> - procedures = i_camp->getProcedures();
> - }
> -
> - std::vector < SmfUpgradeProcedure * >::iterator iter;
> - for (iter = procedures.begin(); iter != procedures.end();
> ++iter) {
> - (*iter)->commit();
> - }
> + for (auto proc: i_camp->getProcedures()) {
> + proc->commit();
> }
>
> i_camp->removeRunTimeObjects(); // No action if it fails
> @@ -1213,12 +1181,7 @@ SmfCampStateSuspendingExec::execute(SmfU
> //in while in SuspendingExec state
> i_camp->setProcExecutionMode(smfd_cb->procExecutionMode);
>
> - std::vector < SmfUpgradeProcedure * > procedures;
> - if (i_camp->getProcExecutionMode() == SMF_MERGE_TO_SINGLE_STEP) {
> - procedures.push_back(i_camp->getMergedProc());
> - } else {
> - procedures = i_camp->getProcedures();
> - }
> + std::vector<SmfUpgradeProcedure*> procedures =
> i_camp->getProcedures();
>
> std::vector < SmfUpgradeProcedure * >::iterator iter;
> bool initialFound = false;
> @@ -1358,12 +1321,7 @@ SmfCampStateExecSuspended::execute(SmfUp
> i_camp->setProcExecutionMode(smfd_cb->procExecutionMode);
>
> /* Send execute to all suspended procedures */
> - std::vector < SmfUpgradeProcedure * > procedures;
> - if (i_camp->getProcExecutionMode() == SMF_MERGE_TO_SINGLE_STEP) {
> - procedures.push_back(i_camp->getMergedProc());
> - } else {
> - procedures = i_camp->getProcedures();
> - }
> + std::vector<SmfUpgradeProcedure*> procedures =
> i_camp->getProcedures();
>
> std::vector < SmfUpgradeProcedure * >::iterator iter;
>
> @@ -1423,12 +1381,7 @@ SmfCampStateExecSuspended::rollback(SmfU
> }
>
> /* Send rollback to all suspended procedures */
> - std::vector < SmfUpgradeProcedure * > procedures;
> - if (i_camp->getProcExecutionMode() == SMF_MERGE_TO_SINGLE_STEP) {
> - procedures.push_back(i_camp->getMergedProc());
> - } else {
> - procedures = i_camp->getProcedures();
> - }
> + std::vector<SmfUpgradeProcedure*> procedures =
> i_camp->getProcedures();
>
> std::vector < SmfUpgradeProcedure * >::iterator iter;
>
> @@ -1728,12 +1681,7 @@ SmfCampStateSuspendedByErrorDetected::ex
> i_camp->setProcExecutionMode(smfd_cb->procExecutionMode);
>
> /* Send execute to all suspended/undone procedures */
> - std::vector < SmfUpgradeProcedure * > procedures;
> - if (i_camp->getProcExecutionMode() == SMF_MERGE_TO_SINGLE_STEP) {
> - procedures.push_back(i_camp->getMergedProc());
> - } else {
> - procedures = i_camp->getProcedures();
> - }
> + std::vector<SmfUpgradeProcedure*> procedures =
> i_camp->getProcedures();
>
> std::vector < SmfUpgradeProcedure * >::iterator iter;
>
> @@ -1789,12 +1737,7 @@ SmfCampStateSuspendedByErrorDetected::ro
> }
>
> /* Send rollback to all suspended/undone procedures */
> - std::vector < SmfUpgradeProcedure * > procedures;
> - if (i_camp->getProcExecutionMode() == SMF_MERGE_TO_SINGLE_STEP) {
> - procedures.push_back(i_camp->getMergedProc());
> - } else {
> - procedures = i_camp->getProcedures();
> - }
> + std::vector<SmfUpgradeProcedure*> procedures =
> i_camp->getProcedures();
>
> std::vector < SmfUpgradeProcedure * >::iterator iter;
>
> @@ -1873,12 +1816,7 @@ SmfCampRollingBack::rollback(SmfUpgradeC
> TRACE_ENTER();
> TRACE("SmfCampRollingBack::rollback implementation");
>
> - std::vector < SmfUpgradeProcedure * > procedures;
> - if (i_camp->getProcExecutionMode() == SMF_MERGE_TO_SINGLE_STEP) {
> - procedures.push_back(i_camp->getMergedProc());
> - } else {
> - procedures = i_camp->getProcedures();
> - }
> + std::vector<SmfUpgradeProcedure*> procedures =
> i_camp->getProcedures();
>
> std::vector < SmfUpgradeProcedure * >::reverse_iterator iter;
>
> @@ -1960,12 +1898,7 @@ SmfCampRollingBack::rollbackProc(SmfUpgr
> //The procedure vector is sorted in execution level order (low -> high)
> //Highest number shall be rolled back first so start from end of list.
>
> - std::vector < SmfUpgradeProcedure * > procedures;
> - if (i_camp->getProcExecutionMode() == SMF_MERGE_TO_SINGLE_STEP) {
> - procedures.push_back(i_camp->getMergedProc());
> - } else {
> - procedures = i_camp->getProcedures();
> - }
> + std::vector<SmfUpgradeProcedure*> procedures =
> i_camp->getProcedures();
>
> std::vector < SmfUpgradeProcedure * >::reverse_iterator iter;
>
> @@ -2017,7 +1950,8 @@ SmfCampRollingBack::rollbackSingleMergeP
> {
> TRACE_ENTER();
> LOG_NO("CAMP:: Rollback merged single step procedure only");
> - SmfUpgradeProcedure * mergedProc = i_camp->getMergedProc();
> + std::vector<SmfUpgradeProcedure*> procedures =
> i_camp->getProcedures();
> + SmfUpgradeProcedure * mergedProc = procedures.at(0);
> if (mergedProc->getState() == SA_SMF_PROC_COMPLETED) {
> SmfProcedureThread *procThread =
> mergedProc->getProcThread();
> PROCEDURE_EVT *evt = new PROCEDURE_EVT();
> @@ -2046,12 +1980,7 @@ SmfCampRollingBack::suspend(SmfUpgradeCa
> TRACE("SmfCampRollingBack::suspend implementation");
>
> /* Send suspend message to all procedures */
> - std::vector < SmfUpgradeProcedure * > procedures;
> - if (i_camp->getProcExecutionMode() == SMF_MERGE_TO_SINGLE_STEP) {
> - procedures.push_back(i_camp->getMergedProc());
> - } else {
> - procedures = i_camp->getProcedures();
> - }
> + std::vector<SmfUpgradeProcedure*> procedures =
> i_camp->getProcedures();
>
> std::vector < SmfUpgradeProcedure * >::iterator iter;
>
> @@ -2172,12 +2101,7 @@ SmfCampRollbackSuspended::rollback(SmfUp
> TRACE("SmfCampRollbackSuspended::rollback implementation");
>
> /* Send rollback to all suspended procedures */
> - std::vector < SmfUpgradeProcedure * > procedures;
> - if (i_camp->getProcExecutionMode() == SMF_MERGE_TO_SINGLE_STEP) {
> - procedures.push_back(i_camp->getMergedProc());
> - } else {
> - procedures = i_camp->getProcedures();
> - }
> + std::vector<SmfUpgradeProcedure*> procedures =
> i_camp->getProcedures();
>
> std::vector < SmfUpgradeProcedure * >::iterator iter;
>
> @@ -2345,16 +2269,8 @@ SmfCampRollbackCompleted::commit(SmfUpgr
> i_camp->resetMaintenanceState(); // No action if it fails
>
> //Remove the procedure runtime objects
> - if (i_camp->getProcExecutionMode() == SMF_MERGE_TO_SINGLE_STEP) {
> - i_camp->getMergedProc()->commit();
> -
> - } else {
> - const std::vector < SmfUpgradeProcedure * >& procedures =
> i_camp->getProcedures();
> - std::vector < SmfUpgradeProcedure * >::const_iterator iter;
> -
> - for (iter = procedures.begin(); iter != procedures.end();
> ++iter) {
> - (*iter)->commit();
> - }
> + for (auto proc: i_camp->getProcedures()) {
> + proc->commit();
> }
>
> i_camp->removeRunTimeObjects(); // No action if it fails
> diff --git a/osaf/services/saf/smfsv/smfd/SmfCampaign.cc
> b/osaf/services/saf/smfsv/smfd/SmfCampaign.cc
> --- a/osaf/services/saf/smfsv/smfd/SmfCampaign.cc
> +++ b/osaf/services/saf/smfsv/smfd/SmfCampaign.cc
> @@ -18,6 +18,7 @@
> #include <sys/stat.h>
> #include <new>
> #include <vector>
> +#include <algorithm>
> #include <string>
> #include <sys/time.h>
>
> @@ -30,7 +31,9 @@
> #include "SmfUpgradeProcedure.hh"
> #include "SmfUpgradeMethod.hh"
> #include "SmfProcedureThread.hh"
> +#include "SmfUpgradeAction.hh"
> #include "SmfUtils.hh"
> +#include "SmfExecControl.h"
>
> #include "saAis.h"
> #include <saSmf.h>
> @@ -661,6 +664,10 @@ SmfCampaign::initExecution(void)
> SaAisErrorT
> SmfCampaign::startProcedureThreads()
> {
> + // If any procedure start goes badly two things happen: delete of the
> + // upgrade campaign pointer to terminate and remove previously
> started
> + // procedures. Return SA_AIS_OK to not change campaign state and
> allow
> + // reexecution
> TRACE_ENTER();
> SmfUpgradeCampaign *p_uc = getUpgradeCampaign();
> if (p_uc->getProcExecutionMode() == SMF_MERGE_TO_SINGLE_STEP) {
> @@ -676,25 +683,26 @@ SmfCampaign::startProcedureThreads()
> std::string singleProcDN = singleProc->getProcName() + "," +
> SmfCampaignThread::instance()->campaign()->getDn();
> singleProc->setDn(singleProcDN);
> - p_uc->setMergedProc(singleProc);
> + p_uc->addModifiedProcedure(singleProc);
>
> - /* Start procedure thread */
> - SmfProcedureThread *procThread = new
> SmfProcedureThread(singleProc);
> - /* The procThread will set itself when started correctly */
> - singleProc->setProcThread(NULL);
> -
> - LOG_NO("SmfCampaign::startProcedureThreads, Starting
> procedure thread %s",
> - singleProc->getProcName().c_str());
> - procThread->start();
> - /* Check if procedure thread started correctly */
> - if (singleProc->getProcThread() == NULL) {
> - std::string error = "Start of procedure thread
> failed for " + singleProcDN;
> - LOG_ER("%s", error.c_str());
> -
> SmfCampaignThread::instance()->campaign()->setError(error);
> - delete p_uc; // To terminate and remove any
> previously started procedure threads
> - /* Don't change campaign state to allow reexecution
> */
> + if (startProcedure(singleProc) == false) {
> + delete p_uc;
> return SA_AIS_OK;
> }
> + } else if (p_uc->getProcExecutionMode() == SMF_BALANCED_MODE) {
> + SmfExecControl execc;
> + if (!execc.initBalancedMode()) {
> + return SA_AIS_ERR_INIT;
> + }
> + auto procedures = p_uc->getProcedures();
> + TRACE("SmfCampaign::startProcedureThreads, number of
> procedures=[%zu]", procedures.size());
> + for (auto proc: procedures) {
> + if (startProcedure(proc) == false) {
> + delete p_uc;
> + return SA_AIS_OK;
> + }
> + }
> +
> } else {
> const std::vector < SmfUpgradeProcedure * >& procedures =
> p_uc->getProcedures();
> std::vector < SmfUpgradeProcedure * >::const_iterator iter;
> @@ -718,24 +726,10 @@ SmfCampaign::startProcedureThreads()
> }
> (*iter)->setDn(dn);
>
> - /* Start procedure thread */
> - SmfProcedureThread *procThread = new
> SmfProcedureThread(*iter);
> - /* The procThread will set itself when started
> correctly */
> - (*iter)->setProcThread(NULL);
> -
> - TRACE("SmfCampaign::startProcedureThreads, Starting
> procedure thread %s", (*iter)->getProcName().c_str());
> - procThread->start();
> -
> - /* Check if procedure thread started correctly */
> - if ((*iter)->getProcThread() == NULL) {
> - std::string error = "Start of procedure
> thread failed for " + dn;
> - LOG_ER("%s", error.c_str());
> -
> SmfCampaignThread::instance()->campaign()->setError(error);
> - delete p_uc; // To terminate and remove any
> previously started procedure threads
> - /* Don't change campaign state to allow
> reexecution */
> + if (startProcedure(*iter) == false) {
> + delete p_uc;
> return SA_AIS_OK;
> }
> -
> iter++;
> }
> }
> @@ -743,6 +737,26 @@ SmfCampaign::startProcedureThreads()
> return SA_AIS_OK; //Will never return here, just for compiler
> }
>
> +//--------------------------------------------------------------------------
> +// Starts one upgrade procedure thread, return false on failure
> +//--------------------------------------------------------------------------
> +bool
> +SmfCampaign::startProcedure(SmfUpgradeProcedure* procedure) {
> + SmfProcedureThread *procedure_thread = new
> SmfProcedureThread(procedure);
> + // The procThread will set itself when started correctly
> + procedure->setProcThread(nullptr);
> + TRACE("SmfCampaign::startProcedure dn: %s",
> procedure->getDn().c_str());
> + procedure_thread->start();
> +
> + if (procedure->getProcThread() == nullptr) {
> + std::string error = "Start of procedure thread failed for "
> + procedure->getDn();
> + LOG_ER("%s", error.c_str());
> + SmfCampaignThread::instance()->campaign()->setError(error);
> + return false;
> + }
> + return true;
> +}
> +
> /**
> * procResult
> * Takes care of procedure result
> diff --git a/osaf/services/saf/smfsv/smfd/SmfCampaign.hh
> b/osaf/services/saf/smfsv/smfd/SmfCampaign.hh
> --- a/osaf/services/saf/smfsv/smfd/SmfCampaign.hh
> +++ b/osaf/services/saf/smfsv/smfd/SmfCampaign.hh
> @@ -107,6 +107,7 @@ class SmfCampaign {
> void stopElapsedTime();
>
> private:
> + bool startProcedure(SmfUpgradeProcedure* procedure);
>
> std::string m_dn;
> std::string m_cmpg;
> diff --git a/osaf/services/saf/smfsv/smfd/SmfExecControl.cc
> b/osaf/services/saf/smfsv/smfd/SmfExecControl.cc
> new file mode 100644
> --- /dev/null
> +++ b/osaf/services/saf/smfsv/smfd/SmfExecControl.cc
> @@ -0,0 +1,423 @@
> +/*
> + *
> + * (C) Copyright 2009 The OpenSAF Foundation
> + *
> + * This program is distributed in the hope that it will be useful, but
> + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
> + * or FITNESS FOR A PARTICULAR PURPOSE. This file and program are licensed
> + * under the GNU Lesser General Public License Version 2.1, February 1999.
> + * The complete license can be accessed from the following location:
> + * http://opensource.org/licenses/lgpl-license.php
> + * See the Copying file included with the OpenSAF distribution for full
> + * licensing terms.
> + *
> + * Author(s): Ericsson AB
> + *
> + */
> +
> +#include "SmfExecControl.h"
> +#include <list>
> +#include <limits>
> +#include <algorithm>
> +#include "logtrace.h"
> +#include "immutil.h"
> +#include "SmfUpgradeProcedure.hh"
> +#include "SmfUpgradeMethod.hh"
> +#include "SmfUtils.hh"
> +#include "SmfUpgradeAction.hh"
> +#include "SmfUpgradeCampaign.hh"
> +
> +
> +bool readExecControlObject(unsigned int* numberOfSingleSteps,
> + std::vector<std::string>* nodesForSingleStep);
> +
> +bool removeDuplicateActivationUnits(SmfUpgradeProcedure * i_newproc,
> + SmfUpgradeStep *newStep);
> +
> +static bool isNodeInGroup(const std::string& node,
> + const std::vector<std::string>& group) {
> + return std::find(group.begin(), group.end(), node) != group.end();
> +}
> +
> +
> +SmfExecControl::SmfExecControl() : m_numberofss(1) {
> + m_campaign = SmfCampaignThread::instance()->campaign();
> +}
> +
> +bool SmfExecControl::initBalancedMode() {
> + TRACE_ENTER();
> + // Enable balanced mode by adding and modifying the procedures in the
> + // campaign. Calls calculateSteps before the procedures are started in
> order
> + // to get the activation units of the steps.
> + m_originalprocs = m_campaign->getUpgradeCampaign()->getProcedures();
> + for (auto proc : m_originalprocs) {
> + proc->setDn(proc->getProcName() + "," + m_campaign->getDn());
> + if (!proc->calculateSteps()) {
> + TRACE("Step calculation failed");
> + return false;
> + }
> + }
> + if (!readExecControlObject(&m_numberofss, &m_nodesforss)) {
> + return false;
> + }
> + if (!setNodesForSingleStep()) {
> + return false;
> + }
> + createBalancedProcedures();
> +
> + for (auto bproc : m_balancedprocs) {
> + std::vector<SmfUpgradeStep*> steps;
> + std::vector<SmfUpgradeAction*> initactions;
> + std::vector<SmfUpgradeAction*> wrapupactions;
> + // Each new balanced procedure needs to copy some steps from the original
> + // procedures.
> + for (auto step : getStepsMatchingBalancedGroup(bproc)) {
> + // copy the steps together with actions and callbacks
> + auto 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());
> + bproc->getCallbackList(oproc->getUpgradeMethod());
> + }
> + if (!steps.empty()) {
> + SmfUpgradeStep* newstep = createMergedStep(bproc, steps);
> + addInitAndWrapupActionsToProcedure(bproc, initactions, wrapupactions);
> + removeDuplicateActivationUnits(bproc, newstep);
> + bproc->addProcStep(newstep);
> + }
> + }
> +
> + // add all the procedures
> + for (auto proc : m_originalprocs) {
> + if (!proc->getIsMergedProcedure()) {
> + TRACE("adding original procedure %s to upgrade campaign",
> proc->getDn().c_str());
> + m_campaign->getUpgradeCampaign()->addModifiedProcedure(proc);
> + } else {
> + TRACE("skipping original procedure %s", proc->getDn().c_str());
> + }
> + proc->setIsMergedProcedure(false); // Clear the flag
> + }
> + for (auto proc : m_balancedprocs) {
> + TRACE("adding balanced procedure %s to upgrade campaign",
> proc->getDn().c_str());
> + m_campaign->getUpgradeCampaign()->addModifiedProcedure(proc);
> + }
> +
> + TRACE_LEAVE();
> + return true;
> +}
> +
> +std::vector<SmfUpgradeStep*> SmfExecControl::getStepsMatchingBalancedGroup(
> + SmfUpgradeProcedure* procedure) {
> + TRACE_ENTER();
> + // Check if the steps are in the balanced group of the procedure. If so
> mark
> + // as completed and return the matching steps.
> + std::vector<SmfUpgradeStep*> steps;
> + for (auto oproc : m_originalprocs) {
> + for (auto ostep : oproc->getProcSteps()) {
> + if (isNodeInGroup(ostep->getSwNode(), procedure->getBalancedGroup())) {
> + if (ostep->getState() != SA_SMF_STEP_COMPLETED) {
> + // step will be started in a new merged step
> + ostep->setStepState(SA_SMF_STEP_COMPLETED);
> + steps.push_back(ostep);
> + }
> + }
> + }
> + }
> + TRACE_LEAVE();
> + return steps;
> +}
> +
> +bool SmfExecControl::setNodesForSingleStep() {
> + // nodesForSingleStep might contain nodes outside of our scope. Modify this
> + // list to only use the nodes that are found in the campaign.
> + TRACE_ENTER();
> + std::vector<std::string> nodes_included;
> + for (auto proc : m_originalprocs) {
> + proc->setIsMergedProcedure(true); // Mark the procedures to be modified
> + if (proc->getUpgradeMethod()->getUpgradeMethod() == SA_SMF_ROLLING) {
> + for (auto step : proc->getProcSteps()) {
> + if (isNodeInGroup(step->getSwNode(), m_nodesforss)) {
> + if (!isNodeInGroup(step->getSwNode(), nodes_included)) {
> + nodes_included.push_back(step->getSwNode());
> + }
> + } else {
> + // This procedure is not to be modified
> + proc->setIsMergedProcedure(false);
> + }
> + }
> + }
> + }
> + m_nodesforss = nodes_included;
> + TRACE_LEAVE();
> + return true;
> +}
> +
> +void SmfExecControl::createBalancedProcedures() {
> + // Creates new procedures based on the ExecControl configuration
> + TRACE_ENTER();
> + // chunk is the size of the balanced group
> + unsigned int chunk = (m_nodesforss.size() + m_numberofss - 1) /
> m_numberofss;
> + TRACE("balanced group size will be %i", chunk);
> + std::vector<std::string>::iterator itr;
> + std::vector<std::string>::iterator iend;
> + // Set the procedure exec level to be as high as possible
> + int procExecLvl = std::numeric_limits<int>::max() - m_numberofss - 1;
> + for (itr = m_nodesforss.begin(); iend < m_nodesforss.end(); itr += chunk) {
> + iend = itr + chunk;
> + SmfUpgradeProcedure *ssproc = new(std::nothrow) SmfUpgradeProcedure;
> + if (iend >= m_nodesforss.end()) {
> + iend = m_nodesforss.end();
> + }
> + ssproc->setUpgradeMethod(new(std::nothrow) SmfSinglestepUpgrade);
> + ssproc->setProcName("safSmfProc=SmfBalancedProcedure" +
> std::to_string(procExecLvl));
> + std::string cdn = SmfCampaignThread::instance()->campaign()->getDn();
> + ssproc->setDn(ssproc->getProcName() + "," + cdn);
> + ssproc->setExecLevel(std::to_string(procExecLvl));
> + ssproc->setIsMergedProcedure(true); // For cleanup purposes
> + // Each new procedure holds the balanced group it steps over
> + ssproc->setBalancedGroup(std::vector<std::string>(itr, iend));
> + m_balancedprocs.push_back(ssproc);
> + procExecLvl++;
> + }
> + TRACE_LEAVE();
> +}
> +
> +SmfUpgradeStep* SmfExecControl::createMergedStep(
> + SmfUpgradeProcedure* procedure,
> + const std::vector<SmfUpgradeStep*>& steps) {
> + // Create a merged step based on the upgrade steps passed in.
> + // The in/out-parameter procedure shall be one of the procedures that was
> + // created with help of the createBalancedProcedures() method.
> + TRACE_ENTER();
> + SmfUpgradeStep* newstep = new(std::nothrow)SmfUpgradeStep;
> + osafassert(newstep != nullptr);
> + newstep->setRdn("safSmfStep=0001");
> + newstep->setDn(newstep->getRdn() + "," + procedure->getDn());
> + newstep->setMaxRetry(0);
> + newstep->setRestartOption(0);
> + std::list <unitNameAndState> deact;
> + for (auto step : steps) {
> + if (isNodeInGroup(step->getSwNode(), procedure->getBalancedGroup())) {
> + TRACE("adding modifications, deact and bundle ref from node:%s",
> + step->getSwNode().c_str());
> + newstep->addModifications(step->getModifications());
> + deact.insert(deact.end(),
> + step->getDeactivationUnitList().begin(),
> + step->getDeactivationUnitList().end());
> + procedure->mergeBundleRefRollingToSingleStep(newstep, step);
> + }
> + }
> + TRACE_LEAVE();
> + return newstep;
> +}
> +
> +void SmfExecControl::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();
> +}
> +
> +void SmfExecControl::trace() {
> + for (auto proc : m_campaign->getUpgradeCampaign()->getProcedures()) {
> + TRACE("-procedure %s to upgrade campaign", proc->getDn().c_str());
> + TRACE("-merged procedure %i", proc->getIsMergedProcedure());
> + for (auto step : proc->getProcSteps()) {
> + TRACE("-step : %s, state %i", step->getDn().c_str(), step->getState());
> + }
> + for (auto iact : proc->getInitActions()) {
> + auto cba = dynamic_cast<SmfCallbackAction*>(iact);
> + TRACE("-iact cb label : %s",
> cba->getCallback().getCallbackLabel().c_str());
> + }
> + }
> +}
> +
> +bool readExecControlObject(unsigned int* numberOfSingleSteps,
> + std::vector<std::string>* nodesForSingleStep) {
> + // Read the attributes from the exec control object from the IMM. The OI
> + // will prevent any changes once a campaign is running.
> + SmfImmUtils immutil;
> + SaImmAttrValuesT_2 **attributes;
> + if (immutil.getObject(SMF_CONFIG_OBJECT_DN, &attributes) == false) {
> + LOG_ER("Could not get SMF config object from IMM %s",
> SMF_CONFIG_OBJECT_DN);
> + return false;
> + }
> + const char* execdn = immutil_getStringAttr(
> + (const SaImmAttrValuesT_2 **)attributes, OPENSAF_SMF_EXEC_CONTROL, 0);
> + if (execdn == NULL || strcmp(execdn, "") == 0) {
> + LOG_ER("Could not get %s attrs from SmfConfig",
> OPENSAF_SMF_EXEC_CONTROL);
> + return false;
> + }
> + if (immutil.getObject(execdn, &attributes) == false) {
> + LOG_ER("Failed to get object from attribute %s",
> OPENSAF_SMF_EXEC_CONTROL);
> + return false;
> + }
> + SaAisErrorT rc;
> + SaUint32T numnodes;
> + rc = immutil_getAttrValuesNumber(const_cast<char*>("nodesForSingleStep"),
> + (const SaImmAttrValuesT_2 **)attributes,
> + &numnodes);
> + if (rc != SA_AIS_OK) {
> + LOG_ER("nodesForSingleStep not configured");
> + return false;
> + }
> + const char* node;
> + for (unsigned int i = 0; i < numnodes; i++) {
> + node = immutil_getStringAttr((const SaImmAttrValuesT_2**)attributes,
> + "nodesForSingleStep", i);
> + if (node == NULL) {
> + break;
> + }
> + nodesForSingleStep->push_back("safAmfNode=" + std::string(node) +
> + ",safAmfCluster=myAmfCluster");
> + }
> + const SaUint32T* numss = immutil_getUint32Attr(
> + (const SaImmAttrValuesT_2 **)attributes, "numberOfSingleSteps", 0);
> + if (numss == NULL) {
> + LOG_ER("could not read numberOfSingleSteps");
> + return false;
> + }
> +
> + *numberOfSingleSteps = *numss;
> +
> + TRACE("numberOfSingleSteps %i", *numberOfSingleSteps);
> + for (auto node : *nodesForSingleStep) {
> + TRACE("nodesForSingleStep %s", node.c_str());
> + }
> + osafassert(numberOfSingleSteps != 0);
> + return true;
> +}
> +
> +bool removeDuplicateActivationUnits(SmfUpgradeProcedure * i_newproc,
> + SmfUpgradeStep *newStep) {
> + // Remove any (de)activation unit duplicates and add them to the step.
> + // Activation and deactivation units are the same because rolling and
> + // formodify is symetric.
> + TRACE_ENTER();
> + std::list < unitNameAndState > tmpDU;
> + std::multimap<std::string, objectInst> objInstances;
> + if (i_newproc->getImmComponentInfo(objInstances) == false) {
> + TRACE("Config info from IMM could not be read");
> + return false;
> + }
> +
> + // Remove DU duplicates
> + tmpDU.sort(compare_du_part);
> + tmpDU.unique(unique_du_part);
> +
> + // Reduce the DU list, check if smaller scope is within bigger scope.
> + std::pair<std::multimap<std::string, objectInst>::iterator,
> + std::multimap<std::string, objectInst>::iterator> nodeName_mm;
> + std::multimap<std::string, objectInst>::iterator iter;
> +
> + std::list < unitNameAndState > nodeLevelDU;
> + std::list < unitNameAndState >::iterator unit_iter;
> + // Find DU on node level and save them in a separate list
> + for (unit_iter = tmpDU.begin(); unit_iter != tmpDU.end();) {
> + if ((*unit_iter).name.find("safAmfNode=") == 0) { // DU is a node node
> + // A node will never be optimized away, save it
> + nodeLevelDU.push_back(*unit_iter);
> + // Remove the node and update iterator
> + unit_iter = tmpDU.erase(unit_iter);
> + } else {
> + ++unit_iter;
> + }
> + }
> +
> + // For all found nodes, look if some other DU (comp/SU) is within scope
> + // tmpDU contain all DU except the node level ones which was removed above
> + // and saved in nodeLevelDU list
> + std::list < unitNameAndState >::iterator itr;
> + for (itr = nodeLevelDU.begin(); itr != nodeLevelDU.end(); ++itr) {
> + // For all comp/SU found in the scope of the node. Find out if any
> + // remaining DU is within it.
> + // Get all components/SU within the node
> + nodeName_mm = objInstances.equal_range((*itr).name);
> + for (iter = nodeName_mm.first; iter != nodeName_mm.second; ++iter) {
> + // For all comp/SU sound in the scope of the node.
sound --> found
> + // Find out if any remaininf DU is within it
remaininf --> remaining
> + for (unit_iter = tmpDU.begin(); unit_iter != tmpDU.end();) {
> + if ((*unit_iter).name == (*iter).second.suDN) { // Check SU
> + TRACE("[%s] is in scope of [%s], remove it from DU list",
> + (*unit_iter).name.c_str(), (*itr).name.c_str());
> + // Remove the node and update iterator
> + unit_iter = tmpDU.erase(unit_iter);
> + } else if ((*unit_iter).name == (*iter).second.compDN) { // Check
> comp
> + TRACE("[%s] is in scope of [%s], remove it from DU list",
> + (*unit_iter).name.c_str(), (*itr).name.c_str());
> + // Remove the node and update iterator
> + unit_iter = tmpDU.erase(unit_iter);
> + } else {
> + ++unit_iter;
> + }
> + }
> + }
> + }
> +
> + // tmpDU contain all DU which was not in the scope of an included node Find
> + // DU on SU level and save them in a separate list. Remove SU from tmpDU
> list
> + std::list < unitNameAndState > suLevelDU;
> + for (unit_iter = tmpDU.begin(); unit_iter != tmpDU.end();) {
> + if ((*unit_iter).name.find("safSu=") == 0) { // DU is a SU
> + // A node will never be optimized away, save it
> + suLevelDU.push_back(*unit_iter);
> + unit_iter = tmpDU.erase(unit_iter); // Remove the SU and update
> iterator
> + } else {
> + ++unit_iter;
> + }
> + }
> +
> + // For all SU in the suLevelDU list, look if remaining DU in tmpDU is
> within
> + // scope of the SU
> + std::list < unitNameAndState >::iterator su_iter;
> + for (su_iter = suLevelDU.begin(); su_iter != suLevelDU.end(); ++su_iter) {
> + for (unit_iter = tmpDU.begin(); unit_iter != tmpDU.end();) {
> + if ((*unit_iter).name.find((*su_iter).name) != std::string::npos) {
> + // The component was in the scope of the SU
> + TRACE("[%s] is in scope of [%s], remove it from DU list",
> + (*unit_iter).name.c_str(), (*su_iter).name.c_str());
> + // Remove the Component and update iterator
> + unit_iter = tmpDU.erase(unit_iter);
> + } else {
> + ++unit_iter;
> + }
> + }
> + }
> +
> + newStep->addDeactivationUnits(nodeLevelDU); // Add the node level DU
> + newStep->addDeactivationUnits(suLevelDU); // Add the SU level DU
> + newStep->addDeactivationUnits(tmpDU); // Add the comp level DU
> +
> + // Rolling and forModify are symetric, add the node level DU
> + newStep->addActivationUnits(nodeLevelDU);
> + // Rolling and forModify are symetric, Add the SU level DU
> + newStep->addActivationUnits(suLevelDU);
> + // Rolling and forModify are symetric, Add the comp level DU
> + newStep->addActivationUnits(tmpDU);
> +
> + TRACE_LEAVE();
> + return true;
> +}
> diff --git a/osaf/services/saf/smfsv/smfd/SmfExecControl.h
> b/osaf/services/saf/smfsv/smfd/SmfExecControl.h
> new file mode 100644
> --- /dev/null
> +++ b/osaf/services/saf/smfsv/smfd/SmfExecControl.h
> @@ -0,0 +1,64 @@
> +/*
> + *
> + * (C) Copyright 2009 The OpenSAF Foundation
> + *
> + * This program is distributed in the hope that it will be useful, but
> + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
> + * or FITNESS FOR A PARTICULAR PURPOSE. This file and program are licensed
> + * under the GNU Lesser General Public License Version 2.1, February 1999.
> + * The complete license can be accessed from the following location:
> + * http://opensource.org/licenses/lgpl-license.php
> + * See the Copying file included with the OpenSAF distribution for full
> + * licensing terms.
> + *
> + * Author(s): Ericsson AB
> + *
> + */
> +#ifndef OPENSAF_STAGING_OSAF_SERVICES_SAF_SMFSV_SMFD_SMFEXECCONTROL_H_
> +#define OPENSAF_STAGING_OSAF_SERVICES_SAF_SMFSV_SMFD_SMFEXECCONTROL_H_
> +
> +#include <vector>
> +#include <string>
> +#include "base/macros.h"
> +#include "SmfUpgradeStep.hh"
> +#include "SmfUpgradeAction.hh"
> +
> +/*
> +* This class enables the balanced mode feature. This mode changes the
> execution
> +* of rolling procedures to be merged into one or several single steps that
> are
> +* spread out across the cluster nodes. This feature is used to give a faster
> +* upgrade time compared to rolling one node at a time, possibly several times
> +* for each node. By splittting the procedures it into several single steps
> +* across the nodes a total service outage can be avoided.
> +*/
> +
> +class SmfExecControl {
> + public:
> + SmfExecControl();
> + bool initBalancedMode();
> +
> + const std::vector<SmfUpgradeProcedure*>& getProcedures() {
> + return m_balancedprocs; }
> +
> + private:
> + bool setNodesForSingleStep();
> + void createBalancedProcedures();
> + SmfUpgradeStep* createMergedStep(SmfUpgradeProcedure* procedure,
> + const std::vector<SmfUpgradeStep*>&
> steps);
> + std::vector<SmfUpgradeStep*>
> getStepsMatchingBalancedGroup(SmfUpgradeProcedure* procedure);
> + void addInitAndWrapupActionsToProcedure(
> + SmfUpgradeProcedure* procedure,
> + const std::vector<SmfUpgradeAction*>& initactions,
> + const std::vector<SmfUpgradeAction*>& wrapupactions);
> + void trace();
> +
> + unsigned int m_numberofss;
> + SmfCampaign* m_campaign;
> + std::vector<std::string> m_nodesforss;
> + std::vector<SmfUpgradeProcedure*> m_balancedprocs;
> + std::vector<SmfUpgradeProcedure*> m_originalprocs;
> +
> + DELETE_COPY_AND_MOVE_OPERATORS(SmfExecControl);
> +};
> +
> +#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
> @@ -36,6 +36,7 @@
> #include "SmfRollback.hh"
> #include "SmfUtils.hh"
> #include "smfd.h"
> +#include "SmfExecControl.h"
>
> /* ========================================================================
> * DEFINITIONS
> @@ -241,8 +242,8 @@ SmfProcStateInitial::executeInit(SmfUpgr
> {
> TRACE_ENTER();
> LOG_NO("PROC: Start procedure init actions");
> - if
> (SmfCampaignThread::instance()->campaign()->getUpgradeCampaign()->getProcExecutionMode()
> - == SMF_MERGE_TO_SINGLE_STEP) {
> + int procExecMode =
> SmfCampaignThread::instance()->campaign()->getUpgradeCampaign()->getProcExecutionMode();
> + if (procExecMode == SMF_MERGE_TO_SINGLE_STEP) {
> LOG_NO("SmfProcStateInitial::executeInit, Merge procedures
> into single step");
> if( !i_proc->mergeStepIntoSingleStep(i_proc)) {
> changeState(i_proc,
> SmfProcStateExecFailed::instance());
> @@ -250,6 +251,8 @@ SmfProcStateInitial::executeInit(SmfUpgr
> TRACE_LEAVE();
> return SMF_PROC_FAILED;
> }
> + } else if (procExecMode == SMF_BALANCED_MODE) {
> + TRACE("SmfProcStateInitial::executeInit, In balanced mode,
> calculation already done");
> } else {
> TRACE("SmfProcStateInitial::executeInit, Calculate steps");
> if( !i_proc->calculateSteps() ) {
> diff --git a/osaf/services/saf/smfsv/smfd/SmfUpgradeCampaign.cc
> b/osaf/services/saf/smfsv/smfd/SmfUpgradeCampaign.cc
> --- a/osaf/services/saf/smfsv/smfd/SmfUpgradeCampaign.cc
> +++ b/osaf/services/saf/smfsv/smfd/SmfUpgradeCampaign.cc
> @@ -84,22 +84,26 @@ class SmfUpgradeProcedure;
> //
> ------------------------------------------------------------------------------
> SmfUpgradeCampaign::~SmfUpgradeCampaign()
> {
> - TRACE_ENTER();
> - //Delete merged procedure first since it contain references to other
> proc
> - //Check campaign state, if verify fails the campaign is still in state
> initial
> - //and the merged procedure is not yet created.
> - if ((getProcExecutionMode() == SMF_MERGE_TO_SINGLE_STEP) &&
> - (m_state->getState() != SA_SMF_CMPG_INITIAL)) {
> - delete(m_mergedProcedure);
> + TRACE_ENTER();
> + for (auto &it: m_procedure) {
> + delete it;
> }
> + m_procedure.clear();
> + m_originalProcedures.clear();
> + TRACE_LEAVE();
> +}
>
> - std::vector < SmfUpgradeProcedure * >::iterator iter;
> -
> - for (iter = m_procedure.begin(); iter != m_procedure.end(); ++iter) {
> - delete(*iter);
> - }
> -
> - TRACE_LEAVE();
> +//
> ------------------------------------------------------------------------------
> +// addModifiedProcedure()
> +//
> ------------------------------------------------------------------------------
> +void SmfUpgradeCampaign::addModifiedProcedure(SmfUpgradeProcedure*
> procedure) {
> + int execMode = getProcExecutionMode();
> + osafassert(execMode != SMF_STANDARD_MODE);
> + if (m_originalProcedures.size() == 0) {
> + m_originalProcedures = m_procedure;
> + m_procedure.clear();
> + }
> + m_procedure.push_back(procedure);
> }
>
> //
> ------------------------------------------------------------------------------
> diff --git a/osaf/services/saf/smfsv/smfd/SmfUpgradeCampaign.hh
> b/osaf/services/saf/smfsv/smfd/SmfUpgradeCampaign.hh
> --- a/osaf/services/saf/smfsv/smfd/SmfUpgradeCampaign.hh
> +++ b/osaf/services/saf/smfsv/smfd/SmfUpgradeCampaign.hh
> @@ -400,23 +400,19 @@ void verify();
> SaAisErrorT checkSmfRestartIndicator();
>
> ///
> -/// Purpose: get procedure list
> -/// @param None.
> -/// @return list of procedures.
> +/// Purpose: Get the unmodified procedures, no merged procedures included
> ///
> - const std::vector < SmfUpgradeProcedure * >& getProcedures() { return
> m_procedure; }
> + const std::vector<SmfUpgradeProcedure*>& getOriginalProcedures() {
> return m_originalProcedures; };
>
> -/// Purpose: set the merged procedure
> -/// @param A SmfUpgradeProcedure *
> -/// @return the procedure.
> ///
> - void setMergedProc(SmfUpgradeProcedure * proc) { m_mergedProcedure =
> proc; }
> +/// Purpose: Add the merged procedure while saving the original
> +///
> + void addModifiedProcedure(SmfUpgradeProcedure* procedure);
>
> -/// Purpose: get the merged procedure
> -/// @param None.
> -/// @return the procedure.
> ///
> - SmfUpgradeProcedure * getMergedProc() { return m_mergedProcedure; }
> +/// Purpose: Can be used with any procedure execution mode
> +///
> + const std::vector<SmfUpgradeProcedure*>& getProcedures() { return
> m_procedure; }
>
> /// Purpose: Set the procedure ecxecution mode
> /// @param The execution mode.
> @@ -482,8 +478,8 @@ private:
> std::string m_configurationBase;
> SmfCampaignInit m_campInit;
> SmfCampaignWrapup m_campWrapup;
> - std::vector < SmfUpgradeProcedure * >m_procedure;
> - SmfUpgradeProcedure * m_mergedProcedure;
> + std::vector<SmfUpgradeProcedure*> m_procedure;
> + std::vector<SmfUpgradeProcedure*> m_originalProcedures;
> SaTimeT m_waitToCommit;
> SaTimeT m_waitToAllowNewCampaign;
> int m_noOfExecutingProc;
> 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
> @@ -51,6 +51,7 @@
> #include "SmfUpgradeAction.hh"
> #include "SmfUtils.hh"
> #include "smfd.h"
> +#include "SmfExecControl.h"
>
> // This static member variable is the object counter for upgrade procedures
> unsigned long SmfUpgradeProcedure::s_procCounter = 1;
> @@ -1171,7 +1172,7 @@ SmfUpgradeProcedure::mergeStepIntoSingle
> std::list < unitNameAndState > forAddRemoveDU;
> std::list < unitNameAndState > tmpDU;
> SmfUpgradeCampaign * camp =
> SmfCampaignThread::instance()->campaign()->getUpgradeCampaign();
> - const std::vector < SmfUpgradeProcedure * >& procedures =
> camp->getProcedures();
> + const std::vector < SmfUpgradeProcedure * >& procedures =
> camp->getOriginalProcedures();
> std::vector < SmfUpgradeProcedure * >::const_iterator proc_iter;
> for (proc_iter = procedures.begin(); proc_iter != procedures.end();
> proc_iter++) {
> LOG_NO("Merging [%s] into a single step procedure",
> (*proc_iter)->getName().c_str());
> @@ -2779,10 +2780,13 @@ SmfUpgradeProcedure::getImmSteps()
> TRACE("Rolling upgrade");
> rc = getImmStepsRolling();
> } else if (upgradeMethod->getUpgradeMethod() == SA_SMF_SINGLE_STEP) {
> - if
> (SmfCampaignThread::instance()->campaign()->getUpgradeCampaign()->getProcExecutionMode()
> - == SMF_MERGE_TO_SINGLE_STEP) { //This is a merged single
> step
> + unsigned int execMode =
> SmfCampaignThread::instance()->campaign()->getUpgradeCampaign()->getProcExecutionMode();
> + if (execMode == SMF_MERGE_TO_SINGLE_STEP) { //This is a
> merged single step
> TRACE("Merged single step upgrade");
> rc = getImmStepsMergedSingleStep();
> + } else if (execMode == SMF_BALANCED_MODE) {
> + TRACE("Balanced single step upgrade");
> + rc = getImmStepsSingleStep();
> } else { //This is a written normal single step
> TRACE("Single step upgrade");
> rc = getImmStepsSingleStep();
> @@ -3140,7 +3144,7 @@ SmfUpgradeProcedure::getImmStepsMergedSi
> int initActionId = 1;
> int wrapupActionId = 1;
> SmfUpgradeCampaign * camp =
> SmfCampaignThread::instance()->campaign()->getUpgradeCampaign();
> - const std::vector < SmfUpgradeProcedure * >& procedures =
> camp->getProcedures();
> + const std::vector < SmfUpgradeProcedure * >& procedures =
> camp->getOriginalProcedures();
> std::vector < SmfUpgradeProcedure * >::const_iterator proc_iter;
> for (proc_iter = procedures.begin(); proc_iter !=
> procedures.end(); proc_iter++) {
>
> LOG_NO("SmfUpgradeProcedure::getImmStepsMergedSingleStep: Fetch callbacks and
> wrapup actions from [%s]",
> @@ -3415,7 +3419,7 @@ SmfUpgradeProcedure::bundleRefFromSsCamp
> //----------------------------------------------------------------
> //Read all the bundles to add/remove from the parsed camaign
> SmfUpgradeCampaign * camp =
> SmfCampaignThread::instance()->campaign()->getUpgradeCampaign();
> - const std::vector < SmfUpgradeProcedure * >& procedures =
> camp->getProcedures();
> + const std::vector < SmfUpgradeProcedure * >& procedures =
> camp->getOriginalProcedures();
> std::vector < SmfUpgradeProcedure * >::const_iterator proc_iter;
> std::list < SmfBundleRef > bundlesOldProcSS;
> std::list < SmfBundleRef *> bundlesOldProcRO;
> 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
> @@ -551,7 +551,7 @@ class SmfUpgradeProcedure {
> /// @param -
> /// @return The list of upgrade steps.
> ///
> - const std::vector < SmfUpgradeStep * >& getProcSteps() { return
> m_procSteps; }
> + std::vector < SmfUpgradeStep * >& getProcSteps() { return
> m_procSteps; }
>
> ///
> /// Purpose: Add the list of upgrade steps
> @@ -706,6 +706,7 @@ class SmfUpgradeProcedure {
> ///
> void setIsMergedProcedure(bool i_state)
> { m_isMergedProcedure = i_state; }
> + bool getIsMergedProcedure() {return m_isMergedProcedure; }
>
> ///
> /// Purpose: Reset the object counter of upgrade procedures
> @@ -717,8 +718,6 @@ class SmfUpgradeProcedure {
> friend class SmfProcState;
> friend class SmfCampStateSuspendingExec;
>
> - private:
> -
> ///
> /// Purpose: Get iformation from AMF config in IMM about Components, SUs
> and nodes needed for upgrade
> /// @param A reference to a std::multimap<std::string, objectInst>
> @@ -726,6 +725,20 @@ class SmfUpgradeProcedure {
> ///
> bool getImmComponentInfo(std::multimap<std::string, objectInst>
> &i_objects);
>
> +
> +///
> +/// Purpose: When merging with SMF_BALANCED_MODE we need to keep track of
> which balanced group procedures belong to.
> +///
> + const std::vector<std::string>& getBalancedGroup() { return
> m_balancedGroup; }
> +
> +///
> +/// Purpose: When merging with SMF_BALANCED_MODE we need to keep track of
> which balanced group procedures belong to.
> +///
> + void setBalancedGroup(std::vector<std::string> group) {
> m_balancedGroup = group; }
> +
> + private:
> +
> +
> ///
> /// Purpose: Change the procedure stste. If i_onlyInternalState == false,
> the IMM procedure object is updated and
> /// a state change event is sent
> @@ -765,6 +778,7 @@ class SmfUpgradeProcedure {
> std::list < SmfCallback * >m_afterUnlock; //Container of the
> procedure callbacks to be invoked onstep, ataction
> sem_t m_semaphore;
> bool m_isMergedProcedure;
> + std::vector<std::string> m_balancedGroup;
> };
>
> //////////////////////////////////////////////////
> diff --git a/osaf/services/saf/smfsv/smfd/SmfUpgradeStep.hh
> b/osaf/services/saf/smfsv/smfd/SmfUpgradeStep.hh
> --- a/osaf/services/saf/smfsv/smfd/SmfUpgradeStep.hh
> +++ b/osaf/services/saf/smfsv/smfd/SmfUpgradeStep.hh
> @@ -707,6 +707,12 @@ class SmfUpgradeStep {
> /// @return true on success else false
> ///
> bool readSmfClusterControllers();
> +///
> +/// Purpose: Set step state
> +/// @param The state
> +/// @return None
> +///
> + void setStepState(SaSmfStepStateT i_state);
>
> friend class SmfStepState;
>
> @@ -761,13 +767,6 @@ class SmfUpgradeStep {
> void setImmStateAndSendNotification(SaSmfStepStateT i_state);
>
> ///
> -/// Purpose: Set step state
> -/// @param The state
> -/// @return None
> -///
> - void setStepState(SaSmfStepStateT i_state);
> -
> -///
> /// Purpose: Disables copy constructor
> ///
> SmfUpgradeStep(const SmfUpgradeStep &);
> diff --git a/osaf/services/saf/smfsv/smfd/smfd.h
> b/osaf/services/saf/smfsv/smfd/smfd.h
> --- a/osaf/services/saf/smfsv/smfd/smfd.h
> +++ b/osaf/services/saf/smfsv/smfd/smfd.h
> @@ -60,7 +60,7 @@ extern "C" {
> /* SMF execution modes */
> #define SMF_STANDARD_MODE 0
> #define SMF_MERGE_TO_SINGLE_STEP 1
> -#define SMF_MERGE_TO_NODE_ROLLING 2
> +#define SMF_BALANCED_MODE 2
>
> /* ========================================================================
> * TYPE DEFINITIONS
------------------------------------------------------------------------------
_______________________________________________
Opensaf-devel mailing list
Opensaf-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/opensaf-devel
