public void OnAcceptTcpClient(IAsyncResult ar)
{
try
{
Socket socket = _listener.EndAcceptSocket(ar);
StompServerClient client = new StompServerClient(socket);
if (OnConnect != null)
{
OnConnect(client);
}
}
catch (Exception ex)
{
if (StompLogger.CanLogException)
{
StompLogger.LogException("Listener failed to initialize the client", ex);
}
}
try
{
_listener.BeginAcceptTcpClient(new AsyncCallback(OnAcceptTcpClient), null);
}
catch (Exception ex)
{
if (StompLogger.CanLogException)
{
StompLogger.LogException("Failed to begin accept", ex);
}
_isListening = false;
}
}
void client_OnMessageReceived(StompServerClient client, StompMessage message)
{
if (_actionMap.ContainsKey(message.Command))
{
try
{
if (StompLogger.CanLogDebug)
{
StompLogger.LogDebug(client.ToString() + " sent a command " + message.Command);
}
_actionMap[message.Command].DynamicInvoke(client, message);
}
catch (Exception ex)
{
if (StompLogger.CanLogException)
{
StompLogger.LogException(client.ToString() + " sent a command " + message.Command + " which caused an exception", ex);
}
}
}
else
{
if (StompLogger.CanLogWarning)
{
StompLogger.LogWarning(client.ToString() + " sent an unhandled command " + message.Command);
}
}
}
private void OnStompCommand_Subscribe(StompServerClient client, StompMessage message)
{
StompPath path = null;
String destination = message["destination"];
if (StompLogger.CanLogDebug)
{
StompLogger.LogDebug(client.ToString() + " subscribes to " + destination);
}
lock (this)
{
if (_paths.ContainsKey(destination))
{
path = _paths[destination];
}
else
{
path = new StompPath(destination);
path.OnLastClientRemoved += new StompPath.OnLastClientRemovedDelegate(path_OnLastClientRemoved);
_paths[destination] = path;
}
}
path.AddClient(client);
}
void _listener_OnConnect(StompServerClient client)
{
lock (this)
{
if (_clients.Count + 1 > StompConfiguration.MaxClients)
{
if (StompLogger.CanLogWarning)
{
StompLogger.LogWarning("Maximum clients (" + StompConfiguration.MaxClients + ") reached. Disconnecting " + client.ToString());
}
client.Stop();
return;
}
_clients.Add(client);
}
InitClientsEvents(client);
StompStatistics.AddConnectedClient();
client.Start();
if (StompLogger.CanLogDebug)
{
StompLogger.LogDebug(client.ToString() + " connected");
}
}
void client_OnDisconnect(StompServerClient client)
{
lock (this)
{
if (StompLogger.CanLogDebug)
{
StompLogger.LogDebug(client.ToString() + " quitted");
}
_clients.Remove(client);
}
StompStatistics.RemoveConnectedClient();
}
private void OnStompCommand_Connect(StompServerClient client, StompMessage message)
{
if (StompLogger.CanLogDebug)
{
StompLogger.LogDebug(client.ToString() + " connected with session-id " + client.SessionId.ToString());
}
StompMessage result = new StompMessage("CONNECTED");
result["session-id"] = client.SessionId.ToString();
client.Send(result);
}
void path_OnLastClientRemoved(StompPath path)
{
lock (this)
{
if (_paths.ContainsKey(path.Name))
{
_paths.Remove(path.Name);
}
}
if (StompLogger.CanLogDebug)
{
StompLogger.LogDebug("Path " + path.Name + " destroyed");
}
}
private void OnStompCommand_Send(StompServerClient client, StompMessage message)
{
StompPath path = null;
String destination = message["destination"];
if (StompLogger.CanLogDebug)
{
StompLogger.LogDebug(client.ToString() + " sent data to " + destination);
}
lock (this)
{
if (_paths.ContainsKey(destination))
{
path = _paths[destination];
}
}
if (path != null)
{
List <StompServerClient> pathClients = path.Clients;
message["message-id"] = Guid.NewGuid().ToString();
message.Command = "MESSAGE";
foreach (StompServerClient pathClient in pathClients)
{
try
{
if (StompLogger.CanLogDebug)
{
StompLogger.LogDebug("Sending " + message.Command + " to " + pathClient.ToString());
}
pathClient.Send(message);
}
catch (Exception ex)
{
if (StompLogger.CanLogException)
{
StompLogger.LogException(pathClient.ToString() + " has thrown an exception while sending data", ex);
}
}
}
}
}
private void OnStompCommand_Unsubscribe(StompServerClient client, StompMessage message)
{
StompPath path = null;
String destination = message["destination"];
if (StompLogger.CanLogDebug)
{
StompLogger.LogDebug(client.ToString() + " unsubscribes from " + destination);
}
lock (this)
{
if (_paths.ContainsKey(destination))
{
path = _paths[destination];
}
}
if (path != null)
{
path.RemoveClient(client);
}
}
private void OnClientReceive(IAsyncResult ar)
{
try
{
int readBytes = _socket.EndReceive(ar);
if (readBytes > 0)
{
_buffer.Cursor += readBytes;
int localCursor = 0;
for (int i = 0; i < _buffer.Cursor; i++)
{
if (_buffer.Buffer[i] == '\0') // match
{
StompMessage message = null;
try
{
message = new StompMessage(_buffer.Buffer, localCursor, i - localCursor);
StompStatistics.CountIncomingMessage();
if (OnMessageReceived != null)
{
try
{
OnMessageReceived(this, message);
}
catch (Exception) { }
}
}
catch (Exception ex)
{
if (StompLogger.CanLogException)
{
StompLogger.LogException("Failed to parse stomp packet", ex);
}
}
localCursor = i + 1;
}
}
if (localCursor > 0)
{
_buffer.Remove(localCursor);
}
BeginReceive();
}
else
{
throw new Exception("Connection closed.");
}
}
catch (Exception)
{
OnInternalDisconnect();
}
}
static void Main(string[] args)
{
if (StompLogger.CanLogInfo)
{
StompLogger.LogInfo("AcidStomp " + Assembly.GetExecutingAssembly().GetName().Version.ToString() + " - Starting in port " + StompConfiguration.ListenPort);
}
try
{
StompServer server = new StompServer(StompConfiguration.ListenPort);
StompStatistics.Start();
server.Start();
DateTime lastLogFlush = DateTime.Now;
DateTime lastStatistics = DateTime.Now;
while (server.IsRunning)
{
try
{
if (StompConfiguration.LogStatisticsInterval > 0 && (DateTime.Now - lastStatistics).TotalSeconds >= StompConfiguration.LogStatisticsInterval)
{
StompLogger.LogInfo(
String.Format("(uptime {0}, connected clients: {1}, messages [in: {2}/sec - out: {3}/sec])",
StompStatistics.Uptime.ToString(),
StompStatistics.ConnectedClients,
StompStatistics.IncomingMessagesPerSecond,
StompStatistics.OutgoingMessagesPerSecond));
lastStatistics = DateTime.Now;
}
if (StompConfiguration.LogFile != null)
{
if ((DateTime.Now - lastLogFlush).TotalSeconds >= StompConfiguration.LogFileFlushInterval)
{
StompLogger.Flush();
lastLogFlush = DateTime.Now;
}
}
}
catch (Exception ex)
{
if (StompLogger.CanLogException)
{
StompLogger.LogException("Failed to flush log file", ex);
}
}
Thread.Sleep(1000);
}
}
catch (Exception ex)
{
if (StompLogger.CanLogException)
{
StompLogger.LogException("Error initializing listen server ", ex);
}
}
}