protected void WaitForData()
{
listenerState = ListenerStates.Running;
//TCPReceiver tcpReceiver = new TCPReceiver(receiveBufferSize);
//tcpClientSocket.BeginReceive(tcpReceiver.ReceiveBuffer, 0, receiveBufferSize, SocketFlags.None, new AsyncCallback(OnReceiveDataFromServer), tcpReceiver);
TCPReceiver tcpReceiver = new TCPReceiver(receiveBufferSize);
tcpReceiver.WaitHandle = new AutoResetEvent(true);
do
{
try
{
//LogManager.LogStatus("Waiting for new requests");
//Console.Write(".");
tcpClientSocket.BeginReceive(tcpReceiver.ReceiveBuffer, 0, receiveBufferSize, SocketFlags.None, new AsyncCallback(OnReceiveDataFromServer), tcpReceiver);
tcpReceiver.WaitHandle.Reset();
tcpReceiver.WaitHandle.WaitOne(this.receiveTimeout);
}
catch (USSDTcpReceiveTimeoutException) { }
catch (Exception ex)
{
LogManager.LogError(ex);
}
}while (listenerState == ListenerStates.Running);
}
public virtual void Stop()
{
listenerState = ListenerStates.Stopping;
if (pingThread != null)
{
if (pingThreadHandle != null)
{
pingThreadHandle.Set();
}
try
{
pingThread.Join(5000);
}
catch (Exception)
{
}
finally
{
pingThread = null;
}
}
if (tcpClientSocket != null)
{
tcpClientSocket.Close();
}
tcpClientSocket = null;
connectWaitEvent.Set();
listenerState = ListenerStates.Stopped;
LogManager.LogStatus("{0} stopped", name);
}
public void Stop()
{
listenerState = ListenerStates.Stopping;
httpListenerWaitHandle.Set();
httpListener.Stop();
listenerState = ListenerStates.Stopped;
}
/// <summary>
/// Resume a paused listener.
/// </summary>
public void Resume()
{
// We can only resume the listener if they are paused!
if (Status != ListenerStates.PAUSED)
{
throw new ListenerStateChangeException();
}
Status = ListenerStates.ACTIVE;
StatusInfo = "";
}
/// <summary>
/// Pause the listener
/// </summary>
public void Pause(DateTime startDate, DateTime?endDate = null)
{
// We can only pause the listener if they are not deleted!
if (Status == ListenerStates.DELETED)
{
throw new ListenerStateChangeException();
}
Status = ListenerStates.PAUSED;
string myDateStr = "";
if (endDate == null)
{
myDateStr = Listener.NEVER_END_PAUSE_STRING;
}
else
{
myDateStr = endDate.Value.ToNiceStr();
}
StatusInfo = startDate.ToNiceStr() + "," + myDateStr;
}
protected void ConnectToServer(Boolean isReconnect)
{
if (!isReconnect)
{
LogManager.LogStatus("{0} starting", name);
}
if (tcpClientSocket != null)
{
if (tcpClientSocket.Connected)
{
return;
}
try
{
tcpClientSocket.Close();
}
catch (Exception)
{
}
finally
{
tcpClientSocket = null;
}
}
if (isReconnect && AutoReconnectWhenConnectionIsLost)
{
LogManager.LogStatus("Connection lost to server {0}. Reconnecting", RemoteIPEndPoint.ToString());
}
if ((!isReconnect || (isReconnect && AutoReconnectWhenConnectionIsLost)) && listenerState != ListenerStates.Stopped && listenerState != ListenerStates.Stopping)
{
listenerState = ListenerStates.Connecting;
tcpClientSocket = new Socket(LocalIPEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
tcpClientSocket.Blocking = false;
tcpClientSocket.BeginConnect(RemoteIPEndPoint, new AsyncCallback(OnConnectedToServer), tcpClientSocket);
}
}
protected void OnReceiveDataFromServer(IAsyncResult asyncResult)
{
if (listenerState != ListenerStates.Running)
{
return;
}
TCPReceiver tcpReceiver = asyncResult.AsyncState as TCPReceiver;
SocketError errorCode;
int bytesReceived = tcpClientSocket.EndReceive(asyncResult, out errorCode);
byte[] tmp = new byte[bytesReceived];
tmp = tcpReceiver.ReceiveBuffer;
string payload = Encoding.ASCII.GetString(tmp);
//LogManager.LogStatus(" ... " + payload);
if (!tcpClientSocket.Connected)
{
listenerState = ListenerStates.Stopped;
Boolean autoReconnectWhenConnectionIsLost = AutoReconnectWhenConnectionIsLost;
OnServerDisconnected(tcpClientSocket, ref autoReconnectWhenConnectionIsLost);
AutoReconnectWhenConnectionIsLost = autoReconnectWhenConnectionIsLost;
ConnectToServer(true);
return;
}
if (bytesReceived != 0)
{
byte[] dataChunk = new byte[] { };
byte[] dataOverflow = new byte[] { };
tcpReceiver.AddReceiveData(tmp, bytesReceived);
string recev = Encoding.ASCII.GetString(tcpReceiver.ReceiveData);
while (tcpReceiver.ReceiveData.Contains((byte)255))
{
for (int x = 0; x < tcpReceiver.ReceiveData.Length; x++)
{
if (tcpReceiver.ReceiveData[x] == (byte)255)
{
dataChunk = new byte[x];
Buffer.BlockCopy(tcpReceiver.ReceiveData, 0, dataChunk, 0, dataChunk.Length);
dataOverflow = new byte[tcpReceiver.ReceiveData.Length - dataChunk.Length - 1];
Buffer.BlockCopy(tcpReceiver.ReceiveData, x + 1, dataOverflow, 0, dataOverflow.Length);
tcpReceiver.ReceiveData = dataOverflow;
if (dataChunk.Length > 0)
{
if (dataChunk[0] == 60)
{
string tempDAta = Encoding.ASCII.GetString(dataChunk);
OnDataReceived(dataChunk);
}
else
{
Console.WriteLine("*** PROBLEM WITH PDU ****");
}
}
break;
}
}
}
//tcpReceiver.AddReceiveData(tcpReceivere.Buffer, e.BytesTransferred);
//if (tcpReceiver.ReceiveData.Contains((byte)255))
//{
//// remove the terminator
//int terminatorIndex = 0;
//Byte[] dataChunk = new Byte[] { };
//Byte[] dataOverflow = new Byte[] { };
//Boolean completePacket = false;
//while (terminatorIndex <= tcpReceiver.ReceiveData.Length)
//{
// if (tcpReceiver.ReceiveData[terminatorIndex].Equals(this.packetTerminator))
// {
// completePacket = true;
// Byte[] copyBuffer = new Byte[tcpReceiver.ReceiveData.Length - dataChunk.Length-1];
// Buffer.BlockCopy(tcpReceiver.ReceiveData, terminatorIndex, copyBuffer, 0, tcpReceiver.ReceiveData.Length - dataChunk.Length-1);
// dataOverflow = copyBuffer;
// break;
// }
// else
// {
// Byte[] copyBuffer = new Byte[dataChunk.Length + 1];
// Buffer.BlockCopy(tcpReceiver.ReceiveData, 0, copyBuffer, 0, copyBuffer.Length);
// dataChunk = copyBuffer;
// copyBuffer = new Byte[tcpReceiver.ReceiveData.Length - dataChunk.Length];
// Buffer.BlockCopy(tcpReceiver.ReceiveData, terminatorIndex, copyBuffer, 0, tcpReceiver.ReceiveData.Length - dataChunk.Length);
// dataOverflow = copyBuffer;
// }
// terminatorIndex++;
//}
//if (completePacket)
//{
// Byte[] copyBuffer = new Byte[Math.Max(tcpReceiver.ReceiveData.Length - dataChunk.Length, 0)];
// if (copyBuffer.Length > 0)
// Buffer.BlockCopy(tcpReceiver.ReceiveData, terminatorIndex, copyBuffer, 0, Math.Max(tcpReceiver.ReceiveData.Length - dataChunk.Length, 0));
// OnDataReceived(dataChunk);
// tcpReceiver.ReceiveData = copyBuffer;
// tcpReceiver.ReceiveData = dataOverflow.Where(b => b != (byte)255).ToArray();
//}
//// Remove thye terminator
//tcpReceiver.ReceiveData = tcpReceiver.ReceiveData.Where(b => b != (byte)255).ToArray();
////OnDataReceived(tcpReceiver.ReceiveData);
////tcpReceiver.Clear();
if (tcpReceiver.WaitHandle != null)
{
tcpReceiver.WaitHandle.Set();
}
//}
}
//if (listenerState == ListenerStates.Running)
//{
// if (listenerState != ListenerStates.Running) return;
// if (tcpReceiver.ReceiveData.Length != 0 && tcpReceiver.ReceiveBuffer.Contains(this.packetTerminator))
// OnDataReceived(tcpReceiver.ReceiveData);
// tcpClientSocket.BeginReceive(tcpReceiver.ReceiveBuffer, 0, receiveBufferSize, SocketFlags.None, new AsyncCallback(OnReceiveDataFromServer), tcpReceiver);
//}
}
protected void OnConnectedToServer(IAsyncResult asyncResult)
{
if (tcpClientSocket == null)
{
return;
}
try
{
tcpClientSocket.EndConnect(asyncResult);
LogManager.LogStatus("{0} connected to {1}{2} ", name, address, (port == null ? String.Empty : ":" + port.Value.ToString()));
if (tcpClientSocket.Connected)
{
listenerState = ListenerStates.Running;
if (listenerState == ListenerStates.Running)
{
OnConnectedToServer(tcpClientSocket);
}
}
else
{
ConnectToServer(true);
}
}
catch (SocketException se)
{
if (se.SocketErrorCode == SocketError.TimedOut && (listenerState != ListenerStates.Stopping || listenerState != ListenerStates.Stopped))
{
int retryInterval = ConfigurationAppSettingsWrapper <int> .GetValue("Tcp Connection retry interval");
LogManager.LogError("Timed out connecting to {0}. Retrying", RemoteIPEndPoint.ToString());
connectWaitEvent.Reset();
connectWaitEvent.WaitOne(new TimeSpan(0, 0, 0, 0, retryInterval));
try
{
if (tcpClientSocket != null)
{
tcpClientSocket.BeginConnect(RemoteIPEndPoint, new AsyncCallback(OnConnectedToServer), tcpClientSocket);
}
}
catch (Exception)
{
if (listenerState != ListenerStates.Stopping || listenerState != ListenerStates.Stopped)
{
throw;
}
}
}
else if (se.SocketErrorCode == SocketError.ConnectionRefused && (listenerState != ListenerStates.Stopping || listenerState != ListenerStates.Stopped))
{
int retryInterval = ConfigurationAppSettingsWrapper <int> .GetValue("Tcp Connection retry interval");
LogManager.LogError("Unable to connect to {0}. Retrying", RemoteIPEndPoint.ToString());
connectWaitEvent.Reset();
connectWaitEvent.WaitOne(new TimeSpan(0, 0, 0, 0, retryInterval));
try
{
if (tcpClientSocket != null)
{
tcpClientSocket.BeginConnect(RemoteIPEndPoint, new AsyncCallback(OnConnectedToServer), tcpClientSocket);
}
}
catch (Exception)
{
if (listenerState != ListenerStates.Stopping || listenerState != ListenerStates.Stopped)
{
throw;
}
}
}
else
{
LogManager.LogError(se);
}
}
}
/// <summary>
/// Get listeners of a status
/// </summary>
/// <param name="status"></param>
/// <returns></returns>
public List <Listener> GetListenersByStatus(ListenerStates status)
{
return(repoLayer.GetListeners(connection).Where(x => x.Status.Equals(status)).ToList());
}
