| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // Copyright (c) 2000-2018 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 |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // File: EPTF_HTTP_Transport_Functions.ttcn |
| // Rev: <RnXnn> |
| // Prodnr: CNL 113 618 |
| // Updated: 2014-03-21 |
| // Contact: http://ttcn.ericsson.se |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Module: EPTF_HTTP_Transport_Functions |
| // |
| // Purpose: |
| // This module contains the HTTP transport layer functions |
| // |
| // Module Parameters: |
| // See <EPTF_HTTP_Transport_Definitions> |
| // |
| // Module depends on: |
| // <EPTF_CLL_TransportRouting_Functions> |
| // |
| // <EPTF_CLL_TransportMessageBufferManager_Functions> |
| // |
| // <EPTF_CLL_Base_Definitions> |
| // |
| // <EPTF_CLL_Base_Functions> |
| // |
| // <EPTF_CLL_Variable_Functions> |
| // |
| // <EPTF_CLL_Logging_Definitions> |
| // |
| // <EPTF_CLL_Logging_Functions> |
| // |
| // <EPTF_CLL_TransportCommPortIPL4_Definitions> |
| // |
| // <EPTF_CLL_TransportCommPortIPL4_Functions> |
| // |
| // <EPTF_CLL_Common_Definitions> |
| // |
| // <EPTF_CLL_LGenBase_Functions> |
| // |
| // <EPTF_CLL_LGenBase_Definitions> |
| // |
| // <EPTF_CLL_HashMapStr2Int_Functions> |
| // |
| // <EPTF_CLL_HashMapInt2Int_Functions> |
| // |
| // <EPTF_CLL_FBQ_Definitions> |
| // |
| // <EPTF_CLL_FBQ_Functions> |
| // |
| // <EPTF_HTTP_Definitions> |
| // |
| // <EPTF_HTTP_Transport_Definitions> |
| // |
| // <IPL4asp_Types> |
| // |
| // <TCCMessageHandling_Functions> |
| // |
| // Current Owner: |
| // EAKOPER |
| // |
| // Last Review Date: |
| // 2009-08-10 |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| module EPTF_HTTP_Transport_Functions { |
| |
| //============================================================================= |
| // Imports |
| //============================================================================= |
| |
| import from EPTF_CLL_TransportRouting_Functions all; |
| import from EPTF_CLL_TransportMessageBufferManager_Functions all; |
| import from EPTF_CLL_Base_Functions all; |
| import from EPTF_CLL_Logging_Definitions all; |
| import from EPTF_CLL_Logging_Functions all; |
| import from EPTF_CLL_TransportCommPortIPL4_Definitions all; |
| import from EPTF_CLL_TransportCommPortIPL4_Functions all; |
| import from EPTF_CLL_HashMapStr2Int_Functions all; |
| import from EPTF_CLL_HashMapInt2Int_Functions all; |
| import from EPTF_CLL_FBQ_Functions all; |
| import from EPTF_CLL_HashMap_Functions all; |
| |
| import from EPTF_HTTP_Definitions all; // events |
| import from EPTF_HTTP_Transport_Definitions all; |
| |
| import from IPL4asp_Types all; |
| |
| import from TCCMessageHandling_Functions all; |
| |
| //============================================================================= |
| // Functions |
| //============================================================================= |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Group: EPTF_HTTP_LocalTransport |
| // |
| // Purpose: |
| // Functions of the EPTF HTTP Local Transport |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| group EPTF_HTTP_LocalTransport |
| { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_init_CT |
| // |
| // Purpose: |
| // Function to init The LocalTransprot component |
| // |
| // Parameters: |
| // - pl_selfName - *in* *charstring* - self name of the component |
| // - pl_receiveFunction - *in* <EPTF_HTTP_messageProcess_FT> - the |
| // receive callback function to handle received messages |
| // - pl_eventReceiveFunction - *in* <EPTF_HTTP_eventReceive_FT> - the |
| // receive event callback function to handle received events |
| // - pl_socketErrorReceiveFunction - *in* <EPTF_HTTP_socketErrorReceive_FT> - the |
| // socket error receive callback function to handle received socket error events and messages |
| // - pl_interfaceInformationList - *in* <EPTF_CommPort_IPL4_InterfaceInformationList> - |
| // the defined interfaces for IPL4 (can be used only with root rights) |
| // |
| // Return Value: |
| // *integer* - if the component is initialized already the return value |
| // will be -1 |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_init_CT( |
| in charstring pl_selfName := "EPTF_HTTP_LocalTransport", |
| in EPTF_HTTP_messageProcess_FT pl_receiveFunction := null, |
| in EPTF_HTTP_eventReceive_FT pl_eventReceiveFunction := null, |
| in EPTF_HTTP_socketErrorReceive_FT pl_socketErrorReceiveFunction := null, |
| in EPTF_CommPort_IPL4_InterfaceInformationList pl_interfaceInformationList := {}, |
| in EPTF_HTTP_listenSocketEvent_FT pl_listenSocketEvent := null, |
| in EPTF_HTTP_listenSocketError_FT pl_listenSocketError := null) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return integer |
| { |
| if (v_EPTF_HTTP_LocalTransport_initialized) |
| { |
| log(%definitionId & // intentionally simple log |
| ": The HTTP LocalTransport component already initialized!"); |
| |
| return -1; |
| } |
| |
| v_EPTF_HTTP_LocalTransport_selfName := pl_selfName |
| |
| f_EPTF_Logging_init_CT(pl_selfName); |
| |
| v_EPTF_HTTP_Transport_loggingMaskId := |
| f_EPTF_Logging_registerComponentMasks( |
| tsp_EPTF_HTTP_Transport_loggingComponentMask, |
| c_EPTF_HTTP_Transport_loggingEventClasses, |
| EPTF_Logging_CLL); |
| |
| if (tsp_EPTF_HTTP_Transport_loggingEnable) |
| { |
| f_EPTF_Logging_enableLocalMask( |
| v_EPTF_HTTP_Transport_loggingMaskId, |
| c_EPTF_HTTP_Transport_loggingClassIdx_Debug); |
| } |
| else |
| { |
| f_EPTF_Logging_disableLocalMask( |
| v_EPTF_HTTP_Transport_loggingMaskId, |
| c_EPTF_HTTP_Transport_loggingClassIdx_Debug); |
| } |
| |
| if (tsp_EPTF_HTTP_Transport_bufferLogEnable) |
| { |
| f_EPTF_Logging_enableLocalMask( |
| v_EPTF_HTTP_Transport_loggingMaskId, |
| c_EPTF_HTTP_Transport_loggingClassIdx_BufferDebug); |
| }else |
| { |
| f_EPTF_Logging_disableLocalMask( |
| v_EPTF_HTTP_Transport_loggingMaskId, |
| c_EPTF_HTTP_Transport_loggingClassIdx_BufferDebug); |
| } |
| |
| vf_getGroupAndPort := refers(f_EPTF_HTTP_LocalTransport_getGroupAndPort_default); |
| vf_getGroup := refers(f_EPTF_HTTP_LocalTransport_getGroup_default); |
| |
| vf_EPTF_HTTP_LocalTransport_receive := pl_receiveFunction; |
| vf_EPTF_HTTP_LocalTransport_eventReceive := pl_eventReceiveFunction; |
| vf_EPTF_HTTP_LocalTransport_socketErrorReceive := pl_socketErrorReceiveFunction; |
| |
| vf_EPTF_HTTP_LocalTransport_listenSocketEvent := pl_listenSocketEvent; |
| vf_EPTF_HTTP_LocalTransport_listenSocketError := pl_listenSocketError; |
| |
| f_EPTF_CommPort_IPL4_init(pl_interfaceInformationList,true); |
| |
| f_EPTF_CommPort_IPL4_setReceive( |
| { asp_RecvFrom := ? },refers(f_EPTF_HTTP_LocalTransport_receiveMessage), pl_selfName); |
| |
| f_EPTF_CommPort_IPL4_setReceive( |
| { asp_Event := ? },refers(f_EPTF_HTTP_LocalTransport_receiveEvent), pl_selfName); |
| |
| f_EPTF_CommPort_IPL4_activateDefaultBufferingHandler(pl_selfName); |
| |
| f_EPTF_CommPort_IPL4_setMsgLen(-1, |
| refers(f_EPTF_HTTP_LocalTransport_getMessageLength), {}); |
| |
| f_EPTF_FBQ_initFreeBusyQueue(v_EPTF_HTTP_Transport_groupQueue); |
| |
| f_EPTF_int2int_HashMap_Init(); |
| f_EPTF_str2int_HashMap_Init(); |
| |
| v_EPTF_HTTP_Transport_groupName2Idx_HM := |
| f_EPTF_str2int_HashMap_New(c_EPTF_HTTP_LocalTransport_HashMap_groupName2Idx); |
| v_EPTF_HTTP_Transport_functions2Idx_HM := |
| f_EPTF_str2int_HashMap_New(c_EPTF_HTTP_LocalTransport_HashMap_fnGrp2Idx); |
| v_EPTF_HTTP_Transport_localHostHashMap := |
| f_EPTF_str2int_HashMap_New(c_EPTF_HTTP_LocalTransport_HashMap_localHost); |
| v_EPTF_HTTP_Transport_remoteHostHashMap := |
| f_EPTF_str2int_HashMap_New(c_EPTF_HTTP_LocalTransport_HashMap_remoteHost); |
| v_EPTF_HTTP_Transport_connId2GroupId_HM := |
| f_EPTF_int2int_HashMap_New(c_EPTF_HTTP_LocalTransport_HashMap_connId2PortGrp); |
| v_EPTF_HTTP_Transport_connId2PortId_HM := |
| f_EPTF_int2int_HashMap_New(c_EPTF_HTTP_LocalTransport_HashMap_connId2Port); |
| v_EPTF_HTTP_Transport_sessId2PortId_HM := |
| f_EPTF_int2int_HashMap_New(c_EPTF_HTTP_LocalTransport_HashMap_sessId2Port); |
| v_EPTF_HTTP_Transport_portId2Idx_HM := |
| f_EPTF_int2int_HashMap_New(c_EPTF_HTTP_LocalTransport_HashMap_portId2Idx); |
| |
| f_EPTF_Base_init_CT(pl_selfName); |
| f_EPTF_Base_registerCleanup(refers(f_EPTF_HTTP_LocalTransport_cleanup_CT)); |
| |
| if (tsp_EPTF_HTTP_Transport_messageBufferEnable == true) { |
| f_EPTF_MessageBufferManager_init_CT(); |
| } |
| |
| v_EPTF_HTTP_LocalTransport_initialized := true; |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & "The initialization of the " & |
| "HTTP LocalTransport component is ready"); |
| |
| return 1; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_cleanup_CT |
| // |
| // Purpose: |
| // Function to clean The LocalTransport component |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_cleanup_CT() |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| if (not v_EPTF_HTTP_LocalTransport_initialized) { |
| return; |
| } |
| v_EPTF_HTTP_LocalTransport_initialized:= false; |
| |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| vf_EPTF_HTTP_LocalTransport_receive := null; |
| vf_EPTF_HTTP_LocalTransport_eventReceive := null; |
| vf_EPTF_HTTP_LocalTransport_socketErrorReceive := null |
| |
| v_EPTF_HTTP_LocalTransport_loggingEnabled := -1; |
| |
| // delate all ports and port groups |
| var integer vl_group; |
| while (f_EPTF_FBQ_getBusyHeadIdx(vl_group, v_EPTF_HTTP_Transport_groupQueue)) { |
| f_EPTF_HTTP_LocalTransport_deletePortGroup(vl_group); |
| } |
| |
| f_EPTF_str2int_HashMap_Delete(c_EPTF_HTTP_LocalTransport_HashMap_groupName2Idx); |
| f_EPTF_str2int_HashMap_Delete(c_EPTF_HTTP_LocalTransport_HashMap_fnGrp2Idx); |
| f_EPTF_str2int_HashMap_Delete(c_EPTF_HTTP_LocalTransport_HashMap_localHost); |
| f_EPTF_str2int_HashMap_Delete(c_EPTF_HTTP_LocalTransport_HashMap_remoteHost); |
| f_EPTF_int2int_HashMap_Delete(c_EPTF_HTTP_LocalTransport_HashMap_connId2PortGrp); |
| f_EPTF_int2int_HashMap_Delete(c_EPTF_HTTP_LocalTransport_HashMap_connId2Port); |
| f_EPTF_int2int_HashMap_Delete(c_EPTF_HTTP_LocalTransport_HashMap_sessId2Port); |
| f_EPTF_int2int_HashMap_Delete(c_EPTF_HTTP_LocalTransport_HashMap_portId2Idx); |
| |
| f_EPTF_FBQ_initFreeBusyQueue(v_EPTF_HTTP_Transport_groupQueue); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": The cleanup of the LocalTransport component is ready"); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_newPortGroup |
| // |
| // Purpose: |
| // Function to create a new port group |
| // |
| // Parameters: |
| // - pl_group - *in* <EPTF_HTTP_Transport_GroupMode> - group data |
| // - pl_portmode - *in* *boolean* - port mode / group mode selector |
| // |
| // Return Value: |
| // *integer* - index of the new port group if creation successful, |
| // otherwise -1 |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Function creats a new port group based on the given port group data. |
| // This includes creation of port database objects within the group |
| // and optionally open ports (based on port group data) |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_newPortGroup( |
| in EPTF_HTTP_Transport_GroupMode pl_group, |
| in boolean pl_portmode := false) |
| runs on EPTF_HTTP_LocalTransport_CT return integer |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| var charstring vl_groupName := ""; |
| var integer i, vl_dummy, vl_fGIdx, vl_newGrpIdx; |
| |
| vl_newGrpIdx := f_EPTF_FBQ_getOrCreateFreeSlot(v_EPTF_HTTP_Transport_groupQueue); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": New group index: " & int2str(vl_newGrpIdx)); |
| |
| // if group name not presented a unique one is generated |
| if (not ispresent(pl_group.name) or pl_group.name == "") { |
| vl_groupName := f_EPTF_HTTP_LocalTransport_createUniqueGroupName( |
| v_EPTF_HTTP_LocalTransport_selfName); |
| } |
| // if group name presented, then it must be unique |
| else { |
| vl_groupName := pl_group.name; |
| |
| if (f_EPTF_str2int_HashMap_Find(v_EPTF_HTTP_Transport_groupName2Idx_HM, |
| vl_groupName, vl_dummy)) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Group name: " & vl_groupName & " is not unique!"); |
| return -1; |
| } |
| } |
| |
| f_EPTF_FBQ_moveFromFreeToBusyTail(vl_newGrpIdx, v_EPTF_HTTP_Transport_groupQueue); // only if name unique |
| |
| // insert new group index into group name - group index hashmap |
| f_EPTF_str2int_HashMap_Insert(v_EPTF_HTTP_Transport_groupName2Idx_HM, |
| vl_groupName, vl_newGrpIdx); |
| |
| |
| // set group database |
| v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx] := c_HTTP_Transport_initPortGroup; |
| |
| v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].name := vl_groupName; |
| v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].localportStep := pl_group.localportStep; |
| v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].remoteportStep := pl_group.remoteportStep; |
| v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].baseLocalHostInformation := pl_group.localHostInformation; |
| v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].baseRemoteHostInformation := pl_group.remoteHostInformation; |
| |
| v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].useSSL := pl_group.useSSL; // FIXME |
| v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].instantConnOpen := pl_group.instantConnOpen; |
| v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].instantConnClose := pl_group.instantConnClose; |
| |
| // overdefine functionality if user functions are presented |
| if (ispresent(pl_group.userFunctions)) |
| { |
| vl_fGIdx := f_EPTF_HTTP_LocalTransport_registerGroupFunctions( |
| vl_newGrpIdx, pl_portmode, pl_group.userFunctions); |
| } else |
| { |
| vl_fGIdx := f_EPTF_HTTP_LocalTransport_registerGroupFunctions( |
| vl_newGrpIdx, pl_portmode, c_EPTF_HTTP_initUserFunctions); |
| } |
| v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].defaultFIdx := vl_fGIdx; |
| |
| // init queues |
| f_EPTF_FBQ_initFreeBusyQueue(v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].portQueue); |
| f_EPTF_FBQ_initFreeBusyQueue(v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].portStateQueue); |
| |
| // add group (and open ports if necessary) |
| var boolean vl_success := true; |
| for (i := 0; i < pl_group.numberOfPorts; i:= i + 1) { |
| if (not v_EPTF_HTTP_Transport_functionDB[vl_fGIdx].addPort.apply(vl_newGrpIdx)) { |
| vl_success := false; |
| i := pl_group.numberOfPorts; |
| } |
| } |
| |
| // evaluate result |
| if (vl_success) |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Group added successfully: " & |
| int2str(vl_newGrpIdx) & " - " & v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].name); |
| |
| return vl_newGrpIdx; |
| } |
| else |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Group addition unsuccessful: " & |
| int2str(vl_newGrpIdx) & " - " & v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].name); |
| |
| f_EPTF_HTTP_LocalTransport_deletePortGroup(vl_newGrpIdx); |
| |
| return -1; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_deletePortGroup |
| // |
| // Purpose: |
| // Function to delete an existing port group |
| // |
| // Parameters: |
| // - pl_group - *in* <EPTF_HTTP_Transport_GroupMode> - group index |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Function deletes a port group based on the given port group index. |
| // This includes closure and deletion of ports within the port group. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_deletePortGroup( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return; }; |
| |
| var integer vl_fGrpIdx := v_EPTF_HTTP_Transport_portDB[pl_group].defaultFIdx; |
| |
| // remove prots |
| while (v_EPTF_HTTP_Transport_functionDB[vl_fGrpIdx].removePort.apply(pl_group)) { }; |
| |
| for (var integer i := 0; i < sizeof(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase); i := i + 1) |
| { |
| if (omit != v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[i].messageBuffer) |
| { |
| f_EPTF_HTTP_MsgBuffer_erase(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[i].messageBuffer, i); |
| } |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[i].messageBuffer := omit; |
| } |
| |
| // remove name |
| f_EPTF_str2int_HashMap_Erase(v_EPTF_HTTP_Transport_groupName2Idx_HM, |
| v_EPTF_HTTP_Transport_portDB[pl_group].name); |
| |
| // unset database |
| v_EPTF_HTTP_Transport_portDB[pl_group] := c_HTTP_Transport_initPortGroup; |
| |
| // free group in FBQ |
| f_EPTF_FBQ_moveFromBusyToFreeTail(pl_group, v_EPTF_HTTP_Transport_groupQueue); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Group deleted successfully: " & |
| int2str(pl_group)); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_newPort |
| // |
| // Purpose: |
| // Function to create a new port group object |
| // |
| // Parameters: |
| // - pl_portInfo - *in* <EPTF_HTTP_Transport_PortMode> - port data |
| // |
| // Return Value: |
| // *integer* - index of the new port group |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Function creats a new port based on the given port data. |
| // It optionally opens the port (based on port group data) |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_newPort( |
| in EPTF_HTTP_Transport_PortMode pl_portInfo) |
| runs on EPTF_HTTP_LocalTransport_CT return integer |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| var integer vl_group; |
| var EPTF_HTTP_Transport_GroupMode vl_groupInfo; |
| |
| // convert port to group |
| vl_groupInfo := { |
| name := pl_portInfo.name, |
| localHostInformation := pl_portInfo.localHostInformation, |
| remoteHostInformation := pl_portInfo.remoteHostInformation, |
| numberOfPorts := 1, |
| localportStep := 0, |
| remoteportStep := 0, |
| instantConnOpen := pl_portInfo.instantConnOpen, |
| instantConnClose := pl_portInfo.instantConnClose, |
| useSSL := pl_portInfo.useSSL, |
| userFunctions := pl_portInfo.userFunctions |
| }; |
| |
| vl_group := f_EPTF_HTTP_LocalTransport_newPortGroup(vl_groupInfo, true); |
| |
| if (vl_group != -1) |
| { |
| var EPTF_HTTP_Transport_Function vl_funcs := v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[vl_group].defaultFIdx]; |
| |
| vl_funcs.addPort := refers(f_EPTF_HTTP_LocalTransport_addRemovePortToGroup_dummy); |
| //vl_funcs.addPort := refers(f_EPTF_HTTP_LocalTransport_addRemovePortToGroup_dummy); |
| |
| // function database index must be updated!! |
| var integer vl_index; |
| |
| // creates a hash map key from the function group |
| var charstring vl_key := log2str(vl_funcs) |
| |
| // if function group is already existing, then return id |
| if (f_EPTF_str2int_HashMap_Find(v_EPTF_HTTP_Transport_functions2Idx_HM, |
| vl_key, vl_index)) |
| { |
| v_EPTF_HTTP_Transport_portDB[vl_group].defaultFIdx := vl_index; |
| } |
| else { |
| // if function group was not existing, then add new element |
| vl_index := sizeof(v_EPTF_HTTP_Transport_functionDB); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": New database index: " & int2str(vl_index) & |
| " for functions: " & vl_key); |
| |
| v_EPTF_HTTP_Transport_portDB[vl_group].defaultFIdx := vl_index; |
| v_EPTF_HTTP_Transport_functionDB[vl_index] := vl_funcs; |
| |
| f_EPTF_str2int_HashMap_Insert(v_EPTF_HTTP_Transport_functions2Idx_HM, |
| vl_key, vl_index); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Functions are registered to group (" & |
| int2str(vl_group) & " - " & v_EPTF_HTTP_Transport_portDB[vl_group].name & ": " & vl_key & |
| " at position " & int2str(vl_index) & " in function database!"); |
| } |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Port created (" & |
| int2str(vl_group) & ") - " & v_EPTF_HTTP_Transport_portDB[vl_group].name); |
| |
| } |
| else { |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Port not created!"); |
| } |
| |
| return vl_group; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_newServerPort |
| // |
| // Purpose: |
| // Function to create a new server port group |
| // |
| // Parameters: |
| // - pl_portInfo - *in* <EPTF_HTTP_Transport_ServerPortMode> - port mode / group mode selector |
| // |
| // Return Value: |
| // *integer* - index of the new port group if creation successful, |
| // otherwise -1 |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Function creats a new port group based on the given port group data. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_newServerPort( |
| in EPTF_HTTP_Transport_ServerPortMode pl_portInfo) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return integer |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| var integer vl_newGrpIdx := -1; |
| |
| v_boolNoWarning := f_EPTF_HTTP_LocalTransport_createServerPort(pl_portInfo, vl_newGrpIdx) |
| |
| return vl_newGrpIdx; |
| } |
| |
| function f_EPTF_HTTP_LocalTransport_createServerPort( |
| in EPTF_HTTP_Transport_ServerPortMode pl_portInfo, |
| inout integer pl_groupId) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return boolean |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| var integer vl_fGIdx, vl_newGrpIdx; |
| |
| if (f_EPTF_str2int_HashMap_Find(v_EPTF_HTTP_Transport_groupName2Idx_HM, |
| pl_portInfo.name, pl_groupId)) |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": Server group already exists."); |
| return false; |
| } |
| |
| vl_newGrpIdx := f_EPTF_FBQ_getOrCreateFreeSlot(v_EPTF_HTTP_Transport_groupQueue); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": New group index: " & int2str(vl_newGrpIdx)); |
| |
| f_EPTF_FBQ_moveFromFreeToBusyTail(vl_newGrpIdx, v_EPTF_HTTP_Transport_groupQueue); |
| |
| // insert new group index into group name - group index hashmap |
| f_EPTF_str2int_HashMap_Insert(v_EPTF_HTTP_Transport_groupName2Idx_HM, |
| pl_portInfo.name, vl_newGrpIdx); |
| |
| |
| // set group database |
| v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx] := c_HTTP_Transport_initPortGroup; |
| f_EPTF_FBQ_initFreeBusyQueue(v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].portQueue); |
| f_EPTF_FBQ_initFreeBusyQueue(v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].portStateQueue); |
| |
| v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].name := pl_portInfo.name; |
| v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].baseLocalHostInformation := pl_portInfo.localHostInformation; |
| |
| v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].instantConnClose := pl_portInfo.instantConnClose; |
| |
| v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].buffer := pl_portInfo.buffer; |
| |
| if(ispresent(pl_portInfo.useSSL) and pl_portInfo.useSSL) { |
| v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].useSSL := true; |
| } |
| else { |
| v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].useSSL := false; |
| } |
| |
| // overdefine functionality if user functions are presented |
| if (ispresent(pl_portInfo.userFunctions)) |
| { |
| vl_fGIdx := f_EPTF_HTTP_LocalTransport_registerServerGroupFunctions( |
| vl_newGrpIdx, pl_portInfo.userFunctions); |
| } else |
| { |
| vl_fGIdx := f_EPTF_HTTP_LocalTransport_registerServerGroupFunctions( |
| vl_newGrpIdx, c_EPTF_HTTP_initServerUserFunctions); |
| } |
| v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].defaultFIdx := vl_fGIdx; |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Group added successfully: " & |
| int2str(vl_newGrpIdx) & " - " & v_EPTF_HTTP_Transport_portDB[vl_newGrpIdx].name); |
| |
| pl_groupId := vl_newGrpIdx; |
| return true; |
| } |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_deletePort |
| // |
| // Purpose: |
| // Function to delete an existing port |
| // |
| // Parameters: |
| // - pl_group - *in* <EPTF_HTTP_Transport_GroupMode> - port index |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Function deletes a port group based on the given port group index. |
| // This includes closure and deletion of ports within the port group. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_deletePort( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return; }; |
| |
| f_EPTF_HTTP_LocalTransport_deletePortGroup(pl_group); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Port deleted (" & |
| int2str(pl_group) & ") - " & v_EPTF_HTTP_Transport_portDB[pl_group].name); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_addPortToGroup_default |
| // |
| // Purpose: |
| // Function to add a single port to an existing port group |
| // |
| // Parameters: |
| // - pl_group - *in* <EPTF_HTTP_Transport_GroupMode> - group index |
| // |
| // Return Value: |
| // *boolean* - result of the operation |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // The new port added to the port group will be created according to |
| // port group data. Set local and remote IP addresses won't be changed, |
| // but local and remote ports will be calculated according to: |
| // (<number of ports in port group> + 1) * (<local/remote port step>). |
| // |
| // Addition of new port optionally opens connection on port group data |
| // to which the port is added (if instant connection open is enabled, |
| // then ports won't be opened, otherwise they will be). |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_addPortToGroup_default( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT return boolean |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return false; }; |
| |
| var EPTF_HTTP_HostInformation vl_lhostInformation, vl_rhostInformation; |
| var integer vl_lhIdx, vl_rhIdx, vl_fbqIdx; |
| |
| f_EPTF_FBQ_createFreeSlots(1, v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue); |
| vl_fbqIdx := f_EPTF_FBQ_getOrCreateFreeSlot(v_EPTF_HTTP_Transport_portDB[pl_group].portQueue); |
| |
| //vl_fbqStateIdx := f_EPTF_FBQ_getOrCreateFreeSlot(v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue); |
| //f_EPTF_Base_assert(%definitionId & "FBQ index mismatch", vl_fbqIdx == vl_fbqStateIdx); |
| //f_EPTF_FBQ_setQueueDidx(vl_fbqStateIdx, {vl_fbqIdx}, v_EPTF_HTTP_Transport_portDB[pl_portGrpIdx].portStateQueue); |
| |
| // calculate next port data according (local) |
| vl_lhostInformation := v_EPTF_HTTP_Transport_portDB[pl_group].baseLocalHostInformation; |
| vl_lhostInformation.hostPort := vl_lhostInformation.hostPort + |
| v_EPTF_HTTP_Transport_portDB[pl_group].localportStep * v_EPTF_HTTP_Transport_portDB[pl_group].numberOfPorts; |
| vl_lhIdx := f_EPTF_HTTP_LocalTransport_addLocalHostInformation(vl_lhostInformation); |
| |
| // calculate next port data according (remote) |
| vl_rhostInformation := v_EPTF_HTTP_Transport_portDB[pl_group].baseRemoteHostInformation; |
| vl_rhostInformation.hostPort := vl_rhostInformation.hostPort + |
| v_EPTF_HTTP_Transport_portDB[pl_group].remoteportStep * v_EPTF_HTTP_Transport_portDB[pl_group].numberOfPorts; |
| vl_rhIdx := f_EPTF_HTTP_LocalTransport_addRemoteHostInformation(vl_rhostInformation); |
| |
| // set port data to port info database |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx] := c_EPTF_HTTP_LocalTransport_initPortInfo; |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].groupIndex := pl_group; // FIXME check |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].portIndex := vl_fbqIdx; // FIXME check |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].localhostInfoIdx := vl_lhIdx; |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].remotehostInfoIdx := vl_rhIdx; |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": New port added to " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, vl_fbqIdx)); |
| |
| // InstantConnOpen == true means that a send request on the group will |
| // automatically trigger a port open -> this case no ports are opened |
| // initially, otherwise ports are opened previosly |
| if (not v_EPTF_HTTP_Transport_portDB[pl_group].instantConnOpen) |
| { |
| if (not f_EPTF_HTTP_LocalTransport_openPortInGroup(pl_group, vl_fbqIdx)) { |
| return false; |
| } |
| } |
| |
| // move to busy (only if everything was previously successful) |
| f_EPTF_FBQ_moveFromFreeToBusyTail(vl_fbqIdx, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portQueue); |
| |
| // administrate new port opening |
| v_EPTF_HTTP_Transport_portDB[pl_group].numberOfPorts := v_EPTF_HTTP_Transport_portDB[pl_group].numberOfPorts + 1; |
| |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_removePortFromGroup_default |
| // |
| // Purpose: |
| // Function to remove a single port from an existing port group |
| // |
| // Parameters: |
| // - pl_group - *in* <EPTF_HTTP_Transport_GroupMode> - group index |
| // |
| // Return Value: |
| // *boolean* - result of the operation |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // The port which is choosen to be removed is the first one added to |
| // the port group from which the port is removed. |
| // |
| // If the port has an open connection, then the connection will be closed. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_removePortFromGroup_default( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT return boolean |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return false; }; |
| |
| var EPTF_HTTP_Transport_ConnectionState vl_state; |
| var integer vl_connId, vl_busyHeadIdx := -1; |
| |
| // the first removed port is the oldest one (busy head) |
| if (f_EPTF_FBQ_getBusyHeadIdx(vl_busyHeadIdx, v_EPTF_HTTP_Transport_portDB[pl_group].portQueue)) |
| { |
| vl_connId := v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_busyHeadIdx].connectionId; |
| vl_state := v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_busyHeadIdx].state; |
| |
| // when port removed, it must be closed |
| // it can be closed if connId != -1 and state is OPENING/OPENED/HALFCLOSED |
| f_EPTF_Base_assert(%definitionId & ": Invalid state of port in " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, vl_busyHeadIdx), |
| vl_connId != -1 or vl_state == IDLE); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Removing port at " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, vl_busyHeadIdx)); |
| |
| if (vl_connId != -1) |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Closing connection on port " & |
| "to be removed!"); |
| |
| // close port |
| f_EPTF_HTTP_Transport_closePortInGroup(pl_group, vl_busyHeadIdx); |
| } |
| |
| // deleted port will be allocated again (if necessary) at last time (free tail) |
| f_EPTF_FBQ_moveFromBusyToFreeTail(vl_busyHeadIdx, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portQueue); |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_busyHeadIdx] := c_EPTF_HTTP_LocalTransport_initPortInfo; |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].numberOfPorts := v_EPTF_HTTP_Transport_portDB[pl_group].numberOfPorts - 1; |
| |
| return true; |
| } |
| //else |
| //{ |
| // f_EPTF_HTTP_Transport_warning(%definitionId & |
| // ": No more ports to remove from group: " & |
| // int2str(pl_group) & " - " & v_EPTF_HTTP_Transport_portDB[pl_group].name); |
| // |
| return false; |
| //} |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_removePortFromGroupServer_default |
| // |
| // Purpose: |
| // Function to remove a single port from an existing server port group |
| // |
| // Parameters: |
| // - pl_group - *in* <EPTF_HTTP_Transport_GroupMode> - group index |
| // |
| // Return Value: |
| // *boolean* - result of the operation |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // The port which is choosen to be removed is the first one added to |
| // the port group from which the port is removed. |
| // |
| // If the port has an open connection, then the connection will be closed. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_removePortFromGroupServer_default( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return boolean |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return false; }; |
| |
| var integer vl_busyHeadIdx := -1; |
| |
| if (f_EPTF_FBQ_getBusyHeadIdx(vl_busyHeadIdx, v_EPTF_HTTP_Transport_portDB[pl_group].portQueue)) |
| { |
| f_EPTF_HTTP_LocalTransport_removeServerPort(pl_group, vl_busyHeadIdx); |
| return true; |
| } |
| |
| return false; |
| } |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_addRemovePortToGroup_dummy |
| // |
| // Purpose: |
| // Dummy function to disable add/remove port |
| // |
| // Parameters: |
| // - pl_group - *in* <EPTF_HTTP_Transport_GroupMode> - group index |
| // |
| // Return Value: |
| // *boolean* - result of the operation |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Application of this function can disable addition or deletion of |
| // new ports from port group |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_addRemovePortToGroup_dummy( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT return boolean |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Cannot add/remove ports to port groups created in Port mode"); |
| |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_selectPortInGroup_defaultGroup |
| // |
| // Purpose: |
| // Function to select a port in the group on which user intends to perform |
| // an send operation |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // |
| // Return Value: |
| // *integer* - index of the selected port within the port group |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // State of ports within a port group are maintained. If someone sends |
| // an a port, its state is busy for further send. This function selects |
| // a port within the port group that is not busy for sending. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_selectPortInGroup_defaultGroup( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT return integer |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return -1; }; |
| |
| var integer vl_nextFreePortIdx; |
| |
| if (f_EPTF_FBQ_getFreeTailIdx(vl_nextFreePortIdx, v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue)) |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Selected port is " & |
| int2str(vl_nextFreePortIdx) & " for group: " & int2str(pl_group)); |
| |
| return vl_nextFreePortIdx; |
| } |
| |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Port selection unsuccessful" |
| & " for group: " & int2str(pl_group)); |
| |
| return -1; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_selectPortInGroup_defaultPort |
| // |
| // Purpose: |
| // Function to select a port in the group on which user intends to perform |
| // an send operation. |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // |
| // Return Value: |
| // *integer* - index of the selected port within the port group |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // The function is the default function for port operation mode and |
| // therefore it will always provide port 0 as in port operation mode |
| // only one port is located within the port group. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_selectPortInGroup_defaultPort( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT return integer |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_FBQ_itemIsBusy(pl_group, v_EPTF_HTTP_Transport_groupQueue)) { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Group already deleted: " & |
| int2str(pl_group) & " - " & v_EPTF_HTTP_Transport_portDB[pl_group].name); |
| return -1; |
| } |
| |
| if (f_EPTF_FBQ_itemIsBusy(0, v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue)) { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Already sending " & |
| "group: " & int2str(pl_group) & " - " & v_EPTF_HTTP_Transport_portDB[pl_group].name); |
| |
| return -1; |
| } |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Selected port is 0" & |
| " for group: " & int2str(pl_group)); |
| |
| return 0; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_getGroupAndPort_defaultGroup |
| // |
| // Purpose: |
| // Function to acquire port and group index for a connection id |
| // |
| // Parameters: |
| // - pl_connId - *in* *integer* - connection id |
| // - pl_group - *in* *integer* - port group index |
| // - pl_port - *in* *integer* - port index within the group id |
| // |
| // Return Value: |
| // *boolean* - true if group and port index successfully retrieved |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Default function for group operation mode |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_getGroupAndPort_default( |
| in integer pl_connId, |
| inout integer pl_group, |
| inout integer pl_port) |
| runs on EPTF_HTTP_LocalTransport_CT return boolean |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (f_EPTF_int2int_HashMap_Find(v_EPTF_HTTP_Transport_connId2GroupId_HM, |
| pl_connId, pl_group)) |
| { |
| if (f_EPTF_int2int_HashMap_Find(v_EPTF_HTTP_Transport_connId2PortId_HM, |
| pl_connId, pl_port)) |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Connection id mapped " & |
| " to port: " & int2str(pl_port) & " and group: " & int2str(pl_group)); |
| |
| return true; |
| } |
| else { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Connection id was " & |
| "not found in Connection id to port id hash map. Message dropped!"); |
| |
| pl_group := -1; pl_port := -1; |
| return false; |
| } |
| } |
| else { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Connection id was " & |
| "not found in Connection id to group id hash map. Message dropped!"); |
| |
| pl_group := -1; pl_port := -1; |
| return false; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_getGroup_default |
| // |
| // Purpose: |
| // Function to acquire group index for a connection id |
| // |
| // Parameters: |
| // - pl_connId - *in* *integer* - connection id |
| // - pl_groupId - *inout* *integer* - port group index |
| // |
| // Return Value: |
| // *boolean* - true if group index is successfully retrieved |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_getGroup_default( |
| in integer pl_connId, |
| inout integer pl_groupId) |
| runs on EPTF_HTTP_LocalTransport_CT return boolean |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_int2int_HashMap_Find(v_EPTF_HTTP_Transport_connId2GroupId_HM, |
| pl_connId, pl_groupId)) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Connection id "& int2str(pl_connId) &" was " & |
| "not found in Connection id to group id hash map. Message dropped!"); |
| |
| pl_groupId := -1 |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_sendMessage_default_IC |
| // |
| // Purpose: |
| // Function to send message and open connection instantly |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // - pl_sessionId - *in* *integer* - unique session id of current send |
| // - pl_msg - *in* *octetstring* - encoded message to be sent |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // The function selects a port within the port group which it has |
| // been applied to, then tries to open the port's connection instantly. If |
| // both of these operations have finished successfully, finally sends |
| // the message. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_sendMessage_default_IC( |
| in integer pl_group, |
| in integer pl_sessionId, |
| in octetstring pl_msg) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return; }; |
| |
| var integer vl_port := |
| v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[pl_group].defaultFIdx].selectPort.apply(pl_group); |
| |
| if (vl_port == -1) |
| { |
| if (tsp_EPTF_HTTP_Transport_messageBufferEnable == false) { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": No more free ports available!"); |
| } |
| else { |
| f_EPTF_MessageBufferManager_setMessageToBuffer(pl_msg, int2str(pl_sessionId), pl_group); |
| } |
| } |
| |
| else |
| { |
| |
| if (v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].state != IDLE and v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].state != OPENED) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Connection is not in Idle state, state: " & |
| log2str(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].state)); |
| } |
| else |
| { |
| if (f_EPTF_FBQ_itemIsBusy(vl_port, v_EPTF_HTTP_Transport_portDB[pl_group].portQueue)) { |
| var EPTF_HTTP_HostInformation vl_local, vl_remote; |
| |
| vl_local := v_EPTF_HTTP_Transport_localHostInformationList[ |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].localhostInfoIdx]; |
| vl_remote := v_EPTF_HTTP_Transport_remoteHostInformationList[ |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].remotehostInfoIdx]; |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].sessionId := pl_sessionId; |
| |
| if (v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].state == OPENED or f_EPTF_HTTP_LocalTransport_openPortInGroup(pl_group, vl_port)) |
| //if (v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[pl_group].defaultFIdx].openPort.apply(pl_group)) |
| { |
| v_EPTF_HTTP_Transport_OutgoingMessage := { asp_Send := { |
| connId := v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].connectionId, |
| proto := {tcp:= {}}, |
| msg := pl_msg |
| } }; |
| |
| v_resultNoWarning := f_EPTF_CommPort_IPL4_send( |
| v_EPTF_HTTP_Transport_OutgoingMessage, |
| null, false, true, v_EPTF_HTTP_LocalTransport_selfName); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Send result is " & |
| log2str(v_resultNoWarning)); |
| if ((not ispresent(v_resultNoWarning.errorCode)) or |
| (v_resultNoWarning.errorCode == ERROR_TEMPORARILY_UNAVAILABLE) or |
| (v_resultNoWarning.errorCode == ERROR_AVAILABLE) ) |
| { |
| if (ispresent(v_resultNoWarning.errorCode) and (v_resultNoWarning.errorCode != ERROR_TEMPORARILY_UNAVAILABLE)) { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": f_EPTF_CommPort_IPL4_send error code: " & |
| log2str(v_resultNoWarning.errorCode)); |
| } |
| // move to busy if sending on port |
| if (not f_EPTF_FBQ_itemIsBusy(vl_port, v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue)) { |
| f_EPTF_FBQ_moveFromFreeToBusyTail(vl_port, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue); |
| } |
| |
| f_EPTF_int2int_HashMap_Insert(v_EPTF_HTTP_Transport_sessId2PortId_HM, |
| pl_sessionId, |
| vl_port); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Message sent on " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, vl_port) & |
| ": " & log2str(pl_msg)); |
| } |
| else |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Send message unsuccessful!" & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, vl_port)); |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].sessionId := -1; |
| |
| // socket error, calling callback |
| if(vf_EPTF_HTTP_LocalTransport_socketErrorReceive != null) { |
| vf_EPTF_HTTP_LocalTransport_socketErrorReceive.apply({ |
| pl_group, |
| pl_sessionId, |
| v_resultNoWarning}); |
| } |
| |
| } |
| } |
| else { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Instant connection opening unsuccessful for port at " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, vl_port)); |
| } |
| } |
| else { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Sending on port which has already been removed!" & |
| int2str(pl_group) & " / " & int2str(vl_port)); |
| } |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_sendMessage_default_NIC |
| // |
| // Purpose: |
| // Function to send message and open connection instantly |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // - pl_sessionId - *in* *integer* - unique session id of current send |
| // - pl_msg - *in* *octetstring* - encoded message to be sent |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // The function selects a port within the port group which it has |
| // been applied to, then tries to send the message. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_sendMessage_default_NIC( |
| in integer pl_group, |
| in integer pl_sessionId, |
| in octetstring pl_msg) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return; }; |
| |
| var integer vl_port := |
| v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[pl_group].defaultFIdx].selectPort.apply(pl_group); |
| |
| if (vl_port == -1) |
| { |
| if (tsp_EPTF_HTTP_Transport_messageBufferEnable == false) { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": No more free ports available"); |
| } |
| else { |
| f_EPTF_MessageBufferManager_setMessageToBuffer(pl_msg, int2str (pl_sessionId), pl_group); |
| } |
| } |
| else { |
| if (v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].state != OPENED) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Connection is not opened, state: " & |
| log2str(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].state)); |
| } |
| else |
| { |
| v_EPTF_HTTP_Transport_OutgoingMessage := { asp_Send := { |
| connId := v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].connectionId, |
| proto := {tcp:= {}}, |
| msg := pl_msg |
| } }; |
| |
| v_resultNoWarning := f_EPTF_CommPort_IPL4_send( |
| v_EPTF_HTTP_Transport_OutgoingMessage, |
| null, false, true, v_EPTF_HTTP_LocalTransport_selfName); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Send result is " & |
| log2str(v_resultNoWarning)); |
| |
| if (not ispresent(v_resultNoWarning.errorCode) or ((v_resultNoWarning.errorCode == ERROR_TEMPORARILY_UNAVAILABLE) or (v_resultNoWarning.errorCode == ERROR_AVAILABLE))) |
| { |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].sessionId := pl_sessionId |
| |
| // move to busy if sending on port |
| if (not f_EPTF_FBQ_itemIsBusy(vl_port, v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue)) { |
| f_EPTF_FBQ_moveFromFreeToBusyTail(vl_port, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue); |
| } |
| |
| f_EPTF_int2int_HashMap_Insert(v_EPTF_HTTP_Transport_sessId2PortId_HM, |
| pl_sessionId, |
| vl_port); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Message sent on " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, vl_port) & |
| ": " & log2str(pl_msg)); |
| } |
| else { |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": Send message unsuccessful!" & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, vl_port)); |
| |
| // socket error, calling callback |
| if(vf_EPTF_HTTP_LocalTransport_socketErrorReceive != null) { |
| vf_EPTF_HTTP_LocalTransport_socketErrorReceive.apply({ |
| pl_group, |
| pl_sessionId, |
| v_resultNoWarning}); |
| } |
| } |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_sendResponse_default_IC |
| // |
| // Purpose: |
| // Function to send a response and close connection instantly |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // - pl_portId - *in* *integer* - unique port id to send the request |
| // - pl_msg - *in* *octetstring* - encoded message to be sent |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_sendResponse_default_IC( |
| in integer pl_group, |
| in integer pl_portId, |
| in integer pl_seqNum, |
| in octetstring pl_msg) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| var integer vl_port := -1; |
| if (not f_EPTF_int2int_HashMap_Find(v_EPTF_HTTP_Transport_portId2Idx_HM, pl_portId, vl_port)) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Could not find port identifier!" & |
| log2str(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase)); |
| return; |
| } |
| |
| if (f_EPTF_HTTP_Transport_sendResponse(pl_group, vl_port, pl_msg)) |
| { |
| var integer vl_fGIdx := v_EPTF_HTTP_Transport_portDB[pl_group].defaultFIdx; |
| |
| v_EPTF_HTTP_Transport_functionDB[vl_fGIdx].removeIncomingConn.apply(pl_group, vl_port); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_sendResponse_default_NIC |
| // |
| // Purpose: |
| // Function to send a response. |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // - pl_portId - *in* *integer* - unique port id to send the request |
| // - pl_seqNum - *in* *integer* - sequence number of the response |
| // - pl_msg - *in* *octetstring* - encoded message to be sent |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_sendResponse_default_NIC( |
| in integer pl_group, |
| in integer pl_portId, |
| in integer pl_seqNum, |
| in octetstring pl_msg) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| var integer vl_port := -1; |
| if (not f_EPTF_int2int_HashMap_Find(v_EPTF_HTTP_Transport_portId2Idx_HM, pl_portId, vl_port)) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Could not find port identifier!" & |
| log2str(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase)); |
| return; |
| } |
| |
| if (-1 == pl_seqNum) |
| { |
| v_boolNoWarning := f_EPTF_HTTP_Transport_sendResponse(pl_group, vl_port, pl_msg); |
| return; |
| } |
| |
| var integer vl_headIdx := |
| f_EPTF_HTTP_RingBuffer_getHeadIdx(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer.seqNums); |
| var integer vl_messageIdx := -1; |
| |
| f_EPTF_HTTP_RingBuffer_setElementBusy( |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer.seqNums, |
| pl_seqNum |
| ); |
| |
| if (pl_seqNum == vl_headIdx) |
| { |
| v_boolNoWarning := f_EPTF_HTTP_Transport_sendResponse(pl_group, vl_port, pl_msg); |
| |
| if (not v_boolNoWarning) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Error while sending buffered responses, clearing buffer."); |
| f_EPTF_HTTP_MsgBuffer_clear(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer); |
| return; |
| } |
| |
| f_EPTF_HTTP_RingBuffer_freeHead(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer.seqNums); |
| |
| while(f_EPTF_HTTP_RingBuffer_isHeadBusy(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer.seqNums)) |
| { |
| //send buffered message |
| vl_headIdx := |
| f_EPTF_HTTP_RingBuffer_getHeadIdx(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer.seqNums); |
| |
| if (f_EPTF_int2int_HashMap_Find( |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer.seqNum2messageIdxHM, |
| vl_headIdx, |
| vl_messageIdx) and |
| f_EPTF_FBQ_itemIsBusy( |
| vl_messageIdx, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer.messageQueue)) |
| { |
| if (f_EPTF_HTTP_Transport_sendResponse( |
| pl_group, |
| vl_port, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer.httpMessages[vl_messageIdx])) |
| { |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer.httpMessages[vl_messageIdx] := ''O; |
| f_EPTF_FBQ_moveFromBusyToFreeHead( |
| vl_messageIdx, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer.messageQueue); |
| f_EPTF_int2int_HashMap_Erase( |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer.seqNum2messageIdxHM, |
| vl_headIdx); |
| f_EPTF_HTTP_RingBuffer_freeHead(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer.seqNums); |
| continue; |
| } |
| |
| f_EPTF_HTTP_MsgBuffer_clear(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer); |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Error while sending buffered responses, clearing buffer."); |
| return; |
| |
| }else{ |
| f_EPTF_HTTP_MsgBuffer_clear(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer); |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Inconsistency in message buffer!"); |
| } |
| } |
| }else{ |
| //store message |
| var integer vl_idx := -1; |
| |
| if (f_EPTF_int2int_HashMap_Find( |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer.seqNum2messageIdxHM, |
| pl_seqNum, |
| vl_idx)) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Re-using slot! Replacing old message with new."); |
| }else |
| { |
| vl_idx := f_EPTF_FBQ_getOrCreateFreeSlot(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer.messageQueue); |
| f_EPTF_FBQ_moveFromFreeToBusyTail( |
| vl_idx, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer.messageQueue); |
| |
| f_EPTF_int2int_HashMap_Insert( |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer.seqNum2messageIdxHM, |
| pl_seqNum, |
| vl_idx) |
| } |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].messageBuffer.httpMessages[vl_idx] := pl_msg; |
| |
| } |
| |
| f_EPTF_HTTP_printBufferStatus(pl_group, vl_port); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Transport_sendResponse |
| // |
| // Purpose: |
| // Sends the response. |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // - pl_port - *in* *integer* - port index |
| // - pl_msg - *in* *octetstring* - encoded message to be sent |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Transport_sendResponse( |
| in integer pl_group, |
| in integer pl_port, |
| in octetstring pl_msg) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return boolean |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return false; }; |
| |
| var ProtoTuple vl_proto := {tcp:= {}}; |
| if(v_EPTF_HTTP_Transport_portDB[pl_group].useSSL){ |
| vl_proto := {ssl:= {}} |
| } |
| |
| v_EPTF_HTTP_Transport_OutgoingMessage := { asp_Send := { |
| connId := v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].connectionId, |
| proto := vl_proto, |
| msg := pl_msg |
| } }; |
| |
| v_resultNoWarning := f_EPTF_CommPort_IPL4_send( |
| v_EPTF_HTTP_Transport_OutgoingMessage, |
| null, false, true, v_EPTF_HTTP_LocalTransport_selfName); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Send result is " & |
| log2str(v_resultNoWarning)); |
| |
| if (ispresent(v_resultNoWarning.errorCode)) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Send message unsuccessful!" & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, pl_port) & " " & |
| log2str(v_resultNoWarning)); |
| |
| // socket error, calling callback |
| if(vf_EPTF_HTTP_LocalTransport_socketErrorReceive != null) { |
| vf_EPTF_HTTP_LocalTransport_socketErrorReceive.apply({ |
| pl_group, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].portId, |
| v_resultNoWarning}); |
| } |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_receiveMessage_default_IC |
| // |
| // Purpose: |
| // Function to receive message and close connection instantly |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // - pl_port - *in* *integer* - port index |
| // - pl_msg - *in* *octetstring* - encoded message to be sent |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // The function administrates port state and then calls the real |
| // message handler |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_receiveMessage_default_IC( |
| in integer pl_group, |
| in integer pl_port, |
| in octetstring pl_msg) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| f_EPTF_int2int_HashMap_Erase(v_EPTF_HTTP_Transport_sessId2PortId_HM, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].sessionId); |
| |
| if (v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].state == IDLE) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Port already closed " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, pl_port)); |
| |
| return; |
| } |
| else |
| { |
| f_EPTF_HTTP_Transport_closePortInGroup(pl_group, pl_port); |
| |
| //v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].state := IDLE; |
| //v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].connectionId := -1; |
| |
| //f_EPTF_int2int_HashMap_Erase(v_EPTF_HTTP_Transport_connId2GroupId_HM, pl_conn); |
| //f_EPTF_int2int_HashMap_Erase(v_EPTF_HTTP_Transport_connId2PortId_HM, pl_conn); |
| |
| // deleted port will be allocated again (if necessary) at last time (free tail) |
| //f_EPTF_FBQ_moveFromBusyToFreeTail(pl_port, v_EPTF_HTTP_Transport_portDB[pl_group].portQueue); |
| |
| // administrate as IDLE port |
| //if (f_EPTF_FBQ_itemIsBusy(pl_port, v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue)) { |
| // f_EPTF_FBQ_moveFromBusyToFreeTail(pl_port, v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue); |
| //} |
| } |
| |
| var integer vl_temp := v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].sessionId; |
| // delete session id only after handle receive message |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].sessionId := -1; |
| if (vf_EPTF_HTTP_LocalTransport_receive != null) { |
| vf_EPTF_HTTP_LocalTransport_receive.apply({ |
| pl_group, |
| vl_temp, |
| -1, |
| pl_msg}); |
| } |
| if (tsp_EPTF_HTTP_Transport_messageBufferEnable == true) { |
| var octetstring vl_message; |
| var charstring vl_sessionId; |
| if (f_EPTF_MessageBufferManager_getMessageFromBuffer(pl_group, vl_message, vl_sessionId)) { |
| if (lengthof (vl_message) > 0) { |
| f_EPTF_HTTP_LocalTransport_sendMessage_default_IC(pl_group, str2int(vl_sessionId), vl_message); |
| } |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_receiveMessage_default_NIC |
| // |
| // Purpose: |
| // Function to handle message recpetion |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // - pl_port - *in* *integer* - port index |
| // - pl_msg - *in* *octetstring* - the received encoded message |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // The function closes the port connection on which the message has |
| // arrived and then calls the real message handler |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_receiveMessage_default_NIC( |
| in integer pl_group, |
| in integer pl_port, |
| in octetstring pl_msg) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| f_EPTF_int2int_HashMap_Erase(v_EPTF_HTTP_Transport_sessId2PortId_HM, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].sessionId); |
| |
| // administrate as IDLE port |
| if (f_EPTF_FBQ_itemIsBusy(pl_port, v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue)) { |
| f_EPTF_FBQ_moveFromBusyToFreeTail(pl_port, v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue); |
| } |
| var integer vl_temp := v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].sessionId; |
| |
| if (vf_EPTF_HTTP_LocalTransport_receive != null) { |
| vf_EPTF_HTTP_LocalTransport_receive.apply({ |
| pl_group, |
| vl_temp, |
| -1, |
| pl_msg}); |
| } |
| |
| if (tsp_EPTF_HTTP_Transport_messageBufferEnable == true) { |
| var octetstring vl_message; |
| var charstring vl_sessionId; |
| if (f_EPTF_MessageBufferManager_getMessageFromBuffer(pl_group, vl_message, vl_sessionId)) { |
| if (lengthof (vl_message) > 0) { |
| f_EPTF_HTTP_LocalTransport_sendMessage_default_NIC(pl_group, str2int(vl_sessionId), vl_message); |
| } |
| } |
| } |
| // session id cannot be deleted if connection stayed open |
| //v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].sessionId := -1; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_receiveMessageServer_default |
| // |
| // Purpose: |
| // Function to handle message recpetion |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // - pl_port - *in* *integer* - port index |
| // - pl_msg - *in* *octetstring* - the received encoded message |
| // |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_receiveMessageServer_default( |
| in integer pl_group, |
| in integer pl_port, |
| in octetstring pl_msg) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| var integer vl_seqNum := -1; |
| |
| if (v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].buffer) |
| { |
| vl_seqNum := f_EPTF_HTTP_RingBuffer_getNext(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].messageBuffer.seqNums); |
| if (-1 == vl_seqNum) |
| { |
| f_EPTF_HTTP_Transport_warning(log2str(%definitionId & |
| ": Dropping message: ", pl_msg)); |
| return; |
| } |
| |
| f_EPTF_HTTP_printBufferStatus(pl_group, pl_port); |
| } |
| |
| if (vf_EPTF_HTTP_LocalTransport_receive != null) { |
| vf_EPTF_HTTP_LocalTransport_receive.apply({ |
| pl_group, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].portId, |
| vl_seqNum, |
| pl_msg}); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_receiveEvent_default |
| // |
| // Purpose: |
| // Function to handle event reception |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // - pl_port - *in* *integer* - port index |
| // - pl_type - *in* *integer* - event type |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_receiveEvent_default( |
| in integer pl_group, |
| in integer pl_port, |
| in integer pl_type) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| select (pl_type) |
| { |
| case (c_EPTF_HTTP_inputIdx_connectionOpened) |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": Connection opened received"); |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].state := OPENED; |
| |
| if (vf_EPTF_HTTP_LocalTransport_eventReceive != null) { |
| vf_EPTF_HTTP_LocalTransport_eventReceive.apply({ |
| pl_group, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].sessionId, |
| pl_type}); |
| } |
| |
| return; |
| } |
| case (c_EPTF_HTTP_inputIdx_connectionClosed) |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": Connection closed received"); |
| |
| if (v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].state != IDLE) |
| { |
| f_EPTF_int2int_HashMap_Erase(v_EPTF_HTTP_Transport_connId2GroupId_HM, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].connectionId); |
| f_EPTF_int2int_HashMap_Erase(v_EPTF_HTTP_Transport_connId2PortId_HM, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].connectionId); |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].state := IDLE; |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].connectionId := -1; |
| |
| // deleted port will be allocated again (if necessary) at last time (free tail) |
| //f_EPTF_FBQ_moveFromBusyToFreeTail(pl_port, v_EPTF_HTTP_Transport_portDB[pl_group].portQueue); |
| |
| // administrate as IDLE port |
| if (f_EPTF_FBQ_itemIsBusy(pl_port, v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue)) { |
| f_EPTF_FBQ_moveFromBusyToFreeTail(pl_port, v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue); |
| } |
| } |
| else { // receivemessage_default_IC can result in this state |
| //f_EPTF_HTTP_Transport_warning(%definitionId & |
| // ": Connection already closed"); |
| } |
| |
| if (vf_EPTF_HTTP_LocalTransport_eventReceive != null) { |
| vf_EPTF_HTTP_LocalTransport_eventReceive.apply({ |
| pl_group, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].sessionId, |
| pl_type}); |
| } |
| |
| return; |
| } |
| case (c_EPTF_HTTP_inputIdx_OKReceived) { |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": OK message received"); |
| |
| if (vf_EPTF_HTTP_LocalTransport_eventReceive != null) { |
| vf_EPTF_HTTP_LocalTransport_eventReceive.apply({ |
| pl_group, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].sessionId, |
| pl_type}); |
| } |
| |
| return; |
| } |
| case (c_EPTF_HTTP_inputIdx_errorReceived) { |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": Error message received"); |
| |
| // socket error, calling callback |
| if(vf_EPTF_HTTP_LocalTransport_socketErrorReceive != null) { |
| vf_EPTF_HTTP_LocalTransport_socketErrorReceive.apply({ |
| pl_group, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].sessionId, |
| v_EPTF_CommPort_IPL4_aspEvent.result}); |
| } |
| return; |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_receiveEventServer_default |
| // |
| // Purpose: |
| // Function to handle event reception in a server group. |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // - pl_port - *in* *integer* - port index |
| // - pl_type - *in* *integer* - event type |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_receiveEventServer_default( |
| in integer pl_group, |
| in integer pl_port, |
| in integer pl_type) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| select (pl_type) |
| { |
| case (c_EPTF_HTTP_inputIdx_connectionOpened) |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": Connection opened received"); |
| |
| var integer vl_fGIdx := v_EPTF_HTTP_Transport_portDB[pl_group].defaultFIdx; |
| var integer vl_port := -1; |
| |
| if (v_EPTF_HTTP_Transport_functionDB[vl_fGIdx].createIncomingConn.apply(pl_group, |
| v_EPTF_CommPort_IPL4_aspEvent.connOpened, |
| vl_port)) |
| { |
| if (vf_EPTF_HTTP_LocalTransport_eventReceive != null) { |
| vf_EPTF_HTTP_LocalTransport_eventReceive.apply({ |
| pl_group, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].portId, |
| pl_type}); |
| } |
| } |
| |
| return; |
| } |
| case (c_EPTF_HTTP_inputIdx_connectionClosed) |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": Connection closed received"); |
| |
| if (vf_EPTF_HTTP_LocalTransport_eventReceive != null) { |
| vf_EPTF_HTTP_LocalTransport_eventReceive.apply({ |
| pl_group, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].portId, |
| pl_type}); |
| } |
| |
| var integer vl_fGIdx := v_EPTF_HTTP_Transport_portDB[pl_group].defaultFIdx; |
| var integer vl_connId := v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].connectionId; |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].state := CLOSED; |
| f_EPTF_HTTP_Transport_socketClosed(vl_connId); |
| |
| v_EPTF_HTTP_Transport_functionDB[vl_fGIdx].removeIncomingConn.apply(pl_group, pl_port); |
| |
| return; |
| } |
| case (c_EPTF_HTTP_inputIdx_OKReceived) { |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": OK message received"); |
| |
| if (LISTENING_PORT == v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].portType) |
| { |
| if (vf_EPTF_HTTP_LocalTransport_listenSocketEvent != null) { |
| vf_EPTF_HTTP_LocalTransport_listenSocketEvent.apply({ |
| pl_group, |
| v_EPTF_HTTP_Transport_portDB[pl_group].baseLocalHostInformation, |
| pl_type}); |
| } |
| |
| }else |
| { |
| if (vf_EPTF_HTTP_LocalTransport_eventReceive != null) { |
| vf_EPTF_HTTP_LocalTransport_eventReceive.apply({ |
| pl_group, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].sessionId, |
| pl_type}); |
| } |
| } |
| |
| return; |
| } |
| case (c_EPTF_HTTP_inputIdx_errorReceived) { |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": Error message received"); |
| |
| if (LISTENING_PORT == v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].portType) |
| { |
| if (vf_EPTF_HTTP_LocalTransport_listenSocketError != null) { |
| vf_EPTF_HTTP_LocalTransport_listenSocketError.apply({ |
| pl_group, |
| v_EPTF_HTTP_Transport_portDB[pl_group].baseLocalHostInformation, |
| v_EPTF_CommPort_IPL4_aspEvent.result}); |
| } |
| |
| }else |
| { |
| // socket error, calling callback |
| if(vf_EPTF_HTTP_LocalTransport_socketErrorReceive != null) { |
| vf_EPTF_HTTP_LocalTransport_socketErrorReceive.apply({ |
| pl_group, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].sessionId, |
| v_EPTF_CommPort_IPL4_aspEvent.result}); |
| } |
| } |
| return; |
| } |
| } |
| } |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_closePortOfUser_default |
| // |
| // Purpose: |
| // Function to close the port of an HTTP user free |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // - pl_sessionId - *in* *integer* - session id |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // An HTTP user is identified internally with a unique session id. |
| // If the HTTP user sends on a port of a port group, it can close the |
| // connection of its port group |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_closePortOfUser_default( |
| in integer pl_group, |
| in integer pl_sessionId) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return; }; |
| |
| var integer vl_port; |
| |
| if (f_EPTF_int2int_HashMap_Find(v_EPTF_HTTP_Transport_sessId2PortId_HM, pl_sessionId, vl_port)) |
| { |
| f_EPTF_HTTP_Transport_closePortInGroup(pl_group, vl_port); |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].sessionId := -1; |
| } |
| else { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Port cannot be closed for session id " & |
| int2str(pl_sessionId) & " in group " & int2str(pl_group)); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_freePortOfUser_default |
| // |
| // Purpose: |
| // Function to make the port of an HTTP user free |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // - pl_sessionId - *in* *integer* - session id |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // An HTTP user is identified internally with a unique session id. |
| // If the HTTP user sends on a port of a port group, it can make the |
| // state of its port free. This case incoming messages on the port |
| // will be dropped and the port is free again for any HTTP user to use. |
| // |
| // If the port is reused by another HTTP user and the message of the |
| // last session arrives during this time, then the message will be |
| // forwaerded to the new HTTP user. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_freePortOfUser_default( |
| in integer pl_group, |
| in integer pl_sessionId) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return; }; |
| |
| var integer vl_port; |
| |
| if (f_EPTF_int2int_HashMap_Find(v_EPTF_HTTP_Transport_sessId2PortId_HM, pl_sessionId, vl_port)) |
| { |
| // administrate as IDLE port |
| if (f_EPTF_FBQ_itemIsBusy(vl_port, v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue)) |
| { |
| f_EPTF_FBQ_moveFromBusyToFreeTail(vl_port, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue); |
| |
| // if port made free again, then messages from last session are disabled |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_port].sessionId := -1; |
| } |
| } |
| else |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Port cannot be made free for session id " & |
| int2str(pl_sessionId) & " in group " & int2str(pl_group)) |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_openConnection_defaultGroup |
| // |
| // Purpose: |
| // Function to open connections within a port group |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // |
| // Return Value: |
| // *boolean* - result of connection opening |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Connection for all the ports will be opened within the port group. If |
| // one fails, all will be closed. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_openConnection_defaultGroup( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT return boolean |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return false; }; |
| |
| var boolean vl_hasMoreElement; |
| var boolean vl_success := true; |
| var integer i; //, vl_ports := sizeof(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase); |
| |
| vl_hasMoreElement := f_EPTF_FBQ_getBusyHeadIdx(i, v_EPTF_HTTP_Transport_portDB[pl_group].portQueue); |
| |
| while (vl_hasMoreElement) |
| //for (i := 0; i < vl_ports; i := i + 1) |
| { |
| if (v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[i].state == IDLE) |
| { |
| f_EPTF_Base_assert(%definitionId & |
| ": Port is in idle state but connection id is presented at " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, i), |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[i].connectionId == -1); |
| |
| if (not f_EPTF_HTTP_LocalTransport_openPortInGroup(pl_group, i)) { |
| vl_success := false; |
| break; //i := vl_ports; |
| } |
| } |
| |
| vl_hasMoreElement := f_EPTF_FBQ_getFwdBusyItemIdx(i, v_EPTF_HTTP_Transport_portDB[pl_group].portQueue); |
| } |
| |
| if (not vl_success) { |
| v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[pl_group].defaultFIdx].closeConnection.apply(pl_group); |
| } |
| |
| return vl_success; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_openPortInGroup |
| // |
| // Purpose: |
| // Auxilary function to open a connection for a given port of a given |
| // port group |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // - pl_port - *in* *integer* - port index |
| // |
| // Return Value: |
| // *boolean* - result of connection opening |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_openPortInGroup( |
| in integer pl_group, |
| in integer pl_port |
| ) |
| runs on EPTF_HTTP_LocalTransport_CT return boolean |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| var EPTF_HTTP_HostInformation vl_local, vl_remote; |
| var Result vl_result; |
| |
| vl_local := v_EPTF_HTTP_Transport_localHostInformationList[ |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].localhostInfoIdx]; |
| vl_remote := v_EPTF_HTTP_Transport_remoteHostInformationList[ |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].remotehostInfoIdx]; |
| |
| v_EPTF_HTTP_Transport_OutgoingMessage := { |
| asp_Connect := { |
| remName := vl_remote.hostIPAddress, |
| remPort := vl_remote.hostPort, |
| locName := vl_local.hostIPAddress, |
| locPort := vl_local.hostPort, |
| proto := {tcp := {}} |
| } |
| } |
| |
| vl_result:={omit,omit,omit,omit}; |
| vl_result := f_EPTF_CommPort_IPL4_send( |
| v_EPTF_HTTP_Transport_OutgoingMessage, |
| null,false,false,v_EPTF_HTTP_LocalTransport_selfName); |
| |
| if (ispresent(vl_result.errorCode) and |
| IPL4_ERROR_TEMPORARILY_UNAVAILABLE != vl_result.errorCode) |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Connection opening unsuccessful" & |
| " for port (" & log2str(vl_result) & ") at " & |
| |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, pl_port)); |
| |
| // socket error, calling callback |
| if(vf_EPTF_HTTP_LocalTransport_socketErrorReceive != null) { |
| vf_EPTF_HTTP_LocalTransport_socketErrorReceive.apply({ |
| pl_group, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].sessionId, |
| vl_result}); |
| } |
| |
| return false; |
| } |
| else { |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].connectionId := vl_result.connId; |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].state := OPENED; |
| |
| f_EPTF_HTTP_Transport_socketOpened(vl_result.connId, pl_group, pl_port); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": Connection opening successful for port at " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, pl_port) & |
| " with connection id: " & int2str(vl_result.connId)); |
| } |
| |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_openConnection_defaultPort |
| // |
| // Purpose: |
| // Function to open connection for a given port |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - port index |
| // |
| // Return Value: |
| // *boolean* - result of connection opening |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_openConnection_defaultPort( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT return boolean |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return false; }; |
| |
| if (v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[0].state != IDLE) |
| { |
| f_EPTF_Base_assert("Non-IDLE port must be busy!", |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[0].state == IDLE or |
| f_EPTF_FBQ_itemIsBusy(0, v_EPTF_HTTP_Transport_portDB[pl_group].portQueue) ); |
| |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Connection already open!"); |
| return true; // because connection is open |
| } |
| else |
| { |
| if (f_EPTF_FBQ_itemIsBusy(0, v_EPTF_HTTP_Transport_portDB[pl_group].portQueue)) |
| { |
| var Result vl_result; |
| |
| log(v_EPTF_HTTP_Transport_portDB[pl_group]); |
| |
| f_EPTF_Base_assert(%definitionId & |
| ": Port is in idle state but connection id is presented at " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, 0), |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[0].connectionId == -1); |
| |
| v_EPTF_HTTP_Transport_OutgoingMessage := { |
| asp_Connect := { |
| remName := v_EPTF_HTTP_Transport_portDB[pl_group].baseRemoteHostInformation.hostIPAddress, |
| remPort := v_EPTF_HTTP_Transport_portDB[pl_group].baseRemoteHostInformation.hostPort, |
| locName := v_EPTF_HTTP_Transport_portDB[pl_group].baseLocalHostInformation.hostIPAddress, |
| locPort := v_EPTF_HTTP_Transport_portDB[pl_group].baseLocalHostInformation.hostPort, |
| proto := {tcp := {}} |
| } |
| } |
| |
| vl_result:={omit,omit,omit,omit}; |
| vl_result := f_EPTF_CommPort_IPL4_send( |
| v_EPTF_HTTP_Transport_OutgoingMessage, |
| null,false,false,v_EPTF_HTTP_LocalTransport_selfName); |
| |
| if (ispresent(vl_result.errorCode) and |
| IPL4_ERROR_TEMPORARILY_UNAVAILABLE != vl_result.errorCode) |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Connection opening unsuccessful" & |
| " for port (" & log2str(vl_result) & ") at " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, 0)); |
| |
| // socket error, calling callback |
| if(vf_EPTF_HTTP_LocalTransport_socketErrorReceive != null) { |
| vf_EPTF_HTTP_LocalTransport_socketErrorReceive.apply({ |
| pl_group, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[0].sessionId, |
| vl_result}); |
| } |
| |
| return false; |
| } |
| else |
| { |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[0].connectionId := vl_result.connId; |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[0].state := OPENED; |
| |
| f_EPTF_HTTP_Transport_socketOpened(vl_result.connId, pl_group, 0); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": Connection opening successful for port at " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, 0) & |
| " with connection id: " & int2str(vl_result.connId)); |
| |
| return true |
| } |
| } |
| else { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Port 0 already deleted from group: " & int2str(pl_group)); |
| |
| return false; |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_listen_default |
| // |
| // Purpose: |
| // Opens a listen port in a server port group. |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - server port group index |
| // |
| // Return Value: |
| // *boolean* - result |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_listen_default( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return integer |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return -1; }; |
| |
| if (-1 != v_EPTF_HTTP_Transport_portDB[pl_group].listeningPortIdx) |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": Already listening on " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, v_EPTF_HTTP_Transport_portDB[pl_group].listeningPortIdx)); |
| return v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[v_EPTF_HTTP_Transport_portDB[pl_group].listeningPortIdx].portId; |
| } |
| |
| var charstring vl_localHost := v_EPTF_HTTP_Transport_portDB[pl_group].baseLocalHostInformation.hostIPAddress; |
| var integer vl_localPort := v_EPTF_HTTP_Transport_portDB[pl_group].baseLocalHostInformation.hostPort; |
| var ProtoTuple vl_proto := {tcp := {}} |
| if(v_EPTF_HTTP_Transport_portDB[pl_group].useSSL) { |
| vl_proto := {ssl := {}}; |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": Using SSL."); |
| } |
| v_EPTF_HTTP_Transport_OutgoingMessage := { |
| asp_Listen := { |
| locName := vl_localHost, |
| locPort := vl_localPort, |
| proto := vl_proto |
| } |
| } |
| |
| v_resultNoWarning := f_EPTF_CommPort_IPL4_send( |
| v_EPTF_HTTP_Transport_OutgoingMessage, |
| null,false,false,v_EPTF_HTTP_LocalTransport_selfName); |
| |
| if (ispresent(v_resultNoWarning.errorCode)) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Listening unsuccessful for port (" & log2str(v_resultNoWarning) & ") at " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, 0)); |
| |
| return -1; |
| } |
| |
| var integer vl_fbqIdx := -1; |
| vl_fbqIdx := f_EPTF_FBQ_getOrCreateFreeSlot(v_EPTF_HTTP_Transport_portDB[pl_group].portQueue); |
| var Result vl_result; |
| |
| vl_result := f_EPTF_CommPort_IPL4_setUserData(v_resultNoWarning.connId, v_resultNoWarning.connId); |
| |
| f_EPTF_HTTP_Transport_socketOpened(v_resultNoWarning.connId, pl_group, vl_fbqIdx); |
| |
| f_EPTF_FBQ_moveFromFreeToBusyTail(vl_fbqIdx, v_EPTF_HTTP_Transport_portDB[pl_group].portQueue) |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx] := c_EPTF_HTTP_LocalTransport_initPortInfo; |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].groupIndex := pl_group; // FIXME check |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].portIndex := vl_fbqIdx; // FIXME check |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].portType := LISTENING_PORT; |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].state := OPENED; |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].portId := f_EPTF_HTTP_Transport_generatePortId(pl_group); |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].connectionId := v_resultNoWarning.connId; |
| v_EPTF_HTTP_Transport_portDB[pl_group].listeningPortIdx := vl_fbqIdx; |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].numberOfPorts := v_EPTF_HTTP_Transport_portDB[pl_group].numberOfPorts + 1; |
| |
| f_EPTF_int2int_HashMap_Insert(v_EPTF_HTTP_Transport_portId2Idx_HM, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].portId, vl_fbqIdx); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": Listening successful on " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, vl_fbqIdx) & |
| " with connection id: " & int2str(v_resultNoWarning.connId)); |
| |
| return v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].portId; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_createIncomingConn_default |
| // |
| // Purpose: |
| // Creates an incoming connection in the port group. |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - port group index |
| // - pl_connOpened - *in* <ConnectionOpenedEvent> - connection opened event |
| // - pl_port - *inout* *integer* - the index of the created port |
| // |
| // Return Value: |
| // boolean - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_createIncomingConn_default( |
| in integer pl_group, |
| in ConnectionOpenedEvent pl_connOpened, |
| inout integer pl_port) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return boolean |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return false;}; |
| |
| var integer vl_fbqIdx := -1, vl_rhIdx := -1; |
| var EPTF_HTTP_HostInformation vl_rhostInformation := {"", -1}; |
| |
| vl_rhostInformation.hostIPAddress := pl_connOpened.remName; |
| vl_rhostInformation.hostPort := pl_connOpened.remPort; |
| vl_rhIdx := f_EPTF_HTTP_LocalTransport_addRemoteHostInformation(vl_rhostInformation); |
| |
| vl_fbqIdx := f_EPTF_FBQ_getOrCreateFreeSlot(v_EPTF_HTTP_Transport_portDB[pl_group].portQueue); |
| |
| f_EPTF_FBQ_moveFromFreeToBusyTail(vl_fbqIdx, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portQueue); |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].numberOfPorts := v_EPTF_HTTP_Transport_portDB[pl_group].numberOfPorts + 1; |
| |
| // set port data to port info database |
| if (sizeof(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase) <= vl_fbqIdx) |
| { |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx] := c_EPTF_HTTP_LocalTransport_initPortInfo; |
| } |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].groupIndex := pl_group; // FIXME check |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].portIndex := vl_fbqIdx; // FIXME check |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].connectionId := pl_connOpened.connId; |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].portId := f_EPTF_HTTP_Transport_generatePortId(pl_group); |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].portType := INCOMING_PORT; |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].state := OPENED; |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].remotehostInfoIdx := vl_rhIdx; |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].buffer := v_EPTF_HTTP_Transport_portDB[pl_group].buffer; |
| if (v_EPTF_HTTP_Transport_portDB[pl_group].buffer and omit == v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].messageBuffer) |
| { |
| f_EPTF_HTTP_MsgBuffer_init( |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].messageBuffer, |
| v_EPTF_HTTP_Transport_bufferSize, |
| vl_fbqIdx); |
| } |
| |
| f_EPTF_HTTP_Transport_socketOpened(pl_connOpened.connId, pl_group, vl_fbqIdx); |
| |
| f_EPTF_int2int_HashMap_Insert(v_EPTF_HTTP_Transport_portId2Idx_HM, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[vl_fbqIdx].portId, vl_fbqIdx); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": New incoming connection added to " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, vl_fbqIdx)); |
| |
| pl_port := vl_fbqIdx; |
| |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_removeIncomingConn_default |
| // |
| // Purpose: |
| // Removes an incoming connection from the server port group. |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - port group index |
| // - pl_port - *in* *integer* - the index of the port to remove |
| // |
| // Return Value: |
| // boolean - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_removeIncomingConn_default( |
| in integer pl_group, |
| in integer pl_port) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| f_EPTF_HTTP_LocalTransport_removeServerPort(pl_group, pl_port); |
| |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_closePort_default |
| // |
| // Purpose: |
| // Closes a connection. |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - port group index |
| // - pl_portId - *in* *integer* - port identifier |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_closePort_default( |
| in integer pl_group, |
| in integer pl_portId) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return; }; |
| |
| var integer vl_port := -1; |
| |
| if (not f_EPTF_int2int_HashMap_Find(v_EPTF_HTTP_Transport_portId2Idx_HM, pl_portId, vl_port)) |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Could not find port identifier!" & |
| log2str(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase)); |
| return; |
| } |
| |
| f_EPTF_HTTP_LocalTransport_removeServerPort(pl_group, vl_port); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_removeServerPort |
| // |
| // Purpose: |
| // Removes a port from the server group. |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - port group index |
| // - pl_port - *in* *integer* - port index |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_removeServerPort( |
| in integer pl_group, |
| in integer pl_port) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return; }; |
| |
| if (f_EPTF_FBQ_itemIsBusy(pl_port, v_EPTF_HTTP_Transport_portDB[pl_group].portQueue)) |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Removing port from group: " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, pl_port)); |
| |
| if (CLOSED != v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].state) |
| { |
| var integer vl_connId := v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].connectionId; |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Closing connection with id " & int2str(vl_connId)); |
| |
| v_EPTF_HTTP_Transport_OutgoingMessage := { |
| asp_Close := { |
| id := vl_connId, |
| proto := {tcp := {}} |
| } |
| } |
| |
| v_resultNoWarning := f_EPTF_CommPort_IPL4_send( |
| v_EPTF_HTTP_Transport_OutgoingMessage, |
| null, false, false, v_EPTF_HTTP_LocalTransport_selfName); |
| |
| f_EPTF_HTTP_Transport_socketClosed(vl_connId); |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].state := CLOSED; |
| } |
| |
| f_EPTF_int2int_HashMap_Erase(v_EPTF_HTTP_Transport_portId2Idx_HM, v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].portId); |
| |
| f_EPTF_FBQ_moveFromBusyToFreeTail(pl_port, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portQueue); |
| |
| if (omit == v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].messageBuffer) |
| { |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port] := c_EPTF_HTTP_LocalTransport_initPortInfo; |
| }else |
| { |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].groupIndex := c_EPTF_HTTP_LocalTransport_initPortInfo.groupIndex; |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].portIndex := c_EPTF_HTTP_LocalTransport_initPortInfo.portIndex; |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].connectionId := c_EPTF_HTTP_LocalTransport_initPortInfo.connectionId; |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].sessionId := c_EPTF_HTTP_LocalTransport_initPortInfo.sessionId; |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].portId := c_EPTF_HTTP_LocalTransport_initPortInfo.portId; |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].localhostInfoIdx := c_EPTF_HTTP_LocalTransport_initPortInfo.localhostInfoIdx; |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].remotehostInfoIdx := |
| c_EPTF_HTTP_LocalTransport_initPortInfo.remotehostInfoIdx; |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].state := c_EPTF_HTTP_LocalTransport_initPortInfo.state; |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].portType := c_EPTF_HTTP_LocalTransport_initPortInfo.portType; |
| |
| f_EPTF_HTTP_MsgBuffer_clear(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].messageBuffer); |
| } |
| v_EPTF_HTTP_Transport_portDB[pl_group].numberOfPorts := v_EPTF_HTTP_Transport_portDB[pl_group].numberOfPorts - 1; |
| v_EPTF_HTTP_Transport_portDB[pl_group].listeningPortIdx := -1; |
| |
| } |
| else |
| { |
| f_EPTF_HTTP_Transport_warning(log2str(%definitionId & |
| ": Error removing incoming connection: port(",pl_port,") is not busy : " & |
| int2str(pl_group) & " - " & |
| v_EPTF_HTTP_Transport_portDB[pl_group].name & "; ", |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port])); |
| } |
| |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_closeConnection_defaultGroup |
| // |
| // Purpose: |
| // Function to close connections for a given port group |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - port index |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // All open ports within the port group will be closed |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_closeConnection_defaultGroup( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return; }; |
| |
| var boolean vl_hasMoreElement; |
| var integer i; |
| |
| //vl_ports := sizeof(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase); |
| vl_hasMoreElement := f_EPTF_FBQ_getBusyHeadIdx(i, v_EPTF_HTTP_Transport_portDB[pl_group].portQueue); |
| while (vl_hasMoreElement) |
| //for (i := 0; i < vl_ports; i := i + 1); |
| { |
| f_EPTF_HTTP_Transport_closePortInGroup(pl_group, i); |
| |
| vl_hasMoreElement := f_EPTF_FBQ_getFwdBusyItemIdx(i, v_EPTF_HTTP_Transport_portDB[pl_group].portQueue); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Transport_closePortInGroup |
| // |
| // Purpose: |
| // Auxialry funtion to close a given port of a given port group |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // - pl_port - *in* *integer* - port index |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Transport_closePortInGroup( |
| in integer pl_group, |
| in integer pl_port) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].state != IDLE) |
| { |
| var integer vl_connId := v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].connectionId; |
| |
| f_EPTF_Base_assert(%definitionId & |
| ": Port is not in IDLE state but connection id is missing at " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, pl_port), |
| vl_connId != -1); |
| |
| v_EPTF_HTTP_Transport_OutgoingMessage := { |
| asp_Close := { |
| id := vl_connId, |
| proto := {tcp := {}} |
| } |
| } |
| |
| v_resultNoWarning := f_EPTF_CommPort_IPL4_send( |
| v_EPTF_HTTP_Transport_OutgoingMessage, |
| null, false, false, v_EPTF_HTTP_LocalTransport_selfName); |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].connectionId := -1; |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].state := IDLE; |
| |
| f_EPTF_HTTP_Transport_socketClosed(vl_connId); |
| |
| // administrate port as free |
| //if (f_EPTF_FBQ_itemIsBusy(pl_port, v_EPTF_HTTP_Transport_portDB[pl_group].portQueue)) { |
| // f_EPTF_FBQ_moveFromBusyToFreeTail(pl_port, |
| // v_EPTF_HTTP_Transport_portDB[pl_group].portQueue); |
| //} |
| |
| // administrate as IDLE port |
| if (f_EPTF_FBQ_itemIsBusy(pl_port, v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue)) { |
| f_EPTF_FBQ_moveFromBusyToFreeTail(pl_port, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue); |
| } |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Connection (" & |
| int2str(vl_connId) & ") closed for port at " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, pl_port)); |
| } |
| else |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Connection (" & |
| int2str(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].connectionId) & |
| ") is already closed for port at " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, pl_port)); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_closeConnection_defaultPort |
| // |
| // Purpose: |
| // Function to close connection of a port |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - port index |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_closeConnection_defaultPort( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return; }; |
| |
| var integer vl_connId; |
| |
| if (v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[0].state == IDLE) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Connection already closed!"); |
| return; |
| } |
| else |
| { |
| vl_connId := v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[0].connectionId; |
| |
| log(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[0]); |
| |
| f_EPTF_Base_assert(%definitionId & |
| ": Port is not in IDLE state but connection id is missing at " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, 0), |
| vl_connId != -1); |
| |
| v_EPTF_HTTP_Transport_OutgoingMessage := { |
| asp_Close := { |
| id := vl_connId, |
| proto := {tcp := {}} |
| } |
| } |
| |
| v_resultNoWarning := f_EPTF_CommPort_IPL4_send( |
| v_EPTF_HTTP_Transport_OutgoingMessage, |
| null, false, false, v_EPTF_HTTP_LocalTransport_selfName); |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[0].connectionId := -1; |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[0].state := IDLE; |
| |
| f_EPTF_HTTP_Transport_socketClosed(vl_connId); |
| |
| // administrate port as free |
| //if (f_EPTF_FBQ_itemIsBusy(0, v_EPTF_HTTP_Transport_portDB[pl_group].portQueue)) { |
| // f_EPTF_FBQ_moveFromBusyToFreeTail(0, |
| // v_EPTF_HTTP_Transport_portDB[pl_group].portQueue); |
| //} |
| |
| // administrate as IDLE port |
| if (f_EPTF_FBQ_itemIsBusy(0, v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue)) { |
| f_EPTF_FBQ_moveFromBusyToFreeTail(0, |
| v_EPTF_HTTP_Transport_portDB[pl_group].portStateQueue); |
| } |
| } |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Connection (" & |
| int2str(vl_connId) & ") closed for port at " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, 0)); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_halfCloseConnection_defaultGroup |
| // |
| // Purpose: |
| // Function to half close connections for a given port group |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - port index |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // State of all opened ports will be set to half closed |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_halfCloseConnection_defaultGroup( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return; }; |
| |
| var boolean vl_hasMoreElement; |
| var integer i; //, vl_ports; |
| |
| //vl_ports := sizeof(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase); |
| |
| vl_hasMoreElement := f_EPTF_FBQ_getBusyHeadIdx(i, v_EPTF_HTTP_Transport_portDB[pl_group].portQueue); |
| while (vl_hasMoreElement) |
| //for (i := 0; i < vl_ports; i := i + 1) |
| { |
| if (v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[i].state != IDLE and |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[i].state != HALFCLOSED) |
| { |
| f_EPTF_Base_assert(%definitionId & |
| ": Port is not in IDLE/HALFCLOSED state but connection id is missing at " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, i), |
| -1 != v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[i].connectionId); |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[i].state := HALFCLOSED; |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Port state is set to " & |
| "half closed at " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, i)); |
| } |
| |
| vl_hasMoreElement := f_EPTF_FBQ_getFwdBusyItemIdx(i, v_EPTF_HTTP_Transport_portDB[pl_group].portQueue); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_halfCloseConnection_defaultPort |
| // |
| // Purpose: |
| // Auxialry funtion to close a given port |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - port index |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_halfCloseConnection_defaultPort( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return; }; |
| |
| if (v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[0].state != IDLE and |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[0].state != HALFCLOSED and |
| f_EPTF_FBQ_itemIsBusy(0, v_EPTF_HTTP_Transport_portDB[pl_group].portQueue)) |
| { |
| f_EPTF_Base_assert(%definitionId & |
| ": Port is not in IDLE/HALFCLOSED state but connection id is missing at " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, 0), |
| -1 != v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[0].connectionId); |
| |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[0].state := HALFCLOSED; |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Port state is set to " & |
| "half closed at " & |
| f_EPTF_HTTP_LocalTransport_createGroupPortInfoString(pl_group, 0)); |
| } |
| else |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Connection already half closed!"); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_createGroupPortInfoString |
| // |
| // Purpose: |
| // Helper function to create port information string for logging |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // - pl_port - *in* *integer* - port index |
| // |
| // Return Value: |
| // *charstring* - the created information string |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Information string will be 'group (<group index>) - <group name> at |
| // port index <port index>: Local: <local host information> / Remote: |
| // <remote host information>' |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_createGroupPortInfoString( |
| in integer pl_group, |
| in integer pl_port) |
| runs on EPTF_HTTP_LocalTransport_CT return charstring |
| { |
| var EPTF_HTTP_HostInformation vl_local := {"", -1}, vl_remote := {"", -1}; |
| if( sizeof(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase) > pl_port ) { |
| var integer vl_localIdx := v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].localhostInfoIdx; |
| var integer vl_remoteIdx := v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].remotehostInfoIdx; |
| |
| if (0 <= vl_localIdx) |
| { |
| vl_local := v_EPTF_HTTP_Transport_localHostInformationList[ |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].localhostInfoIdx]; |
| }else{ |
| vl_local := v_EPTF_HTTP_Transport_portDB[pl_group].baseLocalHostInformation |
| } |
| |
| if (0 <= vl_remoteIdx) |
| { |
| vl_remote := v_EPTF_HTTP_Transport_remoteHostInformationList[ |
| v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].remotehostInfoIdx]; |
| } |
| } else { |
| f_EPTF_HTTP_Transport_debug(%definitionId & " Not fully initialized portDB: v_EPTF_HTTP_Transport_portDB:" & |
| log2str(v_EPTF_HTTP_Transport_portDB) & " pl_group: " & log2str(pl_group) & " pl_port: " & log2str(pl_port)); |
| } |
| return "group (" & int2str(pl_group) & ") - " & v_EPTF_HTTP_Transport_portDB[pl_group].name & |
| " at port index " & int2str(pl_port) & |
| ": Local: " & log2str(vl_local) & " / Remote: " & log2str(vl_remote); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_createUniqueGroupName |
| // |
| // Purpose: |
| // Creates a unique group name for port groups |
| // |
| // Parameters: |
| // - pl_basename - *in* *charstring* - base name for port names |
| // |
| // Return Value: |
| // - charstring - the created group name |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // The function appends a number to the provided pl_basename and increases |
| // the attached number till the created name will be unique |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_createUniqueGroupName( |
| in charstring pl_basename) |
| runs on EPTF_HTTP_LocalTransport_CT return charstring |
| { |
| var integer vl_dummy; |
| var charstring vl_groupName := pl_basename & "." & int2str(v_nameIdx); |
| |
| while (f_EPTF_str2int_HashMap_Find(v_EPTF_HTTP_Transport_groupName2Idx_HM, |
| vl_groupName, vl_dummy)) |
| { |
| v_nameIdx := v_nameIdx + 1; |
| vl_groupName := pl_basename & "." & int2str(v_nameIdx); |
| } |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": Unique group name created: " & vl_groupName); |
| |
| return vl_groupName; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_registerGroupFunctions |
| // |
| // Purpose: |
| // Registers handler functions to a port group |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // - pl_portMode - *in* *boolean* - port group creation mode |
| // (port/group mode) |
| // - pl_funcs - *in* <EPTF_HTTP_Transport_UserFunctions> - record |
| // containing function references of handler functions |
| // |
| // Return Value: |
| // *charstring* - the created group name |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // The function should be applied to an already created port group with |
| // set instant connection close, instant connection open parameters. |
| // |
| // If the port group which the function is applied to has a set |
| // handler function reference index (defaultFIdx != -1), then the functions |
| // which are set in pl_funcs will be used to overdefine the default |
| // handler functions. The ones that are omit in pl_funcs will be left |
| // unchanged. |
| // |
| // If the port group which the function is applied to doesn't have a set |
| // handler function reference index (defaultFIdx != -1), then all the |
| // handler functions will be redefined. If a function reference is omit in |
| // pl_funcs, the handler function will be overdefined with default functions |
| // based on instant connection close, instant connection open parameters |
| // of the port group, otherwise the set function reference will be used to |
| // redefine the handler function. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_registerGroupFunctions( |
| in integer pl_group, |
| in boolean pl_portMode, |
| in EPTF_HTTP_Transport_UserFunctions pl_funcs) |
| runs on EPTF_HTTP_LocalTransport_CT return integer |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return -1; }; |
| |
| var integer vl_index; |
| var charstring vl_key; |
| var EPTF_HTTP_Transport_Function vl_funcs := c_HTTP_Transport_initFunction; |
| |
| f_EPTF_Base_assert(%definitionId & |
| ": Group not yet initialized (" & int2str(pl_group) & ")", |
| pl_group < sizeof(v_EPTF_HTTP_Transport_portDB) and f_EPTF_FBQ_itemIsBusy(pl_group, v_EPTF_HTTP_Transport_groupQueue)); |
| |
| // checks if function group has been checked before |
| var boolean vl_override := v_EPTF_HTTP_Transport_portDB[pl_group].defaultFIdx == -1; |
| var boolean vl_iconn := v_EPTF_HTTP_Transport_portDB[pl_group].instantConnOpen; |
| var boolean vl_iclose := v_EPTF_HTTP_Transport_portDB[pl_group].instantConnClose; |
| |
| // creates new candidate function group for the the port group |
| if (ispresent(pl_funcs.addPort) and pl_funcs.addPort != null) { |
| vl_funcs.addPort := pl_funcs.addPort; |
| } else { |
| if (vl_override) { |
| vl_funcs.addPort := refers(f_EPTF_HTTP_LocalTransport_addPortToGroup_default); |
| } |
| } |
| |
| if (ispresent(pl_funcs.removePort) and pl_funcs.removePort != null) { |
| vl_funcs.removePort := pl_funcs.removePort; |
| } else { |
| if (vl_override) { |
| vl_funcs.removePort := refers(f_EPTF_HTTP_LocalTransport_removePortFromGroup_default); |
| } |
| } |
| |
| if (ispresent(pl_funcs.selectPort) and pl_funcs.selectPort != null) |
| { |
| vl_funcs.selectPort := pl_funcs.selectPort; |
| } else { |
| if (vl_override) { |
| if (pl_portMode) { |
| vl_funcs.selectPort := refers( |
| f_EPTF_HTTP_LocalTransport_selectPortInGroup_defaultPort); |
| } |
| else { |
| vl_funcs.selectPort := refers( |
| f_EPTF_HTTP_LocalTransport_selectPortInGroup_defaultGroup); |
| } |
| } |
| } |
| |
| /* MOVED TO COMPONENT VARIABLE vf_getGroupAndPort |
| if (ispresent(pl_funcs.getGroupAndPort) and pl_funcs.getGroupAndPort != null) |
| { |
| vl_funcs.getGroupAndPort := pl_funcs.getGroupAndPort; |
| } |
| else { |
| if (vl_override) { |
| if (pl_portMode) { |
| vl_funcs.getGroupAndPort := refers( |
| f_EPTF_HTTP_LocalTransport_getGroupAndPort_defaultGroup); |
| } |
| else { |
| vl_funcs.getGroupAndPort := refers( |
| f_EPTF_HTTP_LocalTransport_getGroupAndPort_defaultPort); |
| } |
| } |
| } |
| */ |
| |
| if (ispresent(pl_funcs.sendMessage) and pl_funcs.sendMessage != null) |
| { |
| vl_funcs.sendMessage := pl_funcs.sendMessage; |
| } |
| else { |
| if (vl_override) { |
| if (vl_iconn) { |
| vl_funcs.sendMessage := refers( |
| f_EPTF_HTTP_LocalTransport_sendMessage_default_IC); |
| } |
| else { |
| vl_funcs.sendMessage := refers( |
| f_EPTF_HTTP_LocalTransport_sendMessage_default_NIC); |
| } |
| } |
| } |
| |
| if (ispresent(pl_funcs.closePortOfUser) and pl_funcs.closePortOfUser != null) |
| { |
| vl_funcs.closePortOfUser := pl_funcs.closePortOfUser; |
| } |
| else { |
| if (vl_override) { |
| vl_funcs.closePortOfUser := refers(f_EPTF_HTTP_LocalTransport_closePortOfUser_default); |
| } |
| } |
| |
| if (ispresent(pl_funcs.freePortOfUser) and pl_funcs.freePortOfUser != null) |
| { |
| vl_funcs.freePortOfUser := pl_funcs.freePortOfUser; |
| } |
| else { |
| if (vl_override) { |
| vl_funcs.freePortOfUser := refers(f_EPTF_HTTP_LocalTransport_freePortOfUser_default); |
| } |
| } |
| |
| if (ispresent(pl_funcs.openPort) and pl_funcs.openPort != null) |
| { |
| vl_funcs.openPort := pl_funcs.openPort; |
| } |
| else { |
| if (vl_override) { |
| if (pl_portMode) { |
| vl_funcs.openPort := refers( |
| f_EPTF_HTTP_LocalTransport_openConnection_defaultPort); |
| } |
| else { |
| vl_funcs.openPort := refers( |
| f_EPTF_HTTP_LocalTransport_openConnection_defaultGroup); |
| } |
| } |
| } |
| |
| |
| if (ispresent(pl_funcs.closeConnection) and pl_funcs.closeConnection != null) |
| { |
| vl_funcs.closeConnection := pl_funcs.closeConnection; |
| } |
| else { |
| if (vl_override) { |
| if (pl_portMode) { |
| vl_funcs.closeConnection := refers( |
| f_EPTF_HTTP_LocalTransport_closeConnection_defaultPort); |
| } |
| else { |
| vl_funcs.closeConnection := refers( |
| f_EPTF_HTTP_LocalTransport_closeConnection_defaultGroup); |
| } |
| } |
| } |
| |
| if (ispresent(pl_funcs.halfClosePort) and pl_funcs.halfClosePort != null) |
| { |
| vl_funcs.halfClosePort := pl_funcs.halfClosePort; |
| } |
| else { |
| if (vl_override) { |
| if (pl_portMode) { |
| vl_funcs.halfClosePort := refers( |
| f_EPTF_HTTP_LocalTransport_halfCloseConnection_defaultPort); |
| } |
| else { |
| vl_funcs.halfClosePort := refers( |
| f_EPTF_HTTP_LocalTransport_halfCloseConnection_defaultGroup); |
| } |
| } |
| } |
| |
| if (ispresent(pl_funcs.receiveMessage) and pl_funcs.receiveMessage != null) { |
| vl_funcs.receiveMessage := pl_funcs.receiveMessage; |
| } |
| else { |
| if (vl_override) { |
| if (vl_iclose) { |
| vl_funcs.receiveMessage := refers( |
| f_EPTF_HTTP_LocalTransport_receiveMessage_default_IC); |
| } |
| else { |
| vl_funcs.receiveMessage := refers( |
| f_EPTF_HTTP_LocalTransport_receiveMessage_default_NIC); |
| } |
| } |
| } |
| |
| if (ispresent(pl_funcs.receiveEvent) and pl_funcs.receiveEvent != null) { |
| vl_funcs.receiveEvent := pl_funcs.receiveEvent; |
| } |
| else { |
| if (vl_override) { |
| vl_funcs.receiveEvent := refers(f_EPTF_HTTP_LocalTransport_receiveEvent_default); |
| } |
| } |
| |
| // creates a hash map key from the function group |
| vl_key := log2str(vl_funcs) |
| |
| // if function group is already existing, then return id |
| if (f_EPTF_str2int_HashMap_Find(v_EPTF_HTTP_Transport_functions2Idx_HM, |
| vl_key, vl_index)) |
| { |
| return vl_index; |
| } |
| |
| // if function group was not existing, then add new element |
| vl_index := sizeof(v_EPTF_HTTP_Transport_functionDB); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": New database index: " & int2str(vl_index) & |
| " for functions: " & vl_key); |
| |
| v_EPTF_HTTP_Transport_functionDB[vl_index] := vl_funcs; |
| |
| f_EPTF_str2int_HashMap_Insert(v_EPTF_HTTP_Transport_functions2Idx_HM, |
| vl_key, vl_index); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Functions are registered to group (" & |
| int2str(pl_group) & " - " & v_EPTF_HTTP_Transport_portDB[pl_group].name & ": " & vl_key & |
| " at position " & int2str(vl_index) & " in function database!"); |
| |
| return vl_index; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_registerServerGroupFunctions |
| // |
| // Purpose: |
| // Registers handler functions to a server port group |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // - pl_funcs - *in* <EPTF_HTTP_Transport_ServerUserFunctions> - record |
| // containing function references of handler functions |
| // |
| // Return Value: |
| // *charstring* - the created group name |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // The function should be applied to an already created port group with |
| // set instant connection close, instant connection open parameters. |
| // |
| // If the port group which the function is applied to has a set |
| // handler function reference index (defaultFIdx != -1), then the functions |
| // which are set in pl_funcs will be used to overdefine the default |
| // handler functions. The ones that are omit in pl_funcs will be left |
| // unchanged. |
| // |
| // If the port group which the function is applied to doesn't have a set |
| // handler function reference index (defaultFIdx != -1), then all the |
| // handler functions will be redefined. If a function reference is omit in |
| // pl_funcs, the handler function will be overdefined with default functions |
| // based on instant connection close, instant connection open parameters |
| // of the port group, otherwise the set function reference will be used to |
| // redefine the handler function. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_registerServerGroupFunctions( |
| in integer pl_group, |
| in EPTF_HTTP_Transport_ServerUserFunctions pl_funcs) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return integer |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_group)) { return -1; }; |
| |
| var integer vl_index; |
| var charstring vl_key; |
| var EPTF_HTTP_Transport_Function vl_funcs := c_HTTP_Transport_initFunction; |
| |
| f_EPTF_Base_assert(%definitionId & |
| ": Group not yet initialized (" & int2str(pl_group) & ")", |
| pl_group < sizeof(v_EPTF_HTTP_Transport_portDB) and f_EPTF_FBQ_itemIsBusy(pl_group, v_EPTF_HTTP_Transport_groupQueue)); |
| |
| // checks if function group has been checked before |
| var boolean vl_override := v_EPTF_HTTP_Transport_portDB[pl_group].defaultFIdx == -1; |
| var boolean vl_iclose := v_EPTF_HTTP_Transport_portDB[pl_group].instantConnClose; |
| |
| if (ispresent(pl_funcs.removePort) and pl_funcs.removePort != null) { |
| vl_funcs.removePort := pl_funcs.removePort; |
| } else { |
| if (vl_override) { |
| vl_funcs.removePort := refers(f_EPTF_HTTP_LocalTransport_removePortFromGroupServer_default); |
| } |
| } |
| |
| if (ispresent(pl_funcs.listen) and pl_funcs.listen != null){ |
| vl_funcs.listen := pl_funcs.listen; |
| }else{ |
| if (vl_override) { |
| vl_funcs.listen := refers(f_EPTF_HTTP_LocalTransport_listen_default); |
| } |
| } |
| |
| if (ispresent(pl_funcs.createIncomingConn) and pl_funcs.createIncomingConn != null){ |
| vl_funcs.createIncomingConn := pl_funcs.createIncomingConn; |
| }else{ |
| if (vl_override) { |
| vl_funcs.createIncomingConn := refers(f_EPTF_HTTP_LocalTransport_createIncomingConn_default); |
| } |
| } |
| |
| if (ispresent(pl_funcs.removeIncomingConn) and pl_funcs.removeIncomingConn != null){ |
| vl_funcs.removeIncomingConn := pl_funcs.removeIncomingConn; |
| }else{ |
| if (vl_override) { |
| vl_funcs.removeIncomingConn := refers(f_EPTF_HTTP_LocalTransport_removeIncomingConn_default); |
| } |
| } |
| |
| if (ispresent(pl_funcs.receiveEvent) and pl_funcs.receiveEvent != null) { |
| vl_funcs.receiveEvent := pl_funcs.receiveEvent; |
| } |
| else { |
| if (vl_override) { |
| vl_funcs.receiveEvent := refers(f_EPTF_HTTP_LocalTransport_receiveEventServer_default); |
| } |
| } |
| |
| if (ispresent(pl_funcs.receiveMessage) and pl_funcs.receiveMessage != null) { |
| vl_funcs.receiveMessage := pl_funcs.receiveMessage; |
| } |
| else { |
| if (vl_override) { |
| vl_funcs.receiveMessage := refers( |
| f_EPTF_HTTP_LocalTransport_receiveMessageServer_default); |
| } |
| } |
| |
| if (ispresent(pl_funcs.sendResponse) and pl_funcs.sendResponse != null) |
| { |
| vl_funcs.sendResponse := pl_funcs.sendResponse; |
| } |
| else { |
| if (vl_override) { |
| if (vl_iclose) { |
| vl_funcs.sendResponse := refers( |
| f_EPTF_HTTP_LocalTransport_sendResponse_default_IC); |
| } |
| else { |
| vl_funcs.sendResponse := refers( |
| f_EPTF_HTTP_LocalTransport_sendResponse_default_NIC); |
| } |
| } |
| } |
| |
| if (ispresent(pl_funcs.closePort) and pl_funcs.listen != null){ |
| vl_funcs.closePort := pl_funcs.closePort; |
| }else{ |
| if (vl_override) { |
| vl_funcs.closePort := refers(f_EPTF_HTTP_LocalTransport_closePort_default); |
| } |
| } |
| |
| // creates a hash map key from the function group |
| vl_key := log2str(vl_funcs) |
| |
| // if function group is already existing, then return id |
| if (f_EPTF_str2int_HashMap_Find(v_EPTF_HTTP_Transport_functions2Idx_HM, |
| vl_key, vl_index)) |
| { |
| return vl_index; |
| } |
| |
| // if function group was not existing, then add new element |
| vl_index := sizeof(v_EPTF_HTTP_Transport_functionDB); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": New database index: " & int2str(vl_index) & |
| " for functions: " & vl_key); |
| |
| v_EPTF_HTTP_Transport_functionDB[vl_index] := vl_funcs; |
| |
| f_EPTF_str2int_HashMap_Insert(v_EPTF_HTTP_Transport_functions2Idx_HM, |
| vl_key, vl_index); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Functions are registered to group (" & |
| int2str(pl_group) & " - " & v_EPTF_HTTP_Transport_portDB[pl_group].name & ": " & vl_key & |
| " at position " & int2str(vl_index) & " in function database!"); |
| |
| return vl_index; |
| |
| } |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_checkGroup |
| // |
| // Purpose: |
| // Check the state of a port group |
| // |
| // Parameters: |
| // - pl_group - *in* *integer* - group index |
| // |
| // Return Value: |
| // *boolean* - true if group is okay, false otherwise |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Check group index and group occupation state |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_checkGroup( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT return boolean |
| { |
| if (pl_group == -1) { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Group does not exist!"); |
| return false; |
| } |
| |
| if (sizeof(v_EPTF_HTTP_Transport_portDB) <= pl_group) { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Invalid group index: " & |
| int2str(pl_group)); |
| return false; |
| } |
| |
| if (not f_EPTF_FBQ_itemIsBusy(pl_group, v_EPTF_HTTP_Transport_groupQueue)) { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": Group already deleted: " & |
| int2str(pl_group) & " - " & v_EPTF_HTTP_Transport_portDB[pl_group].name); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_addLocalHostInformation |
| // |
| // Purpose: |
| // Function to add new Local Host Information to the LocalHostInformation database |
| // |
| // Parameters: |
| // pl_hostInformation - *in* - <EPTF_HTTP_HostInformation> - The local host information |
| // |
| // Return Value: |
| // *integer* - the index of the database record |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_addLocalHostInformation ( |
| in EPTF_HTTP_HostInformation pl_hostInformation) |
| runs on EPTF_HTTP_LocalTransport_CT return integer |
| { |
| var integer vl_EPTF_HTTP_index; |
| |
| if (f_EPTF_str2int_HashMap_Find(v_EPTF_HTTP_Transport_localHostHashMap, |
| pl_hostInformation.hostIPAddress&int2str(pl_hostInformation.hostPort), |
| vl_EPTF_HTTP_index)) |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": Local HostIPAddress already exists: "&int2str(vl_EPTF_HTTP_index)); |
| } |
| else |
| { |
| vl_EPTF_HTTP_index := sizeof(v_EPTF_HTTP_Transport_localHostInformationList); |
| |
| f_EPTF_str2int_HashMap_Insert(v_EPTF_HTTP_Transport_localHostHashMap, |
| pl_hostInformation.hostIPAddress&int2str(pl_hostInformation.hostPort), |
| vl_EPTF_HTTP_index); |
| |
| v_EPTF_HTTP_Transport_localHostInformationList[vl_EPTF_HTTP_index] := pl_hostInformation; |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": Local HostIPAddress does not exist, now added: "&int2str(vl_EPTF_HTTP_index)); |
| } |
| |
| return vl_EPTF_HTTP_index; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_addRemoteHostInformation |
| // |
| // Purpose: |
| // Function to add new Remote Host Information to the LocalHostInformation database |
| // |
| // Parameters: |
| // pl_hostInformation - *in* - <EPTF_HTTP_HostInformation> - The remote host information |
| // |
| // Return Value: |
| // *integer* - the index of the database record |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_addRemoteHostInformation ( |
| in EPTF_HTTP_HostInformation pl_hostInformation) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return integer |
| { |
| var integer vl_EPTF_HTTP_index; |
| |
| if (f_EPTF_str2int_HashMap_Find(v_EPTF_HTTP_Transport_remoteHostHashMap, |
| pl_hostInformation.hostIPAddress&int2str(pl_hostInformation.hostPort), |
| vl_EPTF_HTTP_index)) |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": Remote HostIPAddress already exists: "&int2str(vl_EPTF_HTTP_index)); |
| } |
| else |
| { |
| vl_EPTF_HTTP_index := sizeof(v_EPTF_HTTP_Transport_remoteHostInformationList); |
| |
| f_EPTF_str2int_HashMap_Insert(v_EPTF_HTTP_Transport_remoteHostHashMap, |
| pl_hostInformation.hostIPAddress&int2str(pl_hostInformation.hostPort), |
| vl_EPTF_HTTP_index); |
| |
| v_EPTF_HTTP_Transport_remoteHostInformationList[vl_EPTF_HTTP_index] := pl_hostInformation; |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": Remote HostIPAddress not exists, now added: "&int2str(vl_EPTF_HTTP_index)); |
| } |
| |
| return vl_EPTF_HTTP_index; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_addMessageLengthCalculationFunction |
| // |
| // Purpose: |
| // Function to add a new message length calculation function |
| // |
| // Parameters: |
| // pl_functionRef - *in* <f_IPL4_getMsgLen> - function reference of |
| // messagelength calculation function |
| // |
| // Return Value: |
| // *integer* - message length calcualtion function index |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_addMessageLengthCalculationFunction( |
| in f_IPL4_getMsgLen pl_functionRef) |
| runs on EPTF_HTTP_LocalTransport_CT return integer |
| { |
| var integer vl_size := |
| sizeof(v_EPTF_HTTPLocalTransport_lengthCalculationFunctions); |
| |
| v_EPTF_HTTPLocalTransport_lengthCalculationFunctions[vl_size] := |
| pl_functionRef; |
| |
| return vl_size; |
| } |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_setMessageLengthCalculationFunctionToConnId |
| // |
| // Purpose: |
| // Function to set a message length calculation function to a connection |
| // id |
| // |
| // Parameters: |
| // pl_connId - *in* *integer* - connection id |
| // pl_functionIdx - *in* *integer* - message length calculation |
| // function database index |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_setMessageLengthCalculationFunctionToConnId( |
| in integer pl_connId, |
| in integer pl_functionIdx) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| |
| f_EPTF_CommPort_IPL4_setMsgLen(pl_connId, |
| v_EPTF_HTTPLocalTransport_lengthCalculationFunctions[pl_functionIdx], {}); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_getMessageLength |
| // |
| // Purpose: |
| // Function to get the message length of a stream |
| // |
| // Parameters: |
| // stream - *in* *octetstring* - stream |
| // args - *inout* - arguments |
| // |
| // Return Value: |
| // *integer* - message length of stream |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_getMessageLength ( |
| in octetstring stream, |
| inout ro_integer args) |
| return integer |
| { |
| return f_TCCMessageHandling_getMessageLength(stream) |
| } |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_receiveMessage |
| // |
| // Purpose: |
| // Function to receive the incoming messages |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_receiveMessage() |
| runs on EPTF_HTTP_LocalTransport_CT { |
| |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & |
| "(): Message received on connection: " & |
| int2str(v_EPTF_CommPort_IPL4_aspRecvFrom.connId)); |
| |
| var integer vl_group, vl_port; |
| |
| v_boolNoWarning := vf_getGroupAndPort.apply(v_EPTF_CommPort_IPL4_aspRecvFrom.connId, vl_group, vl_port); |
| |
| v_EPTF_HTTP_Transport_lastReceivedGroup := vl_group; |
| |
| v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[vl_group].defaultFIdx].receiveMessage.apply( |
| vl_group, vl_port, |
| v_EPTF_CommPort_IPL4_aspRecvFrom.msg); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_receiveEvent |
| // |
| // Purpose: |
| // Function to receive the incoming events |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_receiveEvent() |
| runs on EPTF_HTTP_LocalTransport_CT { |
| |
| var integer vl_group, vl_port, vl_conn; |
| |
| if (ischosen(v_EPTF_CommPort_IPL4_aspEvent.connOpened)) |
| { |
| vl_conn := v_EPTF_CommPort_IPL4_aspEvent.connOpened.connId; |
| var integer vl_userData := -1; |
| |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "(): " & |
| "Event received on connection:" & int2str(vl_conn) & ": " & |
| log2str(v_EPTF_CommPort_IPL4_aspEvent)); |
| |
| v_resultNoWarning := f_EPTF_CommPort_IPL4_getUserData(vl_conn, vl_userData); |
| |
| v_boolNoWarning := vf_getGroup.apply(vl_userData, vl_group); |
| |
| v_EPTF_HTTP_Transport_lastReceivedGroup := vl_group; |
| |
| v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[vl_group].defaultFIdx].receiveEvent.apply( |
| vl_group, vl_port, |
| //vl_conn, |
| //v_EPTF_HTTP_Transport_portDB[vl_group].portDatabase[vl_port].sessionId, //vl_conn, |
| c_EPTF_HTTP_inputIdx_connectionOpened); |
| } |
| else |
| if (ischosen(v_EPTF_CommPort_IPL4_aspEvent.connClosed)) |
| { |
| vl_conn := v_EPTF_CommPort_IPL4_aspEvent.connClosed.connId; |
| |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()" & |
| "Event received on connection:" & int2str(vl_conn) & ": " & |
| log2str(v_EPTF_CommPort_IPL4_aspEvent)); |
| |
| v_boolNoWarning := vf_getGroupAndPort.apply(vl_conn, vl_group, vl_port); |
| |
| v_EPTF_HTTP_Transport_lastReceivedGroup := vl_group; |
| |
| v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[vl_group].defaultFIdx].receiveEvent.apply( |
| vl_group, vl_port, |
| //vl_conn, |
| //v_EPTF_HTTP_Transport_portDB[vl_group].portDatabase[vl_port].sessionId, //vl_conn, |
| c_EPTF_HTTP_inputIdx_connectionClosed); |
| } |
| else |
| if (ischosen(v_EPTF_CommPort_IPL4_aspEvent.result)) |
| { |
| vl_conn := v_EPTF_CommPort_IPL4_aspEvent.result.connId; |
| |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "(): " & |
| "Event received on connection: " & int2str(vl_conn) & ": " & |
| log2str(v_EPTF_CommPort_IPL4_aspEvent)); |
| |
| v_boolNoWarning := vf_getGroupAndPort.apply(vl_conn, vl_group, vl_port); |
| |
| v_EPTF_HTTP_Transport_lastReceivedGroup := vl_group; |
| |
| if (v_EPTF_CommPort_IPL4_aspEvent.result.errorCode == omit) |
| { |
| v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[vl_group].defaultFIdx].receiveEvent.apply( |
| vl_group, vl_port, |
| //vl_conn, |
| //v_EPTF_HTTP_Transport_portDB[vl_group].portDatabase[vl_port].sessionId, //vl_conn, |
| c_EPTF_HTTP_inputIdx_OKReceived); |
| } |
| else |
| { |
| v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[vl_group].defaultFIdx].receiveEvent.apply( |
| vl_group, vl_port, |
| //vl_conn, |
| //v_EPTF_HTTP_Transport_portDB[vl_group].portDatabase[vl_port].sessionId, //vl_conn, |
| c_EPTF_HTTP_inputIdx_errorReceived); |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_closePortOfUser |
| // |
| // Purpose: |
| // Function to close the port of an HTTP user |
| // |
| // Parameters: |
| // pl_connId - *in* *integer* - group id |
| // pl_sessionId - *in* *integer* - session id of HTTP user |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_closePortOfUser( |
| in integer pl_groupId, |
| in integer pl_sessionId) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_groupId)) { return; }; |
| |
| v_EPTF_HTTP_Transport_functionDB[ |
| v_EPTF_HTTP_Transport_portDB[pl_groupId].defaultFIdx].closePortOfUser.apply( |
| pl_groupId, |
| pl_sessionId); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_freePortOfUser |
| // |
| // Purpose: |
| // Function to free the port of an HTTP user |
| // |
| // Parameters: |
| // pl_groupId - *in* *integer* - group id |
| // pl_sessionId - *in* *integer* - session id of HTTP user |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_freePortOfUser( |
| in integer pl_groupId, |
| in integer pl_sessionId) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_groupId)) { return; }; |
| |
| v_EPTF_HTTP_Transport_functionDB[ |
| v_EPTF_HTTP_Transport_portDB[pl_groupId].defaultFIdx].freePortOfUser.apply( |
| pl_groupId, |
| pl_sessionId); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_connectionOpen |
| // |
| // Purpose: |
| // Function to open the connection |
| // |
| // Parameters: |
| // pl_connId - *in* *integer* - group id |
| // pl_sessionId - *in* *integer* - session id of HTTP user |
| // |
| // Return Value: |
| // <Result> - the result of port open |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_connectionOpen( |
| in integer pl_connId, |
| in integer pl_sessionId) |
| runs on EPTF_HTTP_LocalTransport_CT return boolean |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_connId)) { return false; }; |
| |
| |
| var integer vl_port := |
| v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[pl_connId].defaultFIdx].selectPort.apply(pl_connId); |
| |
| if (vl_port == -1) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & ": No more free ports available!"); |
| } |
| else |
| { |
| v_EPTF_HTTP_Transport_portDB[pl_connId].portDatabase[vl_port].sessionId := pl_sessionId; |
| } |
| |
| return v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[pl_connId].defaultFIdx].openPort.apply(pl_connId); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_connectionClose |
| // |
| // Purpose: |
| // Function to close the connection |
| // |
| // Parameters: |
| // pl_connId - *in* - <Result> - the connection ID |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_connectionClose( |
| in integer pl_connId) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_connId)) { return; }; |
| |
| v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[pl_connId].defaultFIdx].closeConnection.apply(pl_connId); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_connectionClose |
| // |
| // Purpose: |
| // Function to close the connection |
| // |
| // Parameters: |
| // pl_connId - *in* - <Result> - the connection ID |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_connectionHalfClose( |
| in integer pl_connId) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_connId)) { return; }; |
| |
| v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[pl_connId].defaultFIdx].halfClosePort.apply(pl_connId); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_sendMessage |
| // |
| // Purpose: |
| // Function to send the outgoing message |
| // |
| // Parameters: |
| // pl_connId - *in* *integer* - connection id |
| // pl_sessionId - *in* *integer* - session id |
| // pl_message - *in* *octetstring* - encoded message |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_sendMessage( |
| in integer pl_connId, |
| in integer pl_sessionId, |
| in octetstring pl_message) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_connId)) { return; }; |
| |
| v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[pl_connId].defaultFIdx].sendMessage.apply( |
| pl_connId, |
| pl_sessionId, |
| pl_message); |
| |
| if (vf_EPTF_HTTP_messageSentHook != null) { |
| vf_EPTF_HTTP_messageSentHook.apply(pl_sessionId, pl_message); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_sendResponse |
| // |
| // Purpose: |
| // Function to send the response |
| // |
| // Parameters: |
| // pl_groupId - *in* *integer* - connection id |
| // pl_portId - *in* *integer* - unique port id |
| // pl_seqNum - *in* *integer* - sequnence number of the response |
| // pl_message - *in* *octetstring* - encoded message |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_sendResponse( |
| in integer pl_groupId, |
| in integer pl_portId, |
| in integer pl_seqNum, |
| in octetstring pl_message) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_groupId)) { return; }; |
| |
| v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[pl_groupId].defaultFIdx].sendResponse.apply( |
| pl_groupId, |
| pl_portId, |
| pl_seqNum, |
| pl_message); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_listen |
| // |
| // Purpose: |
| // Function to create a listening socket in a server port group. |
| // |
| // Parameters: |
| // pl_groupId - *in* *integer* - the group ID |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_listen( |
| in integer pl_groupId) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return integer |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_groupId)) { return -1; }; |
| |
| return v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[pl_groupId].defaultFIdx].listen.apply(pl_groupId); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_LocalTransport_closePort |
| // |
| // Purpose: |
| // Closes a socket in a server port. |
| // |
| // Parameters: |
| // pl_groupId - *in* *integer* - the group ID |
| // pl_portId - *in* *integer* - the port ID |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_LocalTransport_closePort( |
| in integer pl_groupId, |
| in integer pl_portId) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_groupId)) { return; }; |
| |
| v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[pl_groupId].defaultFIdx].closePort.apply(pl_groupId, pl_portId); |
| } |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Transport_generatePortId |
| // |
| // Purpose: |
| // Generates a port identifier unique in the port group. |
| // |
| // Parameters: |
| // pl_group - *in* *integer* - connection id |
| // |
| // Return Value: |
| // integer - identifier |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Transport_generatePortId(in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return integer |
| { |
| var integer vl_maxNoPortIds:=100000; |
| var integer vl_dummyIdx:=-1; |
| var integer vl_nextPortId:=v_EPTF_HTTP_Transport_portDB[pl_group].currentPortId; |
| var boolean vl_foundFreePortId:=false; |
| |
| //TR: HK96316 |
| for(var integer i:=0;i< vl_maxNoPortIds and not vl_foundFreePortId;i:=i+1) { |
| vl_nextPortId:=(vl_nextPortId+1) mod vl_maxNoPortIds; |
| if( not f_EPTF_int2int_HashMap_Find(v_EPTF_HTTP_Transport_portId2Idx_HM,vl_nextPortId,vl_dummyIdx) ){ |
| vl_foundFreePortId:=true; |
| } |
| } |
| |
| if(not vl_foundFreePortId) { |
| f_EPTF_HTTP_Transport_warning(log2str(%definitionId & |
| " : Error in generating the next free portId. There is no free portId and it will fail" )); |
| } |
| v_EPTF_HTTP_Transport_portDB[pl_group].currentPortId:=vl_nextPortId; |
| return vl_nextPortId; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Transport_socketOpened |
| // |
| // Purpose: |
| // Creates the database entries needed in case of opening a new socket. |
| // |
| // Parameters: |
| // - pl_connId - *in* *integer* - connection Id |
| // - pl_groupId - *in* *integer* - the index of the group |
| // - pl_port - *inout* *integer* - the index of the port |
| // |
| // Return Value: |
| // boolean - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Transport_socketOpened(in integer pl_connId, in integer pl_groupId, in integer pl_portId) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_int2int_HashMap_Insert(v_EPTF_HTTP_Transport_connId2GroupId_HM, |
| pl_connId, pl_groupId); |
| f_EPTF_int2int_HashMap_Insert(v_EPTF_HTTP_Transport_connId2PortId_HM, |
| pl_connId, pl_portId); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Transport_socketClosed |
| // |
| // Purpose: |
| // Removes the database entries needed in case of closing a socket. |
| // |
| // Parameters: |
| // - pl_connId - *in* *integer* - connection Id |
| // |
| // Return Value: |
| // boolean - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Transport_socketClosed(in integer pl_connId) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_int2int_HashMap_Erase(v_EPTF_HTTP_Transport_connId2GroupId_HM, pl_connId); |
| f_EPTF_int2int_HashMap_Erase(v_EPTF_HTTP_Transport_connId2PortId_HM, pl_connId); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_setFunc_getGroupAndPort |
| // |
| // Purpose: |
| // Registers the group and port search function |
| // |
| // Parameters: |
| // pl_func - *in* <EPTF_HTTP_Transport_GetGroupAndPort_FT> - function reference |
| // |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_setFunc_getGroupAndPort(in EPTF_HTTP_Transport_GetGroupAndPort_FT pl_func) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| vf_getGroupAndPort := pl_func; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_setFunc_getGroup |
| // |
| // Purpose: |
| // Registers the group search function |
| // |
| // Parameters: |
| // pl_func - *in* <EPTF_HTTP_Transport_GetGroup_FT> - function reference |
| // |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_setFunc_getGroup(in EPTF_HTTP_Transport_GetGroup_FT pl_func) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| vf_getGroup := pl_func; |
| } |
| |
| } // group LocalTransport |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Group: EPTF_HTTP_RemoteTransport |
| // |
| // Purpose: |
| // Functions of the EPTF HTTP Remote Transport |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| group EPTF_HTTP_RemoteTransport { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Altstep: as_EPTF_HTTP_RemoteTransport_handler |
| // |
| // Purpose: |
| // Altstep to handle the incoming messages from the mapper component |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| altstep as_EPTF_HTTP_RemoteTransport_handler() |
| runs on EPTF_HTTP_RemoteTransport_CT |
| { |
| [] v_EPTF_HTTP_RemoteTransport_commPort.receive(EPTF_HTTP_Transport_Receive:?) -> value v_EPTF_HTTP_RemoteTransport_receive |
| { |
| vf_EPTF_HTTP_RemoteTransport_handleReceive.apply({ |
| v_EPTF_HTTP_RemoteTransport_receive.groupId, |
| v_EPTF_HTTP_RemoteTransport_receive.sessionId, |
| v_EPTF_HTTP_RemoteTransport_receive.seqNum, |
| v_EPTF_HTTP_RemoteTransport_receive.reveivedMessage}); |
| |
| repeat; |
| } |
| [] v_EPTF_HTTP_RemoteTransport_commPort.receive(EPTF_HTTP_Transport_Result:?) -> value v_EPTF_HTTP_RemoteTransport_result |
| { |
| vf_EPTF_HTTP_RemoteTransport_eventReceive.apply({ |
| v_EPTF_HTTP_RemoteTransport_result.groupId, |
| v_EPTF_HTTP_RemoteTransport_result.sessionId, |
| v_EPTF_HTTP_RemoteTransport_result.resultType}); |
| |
| repeat; |
| } |
| [] v_EPTF_HTTP_RemoteTransport_commPort.receive(EPTF_HTTP_Transport_Error:?) -> value v_EPTF_HTTP_RemoteTransport_error |
| { |
| vf_EPTF_HTTP_RemoteTransport_socketErrorReceive.apply({ |
| v_EPTF_HTTP_RemoteTransport_error.groupId, |
| v_EPTF_HTTP_RemoteTransport_error.sessionId, |
| v_EPTF_HTTP_RemoteTransport_error.result}); |
| |
| repeat; |
| } |
| [] v_EPTF_HTTP_RemoteTransport_commPort.receive(EPTF_HTTP_Transport_ListenEvent:?) -> value v_EPTF_HTTP_RemoteTransport_listenEvent |
| { |
| vf_EPTF_HTTP_RemoteTransport_listenSocketEvent.apply({ |
| v_EPTF_HTTP_RemoteTransport_listenEvent.groupId, |
| v_EPTF_HTTP_RemoteTransport_listenEvent.hostInfo, |
| v_EPTF_HTTP_RemoteTransport_listenEvent.eventType}); |
| |
| repeat; |
| } |
| [] v_EPTF_HTTP_RemoteTransport_commPort.receive(EPTF_HTTP_Transport_ListenError:?) -> value v_EPTF_HTTP_RemoteTransport_listenError |
| { |
| vf_EPTF_HTTP_RemoteTransport_listenSocketError.apply({ |
| v_EPTF_HTTP_RemoteTransport_listenError.groupId, |
| v_EPTF_HTTP_RemoteTransport_listenError.hostInfo, |
| v_EPTF_HTTP_RemoteTransport_listenError.transportError}); |
| |
| repeat; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RemoteTransport_init_CT |
| // |
| // Purpose: |
| // Function to init the RemoteTransport component |
| // |
| // Parameters: |
| // pl_selfName - *in* *charstring* - self name of the component |
| // pl_handleReceive - *in* - <EPTF_HTTP_messageProcess_FT> - receive |
| // function |
| // pl_eventReceiveFunction - *in* - <EPTF_HTTP_eventReceive_FT> - |
| // event receive function |
| // |
| // Return Value: |
| // *integer* - if the component initialize already the return value |
| // will be -1 |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RemoteTransport_init_CT( |
| in charstring pl_selfName := "EPTF_HTTP_RemoteTransport", |
| in EPTF_HTTP_messageProcess_FT pl_handleReceive, |
| in EPTF_HTTP_eventReceive_FT pl_eventReceiveFunction, |
| in EPTF_HTTP_socketErrorReceive_FT pl_socketErrorReceiveFunction, |
| in EPTF_HTTP_listenSocketEvent_FT pl_listenSocketEvent := null, |
| in EPTF_HTTP_listenSocketError_FT pl_listenSocketError := null) |
| runs on EPTF_HTTP_RemoteTransport_CT |
| return integer |
| { |
| if (v_EPTF_HTTP_RemoteTransport_initialized) |
| { |
| log(%definitionId & ": " & // intentionally simple log |
| "The HTTP RemoteTransport component already initialized!"); |
| return -1; |
| } |
| |
| v_EPTF_HTTP_RemoteTransport_selfName := pl_selfName |
| |
| f_EPTF_Logging_init_CT(pl_selfName); |
| |
| v_EPTF_HTTP_Transport_loggingMaskId := |
| f_EPTF_Logging_registerComponentMasks( |
| tsp_EPTF_HTTP_Transport_loggingComponentMask, |
| c_EPTF_HTTP_Transport_loggingEventClasses, |
| EPTF_Logging_CLL); |
| |
| if (tsp_EPTF_HTTP_Transport_loggingEnable) |
| { |
| f_EPTF_Logging_enableLocalMask( |
| v_EPTF_HTTP_Transport_loggingMaskId, |
| c_EPTF_HTTP_Transport_loggingClassIdx_Debug); |
| } |
| else |
| { |
| f_EPTF_Logging_disableLocalMask( |
| v_EPTF_HTTP_Transport_loggingMaskId, |
| c_EPTF_HTTP_Transport_loggingClassIdx_Debug); |
| } |
| |
| |
| if (tsp_EPTF_HTTP_Transport_bufferLogEnable) |
| { |
| f_EPTF_Logging_enableLocalMask( |
| v_EPTF_HTTP_Transport_loggingMaskId, |
| c_EPTF_HTTP_Transport_loggingClassIdx_BufferDebug); |
| }else |
| { |
| f_EPTF_Logging_disableLocalMask( |
| v_EPTF_HTTP_Transport_loggingMaskId, |
| c_EPTF_HTTP_Transport_loggingClassIdx_BufferDebug); |
| } |
| |
| vf_EPTF_HTTP_RemoteTransport_handleReceive := pl_handleReceive; |
| vf_EPTF_HTTP_RemoteTransport_eventReceive := pl_eventReceiveFunction; |
| vf_EPTF_HTTP_RemoteTransport_socketErrorReceive := pl_socketErrorReceiveFunction; |
| |
| vf_EPTF_HTTP_RemoteTransport_listenSocketEvent := pl_listenSocketEvent; |
| vf_EPTF_HTTP_RemoteTransport_listenSocketError := pl_listenSocketError; |
| |
| f_EPTF_Base_init_CT(pl_selfName); |
| f_EPTF_Base_registerCleanup(refers(f_EPTF_HTTP_RemoteTransport_cleanup_CT)); |
| f_EPTF_HashMap_init_CT(pl_selfName); |
| |
| v_EPTF_HTTP_RemoteTransport_transportIdToConnId := |
| f_EPTF_int2int_HashMap_New(c_EPTF_HTTP_RemoteTransport_HashMap_transportId2ConnId); |
| |
| v_EPTF_HTTP_RemoteTransport_default := activate(as_EPTF_HTTP_RemoteTransport_handler()); |
| |
| //map(self:IPL4_PCO, system:IPL4_PCO); |
| |
| v_EPTF_HTTP_RemoteTransport_initialized := true; |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": The initialization of the " & |
| "HTTP RemoteTransport component is ready"); |
| |
| return 1; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RemoteTranport_cleanup_CT |
| // |
| // Purpose: |
| // Function to clean the RemoteTransport component |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RemoteTransport_cleanup_CT () |
| runs on EPTF_HTTP_RemoteTransport_CT |
| { |
| if (not v_EPTF_HTTP_RemoteTransport_initialized) { |
| return; |
| } |
| v_EPTF_HTTP_RemoteTransport_initialized := false; |
| |
| deactivate(v_EPTF_HTTP_RemoteTransport_default); |
| v_EPTF_HTTP_RemoteTransport_default := null; |
| |
| f_EPTF_int2int_HashMap_Delete(c_EPTF_HTTP_RemoteTransport_HashMap_transportId2ConnId); |
| v_EPTF_HTTP_RemoteTransport_transportIdToConnId := -1; |
| |
| vf_EPTF_HTTP_RemoteTransport_handleReceive := null; |
| //f_EPTF_Logging_debug(true,"The cleanup of the RemoteTransport component is ready"); |
| } |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RemoteTransport_newPortGroup |
| // |
| // Purpose: |
| // Function to create port group on the mapper component remotely |
| // |
| // Parameters: |
| // pl_result - *out* - <Result> - the result of sending |
| // |
| // Return Value: |
| // *integer* - index of newly created port group, -1 if creation is |
| // unsuccessful |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RemoteTransport_newPortGroup( |
| in EPTF_HTTP_Transport_GroupMode pl_group) |
| runs on EPTF_HTTP_RemoteTransport_CT return integer |
| { |
| var integer vl_groupId; |
| var EPTF_HTTP_Transport_NewPortGroup vl_createPortGroup := { |
| groupInfo := pl_group |
| } |
| |
| v_EPTF_HTTP_RemoteTransport_commPort.send(vl_createPortGroup); |
| |
| alt { |
| [] v_EPTF_HTTP_RemoteTransport_commPort.receive (integer:?) -> value vl_groupId {} |
| } |
| |
| return vl_groupId; |
| } |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RemoteTransport_deletePortGroup |
| // |
| // Purpose: |
| // Function to delete port group on the mapper component remotely |
| // |
| // Parameters: |
| // pl_group - *in* - *integer* - port group index |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RemoteTransport_deletePortGroup( |
| in integer pl_group) |
| runs on EPTF_HTTP_RemoteTransport_CT |
| { |
| var EPTF_HTTP_Transport_DeletePortGroup vl_deletePortGroup := { |
| groupId := pl_group |
| } |
| |
| v_EPTF_HTTP_RemoteTransport_commPort.send(vl_deletePortGroup); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RemoteTransport_newPort |
| // |
| // Purpose: |
| // Function to create a port on the mapper component remotely |
| // |
| // Parameters: |
| // pl_portInfo - *in* - <EPTF_HTTP_Transport_PortMode> - port data |
| // |
| // Return Value: |
| // *integer* - index of newly created port, -1 if creation is |
| // unsuccessful |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RemoteTransport_newPort( |
| in EPTF_HTTP_Transport_PortMode pl_portInfo) |
| runs on EPTF_HTTP_RemoteTransport_CT return integer |
| { |
| var integer vl_groupId; |
| var EPTF_HTTP_Transport_NewPort vl_createPort := { |
| portInfo := pl_portInfo |
| } |
| |
| v_EPTF_HTTP_RemoteTransport_commPort.send(vl_createPort); |
| |
| alt { |
| [] v_EPTF_HTTP_RemoteTransport_commPort.receive (integer:?) -> value vl_groupId {} |
| } |
| |
| return vl_groupId; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RemoteTransport_newServerPort |
| // |
| // Purpose: |
| // Creates a server port on the mapper component remotely |
| // |
| // Parameters: |
| // pl_portInfo - *in* - <EPTF_HTTP_Transport_ServerPortMode> - server port data |
| // |
| // Return Value: |
| // *integer* - index of newly created port, -1 if creation is |
| // unsuccessful |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RemoteTransport_newServerPort( |
| in EPTF_HTTP_Transport_ServerPortMode pl_portInfo) |
| runs on EPTF_HTTP_RemoteTransport_CT return integer |
| { |
| var integer vl_groupId; |
| var EPTF_HTTP_Transport_NewServerPort vl_createServerPort := { |
| portInfo := pl_portInfo |
| } |
| |
| v_EPTF_HTTP_RemoteTransport_commPort.send(vl_createServerPort); |
| |
| alt { |
| [] v_EPTF_HTTP_RemoteTransport_commPort.receive (integer:?) -> value vl_groupId {} |
| } |
| |
| return vl_groupId; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RemoteTransport_deletePort |
| // |
| // Purpose: |
| // Function to delete a port on the mapper component remotely |
| // |
| // Parameters: |
| // pl_group - *in* - *integer* - port group index |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RemoteTransport_deletePort( |
| in integer pl_group) |
| runs on EPTF_HTTP_RemoteTransport_CT |
| { |
| var EPTF_HTTP_Transport_DeletePort vl_deletePort := { |
| portId := pl_group |
| } |
| |
| v_EPTF_HTTP_RemoteTransport_commPort.send(vl_deletePort); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RemoteTransport_addPortToGroup |
| // |
| // Purpose: |
| // Function to add a new port to a port group on the mapper component |
| // remotely |
| // |
| // Parameters: |
| // pl_group - *in* - <EPTF_HTTP_Transport_GroupMode> - port group data |
| // pl_result - *out* - <Result> - the result of sending |
| // |
| // Return Value: |
| // *boolean* - success result of new port addition to port group |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RemoteTransport_addPortToGroup( |
| in integer pl_group) |
| runs on EPTF_HTTP_RemoteTransport_CT return boolean |
| { |
| var integer vl_groupId; |
| var EPTF_HTTP_Transport_AddPort vl_addPort := { |
| groupId := pl_group |
| } |
| |
| v_EPTF_HTTP_RemoteTransport_commPort.send(vl_addPort); |
| |
| alt { |
| [] v_EPTF_HTTP_RemoteTransport_commPort.receive (integer:?) -> value vl_groupId {} |
| } |
| |
| if (vl_groupId == -1) { return false; } else { return true; }; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RemoteTransport_removePortFromGroup |
| // |
| // Purpose: |
| // Function to remove a port from a port group on the mapper remotely |
| // |
| // Parameters: |
| // pl_group - *in* - *integer* - port group data |
| // |
| // Return Value: |
| // *boolean* - result of port removal |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RemoteTransport_removePortFromGroup( |
| in integer pl_group) |
| runs on EPTF_HTTP_RemoteTransport_CT |
| { |
| var EPTF_HTTP_Transport_RemovePort vl_removePort := { |
| groupId := pl_group |
| } |
| |
| v_EPTF_HTTP_RemoteTransport_commPort.send(vl_removePort); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RemoteTransport_sendMessage |
| // |
| // Purpose: |
| // Function to send the messages to the mapper component |
| // |
| // Parameters: |
| // pl_connId - *in* - *integer* - connection id |
| // pl_sessionId - *in* - *integer* - session id |
| // pl_message - *in* *octetstring* - encoded message |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RemoteTransport_sendMessage( |
| in integer pl_connId, |
| in integer pl_sessionId, |
| in octetstring pl_message) |
| runs on EPTF_HTTP_RemoteTransport_CT |
| { |
| var EPTF_HTTP_Transport_Send vl_send := { |
| groupId := pl_connId, |
| sessionId := pl_sessionId, |
| outgoingMessage := pl_message |
| } |
| |
| v_EPTF_HTTP_RemoteTransport_commPort.send(vl_send); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RemoteTransport_sendMessage |
| // |
| // Purpose: |
| // Function to close the port of an HTTP user |
| // |
| // Parameters: |
| // pl_groupId - *in* - *integer* - group id |
| // pl_sessionId - *in* - *integer* - session id |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RemoteTransport_closePortOfUser( |
| in integer pl_groupId, |
| in integer pl_sessionId) |
| runs on EPTF_HTTP_RemoteTransport_CT |
| { |
| var EPTF_HTTP_Transport_ClosePortOfUser vl_send := { |
| groupId := pl_groupId, |
| sessionId := pl_sessionId |
| } |
| |
| v_EPTF_HTTP_RemoteTransport_commPort.send(vl_send); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RemoteTransport_freePortOfUser |
| // |
| // Purpose: |
| // Function to free the port of an HTTP user |
| // |
| // Parameters: |
| // pl_groupId - *in* - *integer* - group id |
| // pl_sessionId - *in* - *integer* - session id |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // If port is freed then it can be reused by any HTTP user. Incoming |
| // messages from last session will be dropped. |
| // |
| // If message arrives on the port from the last session after reuse, |
| // then the message will be forwarded to the new entity |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RemoteTransport_freePortOfUser( |
| in integer pl_groupId, |
| in integer pl_sessionId) |
| runs on EPTF_HTTP_RemoteTransport_CT |
| { |
| var EPTF_HTTP_Transport_FreePortOfUser vl_send := { |
| groupId := pl_groupId, |
| sessionId := pl_sessionId |
| } |
| |
| v_EPTF_HTTP_RemoteTransport_commPort.send(vl_send); |
| } |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RemoteTransport_connectionOpen |
| // |
| // Purpose: |
| // Function to open the connection |
| // |
| // Parameters: |
| // pl_connId - *in* - *integer* - port group index |
| // pl_sessionId - *in* - *integer* - session id |
| // |
| // Return Value: |
| // *boolean* - result of connection opening |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RemoteTransport_connectionOpen( |
| in integer pl_connId, |
| in integer pl_sessionId) |
| runs on EPTF_HTTP_RemoteTransport_CT return boolean |
| { |
| var integer vl_connId; |
| var EPTF_HTTP_Transport_Connect vl_connect := { |
| groupId := pl_connId, |
| sessionId := pl_sessionId |
| } |
| |
| v_EPTF_HTTP_RemoteTransport_commPort.send(vl_connect); |
| |
| alt { |
| [] v_EPTF_HTTP_RemoteTransport_commPort.receive (integer:?) -> value vl_connId {} |
| } |
| |
| if (vl_connId == -1) { return false; } else { return true; }; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RemoteTransport_connectionClose |
| // |
| // Purpose: |
| // Function to close the connection |
| // |
| // Parameters: |
| // pl_connId - *in* - *integer* - the connection ID |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RemoteTransport_connectionClose( |
| in integer pl_connId) |
| runs on EPTF_HTTP_RemoteTransport_CT { |
| |
| var EPTF_HTTP_Transport_Close vl_close := { |
| groupId := pl_connId |
| } |
| |
| v_EPTF_HTTP_RemoteTransport_commPort.send(vl_close); |
| |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RemoteTransport_connectionHalfClose |
| // |
| // Purpose: |
| // Function to close the connection |
| // |
| // Parameters: |
| // pl_connId - *in* - *integer* - the connection ID |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RemoteTransport_connectionHalfClose( |
| in integer pl_connId) |
| runs on EPTF_HTTP_RemoteTransport_CT { |
| |
| var EPTF_HTTP_Transport_HalfClose vl_halfclose := { |
| groupId := pl_connId |
| } |
| |
| v_EPTF_HTTP_RemoteTransport_commPort.send(vl_halfclose); |
| |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RemoteTransport_listen |
| // |
| // Purpose: |
| // Function to open a listening socket |
| // |
| // Parameters: |
| // pl_group - *in* - *integer* - the server port identifier |
| // |
| // Return Value: |
| // boolean - listen result |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RemoteTransport_listen( |
| in integer pl_groupId) |
| runs on EPTF_HTTP_RemoteTransport_CT |
| return integer{ |
| |
| var integer vl_result; |
| var EPTF_HTTP_Transport_Listen vl_listen := { |
| groupId := pl_groupId |
| } |
| |
| v_EPTF_HTTP_RemoteTransport_commPort.send(vl_listen); |
| |
| alt { |
| [] v_EPTF_HTTP_RemoteTransport_commPort.receive (integer:?) -> value vl_result {} |
| } |
| |
| return vl_result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RemoteTransport_closePort |
| // |
| // Purpose: |
| // Closes a socket in the server port. |
| // |
| // Parameters: |
| // pl_group - *in* - *integer* - the server port identifier |
| // pl_portId - *in* - *integer* - the port identifier |
| // |
| // Return Value: |
| // boolean - listen result |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RemoteTransport_closePort( |
| in integer pl_groupId, |
| in integer pl_portId) |
| runs on EPTF_HTTP_RemoteTransport_CT |
| { |
| var EPTF_HTTP_Transport_closePort vl_close :={ |
| groupId := pl_groupId, |
| portId := pl_portId |
| } |
| |
| v_EPTF_HTTP_RemoteTransport_commPort.send(vl_close); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RemoteTransport_sendResponse |
| // |
| // Purpose: |
| // Function to send the responses to the mapper component |
| // |
| // Parameters: |
| // pl_group - *in* - *integer* - server group identifier |
| // pl_portId - *in* - *integer* - unique port identifier of the request |
| // pl_message - *in* *octetstring* - encoded message |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RemoteTransport_sendResponse( |
| in integer pl_groupId, |
| in integer pl_portId, |
| in integer pl_seqNum, |
| in octetstring pl_message |
| ) |
| runs on EPTF_HTTP_RemoteTransport_CT{ |
| |
| var EPTF_HTTP_Transport_SendResponse vl_response :={ |
| groupId := pl_groupId, |
| portId := pl_portId, |
| seqNum := pl_seqNum, |
| msg := pl_message |
| } |
| |
| v_EPTF_HTTP_RemoteTransport_commPort.send(vl_response); |
| } |
| } // group remoteTransport |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Group: EPTF_HTTP_Mapper |
| // |
| // Purpose: |
| // The functions of the EPTF HTTP Mapper |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| group EPTF_HTTP_Mapper { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Altstep: as_EPTF_HTTP_Mapper_Handler |
| // |
| // Purpose: |
| // Altstep to handle the incoming messages from the RemoteTransport component |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| altstep as_EPTF_HTTP_Mapper_Handler() |
| runs on EPTF_HTTP_Mapper_CT |
| { |
| [] v_EPTF_HTTP_Mapper_commPort.receive (EPTF_HTTP_Transport_NewPortGroup:?) -> value v_EPTF_HTTP_Mapper_newPortGroup sender v_EPTF_HTTP_Mapper_componentRef |
| { |
| var integer vl_newGroupId := |
| f_EPTF_HTTP_LocalTransport_newPortGroup(v_EPTF_HTTP_Mapper_newPortGroup.groupInfo); |
| |
| if (vl_newGroupId == -1) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Creation of port group failed for group: " & |
| log2str(v_EPTF_HTTP_Mapper_newPortGroup.groupInfo)); |
| |
| v_EPTF_HTTP_Mapper_commPort.send(-1) to v_EPTF_HTTP_Mapper_componentRef; |
| } |
| else |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| "New group id acquired (" & int2str(vl_newGroupId) & " for group: " & |
| log2str(v_EPTF_HTTP_Mapper_newPortGroup.groupInfo)); |
| |
| v_EPTF_HTTP_Mapper_commPort.send(vl_newGroupId) to v_EPTF_HTTP_Mapper_componentRef; |
| } |
| |
| repeat; |
| } |
| [] v_EPTF_HTTP_Mapper_commPort.receive (EPTF_HTTP_Transport_DeletePortGroup:?) -> value v_EPTF_HTTP_Mapper_deletePortGroup sender v_EPTF_HTTP_Mapper_componentRef |
| { |
| f_EPTF_HTTP_LocalTransport_deletePortGroup(v_EPTF_HTTP_Mapper_deletePortGroup.groupId); |
| |
| repeat; |
| } |
| [] v_EPTF_HTTP_Mapper_commPort.receive (EPTF_HTTP_Transport_NewPort:?) -> value v_EPTF_HTTP_Mapper_newPort sender v_EPTF_HTTP_Mapper_componentRef |
| { |
| var integer vl_newGroupId := |
| f_EPTF_HTTP_LocalTransport_newPort(v_EPTF_HTTP_Mapper_newPort.portInfo); |
| |
| if (vl_newGroupId == -1) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Creation of port failed for port: " & |
| log2str(v_EPTF_HTTP_Mapper_newPort.portInfo)); |
| |
| v_EPTF_HTTP_Mapper_commPort.send(-1) to v_EPTF_HTTP_Mapper_componentRef; |
| } |
| else |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| "New port id acquired (" & int2str(vl_newGroupId) & " for port: " & |
| log2str(v_EPTF_HTTP_Mapper_newPort.portInfo)); |
| |
| v_EPTF_HTTP_Mapper_commPort.send(vl_newGroupId) to v_EPTF_HTTP_Mapper_componentRef; |
| } |
| |
| repeat; |
| } |
| [] v_EPTF_HTTP_Mapper_commPort.receive (EPTF_HTTP_Transport_NewServerPort:?) -> value v_EPTF_HTTP_Mapper_newServerPort sender v_EPTF_HTTP_Mapper_componentRef |
| { |
| var integer vl_newGroupId := -1 |
| var boolean vl_new := |
| f_EPTF_HTTP_LocalTransport_createServerPort(v_EPTF_HTTP_Mapper_newServerPort.portInfo, vl_newGroupId); |
| |
| if (vl_newGroupId == -1) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Creation of port failed for port: " & |
| log2str(v_EPTF_HTTP_Mapper_newServerPort.portInfo)); |
| |
| v_EPTF_HTTP_Mapper_commPort.send(-1) to v_EPTF_HTTP_Mapper_componentRef; |
| |
| } |
| else |
| { |
| if (vl_new) |
| { |
| v_EPTF_HTTP_Mapper_inRoutingDatabase[vl_newGroupId] := c_EPTF_HTTP_initRoutingDBE; |
| } |
| var integer vl_size := v_EPTF_HTTP_Mapper_inRoutingDatabase[vl_newGroupId].size; |
| |
| v_EPTF_HTTP_Mapper_inRoutingDatabase[vl_newGroupId].size := vl_size + 1; |
| v_EPTF_HTTP_Mapper_inRoutingDatabase[vl_newGroupId].compIdList[vl_size] := f_EPTF_Base_upcast(v_EPTF_HTTP_Mapper_componentRef); |
| |
| f_EPTF_HTTP_Transport_debug(log2str(%definitionId, |
| ": Routing database: ", v_EPTF_HTTP_Mapper_inRoutingDatabase[vl_newGroupId])); |
| |
| v_EPTF_HTTP_Mapper_commPort.send(vl_newGroupId) to v_EPTF_HTTP_Mapper_componentRef; |
| } |
| |
| repeat; |
| } |
| [] v_EPTF_HTTP_Mapper_commPort.receive (EPTF_HTTP_Transport_DeletePort:?) -> value v_EPTF_HTTP_Mapper_deletePort sender v_EPTF_HTTP_Mapper_componentRef |
| { |
| f_EPTF_HTTP_LocalTransport_deletePort(v_EPTF_HTTP_Mapper_deletePort.portId); |
| |
| repeat; |
| } |
| [] v_EPTF_HTTP_Mapper_commPort.receive (EPTF_HTTP_Transport_AddPort:?) -> value v_EPTF_HTTP_Mapper_addPort sender v_EPTF_HTTP_Mapper_componentRef |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(v_EPTF_HTTP_Mapper_addPort.groupId)) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Wrong port group index: " & int2str(v_EPTF_HTTP_Mapper_addPort.groupId)); |
| |
| v_EPTF_HTTP_Mapper_commPort.send(-1) to v_EPTF_HTTP_Mapper_componentRef; |
| |
| repeat; |
| }; |
| |
| if (v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[v_EPTF_HTTP_Mapper_addPort.groupId].defaultFIdx].addPort.apply( |
| v_EPTF_HTTP_Mapper_addPort.groupId)) |
| { |
| v_EPTF_HTTP_Mapper_commPort.send(1) to v_EPTF_HTTP_Mapper_componentRef; |
| } |
| else |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Port addition to group failed: " & int2str(v_EPTF_HTTP_Mapper_addPort.groupId)); |
| |
| v_EPTF_HTTP_Mapper_commPort.send(-1) to v_EPTF_HTTP_Mapper_componentRef; |
| } |
| |
| repeat; |
| } |
| [] v_EPTF_HTTP_Mapper_commPort.receive (EPTF_HTTP_Transport_RemovePort:?) -> value v_EPTF_HTTP_Mapper_removePort sender v_EPTF_HTTP_Mapper_componentRef |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(v_EPTF_HTTP_Mapper_removePort.groupId)) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Wrong port group index: " & int2str(v_EPTF_HTTP_Mapper_removePort.groupId)); |
| |
| repeat; |
| }; |
| |
| v_boolNoWarning := v_EPTF_HTTP_Transport_functionDB[v_EPTF_HTTP_Transport_portDB[v_EPTF_HTTP_Mapper_removePort.groupId].defaultFIdx |
| ].removePort.apply(v_EPTF_HTTP_Mapper_removePort.groupId); |
| |
| repeat; |
| } |
| [] v_EPTF_HTTP_Mapper_commPort.receive (EPTF_HTTP_Transport_Connect:?) -> value v_EPTF_HTTP_Mapper_connect sender v_EPTF_HTTP_Mapper_componentRef |
| { |
| if (f_EPTF_HTTP_LocalTransport_connectionOpen(v_EPTF_HTTP_Mapper_connect.groupId, v_EPTF_HTTP_Mapper_connect.sessionId)) |
| { |
| //v_EPTF_HTTP_Transport_lastReceivedGroup := v_EPTF_HTTP_Mapper_connect.groupId; |
| //v_EPTF_HTTP_Mapper_portId := f_EPTF_HTTP_LocalTransport_selectPortInGroup_defaultGroup( |
| // v_EPTF_HTTP_Mapper_groupId); // port on which we will send |
| |
| //f_EPTF_Routing_processOutgoingMessage(); |
| |
| v_EPTF_HTTP_Mapper_commPort.send( v_EPTF_HTTP_Mapper_connect.groupId ) to v_EPTF_HTTP_Mapper_componentRef; |
| } |
| else |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Open connection unsuccessful for port group: " & |
| int2str(v_EPTF_HTTP_Mapper_connect.groupId)); |
| |
| v_EPTF_HTTP_Mapper_commPort.send(-1) to v_EPTF_HTTP_Mapper_componentRef; |
| } |
| |
| repeat; |
| } |
| [] v_EPTF_HTTP_Mapper_commPort.receive (EPTF_HTTP_Transport_Send:?) -> value v_EPTF_HTTP_Mapper_sendMessage sender v_EPTF_HTTP_Mapper_componentRef |
| { |
| v_EPTF_HTTP_Mapper_sessionId := v_EPTF_HTTP_Mapper_sendMessage.sessionId; |
| f_EPTF_Routing_processOutgoingMessage(); |
| |
| if (v_EPTF_HTTP_Mapper_sessionId != -1) |
| { |
| f_EPTF_HTTP_LocalTransport_sendMessage( |
| v_EPTF_HTTP_Mapper_sendMessage.groupId, |
| v_EPTF_HTTP_Mapper_sendMessage.sessionId, |
| v_EPTF_HTTP_Mapper_sendMessage.outgoingMessage); |
| } |
| |
| repeat; |
| } |
| [] v_EPTF_HTTP_Mapper_commPort.receive (EPTF_HTTP_Transport_SendResponse:?) -> value v_EPTF_HTTP_Mapper_sendResponse sender v_EPTF_HTTP_Mapper_componentRef |
| { |
| v_EPTF_HTTP_Mapper_portId := v_EPTF_HTTP_Mapper_sendResponse.portId; |
| |
| f_EPTF_HTTP_LocalTransport_sendResponse( |
| v_EPTF_HTTP_Mapper_sendResponse.groupId, |
| v_EPTF_HTTP_Mapper_sendResponse.portId, |
| v_EPTF_HTTP_Mapper_sendResponse.seqNum, |
| v_EPTF_HTTP_Mapper_sendResponse.msg); |
| |
| repeat; |
| } |
| [] v_EPTF_HTTP_Mapper_commPort.receive (EPTF_HTTP_Transport_ClosePortOfUser:?) -> value v_EPTF_HTTP_Mapper_closePortOfUser sender v_EPTF_HTTP_Mapper_componentRef |
| { |
| f_EPTF_HTTP_LocalTransport_closePortOfUser( |
| v_EPTF_HTTP_Mapper_closePortOfUser.groupId, |
| v_EPTF_HTTP_Mapper_closePortOfUser.sessionId); |
| |
| repeat; |
| } |
| [] v_EPTF_HTTP_Mapper_commPort.receive (EPTF_HTTP_Transport_FreePortOfUser:?) -> value v_EPTF_HTTP_Mapper_freePortOfUser sender v_EPTF_HTTP_Mapper_componentRef |
| { |
| f_EPTF_HTTP_LocalTransport_freePortOfUser( |
| v_EPTF_HTTP_Mapper_freePortOfUser.groupId, |
| v_EPTF_HTTP_Mapper_freePortOfUser.sessionId); |
| |
| repeat; |
| } |
| |
| [] v_EPTF_HTTP_Mapper_commPort.receive (EPTF_HTTP_Transport_Close:?) -> value v_EPTF_HTTP_Mapper_close sender v_EPTF_HTTP_Mapper_componentRef |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(v_EPTF_HTTP_Mapper_close.groupId)) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Wrong port group index: " & int2str(v_EPTF_HTTP_Mapper_close.groupId)); |
| |
| repeat; |
| }; |
| |
| //for (var integer i := 0; i < sizeof(v_EPTF_HTTP_Transport_portDB[v_EPTF_HTTP_Transport_lastReceivedGroup].portDatabase); i := i + 1) |
| //{ |
| // v_EPTF_HTTP_Mapper_portId := i; |
| |
| // f_EPTF_Routing_processOutgoingMessage(); |
| //} |
| |
| f_EPTF_HTTP_LocalTransport_connectionClose(v_EPTF_HTTP_Mapper_close.groupId); |
| |
| repeat; |
| } |
| [] v_EPTF_HTTP_Mapper_commPort.receive (EPTF_HTTP_Transport_HalfClose:?) -> value v_EPTF_HTTP_Mapper_halfClose sender v_EPTF_HTTP_Mapper_componentRef |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(v_EPTF_HTTP_Mapper_halfClose.groupId)) { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Wrong port group index: " & int2str(v_EPTF_HTTP_Mapper_halfClose.groupId)); |
| |
| repeat; |
| }; |
| |
| //for (var integer i := 0; i < sizeof(v_EPTF_HTTP_Transport_portDB[v_EPTF_HTTP_Transport_lastReceivedGroup].portDatabase); i := i + 1) |
| //{ |
| // v_EPTF_HTTP_Mapper_portId := i; |
| |
| // f_EPTF_Routing_processOutgoingMessage(); |
| //} |
| |
| f_EPTF_HTTP_LocalTransport_connectionHalfClose( |
| v_EPTF_HTTP_Mapper_halfClose.groupId); |
| |
| repeat; |
| } |
| [] v_EPTF_HTTP_Mapper_commPort.receive (EPTF_HTTP_Transport_Listen:?) -> value v_EPTF_HTTP_Mapper_listen sender v_EPTF_HTTP_Mapper_componentRef |
| { |
| var integer vl_id := f_EPTF_HTTP_LocalTransport_listen(v_EPTF_HTTP_Mapper_listen.groupId); |
| v_EPTF_HTTP_Mapper_commPort.send(vl_id) to v_EPTF_HTTP_Mapper_componentRef; |
| |
| repeat; |
| } |
| [] v_EPTF_HTTP_Mapper_commPort.receive (EPTF_HTTP_Transport_closePort:?) -> value v_EPTF_HTTP_Mapper_closePort sender v_EPTF_HTTP_Mapper_componentRef |
| { |
| f_EPTF_HTTP_LocalTransport_closePort(v_EPTF_HTTP_Mapper_closePort.groupId, v_EPTF_HTTP_Mapper_closePort.portId); |
| repeat; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Mapper_init_CT |
| // |
| // Purpose: |
| // Function to init the Mapper component |
| // |
| // Parameters: |
| // - pl_selfName - *in charstring* - the name of the component |
| // - pl_interfaceInformationList - <EPTF_CommPort_IPL4_InterfaceInformationList> - The defined interfaces |
| // |
| // Return Value: |
| // *integer* - if the component initialize already the return value will be -1 |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Mapper_init_CT( |
| in charstring pl_selfName := "", |
| in EPTF_CommPort_IPL4_InterfaceInformationList pl_interfaceInformationList := {}, |
| in integer pl_mode := 0) //0: client mode, 1:server mode |
| runs on EPTF_HTTP_Mapper_CT |
| return integer |
| { |
| if (v_EPTF_HTTP_Mapper_initialized) { |
| log(%definitionId & // intentionally simple log! |
| "The Mapper component is initialized already"); |
| return -1; |
| } |
| |
| v_EPTF_HTTP_Mapper_componentId := {}; |
| f_EPTF_HashMap_init_CT(pl_selfName); |
| v_EPTF_HTTP_Mapper_hashMapIdx := f_EPTF_int2int_HashMap_New( |
| c_EPTF_HTTP_Mapper_HashMap_routing); |
| v_intNoWarning := f_EPTF_HTTP_LocalTransport_init_CT(pl_selfName, |
| refers(f_EPTF_HTTP_Mapper_receiveMsg), |
| refers(f_EPTF_HTTP_Mapper_receiveEvent), |
| refers(f_EPTF_HTTP_Mapper_receiveSocketError), |
| pl_interfaceInformationList, |
| refers(f_EPTF_HTTP_Mapper_listenSocketEvent), |
| refers(f_EPTF_HTTP_Mapper_listenSocketError)); |
| |
| if (0 == pl_mode)//client mode |
| { |
| f_EPTF_Routing_init_CT( |
| refers(f_EPTF_HTTP_Mapper_processOutgoingMessage), |
| refers(f_EPTF_HTTP_Mapper_processIncomingMessage)); |
| }else if (1 == pl_mode)//server mode |
| { |
| f_EPTF_Routing_init_CT( |
| -, |
| refers(f_EPTF_HTTP_Mapper_processIncomingMessageServer)); |
| } |
| |
| v_EPTF_HTTP_MapperRoutingUri2LGenDB.uri2lgenIdxHash := |
| f_EPTF_str2int_HashMap_New(c_EPTF_HTTP_Transport_hashMapName_uri2idxHash); |
| |
| f_EPTF_Base_init_CT(pl_selfName); |
| f_EPTF_Base_registerCleanup(refers(f_EPTF_HTTP_Mapper_cleanup_CT)); |
| |
| v_EPTF_HTTP_Mapper_initialized := true; |
| |
| v_EPTF_HTTP_Mapper_default := activate(as_EPTF_HTTP_Mapper_Handler()); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": The initialization of the Mapper component is ready"); |
| |
| return 1; |
| } |
| |
| function f_EPTF_HTTP_Mapper_CommPort_IPL4_setMsgLen( |
| in ConnectionId pl_connId, |
| in f_IPL4_getMsgLen pl_function, |
| in ro_integer pl_msgLenArgs) |
| runs on EPTF_HTTP_Mapper_CT |
| { |
| f_EPTF_CommPort_IPL4_setMsgLen(pl_connId, pl_function, pl_msgLenArgs); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Mapper_cleanup_CT |
| // |
| // Purpose: |
| // Function to clean the Mapper component |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Mapper_cleanup_CT() |
| runs on EPTF_HTTP_Mapper_CT |
| { |
| if (not v_EPTF_HTTP_Mapper_initialized) { |
| return; |
| } |
| v_EPTF_HTTP_Mapper_initialized := false; |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| v_EPTF_HTTP_Mapper_componentId := {}; |
| v_EPTF_HTTP_Mapper_hashMapIdx := -1; |
| |
| f_EPTF_int2int_HashMap_Delete(c_EPTF_HTTP_Mapper_HashMap_routing); |
| |
| v_EPTF_HTTP_Mapper_default := null; |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": The cleanup of the Mapper component is ready"); |
| |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Mapper_setRouting |
| // |
| // Purpose: |
| // Function to set routing information for Mapper database |
| // |
| // Parameters: |
| // pl_route - *in* <EPTF_HTTP_Mapper_RoutingList> - routing data |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Mapper_setRouting( |
| in EPTF_HTTP_Mapper_RoutingList pl_route) |
| runs on EPTF_HTTP_Mapper_CT |
| { |
| f_EPTF_HTTP_Transport_debug("### " & %definitionId & "()"); |
| |
| var integer i, vl_maxGroupIdx := -1; |
| |
| for (i := 0; i < sizeof(pl_route); i := i + 1) |
| { |
| if (vl_maxGroupIdx < pl_route[i].groupId) { |
| vl_maxGroupIdx := pl_route[i].groupId; |
| }; |
| } |
| |
| for (i := 0; i < vl_maxGroupIdx; i := i + 1) |
| { |
| v_EPTF_HTTP_Mapper_routingSetDatabase[i] := false; |
| } |
| |
| for (i := 0; i < sizeof(pl_route); i := i + 1) |
| { |
| v_EPTF_HTTP_Mapper_inRoutingDatabase[pl_route[i].groupId] := { |
| ptr := 0, |
| size := sizeof(pl_route[i].compIdList), |
| compIdList := pl_route[i].compIdList |
| } |
| |
| v_EPTF_HTTP_Mapper_routingSetDatabase[i] := true; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_setRoutingUri2LGen_GetUriCallback |
| // |
| // Purpose: |
| // Function to set the fcb_EPTF_HTTP_MapperRoutingUri2LGen_GetUri. |
| // If fcb_EPTF_HTTP_MapperRoutingUri2LGen_GetUri is set, then the Mapper will use its return value |
| // to look up the subscribed LGen for the returned URI |
| // |
| // Parameters: |
| // pl_callback - *in* <EPTF_HTTP_MapperRoutingUri2LGen_GetUri_FT> - user function to return the URI |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_setRoutingUri2LGen_GetUriCallback(in EPTF_HTTP_MapperRoutingUri2LGen_GetUri_FT pl_callback) runs on EPTF_HTTP_Mapper_CT { |
| fcb_EPTF_HTTP_MapperRoutingUri2LGen_GetUri := pl_callback |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_getUri2LGenRoutingData |
| // |
| // Purpose: |
| // Looks up the subscribed LGen for <pl_uri>, and returns it in the <pl_lgenIdx> |
| // |
| // Parameters: |
| // pl_uri - *in* <charstring> - URI to look up |
| // pl_lgenIdx - *inout* <integer> - LGen index handling the URI |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_HTTP_getUri2LGenRoutingData(in charstring pl_uri, inout integer pl_lgenIdx) runs on EPTF_HTTP_Mapper_CT return boolean { |
| |
| if (f_EPTF_str2int_HashMap_Find(v_EPTF_HTTP_MapperRoutingUri2LGenDB.uri2lgenIdxHash, pl_uri, pl_lgenIdx)) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_addUri2LGenRoutingData |
| // |
| // Purpose: |
| // Adds (subscribes) LGen <pl_lgenIdx> for URI <pl_uri>, and stores it in the database |
| // |
| // Parameters: |
| // pl_uri - *in* <charstring> - URI to look up |
| // pl_lgenIdx - *in* <integer> - LGen index handling the URI |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_addUri2LGenRoutingData(in charstring pl_uri, in integer pl_lgenIdx) runs on EPTF_HTTP_Mapper_CT { |
| f_EPTF_str2int_HashMap_Insert(v_EPTF_HTTP_MapperRoutingUri2LGenDB.uri2lgenIdxHash, pl_uri, pl_lgenIdx); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_removeUri2LGenRoutingData |
| // |
| // Purpose: |
| // Removes (unsubscribes) URI <pl_uri> from the URI <-> LGen database |
| // |
| // Parameters: |
| // pl_uri - *in* <charstring> - URI to look up |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_removeUri2LGenRoutingData(in charstring pl_uri) runs on EPTF_HTTP_Mapper_CT { |
| f_EPTF_str2int_HashMap_Erase(v_EPTF_HTTP_MapperRoutingUri2LGenDB.uri2lgenIdxHash, pl_uri); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Mapper_processOutgoingMessage |
| // |
| // Purpose: |
| // Function to process the outgoing messages |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Functions stores in a hash map the integer casted component id value |
| // of the component from which the message has been received with the |
| // key of the connection id value within the message |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Mapper_processOutgoingMessage() |
| runs on EPTF_HTTP_Mapper_CT |
| { |
| var integer vl_dummy; |
| if (f_EPTF_int2int_HashMap_Find( |
| v_EPTF_HTTP_Mapper_hashMapIdx, |
| v_EPTF_HTTP_Mapper_sessionId, |
| vl_dummy)) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": A component reference for session id (" |
| & int2str(v_EPTF_HTTP_Mapper_sessionId) & |
| ") is already stored! Message not sent!"); |
| |
| v_EPTF_HTTP_Mapper_sessionId := -1; |
| } |
| else |
| { |
| f_EPTF_int2int_HashMap_Insert( |
| v_EPTF_HTTP_Mapper_hashMapIdx, |
| v_EPTF_HTTP_Mapper_sessionId, |
| f_EPTF_Base_upcast(v_EPTF_HTTP_Mapper_componentRef)); |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| " Source component index (" & |
| int2str(f_EPTF_Base_upcast(v_EPTF_HTTP_Mapper_componentRef)) & |
| ") stored in hash map for session id (" & |
| int2str(v_EPTF_HTTP_Mapper_sessionId) & ")!"); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Mapper_processIncomingMessage |
| // |
| // Purpose: |
| // Function to process the incoming messages |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Function retrieves the integer casted component id to which the |
| // received message should be sent and then places this component id |
| // into the component variable v_EPTF_HTTP_Mapper_componentId |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Mapper_processIncomingMessage() |
| runs on EPTF_HTTP_Mapper_CT |
| { |
| f_EPTF_HTTP_Transport_debug(log2str(%definitionId, |
| ": Incoming message received for session id: ", |
| v_EPTF_HTTP_Mapper_sessionId)); |
| |
| /* |
| if (v_EPTF_HTTP_Transport_lastReceivedGroup >= sizeof(v_EPTF_HTTP_Mapper_routingSetDatabase) or |
| not v_EPTF_HTTP_Mapper_routingSetDatabase[v_EPTF_HTTP_Transport_lastReceivedGroup]) |
| { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Group id (" & int2str(v_EPTF_HTTP_Transport_lastReceivedGroup) & |
| ") not found in routing database!"); |
| |
| v_EPTF_HTTP_Mapper_componentId := -1; |
| } |
| else |
| { |
| var integer vl_ptr := v_EPTF_HTTP_Mapper_inRoutingDatabase[v_EPTF_HTTP_Transport_lastReceivedGroup].ptr; |
| var integer vl_size := v_EPTF_HTTP_Mapper_inRoutingDatabase[v_EPTF_HTTP_Transport_lastReceivedGroup].size; |
| |
| //log(v_EPTF_HTTP_Mapper_inRoutingDatabase); |
| //log(vl_ptr); |
| //log(v_EPTF_HTTP_Mapper_groupId); |
| v_EPTF_HTTP_Mapper_componentId := |
| v_EPTF_HTTP_Mapper_inRoutingDatabase[v_EPTF_HTTP_Transport_lastReceivedGroup].compIdList[vl_ptr]; |
| |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| " Destination component acquired (" & |
| int2str(v_EPTF_HTTP_Mapper_componentId) & ") for group id (" & |
| int2str(v_EPTF_HTTP_Transport_lastReceivedGroup) & ")!"); |
| |
| vl_ptr := vl_ptr + 1; |
| if (vl_ptr >= vl_size) { vl_ptr := 1; }; |
| } |
| */ |
| |
| var integer vl_compId := -1; |
| |
| if (f_EPTF_int2int_HashMap_Find( |
| v_EPTF_HTTP_Mapper_hashMapIdx, |
| v_EPTF_HTTP_Mapper_sessionId, |
| vl_compId)) |
| { |
| f_EPTF_HTTP_Transport_debug(log2str(%definitionId, |
| " Destination component acquired (", |
| v_EPTF_HTTP_Mapper_componentId, ") for session id (", |
| int2str(v_EPTF_HTTP_Transport_lastReceivedGroup),")!")); |
| |
| f_EPTF_int2int_HashMap_Erase( |
| v_EPTF_HTTP_Mapper_hashMapIdx, |
| v_EPTF_HTTP_Mapper_sessionId); |
| |
| v_EPTF_HTTP_Mapper_componentId := {vl_compId}; |
| } |
| else { |
| f_EPTF_HTTP_Transport_warning(%definitionId & |
| ": Session id (" & int2str(v_EPTF_HTTP_Mapper_sessionId) & |
| ") not found in hash map! Possibly connection closed remotely on Free port!"); |
| |
| v_EPTF_HTTP_Mapper_componentId := {}; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Mapper_processIncomingMessageServer |
| // |
| // Purpose: |
| // Processes the incoming messages. |
| // |
| // Detailed Comments: |
| // The current LGen to send the request to is chosen round robin. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Mapper_processIncomingMessageServer() |
| runs on EPTF_HTTP_Mapper_CT |
| { |
| f_EPTF_HTTP_Transport_debug(%definitionId & |
| ": Incoming message received for group id: " & |
| int2str(v_EPTF_HTTP_Transport_lastReceivedGroup)) |
| |
| if(fcb_EPTF_HTTP_MapperRoutingUri2LGen_GetUri == null or (not isbound(v_EPTF_CommPort_IPL4_aspRecvFrom.msg))) { |
| var integer vl_current := |
| v_EPTF_HTTP_Mapper_inRoutingDatabase[v_EPTF_HTTP_Transport_lastReceivedGroup].ptr; |
| |
| v_EPTF_HTTP_Mapper_componentId := {v_EPTF_HTTP_Mapper_inRoutingDatabase[v_EPTF_HTTP_Transport_lastReceivedGroup].compIdList[vl_current]}; |
| |
| v_EPTF_HTTP_Mapper_inRoutingDatabase[v_EPTF_HTTP_Transport_lastReceivedGroup].ptr := |
| (vl_current + 1) mod v_EPTF_HTTP_Mapper_inRoutingDatabase[v_EPTF_HTTP_Transport_lastReceivedGroup].size; |
| } else { |
| f_EPTF_HTTP_Transport_debug(%definitionId & ": Incoming message received, calling fcb_EPTF_HTTP_MapperRoutingUri2LGen_GetUri.."); |
| var charstring vl_uri := fcb_EPTF_HTTP_MapperRoutingUri2LGen_GetUri.apply(); |
| var integer vl_comp; |
| if(f_EPTF_HTTP_getUri2LGenRoutingData(vl_uri, vl_comp)) { |
| //log("LGen #", vl_comp, " is subscribed to the URI: ", vl_uri, "."); |
| v_EPTF_HTTP_Mapper_componentId := { vl_comp }; |
| } else { |
| //log("No LGen is subscribed to the URI: ", vl_uri, ". Message discarded!"); |
| v_EPTF_HTTP_Mapper_componentId := {}; |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Mapper_receiveMsg |
| // |
| // Purpose: |
| // Function to receive the incoming messages |
| // |
| // Parameters: |
| // pl_message - *in* <EPTF_HTTP_IncomingMessage> - incoming message from the transport layer |
| // |
| // Detailed Comments: |
| // Function performs routing of incoming messages. It determins to which |
| // load generator component the message should be sent based on |
| // the provided connection id and sends it to this component. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Mapper_receiveMsg( |
| in EPTF_HTTP_IncomingMessage pl_message) |
| runs on EPTF_HTTP_Mapper_CT |
| { |
| v_EPTF_HTTP_Mapper_sessionId := pl_message.sessionId; |
| |
| f_EPTF_Routing_processIncomingMessage(); |
| |
| var EPTF_HTTP_Transport_Receive vl_receive := { |
| groupId := pl_message.groupId, |
| sessionId := pl_message.sessionId, |
| seqNum := pl_message.seqNum, |
| reveivedMessage := pl_message.httpMessage |
| } |
| |
| for (var integer i := 0; i < sizeof(v_EPTF_HTTP_Mapper_componentId); i := i + 1) |
| { |
| v_EPTF_HTTP_Mapper_commPort.send(vl_receive) to f_EPTF_Base_downcast(v_EPTF_HTTP_Mapper_componentId[i]); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Mapper_receiveEvent |
| // |
| // Purpose: |
| // Function to receive the incoming events |
| // |
| // Parameters: |
| // pl_event - *in* <EPTF_HTTP_Event> - incoming event from the transport layer |
| // |
| // Detailed Comments: |
| // Function performs routing of incoming messages. It determins to which |
| // load generator component the message should be sent based on |
| // the provided connection id and sends it to this component. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Mapper_receiveEvent( |
| in EPTF_HTTP_Event pl_event) |
| runs on EPTF_HTTP_Mapper_CT |
| { |
| v_EPTF_HTTP_Mapper_sessionId := pl_event.sessionId; |
| |
| f_EPTF_Routing_processIncomingMessage(); |
| |
| var EPTF_HTTP_Transport_Result vl_result := { |
| groupId := pl_event.groupId, |
| sessionId := pl_event.sessionId, //pl_sessionId, |
| resultType := pl_event.eventType |
| } |
| |
| for (var integer i := 0; i < sizeof(v_EPTF_HTTP_Mapper_componentId); i := i + 1) |
| { |
| v_EPTF_HTTP_Mapper_commPort.send(vl_result) to f_EPTF_Base_downcast(v_EPTF_HTTP_Mapper_componentId[i]); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Mapper_receiveSocketError |
| // |
| // Purpose: |
| // Function to receive the incoming socket errors |
| // |
| // Parameters: |
| // pl_error - <EPTF_HTTP_Error> - the error message |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Function performs routing of incoming messages. It determins to which |
| // load generator component the message should be sent based on |
| // the provided connection id and sends it to this component. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Mapper_receiveSocketError( |
| in EPTF_HTTP_EventError pl_error) |
| runs on EPTF_HTTP_Mapper_CT |
| { |
| v_EPTF_HTTP_Mapper_sessionId := pl_error.sessionId; |
| f_EPTF_Routing_processIncomingMessage(); |
| |
| var EPTF_HTTP_Transport_Error vl_result := { |
| groupId := pl_error.groupId, |
| sessionId := pl_error.sessionId, //pl_sessionId, |
| result := pl_error.transportError |
| } |
| |
| for (var integer i := 0; i < sizeof(v_EPTF_HTTP_Mapper_componentId); i := i + 1) |
| { |
| v_EPTF_HTTP_Mapper_commPort.send(vl_result) to f_EPTF_Base_downcast(v_EPTF_HTTP_Mapper_componentId[i]); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Mapper_listenSocketEvent |
| // |
| // Purpose: |
| // Function to receive the incoming listening socket events |
| // |
| // Parameters: |
| // pl_event - <EPTF_HTTP_listenSocketEvent> - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Events are routed to all of the LGens belonging to the server port. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Mapper_listenSocketEvent( |
| in EPTF_HTTP_listenSocketEvent pl_event) |
| runs on EPTF_HTTP_Mapper_CT |
| { |
| var EPTF_HTTP_Transport_ListenEvent vl_result := { |
| groupId := pl_event.groupId, |
| hostInfo := pl_event.hostInfo, |
| eventType := pl_event.eventType |
| } |
| |
| for (var integer i := 0; i < v_EPTF_HTTP_Mapper_inRoutingDatabase[v_EPTF_HTTP_Transport_lastReceivedGroup].size; i := i + 1) |
| { |
| v_EPTF_HTTP_Mapper_commPort.send(vl_result) to |
| f_EPTF_Base_downcast(v_EPTF_HTTP_Mapper_inRoutingDatabase[v_EPTF_HTTP_Transport_lastReceivedGroup].compIdList[i]); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Mapper_listenSocketError |
| // |
| // Purpose: |
| // Function to receive the incoming listening socket events |
| // |
| // Parameters: |
| // pl_error - <EPTF_HTTP_listenSocketError> - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Events are routed to all of the LGens belonging to the server port. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Mapper_listenSocketError( |
| in EPTF_HTTP_listenSocketError pl_error) |
| runs on EPTF_HTTP_Mapper_CT |
| { |
| var EPTF_HTTP_Transport_ListenError vl_result := { |
| groupId := pl_error.groupId, |
| hostInfo := pl_error.hostInfo, |
| transportError := pl_error.transportError |
| } |
| |
| for (var integer i := 0; i < v_EPTF_HTTP_Mapper_inRoutingDatabase[v_EPTF_HTTP_Transport_lastReceivedGroup].size; i := i + 1) |
| { |
| v_EPTF_HTTP_Mapper_commPort.send(vl_result) to |
| f_EPTF_Base_downcast(v_EPTF_HTTP_Mapper_inRoutingDatabase[v_EPTF_HTTP_Transport_lastReceivedGroup].compIdList[i]); |
| } |
| } |
| |
| } // end of Group: Mapper |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Group: EPTF_HTTP_Transport_Logging |
| // |
| // Purpose: |
| // The functions of the EPTF HTTP Transport Logging |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| group EPTF_HTTP_Transport_Logging { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Transport_error |
| // |
| // Purpose: |
| // Function to log an error from EPTF HTTP Transport |
| // |
| // Parameters: |
| // - pl_message - *in* *charstring* - the message to log |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Transport_error( |
| in @lazy charstring pl_message) |
| runs on EPTF_HTTP_Transport_Logging_CT |
| { |
| f_EPTF_Logging_errorV2(pl_message, |
| v_EPTF_HTTP_Transport_loggingMaskId, |
| {c_EPTF_HTTP_Transport_loggingClassIdx_Error}); |
| f_EPTF_Base_stopAll(); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Transport_warning |
| // |
| // Purpose: |
| // Function to log a warning from EPTF HTTP Transport |
| // |
| // Parameters: |
| // - pl_message - *in* *charstring* - the message to log |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Transport_warning( |
| in @lazy charstring pl_message) |
| runs on EPTF_HTTP_Transport_Logging_CT |
| { |
| f_EPTF_Logging_warningV2(pl_message, |
| v_EPTF_HTTP_Transport_loggingMaskId, |
| {c_EPTF_HTTP_Transport_loggingClassIdx_Warning}); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Transport_debug |
| // |
| // Purpose: |
| // Function to log a debug message from EPTF HTTP Transport |
| // |
| // Parameters: |
| // - pl_message - *in* *charstring* - the message to log |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Transport_debug( |
| in @lazy charstring pl_message) |
| runs on EPTF_HTTP_Transport_Logging_CT |
| { |
| f_EPTF_Logging_debugV2(pl_message, |
| v_EPTF_HTTP_Transport_loggingMaskId, |
| {c_EPTF_HTTP_Transport_loggingClassIdx_Debug}); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Transport_bufferWarning |
| // |
| // Purpose: |
| // Function to log a buffer warning message from EPTF HTTP Transport |
| // |
| // Parameters: |
| // - pl_message - *in* *charstring* - the message to log |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Transport_bufferWarning( |
| in @lazy charstring pl_message) |
| runs on EPTF_HTTP_Transport_Logging_CT |
| { |
| f_EPTF_Logging_warningV2(pl_message, |
| v_EPTF_HTTP_Transport_loggingMaskId, |
| {c_EPTF_HTTP_Transport_loggingClassIdx_BufferWarning}); |
| |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Transport_bufferDebug |
| // |
| // Purpose: |
| // Function to log a buffer debug message from EPTF HTTP Transport |
| // |
| // Parameters: |
| // - pl_message - *in* *charstring* - the message to log |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Transport_bufferDebug( |
| in @lazy charstring pl_message) |
| runs on EPTF_HTTP_Transport_Logging_CT |
| { |
| f_EPTF_Logging_debugV2(pl_message, |
| v_EPTF_HTTP_Transport_loggingMaskId, |
| {c_EPTF_HTTP_Transport_loggingClassIdx_BufferDebug}); |
| |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Transport_debugEnabled |
| // |
| // Purpose: |
| // Function to check if debug is enabled for EPTF HTTP Transport |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // *boolean* - true if debug enalbed |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Transport_debugEnabled() |
| runs on EPTF_HTTP_Transport_Logging_CT |
| return boolean |
| { |
| return f_EPTF_Logging_isEnabled( |
| v_EPTF_HTTP_Transport_loggingMaskId, |
| c_EPTF_HTTP_Transport_loggingClassIdx_Debug); |
| } |
| } // group Logging |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Group: EPTF_HTTP_Transport_DB |
| // |
| // Purpose: |
| // Contains the database handling functions. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| group EPTF_HTTP_Transport_DB{ |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_Transport_debugEnabled |
| // |
| // Purpose: |
| // Function to check if debug is enabled for EPTF HTTP Transport |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // *boolean* - true if debug enalbed |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_Transport_Group_getName(in integer pl_groupId) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return charstring |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_groupId)) { return ""; }; |
| |
| return v_EPTF_HTTP_Transport_portDB[pl_groupId].name; |
| } |
| |
| function f_EPTF_HTTP_Transport_Group_getLocHostInfo(in integer pl_groupId) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return EPTF_HTTP_HostInformation |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_groupId)) { return {"", -1}; }; |
| |
| return v_EPTF_HTTP_Transport_portDB[pl_groupId].baseLocalHostInformation; |
| } |
| |
| function f_EPTF_HTTP_Transport_Group_getRemoteHostInfo(in integer pl_groupId) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return EPTF_HTTP_HostInformation |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_groupId)) { return {"", -1}; }; |
| |
| return v_EPTF_HTTP_Transport_portDB[pl_groupId].baseRemoteHostInformation; |
| } |
| |
| function f_EPTF_HTTP_Transport_Group_getNumberOfPorts(in integer pl_groupId) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return integer |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_groupId)) { return -1; }; |
| |
| return v_EPTF_HTTP_Transport_portDB[pl_groupId].numberOfPorts; |
| } |
| |
| function f_EPTF_HTTP_Transport_Group_getLocalportStep(in integer pl_groupId) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return integer |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_groupId)) { return -1; }; |
| |
| return v_EPTF_HTTP_Transport_portDB[pl_groupId].localportStep; |
| } |
| |
| function f_EPTF_HTTP_Transport_Group_getRemoteportStep(in integer pl_groupId) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return integer |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_groupId)) { return -1; }; |
| |
| return v_EPTF_HTTP_Transport_portDB[pl_groupId].remoteportStep; |
| } |
| |
| function f_EPTF_HTTP_Transport_Group_getUseSSL(in integer pl_groupId, inout boolean pl_useSSL) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return boolean |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_groupId)) { return false; }; |
| |
| pl_useSSL := v_EPTF_HTTP_Transport_portDB[pl_groupId].useSSL; |
| return true; |
| } |
| |
| function f_EPTF_HTTP_Transport_Group_getInstantConnClose(in integer pl_groupId, inout boolean pl_instantConnClose) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return boolean |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_groupId)) { return false; }; |
| |
| pl_instantConnClose := v_EPTF_HTTP_Transport_portDB[pl_groupId].instantConnClose; |
| return true; |
| } |
| |
| function f_EPTF_HTTP_Transport_Group_getInstantConnOpen(in integer pl_groupId, inout boolean pl_instantConnOpen) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return boolean |
| { |
| if (not f_EPTF_HTTP_LocalTransport_checkGroup(pl_groupId)) { return false; }; |
| |
| pl_instantConnOpen := v_EPTF_HTTP_Transport_portDB[pl_groupId].instantConnOpen; |
| return true; |
| } |
| |
| }//EPTF_HTTP_Transport_DB |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Group: EPTF_HTTP_Buffer |
| // |
| // Purpose: |
| // Contains the buffer handling functions. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| group EPTF_HTTP_Buffer{ |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_MsgBuffer_init |
| // |
| // Purpose: |
| // Initializes the message buffer. |
| // |
| // Parameters: |
| // pl_buffer - *inout* <EPTF_HTTP_MessageBuffer> - |
| // pl_size - *in* *integer* - maximum size of the buffer |
| // pl_id - *in* *integer* - unique identifier of the buffer |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_MsgBuffer_init(inout EPTF_HTTP_MessageBuffer pl_buffer, in integer pl_size, in integer pl_id) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_RingBuffer_init(pl_buffer.seqNums, pl_size, pl_id); |
| pl_buffer.seqNum2messageIdxHM := |
| f_EPTF_int2int_HashMap_New(c_EPTF_HTTP_LocalTransport_HashMap_seqNum2messageIdx & int2str(pl_id)); |
| f_EPTF_FBQ_initFreeBusyQueue(pl_buffer.messageQueue); |
| pl_buffer.httpMessages := {} |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RingBuffer_init |
| // |
| // Purpose: |
| // Initializes the sequence numbers. |
| // |
| // Parameters: |
| // pl_buffer - *inout* <EPTF_HTTP_SeqNumMgmt> - |
| // pl_size - *in* *integer* - maximum sequence number |
| // pl_id - *in* *integer* - unique identifier |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RingBuffer_init(inout EPTF_HTTP_RingBuffer pl_buffer, in integer pl_size, in integer pl_id) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| pl_buffer.nextSeqNum := 0; |
| pl_buffer.waitForSeqNum := 0; |
| pl_buffer.usedSlots := 0; |
| pl_buffer.maxSize := pl_size; |
| |
| pl_buffer.isSlotBusyHM := |
| f_EPTF_int2int_HashMap_New(c_EPTF_HTTP_LocalTransport_HashMap_isSlotBusy & int2str(pl_id)); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RingBuffer_clear |
| // |
| // Purpose: |
| // Clears the sequence numbers. |
| // |
| // Parameters: |
| // pl_buffer - *inout* <EPTF_HTTP_RingBuffer> - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RingBuffer_clear(inout EPTF_HTTP_RingBuffer pl_buffer) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| pl_buffer.nextSeqNum := 0; |
| pl_buffer.waitForSeqNum := 0; |
| pl_buffer.usedSlots := 0; |
| |
| f_EPTF_int2int_HashMap_Clear(pl_buffer.isSlotBusyHM); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RingBuffer_erase |
| // |
| // Purpose: |
| // Clears the sequence numbers. |
| // |
| // Parameters: |
| // pl_buffer - *inout* <EPTF_HTTP_RingBuffer> - |
| // pl_id - *in* *integer* - unique identifier |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RingBuffer_erase(inout EPTF_HTTP_RingBuffer pl_buffer, in integer pl_id) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| pl_buffer.nextSeqNum := 0; |
| pl_buffer.waitForSeqNum := 0; |
| pl_buffer.usedSlots := 0; |
| |
| f_EPTF_int2int_HashMap_Delete(c_EPTF_HTTP_LocalTransport_HashMap_isSlotBusy & int2str(pl_id)); |
| |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_MsgBuffer_clear |
| // |
| // Purpose: |
| // Clears the message buffer. |
| // |
| // Parameters: |
| // pl_buffer - *inout* <EPTF_HTTP_Buffer> - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_MsgBuffer_clear(inout EPTF_HTTP_MessageBuffer pl_buffer) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_RingBuffer_clear(pl_buffer.seqNums); |
| f_EPTF_int2int_HashMap_Clear(pl_buffer.seqNum2messageIdxHM) |
| f_EPTF_FBQ_initFreeBusyQueue(pl_buffer.messageQueue); |
| pl_buffer.httpMessages := {} |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_MsgBuffer_erase |
| // |
| // Purpose: |
| // Erases the message buffer. |
| // |
| // Parameters: |
| // pl_buffer - *inout* <EPTF_HTTP_Buffer> - |
| // pl_id - *in* *integer* - unique identifier |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_MsgBuffer_erase(inout EPTF_HTTP_MessageBuffer pl_buffer, in integer pl_id) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_bufferDebug("### " & %definitionId & "()"); |
| |
| f_EPTF_HTTP_RingBuffer_erase(pl_buffer.seqNums, pl_id); |
| f_EPTF_int2int_HashMap_Delete(c_EPTF_HTTP_LocalTransport_HashMap_seqNum2messageIdx & int2str(pl_id)) |
| pl_buffer.seqNum2messageIdxHM := -1; |
| f_EPTF_FBQ_initFreeBusyQueue(pl_buffer.messageQueue); |
| pl_buffer.httpMessages := {} |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RingBuffer_getNext |
| // |
| // Purpose: |
| // Gets the next sequence number. |
| // |
| // Parameters: |
| // pl_buffer - *inout* <EPTF_HTTP_RingBuffer> - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RingBuffer_getNext(inout EPTF_HTTP_RingBuffer pl_buffer) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return integer |
| { |
| if (pl_buffer.usedSlots == pl_buffer.maxSize) |
| { |
| f_EPTF_HTTP_Transport_bufferWarning(log2str(%definitionId & |
| ": Buffer is full!")); |
| return -1; |
| } |
| |
| var integer vl_next := pl_buffer.nextSeqNum; |
| |
| pl_buffer.nextSeqNum := (vl_next + 1) mod pl_buffer.maxSize; |
| |
| pl_buffer.usedSlots := pl_buffer.usedSlots + 1 |
| |
| return vl_next; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RingBuffer_setElementBusy |
| // |
| // Purpose: |
| // Sets the element status to busy. |
| // |
| // Parameters: |
| // pl_buffer - *inout* <EPTF_HTTP_RingBuffer> - |
| // pl_elemIdx -*integer* *integer*- element index |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RingBuffer_setElementBusy(inout EPTF_HTTP_RingBuffer pl_buffer, in integer pl_elemIdx) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| if (pl_elemIdx >= pl_buffer.nextSeqNum and pl_elemIdx < pl_buffer.waitForSeqNum) |
| { |
| f_EPTF_HTTP_Transport_bufferWarning(log2str(%definitionId & |
| ": Setting invalid index (",pl_elemIdx,"). ", "head: ", pl_buffer.waitForSeqNum, " tail: ", pl_buffer.nextSeqNum)); |
| return; |
| } |
| |
| f_EPTF_int2int_HashMap_Insert(pl_buffer.isSlotBusyHM, pl_elemIdx, 1); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RingBuffer_isHeadBusy |
| // |
| // Purpose: |
| // Retreive head slot status. |
| // |
| // Parameters: |
| // pl_buffer - *in* <EPTF_HTTP_RingBuffer> - |
| // |
| // Return Value: |
| // boolean - true if the head is busy |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RingBuffer_isHeadBusy(in EPTF_HTTP_RingBuffer pl_buffer) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return boolean |
| { |
| var integer vl_tmp; |
| return f_EPTF_int2int_HashMap_Find(pl_buffer.isSlotBusyHM, pl_buffer.waitForSeqNum, vl_tmp); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RingBuffer_freeHead |
| // |
| // Purpose: |
| // Sets the status of the head to free. |
| // |
| // Parameters: |
| // pl_buffer - *inout* <EPTF_HTTP_RingBuffer> - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RingBuffer_freeHead(inout EPTF_HTTP_RingBuffer pl_buffer) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_int2int_HashMap_Erase(pl_buffer.isSlotBusyHM, pl_buffer.waitForSeqNum); |
| pl_buffer.usedSlots := pl_buffer.usedSlots - 1; |
| |
| pl_buffer.waitForSeqNum := (pl_buffer.waitForSeqNum + 1) mod pl_buffer.maxSize |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_RingBuffer_getHeadIdx |
| // |
| // Purpose: |
| // Gets the index of the head. |
| // |
| // Parameters: |
| // pl_buffer - *in* <EPTF_HTTP_RingBuffer> - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_RingBuffer_getHeadIdx(in EPTF_HTTP_RingBuffer pl_buffer) |
| runs on EPTF_HTTP_LocalTransport_CT |
| return integer |
| { |
| return pl_buffer.waitForSeqNum; |
| } |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HTTP_printBufferStatus |
| // |
| // Purpose: |
| // Prints message buffer status. |
| // |
| // Parameters: |
| // pl_group - *in* *integer* - group id |
| // pl_port - *in* *integer* - port id |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| function f_EPTF_HTTP_printBufferStatus(in integer pl_group, in integer pl_port) |
| runs on EPTF_HTTP_LocalTransport_CT |
| { |
| f_EPTF_HTTP_Transport_bufferDebug(log2str(%definitionId, ": Buffer status (group: ",pl_group," port: ",pl_port,"):", |
| " next sequence number: "& int2str(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].messageBuffer.seqNums.nextSeqNum), |
| " waiting for: ", int2str(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].messageBuffer.seqNums.waitForSeqNum), |
| " used slots: ", int2str(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].messageBuffer.seqNums.usedSlots), |
| " size of message buffer: ", |
| f_EPTF_FBQ_getLengthOfFreeChain(v_EPTF_HTTP_Transport_portDB[pl_group].portDatabase[pl_port].messageBuffer.messageQueue))); |
| |
| } |
| |
| }//EPTF_HTTP_Buffer |
| |
| }//end of module |
| with { |
| extension "version <RnXnn>" |
| } |
| |
