public override void ExecuteTaskSync(ConnectionTask connectionTask)
{
byte[] sendByte = (connectionTask.Param as List <byte>).ToArray();// Encoding.Default.GetBytes(message);
NetworkData frame = NetworkData.Create(this.Local, sendByte, sendByte.Length);
CaseSendFrame(frame, NetworkConstants.DefaultTaskInterval, NetworkConstants.WAIT_FOR_COMPLETE);
}
/// <summary>
/// Connects to the Queue Manager asynchronously.
/// </summary>
/// <param name="UserName">User name</param>
/// <param name="Password">Password</param>
public Task ConnectAsync(string UserName, string Password)
{
ConnectionTask Item = new ConnectionTask(this, UserName, Password);
MqTasks.ExecuteTask(Item);
return(Item.Completed);
}
private void DelayThread()
{
int delay = 0;
while (true)
{
mSemaphore.WaitOne(delay);
delay = Timeout.Infinite;
lock (mDelayedConnectionTasks)
{
IEnumeratorSpecialized <ConnectionTask> e = mDelayedConnectionTasks.GetEnumerator();
while (e.MoveNext())
{
ConnectionTask task = e.Current;
long currentTicks = DateTime.Now.Ticks;
if (currentTicks > task.Timeout.Ticks)
{
// mehet újra
e.Remove();
mThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(ProcessConnection), task);
}
else
{
// csökkentem a következő várakozási időt
int delayValue = Convert.ToInt32(TimeSpan.FromTicks(task.Timeout.Ticks - currentTicks).TotalMilliseconds);
if (delayValue < delay || delay == Timeout.Infinite)
{
delay = delayValue;
}
}
}
}
}
}
/// <summary>
/// 执行一个请求任务
/// </summary>
/// <param name="functionType"></param>
/// <param name="asyncCallback"></param>
/// <param name="timeout"></param>
/// <param name="value"></param>
public virtual void RequestReactorFunction(int functionType, AsyncCallback asyncCallback, int timeout, object value)
{
ConnectionTask task = new ConnectionTask();
task.Name = functionType.ToString();
task.Param = value;
((ReactorConnectionAdapter)ProtocolProxyAgent.Instance().reactorConnectionAdapter).ExecuteTaskAsync(task, asyncCallback, timeout);
}
/// <summary>
/// 创建发送帧[如需调整重发次数需重写ExecuteTaskSync]
/// </summary>
/// <param name="connectionTask"></param>
/// <returns></returns>
protected override NetworkData CreateNetworkData(ConnectionTask connectionTask)
{
if (connectionTask.Param == null || !(connectionTask.Param is int))
{
return(null);
}
this.frameCount = Convert.ToInt16(connectionTask.Param);
return(this.CreateSendFrameIndexData(this.frameIndex));
}
/// <summary>
/// 执行任务【默认重发3次3S超时】
/// </summary>
/// <param name="connectionTask"></param>
public override void ExecuteTaskSync(ConnectionTask connectionTask)
{
networkData = CreateNetworkData(connectionTask);
if (networkData == null)
{
return;
}
CaseSendFrame(networkData, NetworkConstants.DefaultTaskInterval, NetworkConstants.DefaultTaskCount);
}
private void QueueToReconnect(ConnectionTask task)
{
if (!NetworkManager.Instance.IsShutdown)
{
lock (mDelayedConnectionTasks)
{
task.Timeout = DateTime.Now.AddMilliseconds(task.DelayBetweenAttempsInMS);
mDelayedConnectionTasks.Add(task);
}
mSemaphore.Release();
}
}
/// <summary>
/// Initializes the TCP connections.
/// </summary>
internal void InitializeTCPConnections()
{
if (NetworkManager.Instance.InternalConfiguration.NetworkPeering.TCPConnections.EndPoints.Count > 0)
{
foreach (ConnectionEntry e in NetworkManager.Instance.InternalConfiguration.NetworkPeering.TCPConnections.EndPoints)
{
ConnectionTask task = new ConnectionTask(e.EndPoint, e.ReconnectOnFailure, e.DelayBetweenAttempsInMS, e.ConnectionTimeout);
mConnectionTasks.Add(task);
mThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(ProcessConnection), task);
}
}
}
private void ProcessConnection(object state)
{
if (!NetworkManager.Instance.IsShutdown)
{
ConnectionTask task = (ConnectionTask)state;
try
{
task.NetworkStream = null;
Synapse.NetworkStream stream = NetworkManager.Instance.InternalNetworkManager.Connect(task.EndPoint); // dobhat hibát
stream.SendBufferSize = NetworkManager.Instance.InternalConfiguration.Settings.DefaultLowLevelSocketSendBufferSize;
stream.ReceiveBufferSize = NetworkManager.Instance.InternalConfiguration.Settings.DefaultLowLevelSocketReceiveBufferSize;
stream.NoDelay = NetworkManager.Instance.InternalConfiguration.Settings.DefaultLowLevelNoDelay;
task.NetworkStream = stream;
NetworkPeerRemote result = NetworkManager.Instance.ProcessConnection(stream, task.ConnectionTimeout, true, !NetworkManager.Instance.InternalConfiguration.Settings.EnableMultipleConnectionWithNetworkPeers);
if (result == null)
{
if (task.ReconnectOnFailure)
{
// újra időzítés
QueueToReconnect(task);
}
else
{
lock (mConnectionTasks)
{
mConnectionTasks.Remove(task);
}
}
}
}
catch (Exception ex)
{
// failed to resolve host
if (LOGGER.IsErrorEnabled)
{
LOGGER.Error(string.Format("CONNECTION_MANAGER, failed to establish connection to a remote host. Reason: {0}", ex.Message));
}
if (task.ReconnectOnFailure)
{
// újra időzítés
QueueToReconnect(task);
}
else
{
lock (mConnectionTasks)
{
mConnectionTasks.Remove(task);
}
}
}
}
}
/// <summary>
/// 移除一个任务
/// </summary>
/// <param name="task">被移除的任务</param>
internal bool RemoveTask(ConnectionTask task)
{
bool result;
lock (taskList)
{
result = taskList.Remove(task);
}
if (result)
{
string LogMsg = string.Format("协议“{0}”中“{1}”任务已结束。", task.GetRelatedProtocol().Local.ToString(), task.Name);
Console.WriteLine(LogMsg);
}
return(result);
}
/// <summary>
/// 创建发送帧[如需调整重发次数需重写ExecuteTaskSync]
/// </summary>
/// <param name="connectionTask"></param>
/// <returns></returns>
protected override NetworkData CreateNetworkData(ConnectionTask connectionTask)
{
if (connectionTask.Param == null)
{
return(null);
}
string fileName = connectionTask.Param.ToString();
this.sHSerialPacket = new SHSerialPacket(SHSerialPacket.SwitchPacketFrameSize);
SHSerialPacket.CreateSerialPackage <SHSerialPacket>(this.sHSerialPacket, fileName);
if (this.sHSerialPacket == null)
{
return(null);
}
return(this.CreateSendFrameIndexData((short)this.frameIndex));
}
/// <summary>
/// 移除一个任务
/// </summary>
/// <param name="task">被移除的任务</param>
internal bool RemoveTask(ConnectionTask task)
{
bool result;
lock (taskListBlocking)
{
ConnectionTask connectionTask;
result = taskListBlocking.TryTake(out connectionTask, NetworkConstants.DefaultTaskInterval, task.cancellationToken);
}
if (result)
{
string LogMsg = string.Format("协议“{0}”中“{1}”任务已结束。", task.GetRelatedProtocol().Local.ToString(), task.Name);
Console.WriteLine(LogMsg);
}
return(result);
}
/// <summary>
/// 给规约增加任务
/// </summary>
/// <param name="task">要添加的任务。</param>
internal void AddTask(ConnectionTask task)
{
if (task == null)
{
return;
}
lock (taskList)
{
if (!taskList.Contains(task))
{
task.SetRelatedProtocol(this.relatedProtocol);
taskList.Insert(0, task);
//((EventWaitHandle)this.relatedProtocol.protocolEvents[(int)ProtocolEvents.TaskArrived]).Set();
string LogMsg = string.Format("协议“{0}”增加了一个“{1}”任务。", "未定义协议名称", task.Name);
}
}
}
/// <summary>
/// 协议一收到任务，此函数将被调用。
/// </summary>
/// <param name="newTask"></param>
protected override void ProcessTask(ConnectionTask task)
{
task.SetAsBeProccessing();
try
{
string cmdByte = task.Name;
commCase_Send = this.connectionDocker.GetCase(cmdByte) as IConnection;
if (commCase_Send == null || !(commCase_Send is RefactorRequestChannel))
{
int taskname = Convert.ToInt32(task.Name);
switch (taskname)//应答
{
case ProtocolConst.APP_BROADCAST_SEARCH_NEW_HOST:
commCase_Send = new BroadcastSearchRequest(this._reactor);
break;
default:
string msg = String.Format("协议未实现。 TaskName:{0}; ", task.Name);
Console.WriteLine(msg);
task.Dead = true;
return;
}
}
else
{
//commCase_Send.Task.Param = task.Param;
//commCase_Send.Task.Complete(TaskState.Processing);
}
if (commCase_Send != null)
{
task.SetRelatedProtocol(commCase_Send);
((RefactorRequestChannel)commCase_Send).ExecuteTaskSync(task);
}
}
catch (Exception ex)
{
string msg = String.Format("协议收到任务，此函数被调用。 TaskName:{0}; Message:{1}", task.Name, ex.Message);
Console.WriteLine(msg);
task.Dead = true;
}
}
public override void ExecuteTaskSync(ConnectionTask connectionTask)
{
this.TaskParm = connectionTask != null ? connectionTask.Param : null;
base.ExecuteTaskSync(connectionTask);
}
private void OnCancelButtonClicked(object sender, EventArgs e)
{
if (this.Connecting)
{
if (this._connectionTask != null)
{
this._connectionTask.Cancel();
this._connectionTask = null;
}
this.Connecting = false;
}
else
{
base.DialogResult = DialogResult.Cancel;
base.Close();
}
}
public override void ExecuteTaskSync(ConnectionTask connectionTask)
{
}
/// <summary>
/// 生成发送数据
/// </summary>
/// <param name="connectionTask"></param>
/// <returns></returns>
protected virtual NetworkData CreateNetworkData(ConnectionTask connectionTask)
{
return(null);
}
private void OnDatabaseComboDropDown(object sender, EventArgs e)
{
if (!this.Connecting && !this._skipDropDownEvent)
{
try
{
this._skipDropDownEvent = true;
this._databaseCombo.Items.Clear();
this.Connecting = true;
this.CollectConnectionSettings();
this._connectionTask = new ConnectionTask(this.ConnectionSettings, ConnectType.DropDown);
this._connectionTask.StartSynchronous(new AsyncTaskResultPostedEventHandler(this.OnAsyncConnectCompleted));
this._savedDatabaseText = this._databaseCombo.Text;
this._databaseCombo.Text = "Connecting (please wait)...";
}
finally
{
this._skipDropDownEvent = false;
}
}
}
private void OnConnectButtonClicked(object sender, EventArgs e)
{
this.Connecting = true;
this.CollectConnectionSettings();
this._connectionTask = new ConnectionTask(this.ConnectionSettings, ConnectType.ConnectButton);
this._connectionTask.StartSynchronous(new AsyncTaskResultPostedEventHandler(this.OnAsyncConnectCompleted));
}
/// <summary> /// 开始发送 /// </summary> /// <param name="connectionTask"></param> public abstract void ExecuteTaskSync(ConnectionTask connectionTask);
