private void MessageReceivedCallback(IAsyncResult result)
{
Tuple <MessageReader, bool> state =
result.AsyncState as Tuple <MessageReader, bool>;
MessageReader packetAssembler = state.Item1;
bool listenForNextMessage = state.Item2;
try
{
int bytesReceived = this.client.Socket.EndReceive(result);
if (bytesReceived > 0)
{
Message message =
SerManager.Deserialize <Message>(packetAssembler.DataBuffer);
packetAssembler.Dispose();
this.client.MsgQueue.Enqueue(message);
if (listenForNextMessage)
{
this.ReadLengthPrefix(listenForNextMessage);
}
}
}
catch
{
packetAssembler.Dispose();
}
}
private void LengthPrefixReceivedCallback(IAsyncResult result)
{
Tuple <Client, PrefixReader, bool> state = (Tuple <Client, PrefixReader, bool>)result.AsyncState;
if (state.Item1.Disposed)
{
state.Item2.Dispose();
return;
}
try
{
int bytesRead = state.Item1.Socket.EndReceive(result);
state.Item2.PushReceivedData(bytesRead);
if (state.Item2.BytesToRead == 0)
{
int messageLength = SerManager.GetLengthPrefix(state.Item2.PrefixData) - PrefixReader.PrefixBytes;
state.Item2.Dispose();
this.ReadMessage(state.Item1, messageLength, state.Item3);
}
else
{
this.ContinueReadingLengthPrefix(state);
}
}
catch
{
state.Item1.ErrorsAccumulated++;
state.Item1.Dispose();
state.Item2.Dispose();
Console.WriteLine("Error while reading length prefix");
}
}
private void LengthPrefixReceivedCallback(IAsyncResult result)
{
Tuple <PrefixReader, bool> state = (Tuple <PrefixReader, bool>)result.AsyncState;
try
{
int bytesRead = this.client.Socket.EndReceive(result);
state.Item1.PushReceivedData(bytesRead);
if (state.Item1.BytesToRead == 0)
{
int messageLength = SerManager.GetLengthPrefix(state.Item1.PrefixData) - PrefixReader.PrefixBytes;
state.Item1.Dispose();
this.ReadMessage(messageLength, state.Item2);
}
else
{
this.ContinueReadingLengthPrefix(state);
}
}
catch
{
state.Item1.Dispose();
this.ReadMessagesContinuously();
}
}
public void SendTo(Client client, Message message)
{
if (client.Disposed)
{
return;
}
Tuple <byte[], int> data = null;
try
{
data = SerManager.SerializeToManagedBufferPrefixed(message, this.server.Buffers);
if (client.Disposed)
{
this.server.Buffers.Return(data.Item1);
return;
}
client.Socket.BeginSend(data.Item1, 0, data.Item2, SocketFlags.None, this.SendToCallback, Tuple.Create(client, data.Item1));
}
catch (Exception e)
{
client.ErrorsAccumulated++;
this.server.Buffers.Return(data?.Item1);
Console.WriteLine(e.ToString());
}
}
public void SendToThenDropConnection(Client client, Message message)
{
if (client.Disposed)
{
return;
}
Tuple <byte[], int> data = null;
try
{
data = SerManager.SerializeToManagedBufferPrefixed(message, this.server.Buffers);
if (client.Disposed)
{
this.server.Buffers.Return(data.Item1);
return;
}
client.Socket.Send(data.Item1, 0, data.Item2, SocketFlags.None);
this.server.Auth.TryLogout(client);
client.Dispose();
this.server.Buffers.Return(data.Item1);
}
catch (Exception e)
{
this.server.Buffers.Return(data?.Item1);
this.server.Auth.TryLogout(client);
client.Dispose();
Console.WriteLine(e.ToString());
}
}
/// <summary>
/// Does the "real" translation unit creating, adds it to TranslationUnits collection, from which its later available.
/// </summary>
/// <param name="fileName">
/// A <see cref="string"/>: The filename associated with the translation unit. Basically the source file's name
/// </param>
/// <param name = "unsavedFiles">
/// A <see cref="CXUnsavedFile"/> array: array with the contents of unsaved files in IDE. Safe to be a null sized array - CDocumentParser.Parse reparses the TU with properly initialized unsaved files.
/// </param>
/// <param name = "force">Set to true when an existing Translation Unit should be disposed and remade.</param>
void AddToTranslationUnits(string fileName, CXUnsavedFile[] unsavedFiles, bool force)
{
lock (SyncRoot) {
var options = clang.defaultEditingTranslationUnitOptions(); // & ~(uint)CXTranslationUnit_Flags.PrecompiledPreamble; <- without this we have NO ERROR MARKERS!
if (!force)
{
if (!SerializationManager.SerFormIsUpToDate(fileName))
{
SerManager.Update(fileName, CmdArguments(fileName));
}
translationUnits.Add(fileName, clang.createTranslationUnit(index, fileName + ".pch"));
Loaded [fileName] = true;
}
else
{
translationUnits.Add(fileName, clang.parseTranslationUnit(
index,
fileName,
CmdArguments(fileName),
CmdArguments(fileName).Length,
unsavedFiles,
(uint)unsavedFiles.Length,
options
));
}
UpdateDatabase(fileName, translationUnits[fileName]);
SerManager.Add(fileName, CmdArguments(fileName)); //this is here to avoid a data race with configurations.
}
}
void HandleRename(object sender, ProjectFileRenamedEventArgs args)
{
foreach (var e in args)
{
translationUnits.Remove(e.OldName);
CreateTranslationUnit(e.NewName, project.UnsavedFiles.Get().ToArray());
SerManager.Rename(e.OldName, e.NewName, CmdArguments(e.NewName));
}
}
public void Send(Message message)
{
Tuple <byte[], int> data = null;
try
{
data = SerManager.SerializeToManagedBufferPrefixed(message, this.client.Buffers);
this.client.Socket.BeginSend(data.Item1, 0, data.Item2, SocketFlags.None, this.SendCallback, data.Item1);
}
catch
{
this.client.Buffers.Return(data?.Item1);
}
}
void HandleChange(object sender, ProjectFileEventArgs args)
{
foreach (var e in args)
{
CheckForBom(e.ProjectFile.Name);
if (!project.Loading && !project.IsCompileable(e.ProjectFile.Name) &&
e.ProjectFile.BuildAction == BuildAction.Compile)
{
e.ProjectFile.BuildAction = BuildAction.None;
}
SerManager.Update(e.ProjectFile.Name, CmdArguments(e.ProjectFile.Name));
}
}
void HandleRemoval(object sender, ProjectFileEventArgs args)
{
foreach (var e in args)
{
if (!project.Loading && !project.IsCompileable(e.ProjectFile.Name) &&
e.ProjectFile.BuildAction == BuildAction.Compile)
{
e.ProjectFile.BuildAction = BuildAction.None;
}
if (e.ProjectFile.BuildAction == BuildAction.Compile)
{
RemoveTranslationUnit(e.ProjectFile.Name);
}
SerManager.Remove(e.ProjectFile.Name);
}
}
private void MessageReceivedCallback(IAsyncResult result)
{
Tuple <Client, MessageReader, bool> state =
result.AsyncState as Tuple <Client, MessageReader, bool>;
if (state == null || state.Item1.Disposed)
{
state?.Item2.Dispose();
return;
}
Client client = state.Item1;
MessageReader packetAssembler = state.Item2;
bool listenForNextMessage = state.Item3;
try
{
int bytesReceived = client.Socket.EndReceive(result);
if (bytesReceived > 0)
{
Message message =
SerManager.Deserialize <Message>(packetAssembler.DataBuffer);
packetAssembler.Dispose();
// handle the data
this.server.Parser.ParseReceived(client, message);
if (state.Item3)
{
this.ReadLengthPrefix(client, listenForNextMessage);
}
}
}
catch (Exception e)
{
client.ErrorsAccumulated++;
packetAssembler.Dispose();
this.server.Responses.SomethingWentWrong(client);
client.Dispose();
Console.WriteLine(e.ToString());
}
}
public AsynchronousSocketListener()
{
this.connectionHandle = new ManualResetEvent(false);
this.listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
this.Clients = new ConcurrentDictionary <Guid, Client>();
this.Players = new ConcurrentDictionary <Guid, PlayerDTO>();
this.Battles = new ConcurrentDictionary <Guid, BattleInfo>();
//this.BlockedIps = new ConcurrentDictionary<string, DateTime>();
this.Context = new SimpleWarsContext();
this.Auth = new AuthenticationServices(this);
this.Game = new GameServices(this);
this.Reader = new DefaultReader(this);
this.Writer = new DefaultWriter(this);
this.Responses = new PredefinedResponses(this);
this.Parser = new DefaultParser(this);
this.Buffers = new Buffers(BufferPoolSize, MaxBufferSize);
this.PingByte = SerManager.SerializeWithLengthPrefix(Messages.Ping);
}
