public void Post(Uri uri, Action <JsonRpcResponse, Exception> resultCallback)
{
if (uri == null)
{
throw new ArgumentNullException("uri");
}
if (resultCallback == null)
{
throw new ArgumentNullException("resultCallback");
}
try
{
var ae = new AsyncEnumerator();
ae.BeginExecute(this.GetPostEnumerator(uri, ae, resultCallback), ar =>
{
ae.EndExecute(ar);
});
}
catch (System.Security.SecurityException ex)
{
resultCallback(null, ex);
}
}
static IEnumerator <int> ListenerFiber(AsyncEnumerator ae)
{
var listeningServer = new TcpListener(IPAddress.Loopback, 9998);
listeningServer.Start();
while (!ae.IsCanceled())
{
listeningServer.BeginAcceptTcpClient(ae.End(0, listeningServer.EndAcceptTcpClient), null);
yield return(1);
if (ae.IsCanceled())
{
yield break;
}
var clientSocket = listeningServer.EndAcceptTcpClient(ae.DequeueAsyncResult());
var clientAe = new AsyncEnumerator()
{
SyncContext = null
};
clientAe.BeginExecute(
ClientFiber(clientAe, clientSocket),
ar =>
{
try
{
clientAe.EndExecute(ar);
}
catch { }
}, null);
}
}
static void Main(string[] args)
{
var ae = new AsyncEnumerator()
{
SyncContext = null
};
var mainOp = ae.BeginExecute(ListenerFiber(ae), null, null);
// block until main server is finished
ae.EndExecute(mainOp);
}
public static void Main()
{
String[] urls = new String[] {
"http://Wintellect.com/",
"http://1.1.1.1/", // Demonstrates error recovery
"http://www.Devscovery.com/"
};
// Demonstrate process
AsyncEnumerator ae = new AsyncEnumerator();
ae.EndExecute(ae.BeginExecute(ProcessAllAndEachOps(ae, urls), null));
}
private void BeginAcceptFileCallback(IAsyncResult result)
{
FileWatcherFile file;
try { file = _listener.EndAcceptFile(result); }
catch (ObjectDisposedException) { return; }
catch (Exception e) { _logger.Warn("Error on EndAcceptFile", e); StartAcceptingFile(); return; }
_logger.DebugFormat("Accepting connection from {0}", file.EndPoint);
var enumerator = new AsyncEnumerator("Receiver from " + file.EndPoint);
enumerator.BeginExecute(ProcessRequest(file, enumerator), ar =>
{
try { enumerator.EndExecute(ar); }
catch (Exception e) { _logger.Warn("Failed to recieve message", e); }
});
StartAcceptingFile();
}
public static void Main()
{
AsyncEnumerator.EnableDebugSupport();
// Add this to watch window: AsyncEnumerator.GetInProgressList();
// Also, you can hover over a variable that is of my AsyncEnumerator type
String[] urls = new String[] {
"http://Wintellect.com/",
"http://1.1.1.1/", // Demonstrates error recovery
"http://www.Devscovery.com/"
};
// Demonstrate process
AsyncEnumerator ae = new AsyncEnumerator();
ae.SuspendCallback += sr=>{ Console.WriteLine(123); };
ae.ResumeCallback += sr=> { Console.WriteLine(321); };
ae.EndExecute(ae.BeginExecute(ProcessAllAndEachOps(ae, urls), null));
}
public static void Transfer(
string urlIn,
string urlOut,
Action<double> onProgress,
Action<int> onComplete,
Action<Exception> onError)
{
var ae = new AsyncEnumerator();
ae.BeginExecute(GetAsyncEnumerator(ae, urlIn, urlOut, onProgress, onComplete), ar =>
{
try
{
ae.EndExecute(ar);
}
catch (Exception ex)
{
onError(ex);
}
});
}
public static void Transfer(
string urlIn,
string urlOut,
Action <double> onProgress,
Action <int> onComplete,
Action <Exception> onError)
{
var ae = new AsyncEnumerator();
ae.BeginExecute(GetAsyncEnumerator(ae, urlIn, urlOut, onProgress, onComplete), ar =>
{
try
{
ae.EndExecute(ar);
}
catch (Exception ex)
{
onError(ex);
}
});
}
public void Send()
{
var enumerator = new AsyncEnumerator(
string.Format("Sending {0} messages to {1}", Messages.Length,
Destination)
);
logger.DebugFormat("Starting to send {0} messages to {1}", Messages.Length, Destination);
enumerator.BeginExecute(SendInternal(enumerator), result =>
{
try
{
enumerator.EndExecute(result);
}
catch (Exception exception)
{
logger.Warn("Failed to send message", exception);
Failure(exception);
}
});
}
private void BeginAcceptTcpClientCallback(IAsyncResult result)
{
TcpClient client;
try
{
client = listener.EndAcceptTcpClient(result);
}
catch (ObjectDisposedException)
{
return;
}
logger.DebugFormat("Accepting connection from {0}", client.Client.RemoteEndPoint);
var enumerator = new AsyncEnumerator(
"Receiver from " + client.Client.RemoteEndPoint
);
enumerator.BeginExecute(ProcessRequest(client, enumerator), ar =>
{
try
{
enumerator.EndExecute(ar);
}
catch (Exception exception)
{
logger.Warn("Failed to recieve message", exception);
}
});
try
{
listener.BeginAcceptTcpClient(BeginAcceptTcpClientCallback, null);
}
catch (ObjectDisposedException)
{
}
}
private void BeginAcceptTcpClientCallback(IAsyncResult result)
{
TcpClient client;
try
{
client = listener.EndAcceptTcpClient(result);
}
catch (ObjectDisposedException)
{
return;
}
logger.DebugFormat("Accepting connection from {0}", client.Client.RemoteEndPoint);
var enumerator = new AsyncEnumerator(
"Receiver from " + client.Client.RemoteEndPoint
);
enumerator.BeginExecute(ProcessRequest(client, enumerator), ar =>
{
try
{
enumerator.EndExecute(ar);
}
catch (Exception exception)
{
logger.Warn("Failed to recieve message", exception);
}
});
try
{
listener.BeginAcceptTcpClient(BeginAcceptTcpClientCallback, null);
}
catch (ObjectDisposedException)
{
}
}
private IEnumerator<int> ProcessRequest(TcpClient client, AsyncEnumerator ae)
{
try
{
using (client)
using (var stream = client.GetStream())
{
var sender = client.Client.RemoteEndPoint;
var lenOfDataToReadBuffer = new byte[sizeof(int)];
var lenEnumerator = new AsyncEnumerator(ae.ToString());
try
{
lenEnumerator.BeginExecute(
StreamUtil.ReadBytes(lenOfDataToReadBuffer, stream, lenEnumerator, "length data",false), ae.End());
}
catch (Exception exception)
{
logger.Warn("Unable to read length data from " + sender, exception);
yield break;
}
yield return 1;
try
{
lenEnumerator.EndExecute(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.Warn("Unable to read length data from " + sender, exception);
yield break;
}
var lengthOfDataToRead = BitConverter.ToInt32(lenOfDataToReadBuffer, 0);
if (lengthOfDataToRead < 0)
{
logger.WarnFormat("Got invalid length {0} from sender {1}", lengthOfDataToRead, sender);
yield break;
}
logger.DebugFormat("Reading {0} bytes from {1}", lengthOfDataToRead, sender);
var buffer = new byte[lengthOfDataToRead];
var readBufferEnumerator = new AsyncEnumerator(ae.ToString());
try
{
readBufferEnumerator.BeginExecute(
StreamUtil.ReadBytes(buffer, stream, readBufferEnumerator, "message data", false), ae.End());
}
catch (Exception exception)
{
logger.Warn("Unable to read message data from " + sender, exception);
yield break;
}
yield return 1;
try
{
readBufferEnumerator.EndExecute(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.Warn("Unable to read message data from " + sender, exception);
yield break;
}
Message[] messages = null;
try
{
messages = SerializationExtensions.ToMessages(buffer);
logger.DebugFormat("Deserialized {0} messages from {1}", messages.Length, sender);
}
catch (Exception exception)
{
logger.Warn("Failed to deserialize messages from " + sender, exception);
}
if (messages == null)
{
try
{
stream.BeginWrite(ProtocolConstants.SerializationFailureBuffer, 0,
ProtocolConstants.SerializationFailureBuffer.Length, ae.End(), null);
}
catch (Exception exception)
{
logger.Warn("Unable to send serialization format error to " + sender, exception);
yield break;
}
yield return 1;
try
{
stream.EndWrite(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.Warn("Unable to send serialization format error to " + sender, exception);
}
yield break;
}
IMessageAcceptance acceptance = null;
byte[] errorBytes = null;
try
{
acceptance = acceptMessages(messages);
logger.DebugFormat("All messages from {0} were accepted", sender);
}
catch (QueueDoesNotExistsException)
{
logger.WarnFormat("Failed to accept messages from {0} because queue does not exists", sender);
errorBytes = ProtocolConstants.QueueDoesNoExiststBuffer;
}
catch (Exception exception)
{
errorBytes = ProtocolConstants.ProcessingFailureBuffer;
logger.Warn("Failed to accept messages from " + sender, exception);
}
if (errorBytes != null)
{
try
{
stream.BeginWrite(errorBytes, 0,
errorBytes.Length, ae.End(), null);
}
catch (Exception exception)
{
logger.Warn("Unable to send processing failure from " + sender, exception);
yield break;
}
yield return 1;
try
{
stream.EndWrite(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.Warn("Unable to send processing failure from " + sender, exception);
}
yield break;
}
logger.DebugFormat("Sending reciept notice to {0}", sender);
try
{
stream.BeginWrite(ProtocolConstants.RecievedBuffer, 0, ProtocolConstants.RecievedBuffer.Length,
ae.End(), null);
}
catch (Exception exception)
{
logger.Warn("Could not send reciept notice to " + sender, exception);
acceptance.Abort();
yield break;
}
yield return 1;
try
{
stream.EndWrite(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.Warn("Could not send reciept notice to " + sender, exception);
acceptance.Abort();
yield break;
}
logger.DebugFormat("Reading acknowledgement about accepting messages to {0}", sender);
var acknowledgementBuffer = new byte[ProtocolConstants.AcknowledgedBuffer.Length];
var readAcknoweldgement = new AsyncEnumerator(ae.ToString());
try
{
readAcknoweldgement.BeginExecute(
StreamUtil.ReadBytes(acknowledgementBuffer, stream, readAcknoweldgement, "acknowledgement", false),
ae.End());
}
catch (Exception exception)
{
logger.Warn("Error reading acknowledgement from " + sender, exception);
acceptance.Abort();
yield break;
}
yield return 1;
try
{
readAcknoweldgement.EndExecute(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.Warn("Error reading acknowledgement from " + sender, exception);
acceptance.Abort();
yield break;
}
var senderResponse = Encoding.Unicode.GetString(acknowledgementBuffer);
if (senderResponse != ProtocolConstants.Acknowledged)
{
logger.WarnFormat("Sender did not respond with proper acknowledgement, the reply was {0}",
senderResponse);
acceptance.Abort();
}
bool commitSuccessful;
try
{
acceptance.Commit();
commitSuccessful = true;
}
catch (Exception exception)
{
logger.Warn("Unable to commit messages from " + sender, exception);
commitSuccessful = false;
}
if (commitSuccessful == false)
{
bool writeSuccessful;
try
{
stream.BeginWrite(ProtocolConstants.RevertBuffer, 0, ProtocolConstants.RevertBuffer.Length,
ae.End(),
null);
writeSuccessful = true;
}
catch (Exception e)
{
logger.Warn("Unable to send revert message to " + sender, e);
writeSuccessful = false;
}
if (writeSuccessful)
{
yield return 1;
try
{
stream.EndWrite(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.Warn("Unable to send revert message to " + sender, exception);
}
}
}
}
}
finally
{
var copy = CompletedRecievingMessages;
if (copy != null)
copy();
}
}
private IEnumerator<int> SendInternal(AsyncEnumerator ae)
{
try
{
using (var client = new TcpClient())
{
try
{
client.BeginConnect(Destination.Host, Destination.Port,
ae.End(),
null);
}
catch (Exception exception)
{
logger.WarnFormat("Failed to connect to {0} because {1}", Destination, exception);
Failure(exception);
yield break;
}
yield return 1;
try
{
client.EndConnect(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.WarnFormat("Failed to connect to {0} because {1}", Destination, exception);
Failure(exception);
yield break;
}
logger.DebugFormat("Successfully connected to {0}", Destination);
using (var stream = client.GetStream())
{
var buffer = Messages.Serialize();
var bufferLenInBytes = BitConverter.GetBytes(buffer.Length);
logger.DebugFormat("Writing length of {0} bytes to {1}", buffer.Length, Destination);
try
{
stream.BeginWrite(bufferLenInBytes, 0, bufferLenInBytes.Length, ae.End(), null);
}
catch (Exception exception)
{
logger.WarnFormat("Could not write to {0} because {1}", Destination,
exception);
Failure(exception);
yield break;
}
yield return 1;
try
{
stream.EndWrite(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.WarnFormat("Could not write to {0} because {1}", Destination,
exception);
Failure(exception);
yield break;
}
logger.DebugFormat("Writing {0} bytes to {1}", buffer.Length, Destination);
try
{
stream.BeginWrite(buffer, 0, buffer.Length, ae.End(), null);
}
catch (Exception exception)
{
logger.WarnFormat("Could not write to {0} because {1}", Destination,
exception);
Failure(exception);
yield break;
}
yield return 1;
try
{
stream.EndWrite(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.WarnFormat("Could not write to {0} because {1}", Destination,
exception);
Failure(exception);
yield break;
}
logger.DebugFormat("Successfully wrote to {0}", Destination);
var recieveBuffer = new byte[ProtocolConstants.RecievedBuffer.Length];
var readConfirmationEnumerator = new AsyncEnumerator();
try
{
readConfirmationEnumerator.BeginExecute(
StreamUtil.ReadBytes(recieveBuffer, stream, readConfirmationEnumerator, "recieve confirmation", false), ae.End());
}
catch (Exception exception)
{
logger.WarnFormat("Could not read confirmation from {0} because {1}", Destination,
exception);
Failure(exception);
yield break;
}
yield return 1;
try
{
readConfirmationEnumerator.EndExecute(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.WarnFormat("Could not read confirmation from {0} because {1}", Destination,
exception);
Failure(exception);
yield break;
}
var recieveRespone = Encoding.Unicode.GetString(recieveBuffer);
if (recieveRespone == ProtocolConstants.QueueDoesNotExists)
{
logger.WarnFormat(
"Response from reciever {0} is that queue does not exists",
Destination);
Failure(new QueueDoesNotExistsException());
yield break;
}
else if(recieveRespone!=ProtocolConstants.Recieved)
{
logger.WarnFormat(
"Response from reciever {0} is not the expected one, unexpected response was: {1}",
Destination, recieveRespone);
Failure(null);
yield break;
}
try
{
stream.BeginWrite(ProtocolConstants.AcknowledgedBuffer, 0,
ProtocolConstants.AcknowledgedBuffer.Length, ae.End(), null);
}
catch (Exception exception)
{
logger.WarnFormat("Failed to write acknowledgement to reciever {0} because {1}",
Destination, exception);
Failure(exception);
yield break;
}
yield return 1;
try
{
stream.EndWrite(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.WarnFormat("Failed to write acknowledgement to reciever {0} because {1}",
Destination, exception);
Failure(exception);
yield break;
}
var bookmarks = Success();
buffer = new byte[ProtocolConstants.RevertBuffer.Length];
var readRevertMessage = new AsyncEnumerator(ae.ToString());
bool startingToReadFailed = false;
try
{
readRevertMessage.BeginExecute(
StreamUtil.ReadBytes(buffer, stream, readRevertMessage, "revert", true), ae.End());
}
catch (Exception)
{
//more or less expected
startingToReadFailed = true;
}
if (startingToReadFailed)
yield break;
yield return 1;
try
{
readRevertMessage.EndExecute(ae.DequeueAsyncResult());
var revert = Encoding.Unicode.GetString(buffer);
if (revert == ProtocolConstants.Revert)
{
logger.Warn("Got back revert message from receiver, reverting send");
Revert(bookmarks);
}
}
catch (Exception)
{
// expected, there is nothing to do here, the
// reciever didn't report anything for us
}
}
}
}
finally
{
var completed = SendCompleted;
if (completed != null)
completed();
}
}
public void Send()
{
var enumerator = new AsyncEnumerator(
string.Format("Sending {0} messages to {1}", Messages.Length,
Destination)
);
logger.DebugFormat("Starting to send {0} messages to {1}", Messages.Length, Destination);
enumerator.BeginExecute(SendInternal(enumerator), result =>
{
try
{
enumerator.EndExecute(result);
}
catch (Exception exception)
{
logger.Warn("Failed to send message", exception);
Failure(exception);
}
});
}
static IEnumerator <int> ClientFiber(AsyncEnumerator ae, TcpClient clientSocket)
{
Console.WriteLine("ClientFibers ++{0}", Interlocked.Increment(ref clients));
try
{
// original code to do handshaking and connect to remote host
var ns1 = clientSocket.GetStream();
var r1 = new BinaryReader(ns1);
var w1 = new BinaryWriter(ns1);
if (!(r1.ReadByte() == 5 && r1.ReadByte() == 1))
{
yield break;
}
var c = r1.ReadByte();
for (int i = 0; i < c; ++i)
{
r1.ReadByte();
}
w1.Write((byte)5);
w1.Write((byte)0);
if (!(r1.ReadByte() == 5 && r1.ReadByte() == 1))
{
yield break;
}
if (r1.ReadByte() != 0)
{
yield break;
}
byte[] ipAddr = null;
string hostname = null;
var type = r1.ReadByte();
switch (type)
{
case 1:
ipAddr = r1.ReadBytes(4);
break;
case 3:
hostname = Encoding.ASCII.GetString(r1.ReadBytes(r1.ReadByte()));
break;
case 4:
throw new Exception();
}
var nhport = r1.ReadInt16();
var port = IPAddress.NetworkToHostOrder(nhport);
var socketout = new TcpClient();
if (hostname != null)
{
socketout.Connect(hostname, port);
}
else
{
socketout.Connect(new IPAddress(ipAddr), port);
}
w1.Write((byte)5);
w1.Write((byte)0);
w1.Write((byte)0);
w1.Write(type);
switch (type)
{
case 1:
w1.Write(ipAddr);
break;
case 3:
w1.Write((byte)hostname.Length);
w1.Write(Encoding.ASCII.GetBytes(hostname), 0, hostname.Length);
break;
}
w1.Write(nhport);
using (var ns2 = socketout.GetStream())
{
var forwardAe = new AsyncEnumerator()
{
SyncContext = null
};
forwardAe.BeginExecute(
ForwardingFiber(forwardAe, ns1, ns2), ae.EndVoid(0, forwardAe.EndExecute), null);
yield return(1);
if (ae.IsCanceled())
{
yield break;
}
forwardAe.EndExecute(ae.DequeueAsyncResult());
}
}
finally
{
Console.WriteLine("ClientFibers --{0}", Interlocked.Decrement(ref clients));
}
}
private IEnumerator <int> ProcessRequest(TcpClient client, AsyncEnumerator ae)
{
try
{
using (client)
using (var stream = client.GetStream())
{
var sender = client.Client.RemoteEndPoint;
var lenOfDataToReadBuffer = new byte[sizeof(int)];
var lenEnumerator = new AsyncEnumerator(ae.ToString());
try
{
lenEnumerator.BeginExecute(
StreamUtil.ReadBytes(lenOfDataToReadBuffer, stream, lenEnumerator, "length data", false), ae.End());
}
catch (Exception exception)
{
logger.Warn("Unable to read length data from " + sender, exception);
yield break;
}
yield return(1);
try
{
lenEnumerator.EndExecute(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.Warn("Unable to read length data from " + sender, exception);
yield break;
}
var lengthOfDataToRead = BitConverter.ToInt32(lenOfDataToReadBuffer, 0);
if (lengthOfDataToRead < 0)
{
logger.WarnFormat("Got invalid length {0} from sender {1}", lengthOfDataToRead, sender);
yield break;
}
logger.DebugFormat("Reading {0} bytes from {1}", lengthOfDataToRead, sender);
var buffer = new byte[lengthOfDataToRead];
var readBufferEnumerator = new AsyncEnumerator(ae.ToString());
try
{
readBufferEnumerator.BeginExecute(
StreamUtil.ReadBytes(buffer, stream, readBufferEnumerator, "message data", false), ae.End());
}
catch (Exception exception)
{
logger.Warn("Unable to read message data from " + sender, exception);
yield break;
}
yield return(1);
try
{
readBufferEnumerator.EndExecute(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.Warn("Unable to read message data from " + sender, exception);
yield break;
}
Message[] messages = null;
try
{
messages = SerializationExtensions.ToMessages(buffer);
logger.DebugFormat("Deserialized {0} messages from {1}", messages.Length, sender);
}
catch (Exception exception)
{
logger.Warn("Failed to deserialize messages from " + sender, exception);
}
if (messages == null)
{
try
{
stream.BeginWrite(ProtocolConstants.SerializationFailureBuffer, 0,
ProtocolConstants.SerializationFailureBuffer.Length, ae.End(), null);
}
catch (Exception exception)
{
logger.Warn("Unable to send serialization format error to " + sender, exception);
yield break;
}
yield return(1);
try
{
stream.EndWrite(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.Warn("Unable to send serialization format error to " + sender, exception);
}
yield break;
}
IMessageAcceptance acceptance = null;
byte[] errorBytes = null;
try
{
acceptance = acceptMessages(messages);
logger.DebugFormat("All messages from {0} were accepted", sender);
}
catch (QueueDoesNotExistsException)
{
logger.WarnFormat("Failed to accept messages from {0} because queue does not exists", sender);
errorBytes = ProtocolConstants.QueueDoesNoExiststBuffer;
}
catch (Exception exception)
{
errorBytes = ProtocolConstants.ProcessingFailureBuffer;
logger.Warn("Failed to accept messages from " + sender, exception);
}
if (errorBytes != null)
{
try
{
stream.BeginWrite(errorBytes, 0,
errorBytes.Length, ae.End(), null);
}
catch (Exception exception)
{
logger.Warn("Unable to send processing failure from " + sender, exception);
yield break;
}
yield return(1);
try
{
stream.EndWrite(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.Warn("Unable to send processing failure from " + sender, exception);
}
yield break;
}
logger.DebugFormat("Sending reciept notice to {0}", sender);
try
{
stream.BeginWrite(ProtocolConstants.RecievedBuffer, 0, ProtocolConstants.RecievedBuffer.Length,
ae.End(), null);
}
catch (Exception exception)
{
logger.Warn("Could not send reciept notice to " + sender, exception);
acceptance.Abort();
yield break;
}
yield return(1);
try
{
stream.EndWrite(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.Warn("Could not send reciept notice to " + sender, exception);
acceptance.Abort();
yield break;
}
logger.DebugFormat("Reading acknowledgement about accepting messages to {0}", sender);
var acknowledgementBuffer = new byte[ProtocolConstants.AcknowledgedBuffer.Length];
var readAcknoweldgement = new AsyncEnumerator(ae.ToString());
try
{
readAcknoweldgement.BeginExecute(
StreamUtil.ReadBytes(acknowledgementBuffer, stream, readAcknoweldgement, "acknowledgement", false),
ae.End());
}
catch (Exception exception)
{
logger.Warn("Error reading acknowledgement from " + sender, exception);
acceptance.Abort();
yield break;
}
yield return(1);
try
{
readAcknoweldgement.EndExecute(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.Warn("Error reading acknowledgement from " + sender, exception);
acceptance.Abort();
yield break;
}
var senderResponse = Encoding.Unicode.GetString(acknowledgementBuffer);
if (senderResponse != ProtocolConstants.Acknowledged)
{
logger.WarnFormat("Sender did not respond with proper acknowledgement, the reply was {0}",
senderResponse);
acceptance.Abort();
}
bool commitSuccessful;
try
{
acceptance.Commit();
commitSuccessful = true;
}
catch (Exception exception)
{
logger.Warn("Unable to commit messages from " + sender, exception);
commitSuccessful = false;
}
if (commitSuccessful == false)
{
bool writeSuccessful;
try
{
stream.BeginWrite(ProtocolConstants.RevertBuffer, 0, ProtocolConstants.RevertBuffer.Length,
ae.End(),
null);
writeSuccessful = true;
}
catch (Exception e)
{
logger.Warn("Unable to send revert message to " + sender, e);
writeSuccessful = false;
}
if (writeSuccessful)
{
yield return(1);
try
{
stream.EndWrite(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.Warn("Unable to send revert message to " + sender, exception);
}
}
}
}
}
finally
{
var copy = CompletedRecievingMessages;
if (copy != null)
{
copy();
}
}
}
private XElement LoginAction(SerializedObject request, Token token)
{
List<string> argList = XmlRequestCommandHelper.GetArguments(request.Content);
XElement result = null;
AsyncEnumerator ae = new AsyncEnumerator();
int appType = argList[3].ToInt();
IAsyncResult asyncResult = ae.BeginExecute(LoginManager.Default.Login(request, argList[0], argList[1], argList[2], appType, ae), ae.EndExecute);
if ((int)AppType.Mobile == appType)
{
ae.EndExecute(asyncResult);
token = Trader.Server.Session.SessionManager.Default.GetToken(request.Session);
result = iExchange3Promotion.Mobile.Manager.Login(token);
}
//test:
if (System.Configuration.ConfigurationManager.AppSettings["MobileDebug"] == "true")
{
Dictionary<Guid, Guid> quotePolicyIds = Mobile.Manager.UpdateInstrumentSetting(token, new string[] { });
}
return result;
}
// An ASP.NET thread pool thread calls this when the IAsyncResult returned from BeginHandler indicates
// that the op has completed. When EndHandler returns, ASP.NET renders the page
private void EndHandler(IAsyncResult result)
{
m_ae.EndExecute(result);
}
private IEnumerator <int> SendInternal(AsyncEnumerator ae)
{
try
{
using (var client = new TcpClient())
{
try
{
client.BeginConnect(Destination.Host, Destination.Port,
ae.End(),
null);
}
catch (Exception exception)
{
logger.WarnFormat("Failed to connect to {0} because {1}", Destination, exception);
Failure(exception);
yield break;
}
yield return(1);
try
{
client.EndConnect(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.WarnFormat("Failed to connect to {0} because {1}", Destination, exception);
Failure(exception);
yield break;
}
logger.DebugFormat("Successfully connected to {0}", Destination);
using (var stream = client.GetStream())
{
var buffer = Messages.Serialize();
var bufferLenInBytes = BitConverter.GetBytes(buffer.Length);
logger.DebugFormat("Writing length of {0} bytes to {1}", buffer.Length, Destination);
try
{
stream.BeginWrite(bufferLenInBytes, 0, bufferLenInBytes.Length, ae.End(), null);
}
catch (Exception exception)
{
logger.WarnFormat("Could not write to {0} because {1}", Destination,
exception);
Failure(exception);
yield break;
}
yield return(1);
try
{
stream.EndWrite(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.WarnFormat("Could not write to {0} because {1}", Destination,
exception);
Failure(exception);
yield break;
}
logger.DebugFormat("Writing {0} bytes to {1}", buffer.Length, Destination);
try
{
stream.BeginWrite(buffer, 0, buffer.Length, ae.End(), null);
}
catch (Exception exception)
{
logger.WarnFormat("Could not write to {0} because {1}", Destination,
exception);
Failure(exception);
yield break;
}
yield return(1);
try
{
stream.EndWrite(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.WarnFormat("Could not write to {0} because {1}", Destination,
exception);
Failure(exception);
yield break;
}
logger.DebugFormat("Successfully wrote to {0}", Destination);
var recieveBuffer = new byte[ProtocolConstants.RecievedBuffer.Length];
var readConfirmationEnumerator = new AsyncEnumerator();
try
{
readConfirmationEnumerator.BeginExecute(
StreamUtil.ReadBytes(recieveBuffer, stream, readConfirmationEnumerator, "recieve confirmation", false), ae.End());
}
catch (Exception exception)
{
logger.WarnFormat("Could not read confirmation from {0} because {1}", Destination,
exception);
Failure(exception);
yield break;
}
yield return(1);
try
{
readConfirmationEnumerator.EndExecute(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.WarnFormat("Could not read confirmation from {0} because {1}", Destination,
exception);
Failure(exception);
yield break;
}
var recieveRespone = Encoding.Unicode.GetString(recieveBuffer);
if (recieveRespone == ProtocolConstants.QueueDoesNotExists)
{
logger.WarnFormat(
"Response from reciever {0} is that queue does not exists",
Destination);
Failure(new QueueDoesNotExistsException());
yield break;
}
else if (recieveRespone != ProtocolConstants.Recieved)
{
logger.WarnFormat(
"Response from reciever {0} is not the expected one, unexpected response was: {1}",
Destination, recieveRespone);
Failure(null);
yield break;
}
try
{
stream.BeginWrite(ProtocolConstants.AcknowledgedBuffer, 0,
ProtocolConstants.AcknowledgedBuffer.Length, ae.End(), null);
}
catch (Exception exception)
{
logger.WarnFormat("Failed to write acknowledgement to reciever {0} because {1}",
Destination, exception);
Failure(exception);
yield break;
}
yield return(1);
try
{
stream.EndWrite(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.WarnFormat("Failed to write acknowledgement to reciever {0} because {1}",
Destination, exception);
Failure(exception);
yield break;
}
var bookmarks = Success();
buffer = new byte[ProtocolConstants.RevertBuffer.Length];
var readRevertMessage = new AsyncEnumerator(ae.ToString());
bool startingToReadFailed = false;
try
{
readRevertMessage.BeginExecute(
StreamUtil.ReadBytes(buffer, stream, readRevertMessage, "revert", true), ae.End());
}
catch (Exception)
{
//more or less expected
startingToReadFailed = true;
}
if (startingToReadFailed)
{
yield break;
}
yield return(1);
try
{
readRevertMessage.EndExecute(ae.DequeueAsyncResult());
var revert = Encoding.Unicode.GetString(buffer);
if (revert == ProtocolConstants.Revert)
{
logger.Warn("Got back revert message from receiver, reverting send");
Revert(bookmarks);
}
}
catch (Exception)
{
// expected, there is nothing to do here, the
// reciever didn't report anything for us
}
}
}
}
finally
{
var completed = SendCompleted;
if (completed != null)
{
completed();
}
}
}
