src/HostAdmin/EPTF_CLL_HostAdminServer_Definitions.ttcn

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// 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_Definitions
//
//  Purpose:
//   This module contains data type definitions for EPTF HostAdmin Server.
//
//  Module Parameters:
//    tsp_EPTF_HostAdminServer_loggingComponentMask - *charstring* - component-type mask for logging, default value: "EPTF_HostAdminServer"
//    tsp_EPTF_HostAdminServer_processListRefreshInterval - *float* - interval for refreshing EPTF process list from Base, default: 1.0 second
// 
//  Current Owner:
//    Gabor Tatarka (egbotat)
//
//  Module depends on:
//    <EPTF_CLL_Base_Definitions>
//    <EPTF_CLL_Common_Definitions>
//    <EPTF_CLL_DataSource_Definitions>
//    <EPTF_CLL_HostAdmin_Definitions>
//    <EPTF_CLL_Logging_Definitions>
//    <EPTF_CLL_RBT_Definitions>
//    <EPTF_CLL_HashMap_Definitions>
//
//  Last Review Date:
//    -
//
//  Detailed Comments:
//    -
///////////////////////////////////////////////////////////

module EPTF_CLL_HostAdminServer_Definitions {

import from EPTF_CLL_Base_Definitions all;
import from EPTF_CLL_Common_Definitions all;
import from EPTF_CLL_DataSource_Definitions all;
import from EPTF_CLL_HostAdmin_Definitions all;
import from EPTF_CLL_Logging_Definitions all;
import from EPTF_CLL_RBT_Definitions all;
import from EPTF_CLL_HashMap_Definitions all;

modulepar charstring tsp_EPTF_HostAdminServer_loggingComponentMask := "EPTF_HostAdminServer";
modulepar float tsp_EPTF_HostAdminServer_processListRefreshInterval := 1.0;

type record EPTF_HostAdmin_HostStatVars
{
  integer ipv4Addr,
  integer ipv6Addr,
  integer physicalMem,
  integer physicalMemHRF,
  integer freeMem,
  integer freeMemHRF,
  integer cpuLoad,
  integer cpuMin,
  integer cpuMax,
  integer cpuAvg,
  integer rstMinMaxAvg,
  integer cpuList,
  EPTF_IntegerList perCpuVarKeys
}

const EPTF_HostAdmin_HostStatVars c_EPTF_HostAdmin_HostStatVars_init := {
  ipv4Addr := -1,
  ipv6Addr := -1,
  physicalMem := -1,
  physicalMemHRF := -1,
  freeMem := -1,
  freeMemHRF := -1,
  cpuLoad := -1,
  cpuMin := -1,
  cpuMax := -1,
  cpuAvg := 1,
  rstMinMaxAvg := -1,
  cpuList := -1,
  perCpuVarKeys := {}
}

// per host process statistics
type record EPTF_HostAdmin_HostProcessStatVars
{
  integer selfName, // charstring
  integer pid, // integer
  integer cpuLoad, // float [%]
  integer memUsage, // integer [kB]
  integer memUsageHRF // charstring
}

const EPTF_HostAdmin_HostProcessStatVars c_EPTF_HostAdmin_HostProcessStatVars_init := {
  selfName := -1,
  pid := -1,
  cpuLoad := -1,
  memUsage := -1,
  memUsageHRF := -1
}

type record of EPTF_HostAdmin_HostProcessStatVars EPTF_HostAdmin_HostProcessStatVarsList;

type record EPTF_HostAdmin_Host
{
  charstring        hostName,
  EPTF_HostAdmin_CT compRef,
  boolean           isActive, // true on creation, set to false on receiving Bye, don't send sort option if false
  integer           iteratorVarProcesses,
  EPTF_HostAdmin_HostStatVars hostStats,
  EPTF_HostAdmin_HostProcessStatVarsList processStats,
  integer           tmp// temporal counter used when creating variables
}

type record of EPTF_HostAdmin_Host EPTF_HostAdmin_HostList;

type record EPTF_HostAdmin_HostDB
{
  EPTF_HostAdmin_HostList hosts,
  integer hashRef // host name -> index in hosts
}

const EPTF_HostAdmin_HostDB c_EPTF_HostAdmin_HostDB_init := {
  hosts := {},
  hashRef := -1
}

// global process statistics (i.e. not per host!)
type record EPTF_HostAdmin_ProcessStatVars
{
  integer hostName, // charstring
  integer pid, // integer
  integer cpuLoad, // float [%]
  integer memUsage, // integer [kB]
  integer memUsageHRF // charstring
}

const EPTF_HostAdmin_ProcessStatVars c_EPTF_HostAdmin_ProcessStatVars_init := {
  hostName := -1,
  pid := -1,
  cpuLoad := -1,
  memUsage := -1,
  memUsageHRF := -1
}

type record of EPTF_HostAdmin_ProcessStatVars EPTF_HostAdmin_ProcessStatVarsList;

type record EPTF_HostAdmin_ProcessDB
{
  EPTF_HostAdmin_ProcessStatVarsList processStatVars,
  integer hashRef // process selfName -> index in processStatVars
}

const EPTF_HostAdmin_ProcessDB c_EPTF_HostAdmin_ProcessDB_init := {
  processStatVars := {},
  hashRef := -1
}

/////////////////////////////////////////////////////////////////////////
//  Component: EPTF_HostAdminServer_CT
//
//  Purpose:
//    Component type for EPTF_HostAdminServer
//
//  Detailed Comments:
//    Extends EPTF_Base_CT, EPTF_HostAdminServerBase_CT, EPTF_DataSourceClient_CT, EPTF_RBT_CT
/////////////////////////////////////////////////////////////////////////
type component EPTF_HostAdminServer_CT
  extends EPTF_Base_CT, EPTF_HostAdminServerBase_CT, EPTF_DataSourceClient_CT, EPTF_RBT_CT, EPTF_HashMap_CT
{
  private var boolean v_EPTF_HostAdminServer_initialized := false;
  private var EPTF_Base_ComponentInfoList v_EPTF_HostAdminServer_compInfoList := {};
  private timer T_EPTF_HostAdminServer_refreshProcessList := tsp_EPTF_HostAdminServer_processListRefreshInterval;
  private var default v_EPTF_HostAdminServer_eventHandler := null;
  private var EPTF_HostAdmin_HostDB v_EPTF_HostAdmin_hostDB := c_EPTF_HostAdmin_HostDB_init;
  private var EPTF_HostAdmin_ProcessDB v_EPTF_HostAdmin_processDB := c_EPTF_HostAdmin_ProcessDB_init;

  private port EPTF_HostAdmin_Sync_PT Sync_PCO;

  private var integer v_EPTF_HostAdmin_iteratorVarProcessSortOptionList := -1;
  private var integer v_EPTF_HostAdmin_iteratorVarHosts := -1;
  private var integer v_EPTF_HostAdmin_iteratorVarProcessNames := -1;
  private var integer v_EPTF_HostAdmin_varProcessSortOption := -1;
  private var integer v_EPTF_HostAdmin_varNofHosts := -1;

  private var integer v_HostAdminServer_loggingMaskId := c_EPTF_Logging_invalidMaskId;
}

///////////////////////////////////////////////////////////
//  Constant: c_EPTF_HostAdminServer_loggingEventClasses
// 
//  Purpose:
//    list of logging event class names used on the HostAdminServer
// 
//  Detailed Comments:
//    <EPTF_Logging_EventClassPrefixList> { "Warning", "Debug" }
///////////////////////////////////////////////////////////
const EPTF_Logging_EventClassPrefixList c_EPTF_HostAdminServer_loggingEventClasses := { "Warning", "Debug" };

///////////////////////////////////////////////////////////
//  Constant: c_EPTF_HostAdminServer_loggingClassIdx_Warning
// 
//  Purpose:
//    logging class index for Error
// 
//  Detailed Comments:
//    *0*
///////////////////////////////////////////////////////////
const integer c_EPTF_HostAdminServer_loggingClassIdx_Warning := 0;
///////////////////////////////////////////////////////////
//  Constant: c_EPTF_HostAdminServer_loggingClassIdx_Debug
// 
//  Purpose:
//    logging class index for Error
// 
//  Detailed Comments:
//    *1*
///////////////////////////////////////////////////////////
const integer c_EPTF_HostAdminServer_loggingClassIdx_Debug := 1;

///////////////////////////////////////////////////////////////////////////////
// Constant: c_EPTF_HostAdminServer_host2AdminHashMapName
//
// Purpose:
//   hashmap name for host admin database
///////////////////////////////////////////////////////////////////////////////
const charstring c_EPTF_HostAdminServer_host2AdminHashMapName := "HostAdminServer_host2AdminHashMap";

///////////////////////////////////////////////////////////////////////////////
// Constant: c_EPTF_HostAdminServer_selfName2ProcessHashMapName
//
// Purpose:
//   hashmap name for host admin database
///////////////////////////////////////////////////////////////////////////////
const charstring c_EPTF_HostAdminServer_selfName2ProcessHashMapName := "HostAdminServer_selfName2ProcessHashMapName";

///////////////////////////////////////////////////////////////////////////////
// Constant: c_EPTF_HostAdminServer_varNamePrefix
//
// Purpose:
//   Variable name prefix for the HostAdminServer feature
///////////////////////////////////////////////////////////////////////////////
const charstring c_EPTF_HostAdminServer_varNamePrefix := "HostAdminServer.";

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_DataSource_sourceId
//
// Purpose:
//   HostAdminServer iterators and data elements belong to this dataSource name
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_DataSource_sourceId := "HostAdminServer";

///////////////////////////////////////////////////////////////////////////////
// Constant: c_EPTF_HostAdminServer_dataElement_Help
//
// Purpose:
//   This data element returns the help information about
//   all dataElements supported.
//   ValueType: charstring
//
// Parameters:
//   - <c_EPTF_DataSource_paramNameHelpFormat> - the format of the output
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_EPTF_HostAdminServer_dataElement_help := c_EPTF_DataSource_dataElement_Help

const EPTF_DataSource_Help_DataElement c_EPTF_HostAdminServer_Help_dataElement_help := c_EPTF_DataSource_Help_dataElement_genericHelp;

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_conditionIsMultipleHosts
//
// Purpose:
//   This condition returns true if there are more than one hosts
//
// Parameters:
//   none
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_conditionIsMultipleHosts := "isMultipleHosts"

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_conditionIsMultipleHosts := {
  name := c_HostAdminServer_conditionIsMultipleHosts,
  valueType := boolType,
  description := "This condition returns true if there are more than one hosts"
}

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_DS_iteratorVar_prefix
//
// Purpose:
//   This is the prefix for HostAdminServer iterator variables
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_DS_iteratorVar_prefix := "EPTF_HostAdminServer_DS_iterator_";

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_iteratorProcessSortOptionList
//
// Purpose:
//   This iterator enlists the sort options for process sorting
//
// Parameters:
//   There are no parameters for this iterator
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_iteratorProcessSortOptionList := "ProcessSortOptionList";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_iteratorProcessSortOptionList := {
  name := c_HostAdminServer_iteratorProcessSortOptionList,
  valueType := charstringlistType,
  description := "This iterator enlists the sort options for process sorting that can be used in the data element \""&c_HostAdminServer_dataElementProcessSortOption&"\""
}

const charstring c_HostAdminServer_iteratorProcessSortOptionList_varName := c_HostAdminServer_iteratorProcessSortOptionList;

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_iteratorHosts
//
// Purpose:
//   This iterator enlists the hosts tracked by the HostAdminServer
//
// Parameters:
//   There are no parameters for this iterator
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_iteratorHosts := "Hosts";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_iteratorHosts := {
  name := c_HostAdminServer_iteratorHosts,
  valueType := charstringlistType,
  typeDescriptor := {
    isListOf := true,
    typeName := "HostName"
  },
  description := "This iterator enlists the hosts tracked by the HostAdminServer"
}

const charstring c_HostAdminServer_iteratorHosts_varName := c_HostAdminServer_iteratorHosts;

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_iteratorProcessNames
//
// Purpose:
//   This iterator enlists the process names (globally, regardless of hostname)
//
// Parameters:
//   There are no parameters for this iterator
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_iteratorProcessNames := "ProcessNames";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_iteratorProcessNames := {
  name := c_HostAdminServer_iteratorProcessNames,
  valueType := charstringlistType,
  typeDescriptor := {
    isListOf := true,
    typeName := "ProcessName"
  },
  description := "This iterator enlists the process names (globally, regardless of hostname)"
}

const charstring c_HostAdminServer_iteratorProcessNames_varName := c_HostAdminServer_iteratorProcessNames;

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_iteratorCpus
//
// Purpose:
//   This iterator enlists the CPUs for a host
//
// Parameters:
//   - <c_HostAdminServer_paramNameHostName> - the name of the host
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_iteratorCpus := "CPUs";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_iteratorCpus := {
  name := c_HostAdminServer_iteratorCpus,
  valueType := charstringlistType,
  typeDescriptor := {
    isListOf := true,
    typeName := "CPU"
  },
  description := "This iterator enlists the CPUs for a host",
  parameters := {
    {
      name := c_HostAdminServer_paramNameHostName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorHosts.typeDescriptor.typeName
        }
      },
      description := "the name of the host. Should be one item in the list given by the iterator \""&c_HostAdminServer_iteratorHosts&"\"",
      exampleValue := ""
    }
  } 
}

const charstring c_HostAdminServer_iteratorCpus_varName := c_HostAdminServer_iteratorCpus;

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_iteratorProcessesOnHost
//
// Purpose:
//   This iterator enlists the processes on a given host
//
// Parameters:
//   - <c_HostAdminServer_paramNameHostName> - the name of the host
//
// Detailed Comments:
//  The iterator only returns indices, use the data elements to get the slef name, cpu/mem usage of each process
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_iteratorProcessesOnHost := "ProcessesOnHost";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_iteratorProcessesOnHost := {
  name := c_HostAdminServer_iteratorProcessesOnHost,
  valueType := charstringlistType,
  typeDescriptor := {
    isListOf := true,
    typeName := "ProcessOnHost"
  },
  description := "This iterator enlists the processes on a given host",
  parameters := {
    {
      name := c_HostAdminServer_paramNameHostName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorHosts.typeDescriptor.typeName
        }
      },
      description := "the name of the host. Should be one item in the list given by the iterator \""&c_HostAdminServer_iteratorHosts&"\"",
      exampleValue := ""
    }
  } 
}

const charstring c_HostAdminServer_iteratorProcessesOnHost_varName := c_HostAdminServer_iteratorProcessesOnHost;

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_paramNameHostName
//
// Purpose:
//   Specifies the hostname
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_paramNameHostName := "HostName";

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_paramNameSelfName
//
// Purpose:
//   Specifies the selfName of a process
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_paramNameSelfName := "SelfName";

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_paramNameCpuIdx
//
// Purpose:
//   Specifies the CPU index (as returned by the CPUs iterator)
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_paramNameCpuIdx := "CpuIdx";

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_paramNameProcessIdx
//
// Purpose:
//   Specifies the process index (as returned by the processes iterator
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_paramNameProcessIdx := "ProcessIdx";

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_dataElementProcessSortOption
//
// Purpose:
//   DataElement for process sort option
//   ValueType: charstring
//
// Parameters:
//   none
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_dataElementProcessSortOption := "ProcessSortOption";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementProcessSortOption := {
  name := c_HostAdminServer_dataElementProcessSortOption,
  valueType := charstringType,
  description := "DataElement to set the process sort option. Value should be one of: "&log2str(c_EPTF_HostAdmin_PDUSortByStr)
    &" which is the list returned by the iterator \""&c_HostAdminServer_iteratorProcessSortOptionList&"\""
}

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_dataElementNofHosts
//
// Purpose:
//   This dataElement returns the number of hosts
//   ValueType: integer
//
// Parameters:
//   none
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_dataElementNofHosts := "NofHosts";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementNofHosts := {
  name := c_HostAdminServer_dataElementNofHosts,
  valueType := intType,
  description := "This dataElement returns the number of hosts"
}

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_dataElementSelfName
//
// Purpose:
//   This dataElement returns the SelfName variable for a process
//   ValueType: charstring
//
// Parameters:
//   - <c_HostAdminServer_paramNameHostName>
//   - <c_HostAdminServer_paramNameProcessIdx>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_dataElementSelfName := "SelfName";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementSelfName := {
  name := c_HostAdminServer_dataElementSelfName,
  valueType := charstringType,
  description := "This dataElement returns the SelfName variable for a process",
  parameters := {
    {
      name := c_HostAdminServer_paramNameHostName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorHosts.typeDescriptor.typeName
        }
      },
      description := "the name of the host",
      exampleValue := ""
    },
    {
      name := c_HostAdminServer_paramNameProcessIdx,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorProcessesOnHost.typeDescriptor.typeName
        }
      },
      description := "Specifies the process index (as returned by the processes iterator)",
      exampleValue := "0"
    }
  }   
}

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_dataElementHostName
//
// Purpose:
//   This dataElement returns the host name variable for a process
//   ValueType: charstring
//
// Parameters:
//   - <c_HostAdminServer_paramNameSelfName>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_dataElementHostName := "HostName";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementHostName := {
  name := c_HostAdminServer_dataElementHostName,
  valueType := charstringType,
  description := "This dataElement returns the host name variable for a process",
  parameters := {
    {
      name := c_HostAdminServer_paramNameSelfName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorProcessNames.typeDescriptor.typeName
        }
      },
      description := "Specifies the selfName of a process",
      exampleValue := ""
    }
  }   
}

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_dataElementPID
//
// Purpose:
//   This dataElement returns the PID variable for a process
//   ValueType: integer
//
// Parameters:
//   - <c_HostAdminServer_paramNameHostName>
//   - <c_HostAdminServer_paramNameProcessIdx>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_dataElementPID := "PID";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementPID := {
  name := c_HostAdminServer_dataElementPID,
  valueType := intType,
  description := " This dataElement returns the PID variable for a process",
  parameters := {
    {
      name := c_HostAdminServer_paramNameHostName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorHosts.typeDescriptor.typeName
        }
      },
      description := "the name of the host",
      exampleValue := ""
    },
    {
      name := c_HostAdminServer_paramNameProcessIdx,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorProcessesOnHost.typeDescriptor.typeName
        }
      },
      description := "Specifies the process index (as returned by the processes iterator)",
      exampleValue := "0"
    }
  }   
}

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_dataElementIPv4Addr
//
// Purpose:
//   This dataElement returns the IPv4 Address variable for a host
//   ValueType: charstring
//
// Parameters:
//   - <c_HostAdminServer_paramNameHostName>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_dataElementIPv4Addr := "IPv4Addr";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementIPv4Addr := {
  name := c_HostAdminServer_dataElementIPv4Addr,
  valueType := charstringType,
  description := "This dataElement returns the IPv4 Address variable for a host",
  parameters := {
    {
      name := c_HostAdminServer_paramNameHostName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorHosts.typeDescriptor.typeName
        }
      },
      description := "the name of the host",
      exampleValue := ""
    }
  }   
}

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_dataElementIPv6Addr
//
// Purpose:
//   This dataElement returns the IPv6 Address variable for a host
//   ValueType: charstring
//
// Parameters:
//   - <c_HostAdminServer_paramNameHostName>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_dataElementIPv6Addr := "IPv6Addr";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementIPv6Addr := {
  name := c_HostAdminServer_dataElementIPv6Addr,
  valueType := charstringType,
  description := "This dataElement returns the IPv6 Address variable for a host",
  parameters := {
    {
      name := c_HostAdminServer_paramNameHostName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorHosts.typeDescriptor.typeName
        }
      },
      description := "the name of the host",
      exampleValue := ""
    }
  }   
}

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_dataElementPhysicalMem
//
// Purpose:
//   This dataElement returns the PhysicalMem variable for a host
//   ValueType: integer [kB]
//
// Parameters:
//   - <c_HostAdminServer_paramNameHostName>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_dataElementPhysicalMem := "PhysicalMem";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementPhysicalMem := {
  name := c_HostAdminServer_dataElementPhysicalMem,
  valueType := intType,
  description := "This dataElement returns the PhysicalMem [kB] variable for a host",
  parameters := {
    {
      name := c_HostAdminServer_paramNameHostName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorHosts.typeDescriptor.typeName
        }
      },
      description := "the name of the host",
      exampleValue := ""
    }
  }   
}

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_dataElementPhysicalMemHRF
//
// Purpose:
//   This dataElement returns the PhysicalMem variable for a host in Human Readable Fromat
//   (e.g. "1.5 MB", "3.8 GB")
//   ValueType: charstring
//
// Parameters:
//   - <c_HostAdminServer_paramNameHostName>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_dataElementPhysicalMemHRF := "PhysicalMemHRF";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementPhysicalMemHRF := {
  name := c_HostAdminServer_dataElementPhysicalMemHRF,
  valueType := charstringType,
  description := "This dataElement returns the PhysicalMem variable for a host in Human Readable Fromat (e.g. '1.5 MB', '3.8 GB')",
  parameters := {
    {
      name := c_HostAdminServer_paramNameHostName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorHosts.typeDescriptor.typeName
        }
      },
      description := "the name of the host",
      exampleValue := ""
    }
  }   
}

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_dataElementFreeMem
//
// Purpose:
//   This dataElement returns the FreeMem variable for a host
//   ValueType: integer [kB]
//
// Parameters:
//   - <c_HostAdminServer_paramNameHostName>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_dataElementFreeMem := "FreeMem";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementFreeMem := {
  name := c_HostAdminServer_dataElementFreeMem,
  valueType := intType,
  description := "This dataElement returns the FreeMem [kB] variable for a host",
  parameters := {
    {
      name := c_HostAdminServer_paramNameHostName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorHosts.typeDescriptor.typeName
        }
      },
      description := "the name of the host",
      exampleValue := ""
    }
  }   
}

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_dataElementFreeMemHRF
//
// Purpose:
//   This dataElement returns the FreeMem variable for a host in Human Readable Fromat
//   (e.g. "1.5 MB", "3.8 GB")
//   ValueType: charstring
//
// Parameters:
//   - <c_HostAdminServer_paramNameHostName>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_dataElementFreeMemHRF := "FreeMemHRF";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementFreeMemHRF := {
  name := c_HostAdminServer_dataElementFreeMemHRF,
  valueType := charstringType,
  description := "This dataElement returns the FreeMem variable for a host in Human Readable Fromat (e.g. '1.5 MB', '3.8 GB')",
  parameters := {
    {
      name := c_HostAdminServer_paramNameHostName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorHosts.typeDescriptor.typeName
        }
      },
      description := "the name of the host",
      exampleValue := ""
    }
  }   
}

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_dataElementCpuLoad
//
// Purpose:
//   This dataElement returns the CpuLoad variable for a process or host
//   ValueType: float
//
// Parameters:
//   - <c_HostAdminServer_paramNameHostName> and optionally <c_HostAdminServer_paramNameProcessIdx>
//   - or <c_HostAdminServer_paramNameSelfName>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_dataElementCpuLoad := "CpuLoad";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementCpuLoad_from_HostName := {
  name := c_HostAdminServer_dataElementCpuLoad,
  valueType := floatType,
  description := "This dataElement returns the CpuLoad variable for a process or host",
  parameters := {
    {
      name := c_HostAdminServer_paramNameHostName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorHosts.typeDescriptor.typeName
        }
      },
      description := "the name of the host",
      exampleValue := ""
    }
  }   
}

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementCpuLoad_from_HostName_and_ProcessId := {
  name := c_HostAdminServer_dataElementCpuLoad,
  valueType := floatType,
  description := "This dataElement returns the CpuLoad variable for a process or host",
  parameters := {
    {
      name := c_HostAdminServer_paramNameHostName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorHosts.typeDescriptor.typeName
        }
      },
      description := "the name of the host",
      exampleValue := ""
    },
    {
      name := c_HostAdminServer_paramNameProcessIdx,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorProcessesOnHost.typeDescriptor.typeName
        }
      },
      description := "Specifies the process index (as returned by the processes iterator",
      exampleValue := ""
    }
  }   
}

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementCpuLoad_from_SelfName := {
  name := c_HostAdminServer_dataElementCpuLoad,
  valueType := floatType,
  description := "This dataElement returns the CpuLoad variable for a process or host",
  parameters := {
    {
      name := c_HostAdminServer_paramNameSelfName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorProcessNames.typeDescriptor.typeName
        }
      },
      description := "Specifies the selfName of a process",
      exampleValue := ""
    }
  }   
}

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_dataElementCpuMin
//
// Purpose:
//   This dataElement returns the CpuMin variable for a host
//   ValueType: float
//
// Parameters:
//   - <c_HostAdminServer_paramNameHostName>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_dataElementCpuMin := "CpuMin";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementCpuMin := {
  name := c_HostAdminServer_dataElementCpuMin,
  valueType := floatType,
  description := "This dataElement returns the CpuMin variable for a host",
  parameters := {
    {
      name := c_HostAdminServer_paramNameHostName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorHosts.typeDescriptor.typeName
        }
      },
      description := "the name of the host",
      exampleValue := ""
    }
  }   
}

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_dataElementCpuMax
//
// Purpose:
//   This dataElement returns the CpuMax variable for a host
//   ValueType: float
//
// Parameters:
//   - <c_HostAdminServer_paramNameHostName>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_dataElementCpuMax := "CpuMax";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementCpuMax := {
  name := c_HostAdminServer_dataElementCpuMax,
  valueType := floatType,
  description := "This dataElement returns the CpuMax variable for a host",
  parameters := {
    {
      name := c_HostAdminServer_paramNameHostName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorHosts.typeDescriptor.typeName
        }
      },
      description := "the name of the host",
      exampleValue := ""
    }
  }   
}

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_dataElementCpuAvg
//
// Purpose:
//   This dataElement returns the CpuAvg variable for a host
//   ValueType: float
//
// Parameters:
//   - <c_HostAdminServer_paramNameHostName>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_dataElementCpuAvg := "CpuAvg";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementCpuAvg := {
  name := c_HostAdminServer_dataElementCpuAvg,
  valueType := floatType,
  description := "This dataElement returns the CpuAvg variable for a host",
  parameters := {
    {
      name := c_HostAdminServer_paramNameHostName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorHosts.typeDescriptor.typeName
        }
      },
      description := "the name of the host",
      exampleValue := ""
    }
  }   
}

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_dataElementResetMinMaxAvgCPULoad
//
// Purpose:
//   This dataElement returns the ResetMinMaxAvgCPULoad variable for a host
//   ValueType: integer
//
// Parameters:
//   - <c_HostAdminServer_paramNameHostName> (optional, resets all if not specified)
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_dataElementResetMinMaxAvgCPULoad := "ResetMinMaxAvgCPULoad";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementResetMinMaxAvgCPULoad_on_Specific_Host := {
  name := c_HostAdminServer_dataElementResetMinMaxAvgCPULoad,
  valueType := intType,
  description := "This dataElement returns the ResetMinMaxAvgCPULoad variable for a host which can be used to reset the Min/Max/Avg/CPULoad",
  parameters := {
    {
      name := c_HostAdminServer_paramNameHostName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorHosts.typeDescriptor.typeName
        }
      },
      description := "the name of the host",
      exampleValue := ""
    }
  }   
}

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementResetMinMaxAvgCPULoad := {
  name := c_HostAdminServer_dataElementResetMinMaxAvgCPULoad,
  valueType := intType,
  description := "This dataElement returns the ResetMinMaxAvgCPULoad variable for all hosts" 
}

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_dataElementPerCpuLoad
//
// Purpose:
//   This dataElement returns the PerCpuLoad variable for a cpu on a host
//   ValueType: float
//
// Parameters:
//   - <c_HostAdminServer_paramNameHostName>
//   - <c_HostAdminServer_paramNameCpuIdx>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_dataElementPerCpuLoad := "PerCpuLoad";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementPerCpuLoad := {
  name := c_HostAdminServer_dataElementPerCpuLoad,
  valueType := floatType,
  description := "This dataElement returns the PerCpuLoad variable for a cpu on a host",
  parameters := {
    {
      name := c_HostAdminServer_paramNameHostName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorHosts.typeDescriptor.typeName
        }
      },
      description := "the name of the host",
      exampleValue := ""
    },
    {
      name := c_HostAdminServer_paramNameCpuIdx,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorCpus.typeDescriptor.typeName
        }
      },
      description := "Specifies the CPU index (as returned by the CPUs iterator)",
      exampleValue := "0"
    }
  }   
}

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_dataElementMemUsage
//
// Purpose:
//   This dataElement returns the MemUsage variable for a process
//   ValueType: integer [kB]
//
// Parameters:
//   - <c_HostAdminServer_paramNameHostName> and <c_HostAdminServer_paramNameProcessIdx>
//   - or <c_HostAdminServer_paramNameSelfName>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_dataElementMemUsage := "MemUsage";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementMemUsage_from_HostName_and_ProcessId := {
  name := c_HostAdminServer_dataElementMemUsage,
  valueType := intType,
  description := "This dataElement returns the MemUsage variable for a process",
  parameters := {
    {
      name := c_HostAdminServer_paramNameHostName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorHosts.typeDescriptor.typeName
        }
      },
      description := "the name of the host",
      exampleValue := ""
    },
    {
      name := c_HostAdminServer_paramNameProcessIdx,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorProcessesOnHost.typeDescriptor.typeName
        }
      },
      description := "Specifies the process index (as returned by the processes iterator",
      exampleValue := ""
    }
  }   
}

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementMemUsage_from_SelfName := {
  name := c_HostAdminServer_dataElementMemUsage,
  valueType := intType,
  description := "This dataElement returns the MemUsage variable for a process",
  parameters := {
    {
      name := c_HostAdminServer_paramNameSelfName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorProcessNames.typeDescriptor.typeName
        }
      },
      description := "Specifies the selfName of a process",
      exampleValue := ""
    }
  }   
}

///////////////////////////////////////////////////////////////////////////////
// Constant: c_HostAdminServer_dataElementMemUsageHRF
//
// Purpose:
//   This dataElement returns the MemUsage variable for a process in Human Readable Fromat
//   ValueType: charstring
//
// Parameters:
//   - <c_HostAdminServer_paramNameHostName> and <c_HostAdminServer_paramNameProcessIdx>
//   - or <c_HostAdminServer_paramNameSelfName>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_HostAdminServer_dataElementMemUsageHRF := "MemUsageHRF";

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementMemUsageHRF_from_HostName_and_ProcessId := {
  name := c_HostAdminServer_dataElementMemUsageHRF,
  valueType := charstringType,
  description := "his dataElement returns the MemUsage variable for a process in Human Readable Fromat",
  parameters := {
    {
      name := c_HostAdminServer_paramNameHostName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorHosts.typeDescriptor.typeName
        }
      },
      description := "the name of the host",
      exampleValue := ""
    },
    {
      name := c_HostAdminServer_paramNameProcessIdx,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorProcessesOnHost.typeDescriptor.typeName
        }
      },
      description := "Specifies the process index (as returned by the processes iterator",
      exampleValue := ""
    }
  }   
}

const EPTF_DataSource_Help_DataElement c_HostAdminServer_Help_dataElementMemUsageHRF_from_SelfName := {
  name := c_HostAdminServer_dataElementMemUsageHRF,
  valueType := charstringType,
  description := "his dataElement returns the MemUsage variable for a process in Human Readable Fromat",
  parameters := {
    {
      name := c_HostAdminServer_paramNameSelfName,
      typeDescriptor := {
        reference := {
          typeName := c_HostAdminServer_Help_iteratorProcessNames.typeDescriptor.typeName
        }
      },
      description := "Specifies the selfName of a process",
      exampleValue := ""
    }
  }   
}

// the datasource help database for HostAdmin Server
const EPTF_DataSource_Help_DataElementChildren c_EPTF_HostAdmin_Server_help := {
  {
    dataElement := c_EPTF_HostAdminServer_Help_dataElement_help
  },
  {
    dataElement := c_HostAdminServer_Help_conditionIsMultipleHosts
  },
  {
    dataElement := c_HostAdminServer_Help_iteratorProcessSortOptionList
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementProcessSortOption
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementNofHosts
  },
  {
    dataElement := c_HostAdminServer_Help_iteratorHosts
  },
  {       
    dataElement := c_HostAdminServer_Help_iteratorCpus
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementPerCpuLoad
  },
  {
    dataElement := c_HostAdminServer_Help_iteratorProcessesOnHost
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementSelfName
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementCpuLoad_from_SelfName
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementMemUsage_from_SelfName
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementMemUsageHRF_from_SelfName
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementHostName
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementCpuLoad_from_HostName_and_ProcessId
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementMemUsage_from_HostName_and_ProcessId
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementMemUsageHRF_from_HostName_and_ProcessId
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementPID
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementIPv4Addr
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementIPv6Addr
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementPhysicalMem
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementPhysicalMemHRF
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementFreeMem
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementFreeMemHRF
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementCpuLoad_from_HostName
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementCpuMin
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementCpuMax
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementCpuAvg
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementResetMinMaxAvgCPULoad_on_Specific_Host
  },
  {
    dataElement := c_HostAdminServer_Help_iteratorProcessNames
  },
  {
    dataElement := c_HostAdminServer_Help_dataElementResetMinMaxAvgCPULoad
  } 
}

} // module