| /////////////////////////////////////////////////////////////////////////////// |
| // // |
| // 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_HostAdminServer_Functions |
| // |
| // Purpose: |
| // This module contains function definitions for EPTF HostAdmin Server |
| // |
| // Module Parameters: |
| // tsp_debug_EPTF_HostAdminServer_Functions - *boolean* - debug messages on/off |
| // |
| // Module depends on: |
| // <EPTF_CLL_Base_Definitions> |
| // <EPTF_CLL_Base_Functions> |
| // <EPTF_CLL_Common_Definitions> |
| // <EPTF_CLL_DataSource_Definitions> |
| // <EPTF_CLL_DataSource_Functions> |
| // <EPTF_CLL_DataSourceClient_Functions> |
| // <EPTF_CLL_HostAdminServer_Definitions> |
| // <EPTF_CLL_HostAdmin_Definitions> |
| // <EPTF_CLL_HostAdmin_Functions> |
| // <EPTF_CLL_HashMapStr2Int_Functions> |
| // <EPTF_CLL_Logging_Definitions> |
| // <EPTF_CLL_Logging_Functions> |
| // <EPTF_CLL_Variable_Functions> |
| // <EPTF_CLL_Variable_Definitions> |
| // <EPTF_CLL_RBT_Functions> |
| // <EPTF_CLL_HashMap_Functions> |
| // |
| // Current Owner: |
| // Gabor Tatarka (egbotat) |
| // |
| // Last Review Date: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| /////////////////////////////////////////////////////////// |
| |
| module EPTF_CLL_HostAdminServer_Functions { |
| |
| import from EPTF_CLL_Base_Definitions all; |
| import from EPTF_CLL_Base_Functions all; |
| import from EPTF_CLL_Common_Definitions all; |
| import from EPTF_CLL_DataSource_Definitions all; |
| import from EPTF_CLL_DataSource_Functions all; |
| import from EPTF_CLL_DataSourceClient_Functions all; |
| import from EPTF_CLL_HostAdminServer_Definitions all; |
| import from EPTF_CLL_HostAdmin_Definitions all; |
| import from EPTF_CLL_HostAdmin_Functions all; |
| import from EPTF_CLL_HashMapStr2Int_Functions all; |
| import from EPTF_CLL_Logging_Definitions all; |
| import from EPTF_CLL_Logging_Functions all; |
| import from EPTF_CLL_Variable_Functions all; |
| import from EPTF_CLL_Variable_Definitions all; |
| import from EPTF_CLL_RBT_Functions all; |
| import from EPTF_CLL_HashMap_Functions all; |
| |
| friend module EPTF_HostAdmin_Test_Testcases; |
| modulepar boolean tsp_debug_EPTF_HostAdminServer_Functions := false; |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HostAdminServer_init_CT |
| // |
| // Purpose: |
| // Initialisation for <EPTF_HostAdminServer_CT> |
| // |
| // Parameters: |
| // pl_selfName - *charstring* - name of the component |
| // pl_dataSource_compRef - <EPTF_DataSource_CT> - datasource component reference |
| // |
| // Detailed Comments: |
| // It is recommended (but not necessary) to start HostAdminServer on the MTC |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_HostAdminServer_init_CT( |
| in charstring pl_selfName, |
| in EPTF_DataSource_CT pl_dataSource_compRef := null) |
| runs on EPTF_HostAdminServer_CT |
| { |
| if(v_EPTF_HostAdminServer_initialized) { return; } |
| v_EPTF_HostAdmin_hostDB := c_EPTF_HostAdmin_HostDB_init; |
| f_EPTF_Base_init_CT(pl_selfName); |
| |
| f_EPTF_Logging_init_CT(f_EPTF_Base_selfName()); |
| v_HostAdminServer_loggingMaskId := f_EPTF_Logging_registerComponentMasks(tsp_EPTF_HostAdminServer_loggingComponentMask, c_EPTF_HostAdminServer_loggingEventClasses, EPTF_Logging_CLL); |
| if(tsp_debug_EPTF_HostAdminServer_Functions) { |
| f_EPTF_Logging_enableLocalMask(v_HostAdminServer_loggingMaskId, c_EPTF_HostAdminServer_loggingClassIdx_Debug); |
| } else { |
| f_EPTF_Logging_disableLocalMask(v_HostAdminServer_loggingMaskId, c_EPTF_HostAdminServer_loggingClassIdx_Debug); |
| } |
| |
| f_EPTF_RBT_init_CT(f_EPTF_Base_selfName()); |
| f_EPTF_HashMap_init_CT (pl_selfName); |
| v_EPTF_HostAdmin_hostDB.hashRef := |
| f_EPTF_str2int_HashMap_New(c_EPTF_HostAdminServer_host2AdminHashMapName); |
| v_EPTF_HostAdmin_processDB.hashRef := |
| f_EPTF_str2int_HashMap_New(c_EPTF_HostAdminServer_selfName2ProcessHashMapName); |
| |
| f_EPTF_DataSourceClient_init_CT(f_EPTF_Base_selfName(), pl_dataSource_compRef); |
| f_EPTF_HostAdminServer_DSInit(); |
| |
| v_EPTF_HostAdminServer_compInfoList := f_EPTF_Base_getComponentInfoAll(); |
| f_EPTF_HostAdminServer_debug("hostInfoList: "&log2str(v_EPTF_HostAdminServer_compInfoList)); |
| |
| // start a HostAdmin on this host |
| var integer vl_nofClients := lengthof(v_EPTF_HostAdminServer_compInfoList); |
| for(var integer i:=0; |
| i < lengthof(v_EPTF_HostAdminServer_compInfoList); |
| i := i + 1) { |
| var integer vl_idx := f_EPTF_HostAdminServer_getOrStartClient(v_EPTF_HostAdminServer_compInfoList[i].hostName); |
| } |
| f_EPTF_HostAdminServer_createProcessVarsIfNeeded(v_EPTF_HostAdminServer_compInfoList); |
| |
| var integer vl_rst := -1; |
| f_EPTF_Var_newInt(c_HostAdminServer_DS_iteratorVar_prefix & c_HostAdminServer_dataElementResetMinMaxAvgCPULoad, 0, vl_rst); |
| f_EPTF_Var_addPostProcFn( vl_rst, |
| { funcRef := refers(f_EPTF_HostAdminServer_resetMinMaxAvgCPULoad), argList := {} }); |
| |
| if(pl_dataSource_compRef != null){ |
| f_EPTF_DataSourceClient_registerData(c_HostAdminServer_DataSource_sourceId, f_EPTF_Base_selfName(), refers(f_EPTF_HostAdminServer_DSProcessData)); |
| f_EPTF_DataSourceClient_registerDataValue(c_HostAdminServer_DataSource_sourceId, f_EPTF_Base_selfName(), refers(f_EPTF_HostAdminServer_DSProcessDataValue)); |
| f_EPTF_DataSourceClient_registerCondition(c_HostAdminServer_DataSource_sourceId, f_EPTF_Base_selfName(), refers(f_EPTF_HostAdminServer_conditionHandler_isMultipleHosts),c_HostAdminServer_conditionIsMultipleHosts); |
| f_EPTF_DataSourceClient_sendReady(c_HostAdminServer_DataSource_sourceId, f_EPTF_Base_selfName()); |
| } |
| |
| v_EPTF_HostAdminServer_eventHandler := |
| activate(as_EPTF_HostAdminServer_eventHandler()); |
| T_EPTF_HostAdminServer_refreshProcessList.start; |
| v_EPTF_HostAdminServer_initialized := true; |
| f_EPTF_Base_registerCleanup(refers(f_EPTF_HostAdminServer_cleanup_CT)); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HostAdminServer_setSortBy |
| // |
| // Purpose: |
| // Function to set the process statistics sort option |
| // |
| // Parameters: |
| // pl_sortBy - *in* <EPTF_HostAdmin_PDUSortBy> - the sort option |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_HostAdminServer_setSortBy( |
| in EPTF_HostAdmin_PDUSortBy pl_sortBy) |
| runs on EPTF_HostAdminServer_CT |
| { |
| f_EPTF_Base_assert(%definitionId&": pl_sortBy must not equal max_SortBy", pl_sortBy != max_SortBy); |
| for(var integer i := 0; |
| i < lengthof(v_EPTF_HostAdmin_hostDB.hosts); |
| i := i + 1) { |
| if(v_EPTF_HostAdmin_hostDB.hosts[i].isActive) { |
| Sync_PCO.send(EPTF_HostAdmin_PDU:{sortBy := pl_sortBy}) to v_EPTF_HostAdmin_hostDB.hosts[i].compRef; |
| } |
| } |
| } |
| |
| private function f_EPTF_HostAdminServer_cleanup_CT() |
| runs on EPTF_HostAdminServer_CT |
| { |
| if(not v_EPTF_HostAdminServer_initialized) { return; } |
| deactivate(v_EPTF_HostAdminServer_eventHandler); |
| v_EPTF_HostAdminServer_eventHandler := null; |
| f_EPTF_str2int_HashMap_Delete(c_EPTF_HostAdminServer_host2AdminHashMapName); |
| f_EPTF_str2int_HashMap_Delete(c_EPTF_HostAdminServer_selfName2ProcessHashMapName); |
| v_EPTF_HostAdminServer_initialized := false; |
| } |
| |
| private function f_EPTF_HostAdminServer_resetMinMaxAvgCPULoad(in integer pl_idx, in EPTF_IntegerList pl_argList) |
| runs on EPTF_HostAdminServer_CT |
| { |
| for(var integer i := 0; i<lengthof(v_EPTF_HostAdmin_hostDB.hosts); i:=i+1) { |
| if(v_EPTF_HostAdmin_hostDB.hosts[i].isActive) { |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[i].hostStats.rstMinMaxAvg, |
| {intVal := 1 + f_EPTF_Var_getIntValue(v_EPTF_HostAdmin_hostDB.hosts[i].hostStats.rstMinMaxAvg) }); |
| } |
| } |
| } |
| |
| private function f_EPTF_HostAdminServer_getOrStartClient( |
| in charstring pl_hostName) |
| runs on EPTF_HostAdminServer_CT |
| return integer |
| { |
| var integer vl_idx := -1; |
| if(not f_EPTF_str2int_HashMap_Find( |
| v_EPTF_HostAdmin_hostDB.hashRef, |
| pl_hostName, |
| vl_idx)) { |
| f_EPTF_HostAdminServer_debug("Starting client for new host "&pl_hostName); |
| vl_idx := lengthof(v_EPTF_HostAdmin_hostDB.hosts); |
| v_EPTF_HostAdmin_hostDB.hosts[vl_idx] := { |
| hostName := pl_hostName, |
| compRef := EPTF_HostAdmin_CT.create(-, pl_hostName), |
| isActive := true, |
| iteratorVarProcesses := -1, |
| hostStats := c_EPTF_HostAdmin_HostStatVars_init, |
| processStats := {}, |
| tmp := 0 |
| } |
| connect(self:Sync_PCO, v_EPTF_HostAdmin_hostDB.hosts[vl_idx].compRef:Sync_PCO); |
| var charstring vl_remoteSelfName := "HostAdmin-" & pl_hostName; |
| v_EPTF_HostAdmin_hostDB.hosts[vl_idx].compRef.start(f_EPTF_HostAdmin_behavior( |
| pl_selfName := vl_remoteSelfName, |
| pl_hostName := pl_hostName, |
| pl_dataSource_Ref:= null, |
| pl_server_Ref := self)); |
| f_EPTF_str2int_HashMap_Insert( |
| v_EPTF_HostAdmin_hostDB.hashRef, |
| pl_hostName, |
| vl_idx); |
| |
| // f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_iteratorVarHosts,{charstringlistVal := f_EPTF_Var_getCharstringlistValue(v_EPTF_HostAdmin_iteratorVarHosts) & {pl_hostName}}); |
| var integer vl_sortTree := f_EPTF_RBT_createCharstringTree(); |
| for(var integer i:=0; i<lengthof(v_EPTF_HostAdmin_hostDB.hosts); i:=i+1) { |
| f_EPTF_RBT_insertCharstringItem(vl_sortTree, v_EPTF_HostAdmin_hostDB.hosts[i].hostName); |
| } |
| var EPTF_IntegerList vl_order := {}; |
| f_EPTF_RBT_sortIncremental(vl_sortTree, vl_order); |
| f_EPTF_RBT_deleteTree(vl_sortTree); |
| var EPTF_CharstringList vl_hosts := {}; |
| for(var integer i:=0; i<lengthof(vl_order); i:=i+1) { |
| vl_hosts[i] := v_EPTF_HostAdmin_hostDB.hosts[vl_order[i]].hostName; |
| } |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_iteratorVarHosts,{charstringlistVal := vl_hosts}); |
| |
| var charstring vl_prefix := f_EPTF_HostAdminServer_getHostVarNamePrefix(pl_hostName); |
| f_EPTF_Var_newCharstring( |
| vl_prefix & c_HostAdminServer_dataElementIPv4Addr, |
| "", |
| v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.ipv4Addr); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.ipv4Addr,false); |
| f_EPTF_Var_newCharstring( |
| vl_prefix & c_HostAdminServer_dataElementIPv6Addr, |
| "", |
| v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.ipv6Addr); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.ipv6Addr,false); |
| f_EPTF_Var_newInt( |
| vl_prefix & c_HostAdminServer_dataElementPhysicalMem, |
| 0, |
| v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.physicalMem); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.physicalMem,false); |
| f_EPTF_Var_newCharstring( |
| vl_prefix & c_HostAdminServer_dataElementPhysicalMemHRF, |
| "0", |
| v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.physicalMemHRF); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.physicalMemHRF,false); |
| f_EPTF_Var_newInt( |
| vl_prefix & c_HostAdminServer_dataElementFreeMem, |
| 0, |
| v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.freeMem); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.freeMem,false); |
| f_EPTF_Var_newCharstring( |
| vl_prefix & c_HostAdminServer_dataElementFreeMemHRF, |
| "0", |
| v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.freeMemHRF); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.freeMemHRF,false); |
| f_EPTF_Var_newFloat( |
| vl_prefix & c_HostAdminServer_dataElementCpuLoad, |
| 0.0, |
| v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.cpuLoad); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.cpuLoad,false); |
| f_EPTF_Var_newFloat( |
| vl_prefix & c_HostAdminServer_dataElementCpuMin, |
| 0.0, |
| v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.cpuMin); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.cpuMin,false); |
| f_EPTF_Var_newFloat( |
| vl_prefix & c_HostAdminServer_dataElementCpuMax, |
| 0.0, |
| v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.cpuMax); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.cpuMax,false); |
| f_EPTF_Var_newFloat( |
| vl_prefix & c_HostAdminServer_dataElementCpuAvg, |
| 0.0, |
| v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.cpuAvg); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.cpuAvg,false); |
| f_EPTF_Var_subscribeRemote( |
| pl_remoteCompRef := v_EPTF_HostAdmin_hostDB.hosts[vl_idx].compRef, |
| pl_remoteProviderVarName := vl_remoteSelfName & "." & c_EPTF_HostAdmin_resetMinMaxAvgCPULoad_name, |
| pl_subscriptionMode := realtime, |
| pl_idx := v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.rstMinMaxAvg, |
| pl_localName := vl_prefix & c_HostAdminServer_dataElementResetMinMaxAvgCPULoad); |
| f_EPTF_Var_newCharstringlist( |
| vl_prefix & c_HostAdminServer_iteratorCpus_varName, |
| {}, |
| v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.cpuList); |
| v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.perCpuVarKeys := {}; |
| f_EPTF_Var_newCharstringlist( |
| vl_prefix & c_HostAdminServer_iteratorProcessesOnHost_varName, |
| {}, |
| v_EPTF_HostAdmin_hostDB.hosts[vl_idx].iteratorVarProcesses); |
| } |
| return vl_idx; |
| } |
| |
| friend function f_EPTF_HostAdminServer_getHostVarNamePrefix( |
| in charstring pl_hostName) |
| return charstring |
| { |
| return c_HostAdminServer_DS_iteratorVar_prefix & pl_hostName & "_"; |
| } |
| |
| friend function f_EPTF_HostAdminServer_getCpuVarNamePrefix( |
| in charstring pl_hostName, |
| in charstring pl_cpuIdxStr) |
| return charstring |
| { |
| return c_HostAdminServer_DS_iteratorVar_prefix & pl_hostName & "_cpu" & pl_cpuIdxStr & "_"; |
| } |
| |
| friend function f_EPTF_HostAdminServer_getHostProcessVarNamePrefix( |
| in charstring pl_hostName, |
| in charstring pl_procIdxStr) |
| return charstring |
| { |
| return c_HostAdminServer_DS_iteratorVar_prefix & pl_hostName & "_process" & pl_procIdxStr & "_"; |
| } |
| |
| public function f_EPTF_HostAdminServer_getProcessVarNamePrefix( |
| in charstring pl_procSelfName) |
| return charstring |
| { |
| return c_HostAdminServer_DS_iteratorVar_prefix & "_" & pl_procSelfName & "_"; |
| } |
| |
| private function f_EPTF_HostAdminServer_createProcessVarsIfNeeded(in EPTF_Base_ComponentInfoList pl_compInfoList) |
| runs on EPTF_HostAdminServer_CT |
| { |
| var integer i:=0; |
| for(i:=0; i<lengthof(v_EPTF_HostAdmin_hostDB.hosts);i:=i+1) { |
| v_EPTF_HostAdmin_hostDB.hosts[i].tmp := 0; |
| } |
| |
| // count the number of processes on each host into the tmp field of the host's DB item |
| for(i:=0; i<lengthof(pl_compInfoList);i:=i+1) { |
| var integer vl_idx := -1; |
| if(not f_EPTF_str2int_HashMap_Find( |
| v_EPTF_HostAdmin_hostDB.hashRef, |
| pl_compInfoList[i].hostName, |
| vl_idx)) { |
| f_EPTF_Base_assert(%definitionId&": host "&pl_compInfoList[i].hostName&" was not found in database!", false); |
| } |
| v_EPTF_HostAdmin_hostDB.hosts[vl_idx].tmp := v_EPTF_HostAdmin_hostDB.hosts[vl_idx].tmp + 1; |
| } |
| |
| // for each host, if there's more processes than previously, create the required variables |
| for(i:=0; i<lengthof(v_EPTF_HostAdmin_hostDB.hosts);i:=i+1) { |
| var integer vl_idx := -1; |
| var boolean vl_refreshProcesses := false; |
| for(vl_idx := lengthof(v_EPTF_HostAdmin_hostDB.hosts[i].processStats); |
| vl_idx < v_EPTF_HostAdmin_hostDB.hosts[i].tmp; |
| vl_idx := vl_idx + 1) { |
| |
| v_EPTF_HostAdmin_hostDB.hosts[i].processStats[vl_idx] := c_EPTF_HostAdmin_HostProcessStatVars_init; |
| var charstring vl_prefix := f_EPTF_HostAdminServer_getHostProcessVarNamePrefix(v_EPTF_HostAdmin_hostDB.hosts[i].hostName, int2str(vl_idx)); |
| |
| f_EPTF_Var_newCharstring( |
| vl_prefix & c_HostAdminServer_dataElementSelfName, |
| "", |
| v_EPTF_HostAdmin_hostDB.hosts[i].processStats[vl_idx].selfName); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_hostDB.hosts[i].processStats[vl_idx].selfName,false); |
| f_EPTF_Var_newInt( |
| vl_prefix & c_HostAdminServer_dataElementPID, |
| 0, |
| v_EPTF_HostAdmin_hostDB.hosts[i].processStats[vl_idx].pid); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_hostDB.hosts[i].processStats[vl_idx].pid,false); |
| f_EPTF_Var_newFloat( |
| vl_prefix & c_HostAdminServer_dataElementCpuLoad, |
| 0.0, |
| v_EPTF_HostAdmin_hostDB.hosts[i].processStats[vl_idx].cpuLoad); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_hostDB.hosts[i].processStats[vl_idx].cpuLoad,false); |
| f_EPTF_Var_newInt( |
| vl_prefix & c_HostAdminServer_dataElementMemUsage, |
| 0, |
| v_EPTF_HostAdmin_hostDB.hosts[i].processStats[vl_idx].memUsage); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_hostDB.hosts[i].processStats[vl_idx].memUsage,false); |
| f_EPTF_Var_newCharstring( |
| vl_prefix & c_HostAdminServer_dataElementMemUsageHRF, |
| "0", |
| v_EPTF_HostAdmin_hostDB.hosts[i].processStats[vl_idx].memUsageHRF); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_hostDB.hosts[i].processStats[vl_idx].memUsageHRF,false); |
| vl_refreshProcesses := true; |
| } |
| if(vl_refreshProcesses) { |
| var EPTF_CharstringList vl_csList := {}; |
| for(var integer n:=0;n<lengthof(v_EPTF_HostAdmin_hostDB.hosts[i].processStats);n:=n+1) { vl_csList[n] := int2str(n); } |
| f_EPTF_HostAdminServer_debug(%definitionId&": adjusting "&f_EPTF_Var_getName(v_EPTF_HostAdmin_hostDB.hosts[i].iteratorVarProcesses)&" to "&log2str(vl_csList)); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[i].iteratorVarProcesses, {charstringlistVal := vl_csList}); |
| } |
| } |
| } |
| |
| private function f_EPTF_HostAdminServer_refreshProcessStats( |
| in integer pl_hostDBIdx, |
| in EPTF_HostAdmin_PDUHostStat pl_stat) |
| runs on EPTF_HostAdminServer_CT |
| { |
| for(var integer i:=0; i<lengthof(pl_stat.processes) and i<lengthof(v_EPTF_HostAdmin_hostDB.hosts[pl_hostDBIdx].processStats); i:=i+1) { |
| var integer vl_order := i; |
| if(lengthof(pl_stat.processOrder) > i) { vl_order := pl_stat.processOrder[i]; } |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[pl_hostDBIdx].processStats[i].selfName, {charstringVal := pl_stat.processes[vl_order].selfName}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[pl_hostDBIdx].processStats[i].pid, {intVal := pl_stat.processes[vl_order].pid}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[pl_hostDBIdx].processStats[i].cpuLoad, {floatVal := pl_stat.processes[vl_order].cpuLoad}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[pl_hostDBIdx].processStats[i].memUsage, {intVal := pl_stat.processes[vl_order].memUsage}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[pl_hostDBIdx].processStats[i].memUsageHRF, {charstringVal := f_EPTF_HostAdminServer_kbToHRF(pl_stat.processes[vl_order].memUsage)}); |
| |
| var integer vl_idx := -1; |
| if(not f_EPTF_str2int_HashMap_Find(v_EPTF_HostAdmin_processDB.hashRef, pl_stat.processes[vl_order].selfName, vl_idx)) { |
| // new process, create variables |
| vl_idx := lengthof(v_EPTF_HostAdmin_processDB.processStatVars); |
| f_EPTF_str2int_HashMap_Insert(v_EPTF_HostAdmin_processDB.hashRef, pl_stat.processes[vl_order].selfName, vl_idx); |
| v_EPTF_HostAdmin_processDB.processStatVars[vl_idx] := c_EPTF_HostAdmin_ProcessStatVars_init; |
| var charstring vl_prefix := f_EPTF_HostAdminServer_getProcessVarNamePrefix(pl_stat.processes[vl_order].selfName); |
| f_EPTF_Var_newCharstring( |
| vl_prefix & c_HostAdminServer_dataElementHostName, |
| "", |
| v_EPTF_HostAdmin_processDB.processStatVars[vl_idx].hostName); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_processDB.processStatVars[vl_idx].hostName,false); |
| f_EPTF_Var_newInt( |
| vl_prefix & c_HostAdminServer_dataElementPID, |
| 0, |
| v_EPTF_HostAdmin_processDB.processStatVars[vl_idx].pid); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_processDB.processStatVars[vl_idx].pid,false); |
| f_EPTF_Var_newFloat( |
| vl_prefix & c_HostAdminServer_dataElementCpuLoad, |
| 0.0, |
| v_EPTF_HostAdmin_processDB.processStatVars[vl_idx].cpuLoad); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_processDB.processStatVars[vl_idx].cpuLoad,false); |
| f_EPTF_Var_newInt( |
| vl_prefix & c_HostAdminServer_dataElementMemUsage, |
| 0, |
| v_EPTF_HostAdmin_processDB.processStatVars[vl_idx].memUsage); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_processDB.processStatVars[vl_idx].memUsage,false); |
| f_EPTF_Var_newCharstring( |
| vl_prefix & c_HostAdminServer_dataElementMemUsageHRF, |
| "0", |
| v_EPTF_HostAdmin_processDB.processStatVars[vl_idx].memUsageHRF); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_processDB.processStatVars[vl_idx].memUsageHRF,false); |
| |
| var EPTF_CharstringList vl_csList := f_EPTF_Var_getCharstringlistValue(v_EPTF_HostAdmin_iteratorVarProcessNames); |
| vl_csList[lengthof(vl_csList)] := pl_stat.processes[vl_order].selfName; |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_iteratorVarProcessNames, {charstringlistVal := vl_csList}); |
| } |
| |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_processDB.processStatVars[vl_idx].hostName, {charstringVal := pl_stat.hostName}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_processDB.processStatVars[vl_idx].pid, {intVal := pl_stat.processes[vl_order].pid}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_processDB.processStatVars[vl_idx].cpuLoad, {floatVal := pl_stat.processes[vl_order].cpuLoad}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_processDB.processStatVars[vl_idx].memUsage, {intVal := pl_stat.processes[vl_order].memUsage}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_processDB.processStatVars[vl_idx].memUsageHRF, {charstringVal := f_EPTF_HostAdminServer_kbToHRF(pl_stat.processes[vl_order].memUsage)}); |
| } |
| } |
| |
| modulepar float tsp_EPTF_HostAdminServer_HRF_kilo := 1024.0; |
| modulepar EPTF_CharstringList tsp_EPTF_HostAdminServer_HRF_suffixList := { " kB", " MB", " GB", " TB" } |
| modulepar integer tsp_EPTF_HostAdminServer_HRF_digits := 1; |
| |
| // convert kilobytes to human readable format |
| private function f_EPTF_HostAdminServer_kbToHRF(in integer pl_kb) |
| return charstring |
| { |
| var integer vl_exp := 0; |
| var float vl_num := int2float(pl_kb); |
| while(vl_num > tsp_EPTF_HostAdminServer_HRF_kilo and vl_exp < lengthof(tsp_EPTF_HostAdminServer_HRF_suffixList)-1) { |
| vl_num := vl_num / tsp_EPTF_HostAdminServer_HRF_kilo; |
| vl_exp := vl_exp + 1; |
| } |
| var integer vl_int := float2int(vl_num); |
| var float vl_fractional := vl_num - int2float(vl_int); |
| for(var integer i:=0; i<tsp_EPTF_HostAdminServer_HRF_digits; i:=i+1) { vl_fractional := vl_fractional*10.0; } |
| if(vl_fractional >= 1.0) { |
| return int2str(vl_int)&"."&int2str(float2int(vl_fractional))&tsp_EPTF_HostAdminServer_HRF_suffixList[vl_exp]; |
| } else { |
| return int2str(vl_int)&tsp_EPTF_HostAdminServer_HRF_suffixList[vl_exp]; |
| } |
| } |
| |
| private altstep as_EPTF_HostAdminServer_eventHandler() |
| runs on EPTF_HostAdminServer_CT |
| { |
| var EPTF_HostAdmin_PDU vl_pdu; |
| var EPTF_HostAdmin_CT vl_sender; |
| [] T_EPTF_HostAdminServer_refreshProcessList.timeout { |
| var EPTF_Base_ComponentInfoList vl_compInfoList := f_EPTF_Base_getComponentInfoAll(); |
| if(v_EPTF_HostAdminServer_compInfoList != vl_compInfoList) { |
| var integer vl_nofClients := lengthof(v_EPTF_HostAdmin_hostDB.hosts); |
| for(var integer i:=0; |
| i < lengthof(vl_compInfoList); |
| i := i + 1) { |
| var integer vl_idx := f_EPTF_HostAdminServer_getOrStartClient(vl_compInfoList[i].hostName); |
| } |
| f_EPTF_HostAdminServer_createProcessVarsIfNeeded(vl_compInfoList); |
| if(vl_nofClients != lengthof(v_EPTF_HostAdmin_hostDB.hosts)) { |
| // one of more HostAdmins started, get new component info list from Base |
| vl_compInfoList := f_EPTF_Base_getComponentInfoAll(); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_varNofHosts, {intVal := lengthof(v_EPTF_HostAdmin_hostDB.hosts)}); |
| } |
| v_EPTF_HostAdminServer_compInfoList := vl_compInfoList; |
| f_EPTF_HostAdminServer_debug("updated compInfoList: "&log2str(v_EPTF_HostAdminServer_compInfoList)); |
| } |
| T_EPTF_HostAdminServer_refreshProcessList.start; |
| repeat; |
| } |
| [] Sync_PCO.receive(EPTF_HostAdmin_PDU:?) -> value vl_pdu sender vl_sender { |
| if(ischosen(vl_pdu.hostStat)) { |
| //f_EPTF_HostAdminServer_debug("Received host stat: "&log2str(vl_pdu.hostStat)); |
| var integer vl_idx := -1, i; |
| if(not f_EPTF_str2int_HashMap_Find( |
| v_EPTF_HostAdmin_hostDB.hashRef, |
| vl_pdu.hostStat.hostName, |
| vl_idx)) { |
| f_EPTF_Base_assert(%definitionId&": host "&vl_pdu.hostStat.hostName&" was not found in database!", false); |
| } |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.ipv4Addr, {charstringVal := vl_pdu.hostStat.ipv4Addr}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.ipv6Addr, {charstringVal := vl_pdu.hostStat.ipv6Addr}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.physicalMem, {intVal := vl_pdu.hostStat.physicalMem}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.physicalMemHRF, {charstringVal := f_EPTF_HostAdminServer_kbToHRF(vl_pdu.hostStat.physicalMem)}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.freeMem, {intVal := vl_pdu.hostStat.freeMem}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.freeMemHRF, {charstringVal := f_EPTF_HostAdminServer_kbToHRF(vl_pdu.hostStat.freeMem)}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.cpuLoad, {floatVal := vl_pdu.hostStat.cpuLoad}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.cpuMin, {floatVal := vl_pdu.hostStat.cpuMin}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.cpuMax, {floatVal := vl_pdu.hostStat.cpuMax}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.cpuAvg, {floatVal := vl_pdu.hostStat.cpuAvg}); |
| //f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.cpuList, {floatlistVal := vl_pdu.hostStat.perCpuLoad}); |
| |
| for(i:=0; |
| i<lengthof(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.perCpuVarKeys); |
| i:=i+1) { |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.perCpuVarKeys[i], {floatVal := vl_pdu.hostStat.perCpuLoad[i]}); |
| } |
| |
| for(i:=lengthof(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.perCpuVarKeys); |
| i<lengthof(vl_pdu.hostStat.perCpuLoad); |
| i:=i+1) { |
| var charstring vl_prefix := f_EPTF_HostAdminServer_getCpuVarNamePrefix(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostName, int2str(i)); |
| f_EPTF_Var_newFloat( |
| vl_prefix & c_HostAdminServer_dataElementPerCpuLoad, |
| vl_pdu.hostStat.perCpuLoad[i], |
| v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.perCpuVarKeys[i]); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.perCpuVarKeys[i],false); |
| } |
| |
| var EPTF_CharstringList vl_csList := f_EPTF_Var_getCharstringlistValue(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.cpuList) |
| if(lengthof(vl_csList) != lengthof(vl_pdu.hostStat.perCpuLoad)) { |
| vl_csList := {}; |
| for(i:=0; i<lengthof(vl_pdu.hostStat.perCpuLoad); i:=i+1) { |
| vl_csList[i] := int2str(i); |
| } |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].hostStats.cpuList, {charstringlistVal := vl_csList}); |
| } |
| |
| /* for(i:=0; i<lengthof(vl_pdu.hostStat.processes) and i<lengthof(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].processStats); i:=i+1) { |
| var integer vl_order := i; |
| if(lengthof(vl_pdu.hostStat.processOrder) > i) { vl_order := vl_pdu.hostStat.processOrder[i]; } |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].processStats[i].selfName, {charstringVal := vl_pdu.hostStat.processes[vl_order].selfName}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].processStats[i].pid, {intVal := vl_pdu.hostStat.processes[vl_order].pid}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].processStats[i].cpuLoad, {floatVal := vl_pdu.hostStat.processes[vl_order].cpuLoad}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].processStats[i].memUsage, {intVal := vl_pdu.hostStat.processes[vl_order].memUsage}); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_hostDB.hosts[vl_idx].processStats[i].memUsageHRF, {charstringVal := f_EPTF_HostAdminServer_kbToHRF(vl_pdu.hostStat.processes[vl_order].memUsage)}); |
| }*/ |
| f_EPTF_HostAdminServer_refreshProcessStats(vl_idx, vl_pdu.hostStat); |
| |
| } else if(ischosen(vl_pdu.bye)) { |
| for(var integer i := 0; |
| i < lengthof(v_EPTF_HostAdmin_hostDB.hosts); |
| i := i + 1) { |
| if(v_EPTF_HostAdmin_hostDB.hosts[i].compRef == vl_sender) { |
| f_EPTF_HostAdminServer_debug("Received bye from HostAdmin "&v_EPTF_HostAdmin_hostDB.hosts[i].hostName); |
| v_EPTF_HostAdmin_hostDB.hosts[i].isActive := false; |
| break; |
| } |
| } |
| } else if(ischosen(vl_pdu.sortBy)) { |
| f_EPTF_HostAdminServer_warning(%definitionId&": invalid direction for PDUSortBy"); |
| } else { |
| f_EPTF_HostAdminServer_warning(%definitionId&": unhandled message: "&log2str(vl_pdu)); |
| } |
| repeat; |
| } |
| } |
| |
| group HostAdminServer_DataSource { |
| |
| private function f_EPTF_HostAdminServer_PDUSortBy_2int(in EPTF_HostAdmin_PDUSortBy pl_e) |
| return integer |
| { return enum2int(pl_e); } |
| |
| private function f_EPTF_HostAdminServer_DSInit() |
| runs on EPTF_HostAdminServer_CT |
| { |
| var integer vl_idx := 0; |
| var EPTF_CharstringList vl_sortOpt := {}; |
| for(var integer i:=0; i<f_EPTF_HostAdminServer_PDUSortBy_2int(max_SortBy); i:=i+1) { |
| vl_sortOpt[i] := c_EPTF_HostAdmin_PDUSortByStr[i]; |
| } |
| f_EPTF_Var_newCharstringlist( |
| c_HostAdminServer_DS_iteratorVar_prefix & c_HostAdminServer_iteratorProcessSortOptionList_varName, |
| vl_sortOpt, |
| v_EPTF_HostAdmin_iteratorVarProcessSortOptionList); |
| f_EPTF_Var_newCharstringlist( |
| c_HostAdminServer_DS_iteratorVar_prefix & c_HostAdminServer_iteratorHosts_varName, |
| {}, |
| v_EPTF_HostAdmin_iteratorVarHosts); |
| f_EPTF_Var_newCharstringlist( |
| c_HostAdminServer_DS_iteratorVar_prefix & c_HostAdminServer_iteratorProcessNames, |
| {}, |
| v_EPTF_HostAdmin_iteratorVarProcessNames); |
| f_EPTF_Var_newCharstring( |
| c_HostAdminServer_DS_iteratorVar_prefix & c_HostAdminServer_dataElementProcessSortOption, |
| c_EPTF_HostAdmin_PDUSortByStr[enum2int(tsp_EPTF_HostAdmin_sortBy)], |
| v_EPTF_HostAdmin_varProcessSortOption); |
| f_EPTF_Var_addPostProcFn( |
| v_EPTF_HostAdmin_varProcessSortOption, |
| { funcRef := refers(f_EPTF_HostAdminServer_postProcSortOpt), argList := {} }); |
| f_EPTF_Var_newInt( |
| c_HostAdminServer_DS_iteratorVar_prefix & c_HostAdminServer_dataElementNofHosts, |
| 1, |
| v_EPTF_HostAdmin_varNofHosts); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_HostAdmin_varNofHosts,false); |
| } |
| |
| private function f_EPTF_HostAdminServer_postProcSortOpt(in integer pl_idx, in EPTF_IntegerList pl_argList) |
| runs on EPTF_HostAdminServer_CT |
| { |
| var charstring vl_opt := f_EPTF_Var_getCharstringValue(pl_idx); |
| for(var integer i:=0; i<f_EPTF_HostAdminServer_PDUSortBy_2int(max_SortBy); i:=i+1) { |
| if(vl_opt == c_EPTF_HostAdmin_PDUSortByStr[i]) { |
| f_EPTF_HostAdminServer_setSortBy(c_EPTF_HostAdmin_PDUSortByList[i]); |
| return; |
| } |
| } |
| f_EPTF_HostAdminServer_warning(%definitionId&": invalid sort option "&vl_opt); |
| } |
| |
| private function f_EPTF_HostAdminServer_conditionHandler_isMultipleHosts( |
| out boolean pl_conditionValue, |
| in charstring pl_source, |
| in charstring pl_ptcName, |
| in charstring pl_method, |
| in EPTF_DataSource_Params pl_params) |
| runs on EPTF_HostAdminServer_CT |
| return integer |
| { |
| pl_conditionValue := lengthof(v_EPTF_HostAdmin_hostDB.hosts) > 1; |
| return 0; |
| } |
| |
| private function f_EPTF_HostAdminServer_DSHasDataParam( |
| in EPTF_DataSource_Params pl_params, |
| in charstring pl_name) |
| return boolean |
| { |
| for(var integer i:=0; i<lengthof(pl_params); i:=i+1) { |
| if(pl_params[i].paramName == pl_name) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private function f_EPTF_HostAdminServer_DSGetDataParamsForDataElement( |
| in charstring pl_element, |
| in EPTF_DataSource_Params pl_params, |
| in EPTF_CharstringList pl_names, |
| out EPTF_CharstringList pl_values) |
| runs on EPTF_HostAdminServer_CT |
| return boolean |
| { |
| var boolean vl_retVal := true; |
| var EPTF_BooleanList vl_foundList := {}; |
| for(var integer j:=0; j<lengthof(pl_names); j:=j+1) { |
| vl_foundList[j] := false; |
| pl_values[j] := ""; |
| } |
| for(var integer i:=0; i<lengthof(pl_params); i:=i+1) { |
| var boolean vl_found := false; |
| for(var integer j:=0; j<lengthof(pl_names); j:=j+1) { |
| if(pl_params[i].paramName == pl_names[j]) { |
| if(vl_foundList[j]) { |
| f_EPTF_HostAdminServer_warning(%definitionId&": parameter "&pl_names[j]&" was found more than once for data element "&pl_element); |
| f_EPTF_HostAdminServer_warning(%definitionId&": old value: "&pl_values[j]&", new value: "&pl_params[i].paramValue); |
| //vl_retVal := false; |
| } |
| pl_values[j] := pl_params[i].paramValue; |
| vl_foundList[j] := true; |
| vl_found := true; |
| break; |
| } |
| } |
| if(not vl_found) { |
| f_EPTF_HostAdminServer_warning(%definitionId&": invalid parameter "&pl_params[i].paramName&" for data element "&pl_element); |
| //vl_retVal := false; |
| } |
| } |
| for(var integer j:=0; j<lengthof(pl_names); j:=j+1) { |
| if(not vl_foundList[j]) { |
| f_EPTF_Logging_error(true, %definitionId&": parameter "&pl_names[j]&" for data element "&pl_element&" was not found"); |
| vl_retVal := false; |
| } |
| } |
| return vl_retVal; |
| } |
| |
| private function f_EPTF_HostAdminServer_DSGetHostDataVarName( |
| in charstring pl_element, |
| in EPTF_DataSource_Params pl_params) |
| runs on EPTF_HostAdminServer_CT |
| return charstring |
| { |
| var EPTF_CharstringList vl_par := {}; |
| if(not f_EPTF_HostAdminServer_DSGetDataParamsForDataElement( |
| pl_element, |
| pl_params, |
| { c_HostAdminServer_paramNameHostName }, |
| vl_par)) { |
| return ""; |
| } |
| |
| var charstring vl_prefix := f_EPTF_HostAdminServer_getHostVarNamePrefix(vl_par[0]); |
| return vl_prefix & pl_element; |
| } |
| |
| private function f_EPTF_HostAdminServer_DSGetProcessDataVarName( |
| in charstring pl_element, |
| in EPTF_DataSource_Params pl_params) |
| runs on EPTF_HostAdminServer_CT |
| return charstring |
| { |
| var EPTF_CharstringList vl_par := {}; |
| if(f_EPTF_HostAdminServer_DSHasDataParam(pl_params, c_HostAdminServer_paramNameSelfName)) { |
| if(not f_EPTF_HostAdminServer_DSGetDataParamsForDataElement( |
| pl_element, |
| pl_params, |
| { c_HostAdminServer_paramNameSelfName }, |
| vl_par)) { |
| return ""; |
| } |
| var charstring vl_prefix := f_EPTF_HostAdminServer_getProcessVarNamePrefix(vl_par[0]); |
| return vl_prefix & pl_element; |
| } else { |
| if(not f_EPTF_HostAdminServer_DSGetDataParamsForDataElement( |
| pl_element, |
| pl_params, |
| { c_HostAdminServer_paramNameHostName, c_HostAdminServer_paramNameProcessIdx }, |
| vl_par)) { |
| return ""; |
| } |
| var charstring vl_prefix := f_EPTF_HostAdminServer_getHostProcessVarNamePrefix(vl_par[0], vl_par[1]); |
| return vl_prefix & pl_element; |
| } |
| } |
| |
| private function f_EPTF_HostAdminServer_DSGetCpuDataVarName( |
| in charstring pl_element, |
| in EPTF_DataSource_Params pl_params) |
| runs on EPTF_HostAdminServer_CT |
| return charstring |
| { |
| var EPTF_CharstringList vl_par := {}; |
| if(not f_EPTF_HostAdminServer_DSGetDataParamsForDataElement( |
| pl_element, |
| pl_params, |
| { c_HostAdminServer_paramNameHostName, c_HostAdminServer_paramNameCpuIdx }, |
| vl_par)) { |
| return ""; |
| } |
| |
| var charstring vl_prefix := f_EPTF_HostAdminServer_getCpuVarNamePrefix(vl_par[0], vl_par[1]); |
| return vl_prefix & pl_element; |
| } |
| |
| private function f_EPTF_HostAdminServer_DSProcessData( |
| out charstring pl_dataVarName, |
| in charstring pl_source, |
| in charstring pl_ptcName, |
| in charstring pl_element, |
| in EPTF_DataSource_Params pl_params) |
| runs on EPTF_HostAdminServer_CT |
| return integer |
| { |
| var EPTF_CharstringList vl_result := {} |
| pl_dataVarName := ""; |
| select(pl_element){ |
| case(c_HostAdminServer_iteratorProcessSortOptionList) { |
| if(sizeof(pl_params) > 0){ |
| f_EPTF_HostAdminServer_warning(%definitionId& ": DataSource parameter not needed for iterator "&c_HostAdminServer_iteratorProcessSortOptionList); |
| } |
| pl_dataVarName := c_HostAdminServer_DS_iteratorVar_prefix & c_HostAdminServer_iteratorProcessSortOptionList_varName; |
| } |
| case(c_HostAdminServer_iteratorHosts) { |
| if(sizeof(pl_params) > 0){ |
| f_EPTF_HostAdminServer_warning(%definitionId& ": DataSource parameter not needed for iterator "&c_HostAdminServer_iteratorHosts); |
| } |
| pl_dataVarName := c_HostAdminServer_DS_iteratorVar_prefix & c_HostAdminServer_iteratorHosts_varName; |
| } |
| case(c_HostAdminServer_iteratorProcessNames) { |
| if(sizeof(pl_params) > 0){ |
| f_EPTF_HostAdminServer_warning(%definitionId& ": DataSource parameter not needed for iterator "&c_HostAdminServer_iteratorProcessNames); |
| } |
| pl_dataVarName := c_HostAdminServer_DS_iteratorVar_prefix & c_HostAdminServer_iteratorProcessNames_varName; |
| } |
| case(c_HostAdminServer_iteratorProcessesOnHost) { |
| var EPTF_CharstringList vl_par := {}; |
| if(f_EPTF_HostAdminServer_DSGetDataParamsForDataElement( |
| pl_element, |
| pl_params, |
| { c_HostAdminServer_paramNameHostName }, |
| vl_par)) { |
| pl_dataVarName := c_HostAdminServer_DS_iteratorVar_prefix & vl_par[0] & "_" & c_HostAdminServer_iteratorProcessesOnHost_varName; |
| } |
| } |
| case(c_HostAdminServer_dataElementProcessSortOption, |
| c_HostAdminServer_dataElementNofHosts) { |
| pl_dataVarName := c_HostAdminServer_DS_iteratorVar_prefix & pl_element; |
| } |
| case(c_HostAdminServer_dataElementIPv4Addr, |
| c_HostAdminServer_dataElementIPv6Addr, |
| c_HostAdminServer_dataElementCpuMin, |
| c_HostAdminServer_dataElementCpuMax, |
| c_HostAdminServer_dataElementCpuAvg, |
| c_HostAdminServer_dataElementPhysicalMem, |
| c_HostAdminServer_dataElementPhysicalMemHRF, |
| c_HostAdminServer_dataElementFreeMem, |
| c_HostAdminServer_dataElementFreeMemHRF, |
| c_HostAdminServer_iteratorCpus) { |
| pl_dataVarName := f_EPTF_HostAdminServer_DSGetHostDataVarName(pl_element, pl_params); |
| } |
| case(c_HostAdminServer_dataElementCpuLoad) { |
| if( f_EPTF_HostAdminServer_DSHasDataParam(pl_params, c_HostAdminServer_paramNameSelfName) or |
| f_EPTF_HostAdminServer_DSHasDataParam(pl_params, c_HostAdminServer_paramNameProcessIdx)) { |
| pl_dataVarName := f_EPTF_HostAdminServer_DSGetProcessDataVarName(pl_element, pl_params); |
| } else { |
| pl_dataVarName := f_EPTF_HostAdminServer_DSGetHostDataVarName(pl_element, pl_params); |
| } |
| } |
| case(c_HostAdminServer_dataElementResetMinMaxAvgCPULoad) { |
| if( f_EPTF_HostAdminServer_DSHasDataParam(pl_params, c_HostAdminServer_paramNameHostName)) { |
| pl_dataVarName := f_EPTF_HostAdminServer_DSGetHostDataVarName(pl_element, pl_params); |
| } else { |
| pl_dataVarName := c_HostAdminServer_DS_iteratorVar_prefix & pl_element; |
| } |
| } |
| case(c_HostAdminServer_dataElementPerCpuLoad) { |
| pl_dataVarName := f_EPTF_HostAdminServer_DSGetCpuDataVarName(pl_element, pl_params); |
| } |
| case(c_HostAdminServer_dataElementSelfName, |
| c_HostAdminServer_dataElementHostName, |
| c_HostAdminServer_dataElementPID, |
| c_HostAdminServer_dataElementMemUsage, |
| c_HostAdminServer_dataElementMemUsageHRF) { |
| pl_dataVarName := f_EPTF_HostAdminServer_DSGetProcessDataVarName(pl_element, pl_params); |
| } |
| case else { |
| f_EPTF_HostAdminServer_warning(%definitionId&": undefined datasource element \""&pl_element&"\""); |
| } |
| } |
| |
| if(pl_dataVarName == "") { return -1; } |
| |
| var integer vl_iteratorVarIdx := f_EPTF_Var_getId(pl_dataVarName); |
| if(vl_iteratorVarIdx == -1){ |
| f_EPTF_HostAdminServer_warning(%definitionId&": Invalid DataSource parameter: Invalid iterator or externalData or parameter: "& |
| "\nSource: "&pl_source& |
| "\nPTC : "&pl_ptcName & |
| "\nElement Name : " &pl_element& |
| "\nParams: " & log2str(pl_params)& |
| "\nData Var name: "& pl_dataVarName); |
| return -2; |
| } |
| return 0; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HostAdminServer_DSProcessDataValue |
| // |
| // Purpose: |
| // Processes the incoming DataValue requests - iterators and external data elements - and gives back the value. |
| // It should be registered in the HostAdmin_init_CT. Type function fcb_EPTF_DataSourceClient_dataValueHandler |
| // |
| // Parameters: |
| // *out *<EPTF_Var_DirectContent>* pl_dataValue* - the value of the data or the iterator result |
| // *in charstring pl_source* - the name of the data source 'feature' |
| // *in charstring pl_ptcName* - the name of the ptc (ID of the PTC) |
| // *in charstring pl_element* - the name of the data element |
| // *in* <EPTF_DataSource_Params> *pl_params* - the parameters |
| // of the data for the dataElement |
| // |
| // Return Value: |
| // integer - error code (0 of OK, non zero if unsuccessful: e.g. invalid parameters given in pl_params) |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_HostAdminServer_DSProcessDataValue(out EPTF_Var_DirectContent pl_dataValue, |
| in charstring pl_source, |
| in charstring pl_ptcName, |
| in charstring pl_element, |
| in EPTF_DataSource_Params pl_params) |
| runs on EPTF_HostAdminServer_CT return integer{ |
| var integer vl_errorCode := -1; |
| pl_dataValue := {unknownVal := {omit}}; // set it to invalid |
| select( pl_element ) |
| { |
| case(c_EPTF_DataSource_dataElement_Help) { |
| vl_errorCode := f_EPTF_DataSource_handleHelp(pl_dataValue,pl_source,pl_params,c_EPTF_HostAdmin_Server_help); |
| } |
| case else |
| { |
| } |
| } |
| return vl_errorCode; |
| } |
| } // group HostAdminServer_DataSource |
| |
| private function f_EPTF_HostAdminServer_warning(in @lazy charstring pl_message) |
| runs on EPTF_HostAdminServer_CT |
| { |
| f_EPTF_Logging_warningV2(pl_message, v_HostAdminServer_loggingMaskId, {c_EPTF_HostAdminServer_loggingClassIdx_Warning}); |
| } |
| |
| private function f_EPTF_HostAdminServer_debug(in @lazy charstring pl_message) |
| runs on EPTF_HostAdminServer_CT |
| { |
| f_EPTF_Logging_debugV2(pl_message, v_HostAdminServer_loggingMaskId, {c_EPTF_HostAdminServer_loggingClassIdx_Debug}); |
| } |
| |
| } // module |
