internal void AddPublicationConnectionHandler(DPE_PublicationConnectionHandler publicationConnectionHandler) { lock (this._tableOfPublicationConnectionHandlers) { if (!this._tableOfPublicationConnectionHandlers.ContainsKey(publicationConnectionHandler.PublicationName)) { this._tableOfPublicationConnectionHandlers.Add(publicationConnectionHandler.PublicationName, publicationConnectionHandler); } else { throw (new Exception("The connection handler for publication \'" + publicationConnectionHandler.PublicationName + "\' is already added.")); } } }
internal void DisposeConnectionHandler(string publicationName) { if (this.ContainsConnectionHandler(publicationName)) { DPE_PublicationConnectionHandler publicationCnnHandler = default(DPE_PublicationConnectionHandler); publicationCnnHandler = this._STXDSSPublicationConnectionHandlersContainer.GetConnectionHandler(publicationName); //-------------------------------------------------------------- try { publicationCnnHandler.PublicationDataReceived -= STXDSSPublicationConnectionHandler_PublicationDataReceived; publicationCnnHandler.ConnectionToPublicationLost -= STXDSSPublicationConnectionHandler_ConnectionLost; publicationCnnHandler.PublicationDataResetReceived -= STXDSSPublicationConnectionHandler_PublicationDataResetReceived; } catch (Exception) { } try { publicationCnnHandler.Dispose(); } catch (Exception) { } //stops any attempt to connect to a publication if (this.ContainsScheduledPublicationConnectionTask(publicationName)) { this.AbortScheduledConnectionToAPublication(publicationName); } this._STXDSSPublicationConnectionHandlersContainer.RemoveConnectionHandler(publicationName); //If Me._tableOfConnectionInfoRegistersOfConnectionsToPublications.ContainsKey(publicationName) Then // Me._tableOfConnectionInfoRegistersOfConnectionsToPublications.Remove(publicationName) //End If } }
internal void DiscardAllLocalConnectionsToPublications() { lock (this._tableOfPublicationConnectionHandlers) { IEnumerator enumm = default(IEnumerator); DPE_PublicationConnectionHandler handler = default(DPE_PublicationConnectionHandler); enumm = this._tableOfPublicationConnectionHandlers.GetEnumerator(); while (enumm.MoveNext()) { handler = (DPE_PublicationConnectionHandler)((DictionaryEntry)enumm.Current).Value; try { handler.DisconnectFromPublication(); handler.Dispose(); } catch (Exception) { } } this._tableOfPublicationConnectionHandlers.Clear(); } }
private void ReconnectToDataPublication(string publicationName) { //*********************************************************************** //creates a task to restablisht the connection to the publication if (this._tableOfConnectionInfoRegistersOfConnectionsToPublications.ContainsKey(publicationName)) { PublicationConnectionInfo cnnInfo = new PublicationConnectionInfo(); cnnInfo = (PublicationConnectionInfo)this._tableOfConnectionInfoRegistersOfConnectionsToPublications[publicationName]; this.ScheduleConnectionTaskToAPublication(cnnInfo.PublicationName, cnnInfo.ConnectionMode); } //*********************************************************************** //frees the connection handler resources of previous connection to the publication DPE_PublicationConnectionHandler publicationCnnHandler = default(DPE_PublicationConnectionHandler); publicationCnnHandler = this._STXDSSPublicationConnectionHandlersContainer.GetConnectionHandler(publicationName); if (!(publicationCnnHandler == null)) { try { publicationCnnHandler.PublicationDataReceived -= STXDSSPublicationConnectionHandler_PublicationDataReceived; publicationCnnHandler.ConnectionToPublicationLost -= STXDSSPublicationConnectionHandler_ConnectionLost; publicationCnnHandler.PublicationDataResetReceived -= STXDSSPublicationConnectionHandler_PublicationDataResetReceived; } catch (Exception) { } try { publicationCnnHandler.Dispose(); } catch (Exception) { } } }
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)); } } } }
internal DPE_PublicationConnectionHandler CreatePublicationConnectionHandler(DPE_PublicationConnectionHandler_Type handlerType, DPE_DataPublicationsClient client, string PublicationName, string PublicationHostName, int publicationsSocketsServerPortNumber, DPE_ServerDefs.DPE_PublicationConnectionMode connectionMode) { //*********************************************************************************************** //creates the handler according to the type of connection DPE_PublicationConnectionHandler publicationCnnHandler = null; publicationCnnHandler = new DPE_PublicationConnectionHandler(handlerType, client, PublicationName, PublicationHostName, publicationsSocketsServerPortNumber, connectionMode); if (!(publicationCnnHandler == null)) { try { //evaluates if the client is not the publisher of the publication, in order to avoid thepublisher client to //receive its own publication update if (!this._STXDataSocketClient.PublicationsPostManager.ContainsPublicationDefinition(PublicationName)) { if (publicationCnnHandler.HandlerType == DPE_PublicationConnectionHandler_Type.subscriptorHandler) { publicationCnnHandler.PublicationDataReceived += STXDSSPublicationConnectionHandler_PublicationDataReceived; publicationCnnHandler.PublicationDataResetReceived += STXDSSPublicationConnectionHandler_PublicationDataResetReceived; } } //for both type of handlers is created a handler to the connectio lost event in order to know when a connection to a publication //is lost publicationCnnHandler.ConnectionToPublicationLost += STXDSSPublicationConnectionHandler_ConnectionLost; } catch (Exception) { publicationCnnHandler.PublicationDataReceived -= STXDSSPublicationConnectionHandler_PublicationDataReceived; publicationCnnHandler.ConnectionToPublicationLost -= STXDSSPublicationConnectionHandler_ConnectionLost; publicationCnnHandler.PublicationDataResetReceived -= STXDSSPublicationConnectionHandler_PublicationDataResetReceived; } try { this._STXDSSPublicationConnectionHandlersContainer.AddPublicationConnectionHandler(publicationCnnHandler); } catch (Exception ex) { CustomEventLog.WriteEntry(EventLogEntryType.Error, ex.ToString()); } if (handlerType == DPE_PublicationConnectionHandler_Type.subscriptorHandler) { //--------------------------------------- //saves into a has table the publication name and its connection mode for further reference when is needed to perfofm //automatic reconnections just for connections handlers defined as subscriptors handler PublicationConnectionInfo cnnInfo = new PublicationConnectionInfo(); cnnInfo.connectionType = handlerType; cnnInfo.PublicationName = PublicationName; cnnInfo.ConnectionMode = connectionMode; try { //saves the connection information for the subscriptors connection type handlers if (this._tableOfConnectionInfoRegistersOfConnectionsToPublications.ContainsKey(PublicationName)) { this._tableOfConnectionInfoRegistersOfConnectionsToPublications.Remove(PublicationName); } this._tableOfConnectionInfoRegistersOfConnectionsToPublications.Add(PublicationName, cnnInfo); } catch (Exception ex) { CustomEventLog.WriteEntry(EventLogEntryType.Error, ex.ToString()); } } } //--------------------------------------- return(publicationCnnHandler); }