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);