public PublicationScheduledTaskRegister(DPE_ClientPublicationDefinition def, System.Threading.Thread scheduleTask)
{
this.PublicationDefinition = def;
this.scheduledPostTaskThread = scheduleTask;
this.keepScheduleTaskWorking = true;
this.TaskTrialCounter = 0;
}
internal void RemovePublicationDefinition(DPE_ClientPublicationDefinition definition)
{
if (this.ContainsPublicationDefinition(definition))
{
this._publicationsDefinitionsTable.Remove(definition.PublicationName);
}
}
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 void btnOK_Click(System.Object sender, System.EventArgs e)
{
try
{
if (this.txtPublicationName.Text.Length <= 0)
{
this.txtPublicationName.Focus();
throw (new Exception("No Publication Name specified"));
}
if (this.lstBoxPublicationVariables.Items.Count <= 0)
{
throw (new Exception("No variables specified for the publication"));
}
DPE_ClientPublicationDefinition publication = default(DPE_ClientPublicationDefinition);
if (this.txtPublicationsGroup.Text.Length > 0)
{
publication = new DPE_ClientPublicationDefinition(this.txtPublicationsGroup.Text, this.txtPublicationName.Text);
}
else
{
publication = new DPE_ClientPublicationDefinition(this.txtPublicationName.Text);
}
string varName = "";
DPE_ServerDefs.PublicationVariableDataType varType = default(DPE_ServerDefs.PublicationVariableDataType);
IEnumerator enumm = this._publicationVariables.GetEnumerator();
while (enumm.MoveNext())
{
varName = System.Convert.ToString(((DictionaryEntry)enumm.Current).Key);
varType = (DPE_ServerDefs.PublicationVariableDataType)(((DictionaryEntry)enumm.Current).Value);
publication.AddVaribleToPublication(varName, varType);
}
this._client.CreateDataPublication(publication);
//creation of support object to serialize publicatio creation data
this._publicationsPostingData = new publicationsPosting.PostedPublicationDefinitionData(publication.PublicationName);
enumm = this._publicationVariables.GetEnumerator();
while (enumm.MoveNext())
{
varName = System.Convert.ToString(((DictionaryEntry)enumm.Current).Key);
varType = (DPE_ServerDefs.PublicationVariableDataType)(((DictionaryEntry)enumm.Current).Value);
publicationsPosting.PublicationVariableDefinitionData def = new publicationsPosting.PublicationVariableDefinitionData(varName, varType);
this._publicationsPostingData.AddVariableDefinition(def);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
this.DialogResult = System.Windows.Forms.DialogResult.None;
}
}
public bool ContainsPublicationDefinition(DPE_ClientPublicationDefinition definition)
{
if (this._publicationsDefinitionsTable.ContainsKey(definition.PublicationName))
{
return(true);
}
else
{
return(false);
}
}
internal void AddPublicationDefinition(DPE_ClientPublicationDefinition definition)
{
if (this.ContainsPublicationDefinition(definition))
{
throw (new Exception("The DPE publication definition is aleady included in the container"));
}
else
{
this._publicationsDefinitionsTable.Add(definition.PublicationName, definition);
}
}
public CF_DPE_ClientHandler(ClientHandlerData data)
{
// This call is required by the Windows Form Designer.
InitializeComponent();
// Add any initialization after the InitializeComponent() call.
this._client = new DPE_DataPublicationsClient(data.ClientName);
this._client.ConnectionWithSTXDataServerLost += this.ConnectionWithServerLost;
if (!this._client.IsConnected)
{
this._client.ConnectToServer();
}
this._ClientHandlerData = data;
this.lblSErverConnectionStatus.Text = "Status: Connected To Server";
this._PublicationsHandlersContainer = new CF_DPE_PublicationsPostHandlersContainer(this._client, this._ClientHandlerData);
this._PublicationsConnectionsHandlersContainer = new CF_DPE_PublicationsSubscriptionsHandlersContainer(this._client, this._ClientHandlerData);
//creates all the publications configured for the client
IEnumerator enumm = data.PublicationsPostEnumerator;
publicationsPosting.PostedPublicationDefinitionData pubPostData = null;
while (enumm.MoveNext())
{
pubPostData = (publicationsPosting.PostedPublicationDefinitionData)enumm.Current;
DPE_ClientPublicationDefinition publication = new DPE_ClientPublicationDefinition(pubPostData.PublicationName);
IEnumerator enumm2 = pubPostData.VariablesDefinitionContainer.GetEnumerator();
publicationsPosting.PublicationVariableDefinitionData varDAta = null;
while (enumm2.MoveNext())
{
varDAta = (publicationsPosting.PublicationVariableDefinitionData)enumm2.Current;
publication.AddVaribleToPublication(varDAta.VariableName, varDAta.DataType);
}
this._client.CreateDataPublication(publication);
this._PublicationsHandlersContainer.AddPublicationHandler(publication.PublicationName);
}
//creates all the connections with publications configured for the client
IEnumerator pubCnnEnumm = data.PublicationsConnectionsEnumerator;
publicationsConnection.PublicationConnectionData cnndta = default(publicationsConnection.PublicationConnectionData);
while (pubCnnEnumm.MoveNext())
{
cnndta = (publicationsConnection.PublicationConnectionData)pubCnnEnumm.Current;
this._client.ConnectToADataPublication(cnndta.PublicationName, cnndta.ConnectionMode);
this._PublicationsConnectionsHandlersContainer.AddPublicationConnectionHandler(cnndta.PublicationName);
}
}
public void btnOK_Click(System.Object sender, System.EventArgs e)
{
try
{
if (this.txtPublicationName.Text.Length <= 0)
{
this.txtPublicationName.Focus();
throw (new Exception("No Publication Name specified"));
}
this.ValidateSelectedType();
DPE_ClientPublicationDefinition publication = default(DPE_ClientPublicationDefinition);
if (this.txtPublicationsGroup.Text.Length > 0)
{
publication = new DPE_ClientPublicationDefinition(this.txtPublicationsGroup.Text, this.txtPublicationName.Text);
}
else
{
publication = new DPE_ClientPublicationDefinition(this.txtPublicationName.Text);
}
this._publicationsPostingData = new publicationsPosting.PostedPublicationDefinitionData(publication.PublicationName);
string variableName = "";
DPE_ServerDefs.PublicationVariableDataType varType = default(DPE_ServerDefs.PublicationVariableDataType);
for (this._variablesCount = 1; this._variablesCount <= this.nudNumberOfVariables.Value; this._variablesCount++)
{
varType = this.GetRandomDataType();
variableName = this.txtPublicationName.Text + "_VAR_" + System.Convert.ToString(this._variablesCount);
publication.AddVaribleToPublication(variableName, varType);
publicationsPosting.PublicationVariableDefinitionData def = new publicationsPosting.PublicationVariableDefinitionData(variableName, varType);
this._publicationsPostingData.AddVariableDefinition(def);
}
this._client.CreateDataPublication(publication);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
this.DialogResult = System.Windows.Forms.DialogResult.None;
}
}
private void ScheduleTasksToRestorePreviousPostedPublicationsAfterConnectionLost()
{
try
{
if (this._ContainerOfPostedPublicationsOnServer.Count > 0)
{
DPE_ClientPublicationDefinition publicationDef = null;
Collection listOfPublicationsToPostAfterServerDesconection = new Collection();
IEnumerator enumm = null;
lock (this._ContainerOfPostedPublicationsOnServer)
{
enumm = this._ContainerOfPostedPublicationsOnServer.GetEnumerator();
while (enumm.MoveNext())
{
publicationDef = (DPE_ClientPublicationDefinition)enumm.Current;
listOfPublicationsToPostAfterServerDesconection.Add(publicationDef, null, null, null);
}
//clears the container of posted publications
this._ContainerOfPostedPublicationsOnServer.Clear();
}
enumm = listOfPublicationsToPostAfterServerDesconection.GetEnumerator();
while (enumm.MoveNext())
{
publicationDef = (DPE_ClientPublicationDefinition)enumm.Current;
this.ScheduleTaskToPostAPublicationOnServer(publicationDef);
try
{
if (PublicationPostLostOnServerEvent != null)
{
PublicationPostLostOnServerEvent(publicationDef.PublicationName);
}
}
catch (Exception)
{
}
}
}
}
catch (Exception ex)
{
CustomEventLog.WriteEntry(ex);
}
}
internal void ScheduleTaskToPostAPublicationOnServer(DPE_ClientPublicationDefinition publicationDefinition)
{
if (!this.ContainsScheduledPublicationPost(publicationDefinition.PublicationName))
{
lock (this._ContainerOfScheduledPublicationsPostingOnServer)
{
if (!this._ContainerOfScheduledPublicationsPostingOnServer.ContainsPublicationDefinition(publicationDefinition))
{
this._ContainerOfScheduledPublicationsPostingOnServer.AddPublicationDefinition(publicationDefinition);
System.Threading.Thread scheduleTask = new System.Threading.Thread(new System.Threading.ThreadStart(ScheduleTaskToPostAPublicationOnServer_ThreadFcn));
scheduleTask.IsBackground = true;
scheduleTask.Priority = System.Threading.ThreadPriority.Normal;
PublicationScheduledTaskRegister reg = new PublicationScheduledTaskRegister(publicationDefinition, scheduleTask);
lock (this._PublicationScheduleREgistersTable)
{
try
{
this._PublicationScheduleREgistersTable.Remove(publicationDefinition.PublicationName);
}
catch (Exception)
{
}
this._PublicationScheduleREgistersTable.Add(publicationDefinition.PublicationName, reg);
}
lock (this._publicationsScheduledPostingQueue)
{
this._publicationsScheduledPostingQueue.Enqueue(reg);
}
scheduleTask.Start();
string msg = "";
msg = "Task to post the publication \'" + publicationDefinition.PublicationName + " was scheduled and started\'";
CustomEventLog.WriteEntry(EventLogEntryType.Information, msg);
}
}
}
}
internal void RemovePublicationDefinition(DPE_ClientPublicationDefinition definition)
{
this._ContainerOfPostedPublicationsOnServer.RemovePublicationDefinition(definition);
}
internal void AddPublicationDefinitionAfterCreation(DPE_ClientPublicationDefinition definition)
{
this._ContainerOfPostedPublicationsOnServer.AddPublicationDefinition(definition);
}
