src/PTCDeployment/EPTF_CLL_PTCDeployment_PrivateFunctions.ttcn - titan/titan.Libraries.CLL - Git at Google

 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
 // Copyright (c) 2000-2019 Ericsson Telecom AB                               //
 //                                                                           //
 // All rights reserved. This program and the accompanying materials          //
 // are made available under the terms of the Eclipse Public License v2.0     //
 // which accompanies this distribution, and is available at                  //
 // https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html                                 //
 ///////////////////////////////////////////////////////////////////////////////

 ///////////////////////////////////////////////////////////
 //  Module: EPTF_CLL_PTCDeployment_PrivateFunctions
 //
 //  Purpose:
 //    This module contains the implementation of the EPTF_PTCDeployment private functions.
 //
 //  Module depends on:
 //    <EPTF_CLL_Common_Definitions>
 //    <EPTF_CLL_PTCDeployment_Definitions>
 //    <EPTF_CLL_Base_Functions>
 //    <EPTF_CLL_Logging_Functions>
 //
 //  Current Owner:
 //    Zsolt Szalai (EZSOSZA)
 //
 //  Last Review Date:
 //    2007-11-14
 //
 //  Detailed Comments:
 //    This module contains the private functions for EPTF_PTCDeployment.
 //
 ///////////////////////////////////////////////////////////////
 module EPTF_CLL_PTCDeployment_PrivateFunctions {

   import from EPTF_CLL_Common_Definitions all;
   import from EPTF_CLL_PTCDeployment_Definitions all;
   import from EPTF_CLL_Base_Functions all;
   import from EPTF_CLL_Logging_Functions all;

   friend module EPTF_CLL_PTCDeployment_Functions;

   ///////////////////////////////////////////////////////////
   //  Function: f_PTCD_role_in_database
   //
   //  Purpose:
   //    Decides whether there is such a role in the database.
   //
   //  Parameters:
   //    pl_role - *in* *charstring*  - name of the role
   //    pl_roleindex - *out* *integer* - the index of the role in the database
   //
   //  Return Value:
   //    Boolean - true if the role is present
   //
   //  Errors:
   //    -
   //
   //  Detailed Comments:
   //    -
   //
   ///////////////////////////////////////////////////////////
   friend function f_PTCD_role_in_database(in charstring pl_role, out integer pl_roleindex) runs on EPTF_PTCD_CT return boolean {
     var integer i := 0;
     while (i < sizeof(v_roledatabase) and v_roledatabase[i].role != pl_role){i := i+1;}
     if (i == sizeof(v_roledatabase)) {return false;}
     else {pl_roleindex := i; return true;}
   }

   ///////////////////////////////////////////////////////////
   //  Function: f_PTCD_choose_host
   //
   //  Purpose:
   //    Main function on choosing the host from the role.
   //
   //  Parameters:
   //    pl_hostdeploymentlist - *in* <EPTF_HostDeploymentEntryList> - list of hosts and weights
   //    pl_method - *in* *integer* - methodology of choosing the host
   //
   //  Return Value:
   //    charstring - the host
   //
   //  Errors:
   //    Gives back "" on error
   //
   //  Detailed Comments:
   //    -
   //
   ///////////////////////////////////////////////////////////
   friend function f_PTCD_choose_host(in EPTF_HostDeploymentEntryList pl_hostdeploymentlist, in integer pl_method) runs on EPTF_PTCD_CT return charstring {
     var EPTF_HostDeploymentEntryList vl_hostlist:={};
     //filter for invalid hosts(empty host, or weight leq 0)
     for (var integer i:=0,j:=0;i<sizeof(pl_hostdeploymentlist);i:=i+1){
       if (pl_hostdeploymentlist[i].host != "" and not pl_hostdeploymentlist[i].weight<=0){
 	vl_hostlist[j] := pl_hostdeploymentlist[i];
       j:=j+1;
       }
     }
     // filter for emptyness
     if (sizeof(vl_hostlist)==0){return "";}
     // get the host
     return vl_hostlist[f_PTCD_probrandomindex(vl_hostlist, pl_method)].host;
   }

   ///////////////////////////////////////////////////////////
   //  Function: f_PTCD_probrandomindex
   //
   //  Purpose:
   //    Gets a random index from hostlist according to probability calculations.
   //
   //  Parameters:
   //    pl_hostdeploymentlist - *in* <EPTF_HostDeploymentEntryList> - list of hosts and weights
   //
   //  Return Value:
   //    integer - an index in the hostlist
   //
   //  Errors:
   //    -
   //
   //  Detailed Comments:
   //    Works in thw different way: Deterministic and using rnd to choose the index.
   //
   ///////////////////////////////////////////////////////////
   private function f_PTCD_probrandomindex(in EPTF_HostDeploymentEntryList pl_hostdeploymentlist, in integer method) runs on EPTF_PTCD_CT return integer {
     var integer size := sizeof(pl_hostdeploymentlist);
     if (method == 1){
       var EPTF_IntegerList burstlist := {};
       var EPTF_FloatList rof;
       for (var integer i:=0;i<size;i:=i+1){
 	rof[i] := int2float(pl_hostdeploymentlist[i].weight);
       }
       var float sum:=0.0;
       for (var integer i:=0;i<sizeof(rof);i:=i+1){sum := sum + rof[i]}
       // normalize
       for(var integer i:=0;i<size;i:=i+1) {
 	rof[i] := rof[i]/sum;
       }
       var integer r := 0;
       for(var integer i:=0;i<size;i:=i+1) {
 	if (i>=sizeof(v_currentBurst)) {v_currentBurst[i] := 0.0;}
 	v_currentBurst[i] := v_currentBurst[i]+rof[i];
 	burstlist[i] := float2int(v_currentBurst[i]);
 	v_currentBurst[i] := v_currentBurst[i] - int2float(burstlist[i]);
 	if (burstlist[i] == 1) {r := i;}
       }
       log(burstlist, v_currentBurst, rof);
       return r;
     } else {
       // all inputs are valid now!
       var float scale := 100.0;
       if (sizeof(pl_hostdeploymentlist) == 1){return 0;}
       var EPTF_IntegerList roi;
       // get the weights in a record of integer
       for (var integer i:=0;i<size;i:=i+1){
 	roi[i] := pl_hostdeploymentlist[i].weight;
       }
       var integer sum := f_sumroi(roi);
       // roi := scanl1(add,map(f_calcpercent,roi));
       roi[0] := float2int((int2float(roi[0])/int2float(sum)) * scale);
       for (var integer i:=1;i<size-1;i:=i+1){
 	roi[i] := float2int((int2float(roi[i])/int2float(sum)) * scale) + roi[i-1];
       }
       roi[size-1] := float2int(scale);
       var integer rnum := float2int(rnd()*scale);
       var integer i := 0;
       // search for the proper interval and return it
       while(rnum>=roi[i]){i:=i+1;}
       return i;
     }
   }

   ///////////////////////////////////////////////////////////
   //  Function: f_sumroi
   //
   //  Purpose:
   //    Sums up the elements of a record of integer.
   //
   //  Parameters:
   //    roi - *in* <EPTF_IntegerList> - list of integers
   //
   //  Return Value:
   //    integer - The sum
   //
   //  Errors:
   //    -
   //
   //  Detailed Comments:
   //    -
   //
   ///////////////////////////////////////////////////////////
   private function f_sumroi(in EPTF_IntegerList roi) return integer {
     var integer sum:=0;
     for (var integer i:=0;i<sizeof(roi);i:=i+1){sum := sum + roi[i]}
     return sum;
   }

   ///////////////////////////////////////////////////////////
   //  Function: f_PTCD_AddRole
   //
   //  Purpose:
   //    Adds a role to the end of the database
   //
   //  Parameters:
   //    pl_ptcdentry - *in* <EPTF_PtcDeploymentEntry> - a role
   //
   //  Return Value:
   //    -
   //
   //  Errors:
   //    -
   //
   //  Detailed Comments:
   //    -
   //
   ///////////////////////////////////////////////////////////
   friend function f_PTCD_AddRole(in EPTF_PtcDeploymentEntry pl_ptcdentry) runs on EPTF_PTCD_CT {
     v_roledatabase[sizeof(v_roledatabase)] := pl_ptcdentry;
   }

   ///////////////////////////////////////////////////////////
   //  Function: f_PTCD_RemoveHost
   //
   //  Purpose:
   //    Removes the given host from a role
   //
   //  Parameters:
   //    pl_roleindex - *in* *integer* - the role's index
   //    pl_host - *in* *charstring* - the host to erease
   //
   //  Return Value:
   //    -
   //
   //  Errors:
   //    -
   //
   //  Detailed Comments:
   //    -
   //
   ///////////////////////////////////////////////////////////
   friend function f_PTCD_RemoveHost(in integer pl_roleindex, in charstring pl_host) runs on EPTF_PTCD_CT {
     var EPTF_HostDeploymentEntryList data:={};
     for (var integer i:=0;i<sizeof(v_roledatabase[pl_roleindex].deployment);i:=i+1){
       if (v_roledatabase[pl_roleindex].deployment[i].host != pl_host) {
 	data[sizeof(data)] := v_roledatabase[pl_roleindex].deployment[i];
       }
     }
     v_roledatabase[pl_roleindex].deployment := data;
   }

   group Logging {

   ///////////////////////////////////////////////////////////
   //  Function: f_EPTF_PTCDeployment_error
   //
   //  Purpose:
   //    Function to log an error from PTCDeployment feature.
   //
   //  Parameters:
   //    - pl_message - *in* *charstring* - the message to log
   //
   //  Return Value:
   //    -
   //
   //  Errors & assertions:
   //    -
   //
   //  Detailed Comments:
   //    -
   //
   ///////////////////////////////////////////////////////////
   friend function f_EPTF_PTCDeployment_error(in charstring pl_message)
   runs on EPTF_PTCD_CT
   {
     f_EPTF_Logging_error(true, tsp_EPTF_PTCDeployment_loggingComponentMask&": "&pl_message);
     f_EPTF_Base_stopAll();
   }

   ///////////////////////////////////////////////////////////
   //  Function: f_EPTF_PTCDeployment_warning
   //
   //  Purpose:
   //    Function to log a warning from PTCDeployment feature.
   //
   //  Parameters:
   //    - pl_message - *in* *charstring* - the message to log
   //
   //  Return Value:
   //    -
   //
   //  Errors & assertions:
   //    -
   //
   //  Detailed Comments:
   //    -
   //
   ///////////////////////////////////////////////////////////
   friend function f_EPTF_PTCDeployment_warning(in @lazy charstring pl_message)
   runs on EPTF_PTCD_CT
   {
     f_EPTF_Logging_warningV2(pl_message, v_PTCDeployment_loggingMaskId, {c_EPTF_PTCDeployment_loggingClassIdx_Warning});
   }

   ///////////////////////////////////////////////////////////
   //  Function: f_EPTF_PTCDeployment_debug
   //
   //  Purpose:
   //    Function to log a debug message from PTCDeployment feature.
   //
   //  Parameters:
   //    - pl_message - *in* *charstring* - the message to log
   //
   //  Return Value:
   //    -
   //
   //  Errors & assertions:
   //    -
   //
   //  Detailed Comments:
   //    -
   //
   ///////////////////////////////////////////////////////////
   friend function f_EPTF_PTCDeployment_debug(in @lazy charstring pl_message)
   runs on EPTF_PTCD_CT
   {
     f_EPTF_Logging_debugV2(pl_message, v_PTCDeployment_loggingMaskId, {c_EPTF_PTCDeployment_loggingClassIdx_Debug});
   }

   ///////////////////////////////////////////////////////////
   //  Function: f_EPTF_PTCDeployment_debugEnabled
   //
   //  Purpose:
   //    Function to check if debug is enabled for PTCDeployment
   //
   //  Parameters:
   //    -
   //
   //  Return Value:
   //    *boolean* - true if debug enalbed
   //
   //  Errors & assertions:
   //    -
   //
   //  Detailed Comments:
   //    -
   //
   ///////////////////////////////////////////////////////////
   friend function f_EPTF_PTCDeployment_debugEnabled()
   runs on EPTF_PTCD_CT
   return boolean
   {
     return f_EPTF_Logging_isEnabled(v_PTCDeployment_loggingMaskId, c_EPTF_PTCDeployment_loggingClassIdx_Debug);
   }
 } // group Logging


 }
	///////////////////////////////////////////////////////////////////////////////
	// //
	// Copyright (c) 2000-2019 Ericsson Telecom AB //
	// //
	// All rights reserved. This program and the accompanying materials //
	// are made available under the terms of the Eclipse Public License v2.0 //
	// which accompanies this distribution, and is available at //
	// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html //
	///////////////////////////////////////////////////////////////////////////////

	///////////////////////////////////////////////////////////
	// Module: EPTF_CLL_PTCDeployment_PrivateFunctions
	//
	// Purpose:
	// This module contains the implementation of the EPTF_PTCDeployment private functions.
	//
	// Module depends on:
	// <EPTF_CLL_Common_Definitions>
	// <EPTF_CLL_PTCDeployment_Definitions>
	// <EPTF_CLL_Base_Functions>
	// <EPTF_CLL_Logging_Functions>
	//
	// Current Owner:
	// Zsolt Szalai (EZSOSZA)
	//
	// Last Review Date:
	// 2007-11-14
	//
	// Detailed Comments:
	// This module contains the private functions for EPTF_PTCDeployment.
	//
	///////////////////////////////////////////////////////////////
	module EPTF_CLL_PTCDeployment_PrivateFunctions {

	import from EPTF_CLL_Common_Definitions all;
	import from EPTF_CLL_PTCDeployment_Definitions all;
	import from EPTF_CLL_Base_Functions all;
	import from EPTF_CLL_Logging_Functions all;

	friend module EPTF_CLL_PTCDeployment_Functions;

	///////////////////////////////////////////////////////////
	// Function: f_PTCD_role_in_database
	//
	// Purpose:
	// Decides whether there is such a role in the database.
	//
	// Parameters:
	// pl_role - in charstring - name of the role
	// pl_roleindex - out integer - the index of the role in the database
	//
	// Return Value:
	// Boolean - true if the role is present
	//
	// Errors:
	// -
	//
	// Detailed Comments:
	// -
	//
	///////////////////////////////////////////////////////////
	friend function f_PTCD_role_in_database(in charstring pl_role, out integer pl_roleindex) runs on EPTF_PTCD_CT return boolean {
	var integer i := 0;
	while (i < sizeof(v_roledatabase) and v_roledatabase[i].role != pl_role){i := i+1;}
	if (i == sizeof(v_roledatabase)) {return false;}
	else {pl_roleindex := i; return true;}
	}

	///////////////////////////////////////////////////////////
	// Function: f_PTCD_choose_host
	//
	// Purpose:
	// Main function on choosing the host from the role.
	//
	// Parameters:
	// pl_hostdeploymentlist - in <EPTF_HostDeploymentEntryList> - list of hosts and weights
	// pl_method - in integer - methodology of choosing the host
	//
	// Return Value:
	// charstring - the host
	//
	// Errors:
	// Gives back "" on error
	//
	// Detailed Comments:
	// -
	//
	///////////////////////////////////////////////////////////
	friend function f_PTCD_choose_host(in EPTF_HostDeploymentEntryList pl_hostdeploymentlist, in integer pl_method) runs on EPTF_PTCD_CT return charstring {
	var EPTF_HostDeploymentEntryList vl_hostlist:={};
	//filter for invalid hosts(empty host, or weight leq 0)
	for (var integer i:=0,j:=0;i<sizeof(pl_hostdeploymentlist);i:=i+1){
	if (pl_hostdeploymentlist[i].host != "" and not pl_hostdeploymentlist[i].weight<=0){
	vl_hostlist[j] := pl_hostdeploymentlist[i];
	j:=j+1;
	}
	}
	// filter for emptyness
	if (sizeof(vl_hostlist)==0){return "";}
	// get the host
	return vl_hostlist[f_PTCD_probrandomindex(vl_hostlist, pl_method)].host;
	}

	///////////////////////////////////////////////////////////
	// Function: f_PTCD_probrandomindex
	//
	// Purpose:
	// Gets a random index from hostlist according to probability calculations.
	//
	// Parameters:
	// pl_hostdeploymentlist - in <EPTF_HostDeploymentEntryList> - list of hosts and weights
	//
	// Return Value:
	// integer - an index in the hostlist
	//
	// Errors:
	// -
	//
	// Detailed Comments:
	// Works in thw different way: Deterministic and using rnd to choose the index.
	//
	///////////////////////////////////////////////////////////
	private function f_PTCD_probrandomindex(in EPTF_HostDeploymentEntryList pl_hostdeploymentlist, in integer method) runs on EPTF_PTCD_CT return integer {
	var integer size := sizeof(pl_hostdeploymentlist);
	if (method == 1){
	var EPTF_IntegerList burstlist := {};
	var EPTF_FloatList rof;
	for (var integer i:=0;i<size;i:=i+1){
	rof[i] := int2float(pl_hostdeploymentlist[i].weight);
	}
	var float sum:=0.0;
	for (var integer i:=0;i<sizeof(rof);i:=i+1){sum := sum + rof[i]}
	// normalize
	for(var integer i:=0;i<size;i:=i+1) {
	rof[i] := rof[i]/sum;
	}
	var integer r := 0;
	for(var integer i:=0;i<size;i:=i+1) {
	if (i>=sizeof(v_currentBurst)) {v_currentBurst[i] := 0.0;}
	v_currentBurst[i] := v_currentBurst[i]+rof[i];
	burstlist[i] := float2int(v_currentBurst[i]);
	v_currentBurst[i] := v_currentBurst[i] - int2float(burstlist[i]);
	if (burstlist[i] == 1) {r := i;}
	}
	log(burstlist, v_currentBurst, rof);
	return r;
	} else {
	// all inputs are valid now!
	var float scale := 100.0;
	if (sizeof(pl_hostdeploymentlist) == 1){return 0;}
	var EPTF_IntegerList roi;
	// get the weights in a record of integer
	for (var integer i:=0;i<size;i:=i+1){
	roi[i] := pl_hostdeploymentlist[i].weight;
	}
	var integer sum := f_sumroi(roi);
	// roi := scanl1(add,map(f_calcpercent,roi));
	roi[0] := float2int((int2float(roi[0])/int2float(sum)) * scale);
	for (var integer i:=1;i<size-1;i:=i+1){
	roi[i] := float2int((int2float(roi[i])/int2float(sum)) * scale) + roi[i-1];
	}
	roi[size-1] := float2int(scale);
	var integer rnum := float2int(rnd()*scale);
	var integer i := 0;
	// search for the proper interval and return it
	while(rnum>=roi[i]){i:=i+1;}
	return i;
	}
	}

	///////////////////////////////////////////////////////////
	// Function: f_sumroi
	//
	// Purpose:
	// Sums up the elements of a record of integer.
	//
	// Parameters:
	// roi - in <EPTF_IntegerList> - list of integers
	//
	// Return Value:
	// integer - The sum
	//
	// Errors:
	// -
	//
	// Detailed Comments:
	// -
	//
	///////////////////////////////////////////////////////////
	private function f_sumroi(in EPTF_IntegerList roi) return integer {
	var integer sum:=0;
	for (var integer i:=0;i<sizeof(roi);i:=i+1){sum := sum + roi[i]}
	return sum;
	}

	///////////////////////////////////////////////////////////
	// Function: f_PTCD_AddRole
	//
	// Purpose:
	// Adds a role to the end of the database
	//
	// Parameters:
	// pl_ptcdentry - in <EPTF_PtcDeploymentEntry> - a role
	//
	// Return Value:
	// -
	//
	// Errors:
	// -
	//
	// Detailed Comments:
	// -
	//
	///////////////////////////////////////////////////////////
	friend function f_PTCD_AddRole(in EPTF_PtcDeploymentEntry pl_ptcdentry) runs on EPTF_PTCD_CT {
	v_roledatabase[sizeof(v_roledatabase)] := pl_ptcdentry;
	}

	///////////////////////////////////////////////////////////
	// Function: f_PTCD_RemoveHost
	//
	// Purpose:
	// Removes the given host from a role
	//
	// Parameters:
	// pl_roleindex - in integer - the role's index
	// pl_host - in charstring - the host to erease
	//
	// Return Value:
	// -
	//
	// Errors:
	// -
	//
	// Detailed Comments:
	// -
	//
	///////////////////////////////////////////////////////////
	friend function f_PTCD_RemoveHost(in integer pl_roleindex, in charstring pl_host) runs on EPTF_PTCD_CT {
	var EPTF_HostDeploymentEntryList data:={};
	for (var integer i:=0;i<sizeof(v_roledatabase[pl_roleindex].deployment);i:=i+1){
	if (v_roledatabase[pl_roleindex].deployment[i].host != pl_host) {
	data[sizeof(data)] := v_roledatabase[pl_roleindex].deployment[i];
	}
	}
	v_roledatabase[pl_roleindex].deployment := data;
	}

	group Logging {

	///////////////////////////////////////////////////////////
	// Function: f_EPTF_PTCDeployment_error
	//
	// Purpose:
	// Function to log an error from PTCDeployment feature.
	//
	// Parameters:
	// - pl_message - in charstring - the message to log
	//
	// Return Value:
	// -
	//
	// Errors & assertions:
	// -
	//
	// Detailed Comments:
	// -
	//
	///////////////////////////////////////////////////////////
	friend function f_EPTF_PTCDeployment_error(in charstring pl_message)
	runs on EPTF_PTCD_CT
	{
	f_EPTF_Logging_error(true, tsp_EPTF_PTCDeployment_loggingComponentMask&": "&pl_message);
	f_EPTF_Base_stopAll();
	}

	///////////////////////////////////////////////////////////
	// Function: f_EPTF_PTCDeployment_warning
	//
	// Purpose:
	// Function to log a warning from PTCDeployment feature.
	//
	// Parameters:
	// - pl_message - in charstring - the message to log
	//
	// Return Value:
	// -
	//
	// Errors & assertions:
	// -
	//
	// Detailed Comments:
	// -
	//
	///////////////////////////////////////////////////////////
	friend function f_EPTF_PTCDeployment_warning(in @lazy charstring pl_message)
	runs on EPTF_PTCD_CT
	{
	f_EPTF_Logging_warningV2(pl_message, v_PTCDeployment_loggingMaskId, {c_EPTF_PTCDeployment_loggingClassIdx_Warning});
	}

	///////////////////////////////////////////////////////////
	// Function: f_EPTF_PTCDeployment_debug
	//
	// Purpose:
	// Function to log a debug message from PTCDeployment feature.
	//
	// Parameters:
	// - pl_message - in charstring - the message to log
	//
	// Return Value:
	// -
	//
	// Errors & assertions:
	// -
	//
	// Detailed Comments:
	// -
	//
	///////////////////////////////////////////////////////////
	friend function f_EPTF_PTCDeployment_debug(in @lazy charstring pl_message)
	runs on EPTF_PTCD_CT
	{
	f_EPTF_Logging_debugV2(pl_message, v_PTCDeployment_loggingMaskId, {c_EPTF_PTCDeployment_loggingClassIdx_Debug});
	}

	///////////////////////////////////////////////////////////
	// Function: f_EPTF_PTCDeployment_debugEnabled
	//
	// Purpose:
	// Function to check if debug is enabled for PTCDeployment
	//
	// Parameters:
	// -
	//
	// Return Value:
	// boolean - true if debug enalbed
	//
	// Errors & assertions:
	// -
	//
	// Detailed Comments:
	// -
	//
	///////////////////////////////////////////////////////////
	friend function f_EPTF_PTCDeployment_debugEnabled()
	runs on EPTF_PTCD_CT
	return boolean
	{
	return f_EPTF_Logging_isEnabled(v_PTCDeployment_loggingMaskId, c_EPTF_PTCDeployment_loggingClassIdx_Debug);
	}
	} // group Logging



	}