public Services.P2PCommunicationsScheme.Data.P2PData RetrieveData(Services.P2PCommunicationsScheme.Data.P2PDataRequest request, int P2PPortNumber) { if (request.RequestedDataName == CNDServiceDefinitions.CND_TABLE_DATA_NAME) { P2PData cndTable = new P2PData(CNDServiceDefinitions.CND_TABLE_DATA_NAME, this.CNDTable.DataTable); return(cndTable); //***************************************************************** // !!!!! IMPORTANT EVALUATION //this indicates to the connected client that the port belongs to //the CND service, //***************************************************************** } else if (request.RequestedDataName == CNDServiceDefinitions.CND_SERVICE_PORT_CONNECTION_CHECK_DATA) { return(new P2PData(CNDServiceDefinitions.CND_SERVICE_PORT_CONNECTION_CHECK_DATA, true)); //***************************************************************** //***************************************************************** } else if (request.RequestedDataName == CNDServiceDefinitions.CND_GET_COMPONENT_CND_REGISTRY_CMD) { return(this.Handle_GetComponentAddressingRegistry_Request(request)); } else { throw (new Exception("The CND Service can handle the data named \'" + request.RequestedDataName + "\'")); } }
public void btnRequestData_Click(System.Object sender, System.EventArgs e) { try { this.Cursor = Cursors.WaitCursor; if (this.txtDataNameToRequest.Text.Length <= 0) { throw (new Exception("No data name to request")); } P2PData data = default(P2PData); P2PDataRequest request = new P2PDataRequest(this.txtDataNameToRequest.Text); data = this._p2pPortclient.RetrieveData(request); this.CfDataDisplayCtrl1.ShowData(data.Value); } catch (Exception ex) { MessageBox.Show(ex.Message); } finally { this.Cursor = Cursors.Default; this.dgrdGeneralStatistics.DataSource = this._p2pPortclient.Statistics.GeneralStatisticsTable; this.dgrdRequestStats.DataSource = this._p2pPortclient.Statistics.DataRequestsStatisticsTable; } }
public void tmrAutoSend_Tick(System.Object sender, System.EventArgs e) { try { IEnumerator enumm = this.lstAutoSend.Items.GetEnumerator(); Data dat = default(Data); P2PData p2pdat = default(P2PData); while (enumm.MoveNext()) { dat = (CommunicationsUISupportLibrary.Data)enumm.Current; p2pdat = GetP2PDataToSend(dat); AssingDataAttributesToP2PData(p2pdat); try { this._p2pPortclient.SendData(P2PDataSendMode.SyncrhonicalSend, p2pdat); } catch (Exception ex) { this.lstErrorsOnAutoSEnd.Items.Add(ex.Message); } } this.dgrdGeneralStatistics.DataSource = this._p2pPortclient.Statistics.GeneralStatisticsTable; this.dgrdSendStats.DataSource = this._p2pPortclient.Statistics.DataSendingStatisticsTable; } catch (Exception ex) { this.lstErrorsOnAutoSEnd.Items.Add(ex.Message); } }
private P2PData GetP2PDataToSend() { if (this.CfDataManagerContainer1.DataCount > 0) { Data dat = this.CfDataManagerContainer1.SelectedData; P2PData p2pDat = default(P2PData); if (!(dat == null)) { p2pDat = P2PData.GetP2PDataObject(dat.DataName, dat.data); if (!(p2pDat == null)) { this.AssingDataAttributesToP2PData(p2pDat); return(p2pDat); } else { throw new Exception("No valid p2p data to return"); } } else { throw (new Exception("No selected data to send")); } } else { throw (new Exception("No data available to send")); } }
internal void PostPublicationOnServer(DPE_ClientPublicationDefinition PublicationDefinition) { //crates the publication definition into a P2PData to send to the server CustomHashTable varsToPublish = new CustomHashTable(); string variableName = ""; DPE_ServerDefs.PublicationVariableDataType variableDataType = default(DPE_ServerDefs.PublicationVariableDataType); string variableDataTypeAsString = ""; IEnumerator enumm = PublicationDefinition.VariablesToPublishTable.GetEnumerator(); while (enumm.MoveNext()) { variableName = System.Convert.ToString(((DictionaryEntry)enumm.Current).Key); variableDataType = (DPE_ServerDefs.PublicationVariableDataType)(((DictionaryEntry)enumm.Current).Value); variableDataTypeAsString = DPE_ServerDefs.Get_String_FromPublicationVariableDataType(variableDataType); varsToPublish.Add(variableName, variableDataTypeAsString); } P2PData data = new P2PData(DPE_ServerDefs.DPE_CMD_CREATE_PUBLICATION, varsToPublish); data.DataAttributesTable.AddAttribute(DPE_PublicationsDefinitions.DPE_PUBLICATIONS_GROUP, PublicationDefinition.PublicationsGroup); data.DataAttributesTable.AddAttribute(DPE_PublicationsDefinitions.DPE_CLIENT_ID, this._STXDataSocketClient.ClientID); data.DataAttributesTable.AddAttribute(DPE_PublicationsDefinitions.DPE_PUBLICATION_NAME, PublicationDefinition.PublicationName); Services.P2PCommunicationsScheme.P2PPortClient p2pclient = default(Services.P2PCommunicationsScheme.P2PPortClient); try { p2pclient = new Services.P2PCommunicationsScheme.P2PPortClient(this._STXDataSocketClient.DSSServerHostName, this._STXDataSocketClient.PublicationsPost_PortNumber); p2pclient.Connect(); //sends the information to the server in order to create it p2pclient.SendData(P2PDataSendMode.SyncrhonicalSend, data); p2pclient.Dispose(); //it the publication was created in the server then ists definition is saved in the publications posted manager //in order to allow it to re create ii if needed this.AddPublicationDefinitionAfterCreation(PublicationDefinition); string msg = "Publication \'" + PublicationDefinition.PublicationName + "\' -> POSTED succesfully."; CustomEventLog.WriteEntry(EventLogEntryType.SuccessAudit, msg); } catch (Exception ex) { try { this.RemovePublicationDefinition(PublicationDefinition); } catch (Exception) { } string errMSg = ""; errMSg = "Error creating the publication \'" + PublicationDefinition.PublicationName + "\' : " + ex.Message; throw (new Exception(errMSg)); } }
public CommunicationsData(string addresseComponentName, string senderComponentName, string dataName, DataSet data) { dataName = dataName.ToUpper(); this._senderComponentName = senderComponentName; this._addresseComponentName = addresseComponentName; this._p2pData = new P2PData(dataName, data); this._p2pData.DataAttributesTable.AddAttribute("SENDER_COMPONENT", senderComponentName); this._p2pData.DataAttributesTable.AddAttribute("ADDRESSE_COMPONENT", addresseComponentName); }
internal void LogDataReceptionEvent(P2PData data) { try { this._LogDataReceptionEventQueue.Enqueue(data); } catch (Exception) { } }
internal void LogDataSendEvent(P2PData data) { try { this.LogDataSendEventsOnTable(data); } catch (Exception) { } }
internal CommunicationsData RetrieveData(CNDCommunicationsEnvironment.Data.CommunicationsDataRequest datarequest) { P2PData dataResult = default(P2PData); dataResult = this._p2pPortClient.RetrieveData(datarequest.P2PDataRequest); CommunicationsData dataRetrieved = default(CommunicationsData); dataRetrieved = CommunicationsData.GetCommunicationsDataObject(datarequest.RemoteAddresseComponentName, datarequest.SenderComponentName, dataResult.DataName, dataResult.Value); return(dataRetrieved); }
public CommunicationsLibrary.Services.P2PCommunicationsScheme.Data.P2PData RetrieveData(CommunicationsLibrary.Services.P2PCommunicationsScheme.Data.P2PDataRequest request, int HandlerP2PPortNumber) { string dataName = request.RequestedDataName; if (this.chkSimulateHaltExecution.Checked) { while (true) { System.Threading.Thread.Sleep(10); if (!this.chkSimulateHaltExecution.Checked) { break; } } } if (this.chkSimulateFailure.Checked) { if (rbtnSimulateNull.Checked) { return(null); } else { throw (new Exception(this.txtExceptionText.Text)); } } if (this.chkRequestLog.Checked) { string msgStr = "Data Requested : " + dataName; this.SetListBoxItem(this.lstRequestReceived, msgStr); } this.SetDataGridDataSource(this.dgrGeneralStatistics, this._P2PPort.Statistics.GeneralStatisticsTable); this.SetDataGridDataSource(this.dgrRequestStatistics, this._P2PPort.Statistics.DataRequestsStatisticsTable); if (this.CfDataManagerContainer1.ContainsData(dataName)) { Data dat = this.CfDataManagerContainer1.DataItem(dataName); P2PData data = default(P2PData); data = P2PData.GetP2PDataObject(dataName, dat.data); return(data); } else { return(null); } }
private void SendDataInAsynchronicalMode(P2PData data) { //this method send data to the P2PPort without waiting a callback or a result from the remote port bool throwError = false; string errMsg = ""; if (!(this._tcpClient == null)) { lock (this._socketPortBlockingFlag) { this._dataDEliveryResultISAvailable = false; byte[] dataByteBuffer = data.Serialize(); if (dataByteBuffer.Length > P2PNetworkingDefinitions.DATABUFFER_SIZE) { throwError = true; errMsg = "The size of the data exceeds the maximun limit of " + System.Convert.ToString(P2PNetworkingDefinitions.DATABUFFER_SIZE) + " for the P2P port"; } else { if (!(this._socketStream == null)) { try { this._socketStream.Write(dataByteBuffer, 0, dataByteBuffer.Length); this.Statistics.LogDataSendEvent(data); } catch (Exception ex) { throwError = true; errMsg = ex.Message; } } else { throwError = true; errMsg = "The socket stream is not available"; } } } if (throwError) { throw (new Exception(errMsg)); } } else { throw (new Exception("The client is not connected to the remote port specified as [" + this._remoteHostName + " : " + System.Convert.ToString(this._remotePortNumber) + "]")); } }
private void Handle_ComponentRegistrationRemoval_Data(P2PData data) { if (!data.DataAttributesTable.ContainsAttribute(CNDServiceDefinitions.COMPONENT_NAME)) { throw (new Exception("can\'t remove a component registry becuase the parameter \'" + CNDServiceDefinitions.COMPONENT_NAME + " \' is missing")); } P2PDataAttributesTable.P2PDataAttribute attr = new P2PDataAttributesTable.P2PDataAttribute(); attr = data.DataAttributesTable.GetAttribute(CNDServiceDefinitions.COMPONENT_NAME); string compName = ""; compName = attr.AttrValue; this.UnsubsribeComponent(compName); }
public static P2PData GetP2PDataObject(string dataName, object data) { string type = data.GetType().ToString(); P2PData _p2pData = default(P2PData); switch (type) { case "System.String": _p2pData = new P2PData(dataName, System.Convert.ToString(data)); break; case "System.Int32": _p2pData = new P2PData(dataName, System.Convert.ToInt32(data)); break; case "System.Decimal": _p2pData = new P2PData(dataName, System.Convert.ToDecimal(data)); break; case "System.Boolean": _p2pData = new P2PData(dataName, System.Convert.ToBoolean(data)); break; case "System.Data.DataTable": _p2pData = new P2PData(dataName, (DataTable)data); break; case "System.Data.DataSet": _p2pData = new P2PData(dataName, (DataSet)data); break; case "UtilitiesLibrary.Data.CustomHashTable": _p2pData = new P2PData(dataName, (CustomHashTable)data); break; case "UtilitiesLibrary.Data.CustomList": _p2pData = new P2PData(dataName, (CustomList)data); break; case "UtilitiesLibrary.Data.CustomSortedList": _p2pData = new P2PData(dataName, (CustomSortedList)data); break; default: throw (new Exception("Unsupported data type \'" + type + "\' for \'P2PData\' data type ")); } return(_p2pData); }
private void Handle_ComponentRegistration_Data(P2PData data) { UtilitiesLibrary.Data.CustomHashTable table = default(UtilitiesLibrary.Data.CustomHashTable); table = (CustomHashTable)data.Value; if (!table.Contains(CNDServiceDefinitions.CND_TABLE_COMPONENT_NAME)) { throw (new Exception("Can\'t register a component in CNDService becuase the parameter \'[Component Name]\' is missing.")); } if (!table.Contains(CNDServiceDefinitions.CND_TABLE_HOST_NAME)) { throw (new Exception("Can\'t register a component in CNDService becuase the parameter \'[Hostname]\' is missing.")); } if (!table.Contains(CNDServiceDefinitions.CND_TABLE_P2P_PORT_NUMBER)) { throw (new Exception("Can\'t register a component in CNDService becuase the parameter \'[P2PPortNumber]\' is missing.")); } if (!table.Contains(CNDServiceDefinitions.CND_TABLE_IP_ADDRESS)) { throw (new Exception("Can\'t register a component in CNDService becuase the parameter \'[IPAddress]\' is missing.")); } if (!table.Contains(CNDServiceDefinitions.CND_TABLE_APPLICATION_NAME)) { throw (new Exception("Can\'t register a component in CNDService becuase the parameter \'[Application Name]\' is missing.")); } if (!table.Contains(CNDServiceDefinitions.CND_TABLE_APPLICATION_PROCESS_ID)) { throw (new Exception("Can\'t register a component in CNDService becuase the parameter \'[Application Process ID]\' is missing.")); } string compName = System.Convert.ToString(table.Item(CNDServiceDefinitions.CND_TABLE_COMPONENT_NAME)); compName = compName.ToUpper(); string hostName = System.Convert.ToString(table.Item(CNDServiceDefinitions.CND_TABLE_HOST_NAME)); string P2PPortNumber = System.Convert.ToString(table.Item(CNDServiceDefinitions.CND_TABLE_P2P_PORT_NUMBER)); string IPAddress = System.Convert.ToString(table.Item(CNDServiceDefinitions.CND_TABLE_IP_ADDRESS)); string ApplicationName = System.Convert.ToString(table.Item(CNDServiceDefinitions.CND_TABLE_APPLICATION_NAME)); string ApplicationProcessID = System.Convert.ToString(table.Item(CNDServiceDefinitions.CND_TABLE_APPLICATION_PROCESS_ID)); int portNumber = Convert.ToInt32(P2PPortNumber); this.SubscribeComponent(compName, hostName, IPAddress, portNumber, ApplicationName, ApplicationProcessID); }
private void LoadDataAttributes(P2PData data) { this.lstDataAttributes.Items.Clear(); IEnumerator enumm = default(IEnumerator); enumm = data.DataAttributesTable.GetEnumerator(); CommunicationsLibrary.Services.P2PCommunicationsScheme.Data.P2PDataAttributesTable.P2PDataAttribute attr = default(CommunicationsLibrary.Services.P2PCommunicationsScheme.Data.P2PDataAttributesTable.P2PDataAttribute); string str = ""; while (enumm.MoveNext()) { attr = (CommunicationsLibrary.Services.P2PCommunicationsScheme.Data.P2PDataAttributesTable.P2PDataAttribute)enumm.Current; str = attr.AttrName + " , " + attr.AttrValue; this.lstDataAttributes.Items.Add(str); } }
private void AssingDataAttributesToP2PData(P2PData data) { if (this._dataAttributesTable.ContainsKey(data.DataName)) { //the data has attributes Hashtable attrTable = (Hashtable)(this._dataAttributesTable[data.DataName]); IEnumerator enumm = attrTable.GetEnumerator(); string attrName = ""; string attrValue = ""; while (enumm.MoveNext()) { attrName = System.Convert.ToString(((DictionaryEntry)enumm.Current).Key); attrValue = System.Convert.ToString(((DictionaryEntry)enumm.Current).Value); data.DataAttributesTable.AddAttribute(attrName, attrValue); } } }
public void btnSendData_Click(System.Object sender, System.EventArgs e) { try { P2PData dat = this.GetP2PDataToSend(); this._p2pPortclient.SendData(P2PDataSendMode.SyncrhonicalSend, dat); } catch (Exception ex) { MessageBox.Show(ex.Message); } finally { this.dgrdGeneralStatistics.DataSource = this._p2pPortclient.Statistics.GeneralStatisticsTable; this.dgrdSendStats.DataSource = this._p2pPortclient.Statistics.DataSendingStatisticsTable; } }
private P2PData Handle_GetComponentAddressingRegistry_Request(P2PDataRequest request) { string componentName = ""; componentName = request.GetRequestParameter(CNDServiceDefinitions.COMPONENT_NAME); if (componentName == null) { throw (new Exception("Can\'t resolve the Addressing because the paramter \'COMPONENT_NAME\' was missing in the data request.")); } if (!this.CNDTable.ContainsComponentRegistry(componentName)) { throw (new Exception("Can\'t resolve the Addressig for component \'" + componentName + "\' because is not registered on the Service")); } CustomHashTable cnsREgister = this.CNDTable.GetComponentRegistry(componentName); P2PData register = new P2PData("CND_ADDRESSING_REGISTER", cnsREgister); return(register); }
public void lstDataReceived_SelectedIndexChanged(System.Object sender, System.EventArgs e) { this.txtXMLDataString.Text = ""; this.lstDataAttributes.Items.Clear(); if (this.lstDataReceived.SelectedIndex >= 0) { P2PData dat = default(P2PData); dat = (CommunicationsLibrary.Services.P2PCommunicationsScheme.Data.P2PData) this.lstDataReceived.SelectedItem; this.CfDataDisplayCtrl1.ShowData(dat.Value); this.txtXMLDataString.Text = dat.XMLDataString; if (dat.DataAttributesTable.count > 0) { this.LoadDataAttributes(dat); } } }
private void _net_DisplayPeerMessage(P2PData message, string from) { // Показать полученное сообщение (вызывается из службы WCF) _board.SetMap(message.Map); var method = new MethodInvoker(() => { Invalidate(); _game.Direction = message.Player == Player.Black; _game.BlackScore = message.BlackScore; _game.WhiteScore = message.WhiteScore; UpdateStatusText(message.Step); UpdateStatus(); if (message.Player == Player.Black) { var item = new LogItem() { Number = _game.Log.Count + 1, White = message.Step }; item.AddToMap(_board.GetMap().DeepClone()); _game.Log.Add(item); lvLog.VirtualListSize = _game.Log.Count; var lvi = lvLog.Items[lvLog.Items.Count - 1]; lvLog.FocusedItem = lvi; lvi.EnsureVisible(); lvLog.Invalidate(); } else { var item = _game.Log[_game.Log.Count - 1]; item.Black = message.Step; item.AddToMap(_board.GetMap().DeepClone()); lvLog.Invalidate(); } }); if (InvokeRequired) { BeginInvoke(method); } else { method(); } }
public void tmrAutoRequest_Tick(System.Object sender, System.EventArgs e) { try { P2PData data = default(P2PData); P2PDataRequest request = new P2PDataRequest(this.txtDataNameToRequest.Text); data = this._p2pPortclient.RetrieveData(request); this.CfDataDisplayCtrl1.ShowData(data.Value); } catch (Exception ex) { this.lstErrorsOnAutoRequest.Items.Add(ex.Message); } finally { this.dgrdGeneralStatistics.DataSource = this._p2pPortclient.Statistics.GeneralStatisticsTable; this.dgrdRequestStats.DataSource = this._p2pPortclient.Statistics.DataRequestsStatisticsTable; } }
public void SendData(P2PDataSendMode mode, P2PData data) { switch (mode) { case P2PDataSendMode.SyncrhonicalSend: //sends data to the remote port and waits intil the remote port returns a operation //result try { this.SendDataInSynchronicalMode(data); } catch (Exception ex) { throw (ex); } try { if (SuccesfullyDataSentEvent != null) { SuccesfullyDataSentEvent(data); } } catch (Exception) { } break; case P2PDataSendMode.AsynchronycalSend: //this method send data to the P2PPort without waiting a callback or a result from the remote port this.SendDataInAsynchronicalMode(data); try { if (SuccesfullyDataSentEvent != null) { SuccesfullyDataSentEvent(data); } } catch (Exception) { } break; } }
private P2PData GetP2PDataToSend(Data dat) { P2PData p2pDat = default(P2PData); string dataType = dat.data.GetType().ToString(); switch (dataType) { case "System.String": p2pDat = new P2PData(dat.DataName, System.Convert.ToString(dat.data)); break; case "System.Int32": p2pDat = new P2PData(dat.DataName, System.Convert.ToInt32(dat.data)); break; case "System.Boolean": p2pDat = new P2PData(dat.DataName, System.Convert.ToBoolean(dat.data)); break; case "System.Decimal": p2pDat = new P2PData(dat.DataName, System.Convert.ToDecimal(dat.data)); break; case "System.Data.DataTable": p2pDat = new P2PData(dat.DataName, (DataTable)dat.data); break; case "UtilitiesLibrary.Data.CustomHashTable": p2pDat = new P2PData(dat.DataName, (CustomHashTable)dat.data); break; case "UtilitiesLibrary.Data.CustomList": p2pDat = new P2PData(dat.DataName, (CustomList)dat.data); break; case "UtilitiesLibrary.Data.CustomSortedList": p2pDat = new P2PData(dat.DataName, (CustomSortedList)dat.data); break; } return(p2pDat); }
public Services.P2PCommunicationsScheme.Data.P2PData RetrieveData(Services.P2PCommunicationsScheme.Data.P2PDataRequest request, int P2PPortNumber) { string adresseComponentName = System.Convert.ToString(request.GetRequestParameter("ADDRESSE_COMPONENT")); if (adresseComponentName == null) { throw (new Exception("Can\'t retrieve data because the parameter \'ADDRESSE_COMPONENT\' was missing in the request structure")); } string senderComponentName = System.Convert.ToString(request.GetRequestParameter("SENDER_COMPONENT")); if (senderComponentName == null) { throw (new Exception("Can\'t retrieve data because the parameter \'SENDER_COMPONENT\' was missing in the request structure")); } CNDCommunicationsEnvironment.Data.CommunicationsDataRequest commdDataRequest = new CNDCommunicationsEnvironment.Data.CommunicationsDataRequest(adresseComponentName, senderComponentName, System.Convert.ToString(request.RequestedDataName)); CommunicationsData dataResult = ((CNDCommunicationsEnvironment.Interfaces.IUseCNDCommunicationsScheme) this._componentOwner).RetrieveDataToRemoteComponent(commdDataRequest); P2PData resultData = P2PData.GetP2PDataObject(dataResult.P2PData.DataName, dataResult.P2PData.Value); return(resultData); }
internal static void PrepareDataToSend(SocketAsyncEventArgs e, P2PData data) { Byte[] SerializedData = data.Serialize(); DataPreparationHandler.PrepareAndBufferData(e, SerializedData); }
internal void ConnectoToPublication(DPE_PublicationConnectionHandler_Type connectionHandlerType, string publicationName, DPE_ServerDefs.DPE_PublicationConnectionMode connectionMode) { //***************************************************************************** //request to the server the connection parameters of the publication P2PDataRequest dataREquest = new P2PDataRequest(DPE_ServerDefs.DPE_CMD_PUBLICATION_SUBSCRIPTION_DATA); dataREquest.AddRequestParameter(DPE_PublicationsDefinitions.DPE_PUBLICATION_NAME, publicationName); P2PData publicationPArams = null; string msg = ""; Services.P2PCommunicationsScheme.P2PPortClient publicationsInformationRetrieveP2PPortClient = null; int trialsCount = 0; publicationsInformationRetrieveP2PPortClient = new Services.P2PCommunicationsScheme.P2PPortClient(this._STXDataSocketClient.DSSServerHostName, this._STXDataSocketClient.PublicationsInformationRetrieve_PortNumber); publicationsInformationRetrieveP2PPortClient.Connect(); //performs a while cycle until the client gets the connection parameters while (true) { try { publicationPArams = publicationsInformationRetrieveP2PPortClient.RetrieveData(dataREquest); break; } catch (Exception ex) { trialsCount++; if (trialsCount >= MAX_DATA_CONNECTION_PARAMETERS_INQUIRY_TRIALS) { msg = "Error trying to connect to publication \'" + publicationName + "\': " + ex.Message; throw (new Exception(msg)); } } System.Threading.Thread.Sleep(10); } try { publicationsInformationRetrieveP2PPortClient.Dispose(); } catch (Exception) { } CustomHashTable paramsList = (CustomHashTable)publicationPArams.Value; string publicationHostNAme = System.Convert.ToString(paramsList.Item(DPE_PublicationsDefinitions.DPE_PUBLICATION_HOSTNAME)); int publicationPort = System.Convert.ToInt32(paramsList.Item(DPE_PublicationsDefinitions.DPE_PUBLICATION_PORT)); //***************************************************************************** //CREATION OF THE PUBLICATION HANDLER and CONNECTION WITH publication DPE_PublicationConnectionHandler publicationConnectionHandler = default(DPE_PublicationConnectionHandler); publicationConnectionHandler = this.CreatePublicationConnectionHandler(connectionHandlerType, this._STXDataSocketClient, publicationName, publicationHostNAme, publicationPort, connectionMode); //***************************************************************************** //Ciclic process in order to allow the server to register the client socket connection . -> to synchronize the client registration //by ser client with the server event to log the publication event msg = "Error trying to perform the client connection registration to the publication \'" + publicationName + "\' : "; //***************************************************************************** //registration of the client connection to a publication in the server //the client sends to the server a information telling to which publication has already connected //and also for the TCP client mode to tell the publication to which port send the data int connectionRegistrationTrialCounter = 0; bool connectionRegistration = false; //preparation of the connection information into a p2p data P2PData clientPubCnnData = new P2PData(DPE_ServerDefs.DPE_CMD_CLIENT_PUBLICATION_CONNECTION_REGISTRATION, DPE_ServerDefs.DPE_CMD_CLIENT_PUBLICATION_CONNECTION_REGISTRATION); clientPubCnnData.DataAttributesTable.AddAttribute(DPE_PublicationsDefinitions.DPE_CLIENT_ID, this._STXDataSocketClient.ClientID); clientPubCnnData.DataAttributesTable.AddAttribute(DPE_PublicationsDefinitions.DPE_PUBLICATION_NAME, publicationName); clientPubCnnData.DataAttributesTable.AddAttribute(DPE_PublicationsDefinitions.DPE_PUBLICATION_CONNECTION_HANDLER_ID, publicationConnectionHandler.HandlerID); //---------------------HANDLING FOR THE CONNECTION MODE ------------------------------ string connectionModeAsString = ""; connectionModeAsString = DPE_ServerDefs.Get_STXDSS_PublicationConnectionMode_ToAString(connectionMode); clientPubCnnData.DataAttributesTable.AddAttribute(DPE_PublicationsDefinitions.DPE_PUBLICATION_CLIENT_CONNECTION_MODE, connectionModeAsString); msg = "Error trying to perform the client connection registration to the publication \'" + publicationName + "\' : "; //sends to server the information to the server several times until the information reaches the server Services.P2PCommunicationsScheme.P2PPortClient publicationsClientRegistrationP2PPortClient = default(Services.P2PCommunicationsScheme.P2PPortClient); publicationsClientRegistrationP2PPortClient = new Services.P2PCommunicationsScheme.P2PPortClient(this._STXDataSocketClient.DSSServerHostName, this._STXDataSocketClient.PublicationsClientRegistration_PortNumber); publicationsClientRegistrationP2PPortClient.Connect(); while (connectionRegistration == false) { try { publicationsClientRegistrationP2PPortClient.SendData(P2PDataSendMode.SyncrhonicalSend, clientPubCnnData); connectionRegistration = true; publicationsClientRegistrationP2PPortClient.Dispose(); CustomEventLog.WriteEntry(EventLogEntryType.SuccessAudit, "Connection to publication \'" + publicationName + "\' succesfull"); break; } catch (Exception ex) { System.Threading.Thread.Sleep(10); connectionRegistrationTrialCounter++; if (connectionRegistrationTrialCounter >= MAX_CONNECTION_REGISTRATION_TRIALS) { msg = msg + ex.Message; try { publicationsClientRegistrationP2PPortClient.Dispose(); } catch (Exception) { } try { this.DisposeConnectionHandler(publicationName); } catch (Exception) { } throw (new Exception(msg)); } } } }
// function that mainly process the received data in the server port private void ProcessReceivedData(P2PPortClientHandler client) { try { if (!(client == null)) { try { //***************************************** //tries to deserialize to a P2PDATA //***************************************** P2PData data = P2PData.Deserialize(client.ReceiveDataBuffer); this.Statistics.LogDataReceptionEvent(data); try { //catches if an exception ocurrs to avoid the programm exist from the reading thread //because of a failure in the object that implements the interface. ((IUseP2PCommunicationsScheme)this._portOwnerComponent).ReceiveData(data, this.ListeningPortNumber); Services.P2PCommunicationsScheme.Data.P2PDataDeliveryResult successfulDataDelivery = Services.P2PCommunicationsScheme.Data.P2PDataDeliveryResult.GetSucceedDeliveryResult(data); client.handlerSocket.Send(successfulDataDelivery.Serialize()); //*************************************************************************************** } catch (Exception ex) { Services.P2PCommunicationsScheme.Data.P2PDataDeliveryResult failureDataDelivery = Services.P2PCommunicationsScheme.Data.P2PDataDeliveryResult.GetFailureDeliveryResult(data, ex.Message); client.handlerSocket.Send(failureDataDelivery.Serialize()); //*************************************************************************************** } } catch (Exception ex) { //***************************************** //tries to deserialize to a P2P_DATA_DELIVERY_RESULT //***************************************** P2PDataRequest dataRequest = default(P2PDataRequest); P2PData dataRequested = default(P2PData); try { dataRequest = P2PDataRequest.Deserialize(client.ReceiveDataBuffer); try { dataRequested = ((IUseP2PCommunicationsScheme)this._portOwnerComponent).RetrieveData(dataRequest, this.ListeningPortNumber); if (!(dataRequested == null)) { this.Statistics.LogSuccesfulDataRequestEvent(dataRequest); client.handlerSocket.Send(dataRequested.Serialize()); //*************************************************************************************** } else { this.Statistics.LogFailedDataRequestEvent(dataRequest); string portOwnerName = ((IUseP2PCommunicationsScheme)this._portOwnerComponent).P2PPortOwnerName; if (portOwnerName == null) { portOwnerName = "UNKNOWN"; } string errorMessage = "The remote object \'" + portOwnerName + "\' can\'t handle the requested data named \'" + dataRequest.RequestedDataName + "\'"; P2PDataRequestFailure reqFAilure = P2PDataRequestFailure.GetP2PDataRequestFailure(dataRequest, errorMessage); client.handlerSocket.Send(reqFAilure.Serialize()); //*************************************************************************************** } } catch (Exception ex2) { this.Statistics.LogFailedDataRequestEvent(dataRequest); string portOwnerName = ((IUseP2PCommunicationsScheme)this._portOwnerComponent).P2PPortOwnerName; if (portOwnerName == null) { portOwnerName = "UNKNOWN"; } string errorMessage = ex2.Message; P2PDataRequestFailure reqFAilure = P2PDataRequestFailure.GetP2PDataRequestFailure(dataRequest, errorMessage); client.handlerSocket.Send(reqFAilure.Serialize()); //*************************************************************************************** } } catch (Exception) { string msg = ""; msg = "Error processing incomming data from P2PPort client : " + ex.ToString(); CustomEventLog.WriteEntry(EventLogEntryType.Error, msg); } } } } catch (Exception ex) { string msg = ""; msg = "Error processing incomming data from P2PPort client : " + ex.ToString(); CustomEventLog.WriteEntry(EventLogEntryType.Error, msg); } }
internal static P2PDataDeliveryResult GetSucceedDeliveryResult(P2PData data) { P2PDataDeliveryResult result = new P2PDataDeliveryResult(data); return(result); }
private void LogDataSendEventsOnTable(P2PData Data) { if (!(Data == null)) { string selectionCriteria = ""; DataRow[] resultRows = null; //***************************************************************************** //updates the general statistics table //***************************************************************************** try { lock (this._generalStatisticsTable) { selectionCriteria = "[Client Port Event] = \'Successful Data Send\'"; resultRows = this._generalStatisticsTable.Select(selectionCriteria); if (resultRows.Length <= 0) { DataRow row = this._generalStatisticsTable.NewRow(); row["Client Port Event"] = "Successful Data Send"; row["Count"] = 1; this._generalStatisticsTable.Rows.Add(row); } else { long count = (long)(resultRows[0]["Count"]); count++; resultRows[0]["Count"] = count; resultRows[0].AcceptChanges(); } } } catch (Exception ex) { string msg = "Error updating P2PPortClient General Statistics Table : " + ex.ToString(); CustomEventLog.WriteEntry(EventLogEntryType.Error, msg); } //***************************************************************************** //updates the data send statistics table //***************************************************************************** try { lock (this._dataSendingStatisticsTable) { selectionCriteria = "DataName = \'" + Data.DataName + "\' AND DataType = \'" + Data.Value.GetType().ToString() + "\'"; resultRows = this._dataSendingStatisticsTable.Select(selectionCriteria); if (resultRows.Length <= 0) { //the dataname with the datatype is not registered DataRow row = this._dataSendingStatisticsTable.NewRow(); row["DataName"] = Data.DataName; row["DataType"] = Data.Value.GetType().ToString(); row["Count"] = 1; row["FirstSendDateTime"] = DateTime.Now; row["LastSendDateTime"] = DateTime.Now; this._dataSendingStatisticsTable.Rows.Add(row); } else { //the dataname with the datatype is registered long count = (long)(resultRows[0]["Count"]); count++; resultRows[0]["Count"] = count; resultRows[0]["LastSendDateTime"] = DateTime.Now; resultRows[0].AcceptChanges(); } } } catch (Exception ex) { string msg = "Error updating P2PPortClient Data Send Statistics Table : " + ex.ToString(); CustomEventLog.WriteEntry(EventLogEntryType.Error, msg); } } }
internal static P2PData ParseAndGet_P2PData_FromXMLDataString(string XMLString) { System.IO.StringReader sr = null; System.Xml.XmlTextReader m_xmlr = null; try { sr = new System.IO.StringReader(XMLString); m_xmlr = new System.Xml.XmlTextReader(sr); m_xmlr.WhitespaceHandling = System.Xml.WhitespaceHandling.None; } catch (System.Xml.XmlException) { string msg; msg = "Error trying to get XML format from P2P Data string [" + XMLString + "]"; } catch (Exception ex) { string msg = ""; msg = "Error trying to parse P2P socket XML string : " + ex.Message; throw (new Exception(msg)); } m_xmlr.Read(); string HeaderIdentifier = m_xmlr.Name; if (HeaderIdentifier != "P2P_DATA") { throw (new System.Xml.XmlException("Invalid P2P data header " + HeaderIdentifier + ". Must be \'P2P_DATA\'")); } else { //********************************************************** //retrieves the data operation type //********************************************************** string operationID = ""; operationID = m_xmlr.GetAttribute("P2PDataOperationID"); if (operationID == null) { operationID = Guid.NewGuid().ToString(); } //********************************************************** //retrieves the data itself //********************************************************** m_xmlr.Read(); string dataSectionName = m_xmlr.Name; DataVariable variable = default(DataVariable); if (dataSectionName == "DATA") { string variableXMLstring = m_xmlr.ReadOuterXml(); variable = XMLDataFormatting.RetrieveDataVariableFromXMLString(variableXMLstring); } else { throw (new Exception("Invalid data XML section name \'" + dataSectionName + "\'. Is expected to be \'DATA\'")); } //********************************************************** //retrieves the attributes table and its XML attributes //********************************************************** string dataAttributesSectionName = m_xmlr.Name; P2PDataAttributesTable attrTAble = null; int AttrCount = 0; if (dataAttributesSectionName == "DATA_ATTRIBUTES") { string attributesCount = m_xmlr.GetAttribute("DataAttrCount"); if (!(attributesCount == null)) { AttrCount = System.Convert.ToInt32(attributesCount); if (AttrCount > 0) { string attrTableXMLString = m_xmlr.ReadInnerXml(); DataVariable tableVar = default(DataVariable); tableVar = XMLDataFormatting.RetrieveDataVariableFromXMLString(attrTableXMLString); attrTAble = new P2PDataAttributesTable((CustomHashTable)tableVar.Data); } } else { throw (new Exception("The parameter \'AttrCount\' is missing on the XML string in te section \'DATA_ATTRIBUTES\'")); } } else { throw (new Exception("Invalid data attributes XML section name \'" + dataSectionName + "\'. Is expected to be \'DATA_ATTRIBUTES\'")); } P2PData data = default(P2PData); data = new P2PData(operationID, System.Convert.ToString(variable.Name), variable.Data); if (AttrCount > 0) { data.AttachAttributesTable(attrTAble); } return(data); } }