private static IEnumerator<Int32> PipeServerAsyncEnumerator(AsyncEnumerator ae) {
// Each server object performs asynchronous operation on this pipe
using (var pipe = new NamedPipeServerStream(
"Echo", PipeDirection.InOut, -1, PipeTransmissionMode.Message,
PipeOptions.Asynchronous | PipeOptions.WriteThrough)) {
// Asynchronously accept a client connection
pipe.BeginWaitForConnection(ae.End(), null);
yield return 1;
// A client connected, let's accept another client
var aeNewClient = new AsyncEnumerator();
aeNewClient.BeginExecute(PipeServerAsyncEnumerator(aeNewClient),
aeNewClient.EndExecute);
// Accept the client connection
pipe.EndWaitForConnection(ae.DequeueAsyncResult());
// Asynchronously read a request from the client
Byte[] data = new Byte[1000];
pipe.BeginRead(data, 0, data.Length, ae.End(), null);
yield return 1;
// The client sent us a request, process it
Int32 bytesRead = pipe.EndRead(ae.DequeueAsyncResult());
// Just change to upper case
data = Encoding.UTF8.GetBytes(
Encoding.UTF8.GetString(data, 0, bytesRead).ToUpper().ToCharArray());
// Asynchronously send the response back to the client
pipe.BeginWrite(data, 0, data.Length, ae.End(), null);
yield return 1;
// The response was sent to the client, close our side of the connection
pipe.EndWrite(ae.DequeueAsyncResult());
} // Close happens in a finally block now!
}
public static IEnumerator<int> GetInitData(SerializedObject request, DataSet initData, AsyncEnumerator ae)
{
XElement result = null;
long session = request.Session;
Token token = SessionManager.Default.GetToken(session);
if (initData == null)
{
Application.Default.StateServer.BeginGetInitData(token, null, ae.End(), null);
yield return 1;
int sequence;
initData = Application.Default.StateServer.EndGetInitData(ae.DequeueAsyncResult(), out sequence);
}
try
{
var data = Init(session, initData);
int commandSequence = data.Item2;
DataSet ds = data.Item1;
var dict = new Dictionary<string, string>()
{
{"commandSequence",commandSequence.ToString()},
{"data",ds.ToXml()}
};
result = XmlResultHelper.NewResult(dict);
request.Content = result;
SendCenter.Default.Send(request);
}
catch (Exception ex)
{
request.Content = XmlResultHelper.NewErrorResult(ex.ToString());
SendCenter.Default.Send(request);
}
}
private async Task MigrateConversation(
Conversation conversation, CancellationToken cancellationToken)
{
Logger.Debug("Getting messages ...");
using (AsyncEnumerator <Message> messageEnumerator =
await input.GetMessages(conversation.Id, filter))
{
while (await messageEnumerator.Move())
{
// Read message.
Message message = await messageEnumerator.Read();
Logger.Trace("Read message: {0}", message);
if (message.MessageType == Enums.InternalMessageType.Unknown)
{
Logger.Warn("Skip message.");
continue;
}
// Get message group and open new group if necessary.
Group group = await grouper.GetGroup(input, conversation, message);
Logger.Trace("Group: {0}", group);
if (!group.Equals(output.CurrentGroup))
{
output.EndGroup();
output.BeginGroup(group);
}
// Insert message.
await output.InsertMessage(message);
// Check cancellation token.
cancellationToken.ThrowIfCancellationRequested();
}
}
}
/// <summary>
/// Enumerates a given <paramref name="enumerable"/> until the predicate <paramref name="predicate"/> returns true.
/// </summary>
private static System.Collections.Generic.IAsyncEnumerable <T> StopAfter <T>(this System.Collections.Generic.IAsyncEnumerable <T> enumerable, Func <T, bool> predicate)
{
return(AsyncEnumerable.Create(
token =>
{
var enumerator = enumerable.GetAsyncEnumerator(token);
bool stop = false;
return AsyncEnumerator.Create(
async() =>
{
if (stop)
{
return false;
}
if (await enumerator.MoveNextAsync(token))
{
if (!predicate(enumerator.Current))
{
stop = true;
}
return true;
}
return false;
},
() => enumerator.Current,
() => enumerator.DisposeAsync());
}));
}
private static IEnumerator <Int32> PipeClientAsyncEnumerator(AsyncEnumerator ae, String serverName, String message)
{
// Each client object performs asynchronous operations on this pipe
using (var pipe = new NamedPipeClientStream(serverName, "Echo",
PipeDirection.InOut, PipeOptions.Asynchronous | PipeOptions.WriteThrough)) {
pipe.Connect(); // Must Connect before setting ReadMode
pipe.ReadMode = PipeTransmissionMode.Message;
// Asynchronously send data to the server
Byte[] output = Encoding.UTF8.GetBytes(message);
pipe.BeginWrite(output, 0, output.Length, ae.End(), null);
yield return(1);
// The data was sent to the server
pipe.EndWrite(ae.DequeueAsyncResult());
// Asynchronously read the server's response
Byte[] data = new Byte[1000];
pipe.BeginRead(data, 0, data.Length, ae.End(), data);
yield return(1);
// The server responded, display the response and close out connection
Int32 bytesRead = pipe.EndRead(ae.DequeueAsyncResult());
Console.WriteLine("Server response: " + Encoding.UTF8.GetString(data, 0, bytesRead));
} // Close();
}
public static System.Collections.Generic.IAsyncEnumerable <T> CreateSingleProducerTaskAsyncEnumerable <T>(
Func <Task <IEnumerable <T> > > producerTaskFunc)
where T : ResultBase
{
Task <IEnumerator <T> > producerTask = Task.Run(async() =>
{
var enumerable = await producerTaskFunc();
return(enumerable.GetEnumerator());
});
IEnumerator <T> enumerator = Enumerable.Empty <T>().GetEnumerator();
return(AsyncEnumerable.Create(
(token) => AsyncEnumerator.Create(
async() =>
{
enumerator = await producerTask;
return enumerator.MoveNext();
},
() => enumerator.Current,
() =>
{
enumerator.Dispose();
return new ValueTask();
})));
}
/// <summary>
/// remove package from all feeds
/// тут нужны перегрузки для конкретного фида, либо отдельный фид комбайнить, тогда нужен злой конструктор фида как у нугет репоза
/// </summary>
/// <param name="nuGetPackage"></param>
/// <returns></returns>
public AsyncEnumerable <bool> Remove(NuGetPackage nuGetPackage)
{
var enumerator = new AsyncEnumerator <bool>(this.nuGetRepository.Remove(nuGetPackage));
var enumerable = AsyncEnumerable.FromResult(enumerator);
return(enumerable);
}
private static IEnumerator <int> GenerateTransferTask(
AsyncEnumerator ae, HttpContext context, string url)
{
WebRequest request = WebRequest.Create(url);
request.BeginGetResponse(ae.End(), null);
yield return(1);
using (WebResponse response = request.EndGetResponse(ae.DequeueAsyncResult()))
{
Stream streamIn = response.GetResponseStream();
Stream streamOut = context.Response.OutputStream;
byte[] buffer = new byte[1024];
while (true)
{
streamIn.BeginRead(buffer, 0, buffer.Length, ae.End(), null);
yield return(1);
int lengthRead = streamIn.EndRead(ae.DequeueAsyncResult());
if (lengthRead <= 0)
{
break;
}
streamOut.BeginWrite(buffer, 0, lengthRead, ae.End(), null);
yield return(1);
streamOut.EndWrite(ae.DequeueAsyncResult());
}
}
}
public static IAsyncEnumerable <TDocument> ToAsyncEnumerable <TDocument>(
this IAsyncCursorSource <TDocument> source,
CancellationToken cancellationToken = default(CancellationToken))
{
return(AsyncEnumerable.Create(
token =>
{
IAsyncCursor <TDocument>?cursor = null;
async ValueTask <bool> MoveNextAsync()
{
cursor ??= await source.ToCursorAsync(cancellationToken);
return await cursor.MoveNextAsync(token);
}
return AsyncEnumerator.Create(
MoveNextAsync,
() => cursor?.Current ?? ImmutableList <TDocument> .Empty,
() =>
{
cursor?.Dispose();
return default;
});
})
.SelectMany(x => x.ToAsyncEnumerable()));
}
private static IEnumerator <int> CopyStream(AsyncEnumerator ae, Stream readStream, Stream writeStream)
{
byte[][] buffer = new byte[][]
{
new byte[8192],
new byte[8192]
};
int bytesRead = 0;
int currentBuffer = 0;
ae.AddAsync <IAsyncResult>(readStream.BeginRead(buffer[currentBuffer], 0, buffer[0].Length, ae.GetAsyncCallback(), null));
yield return(1);
for (bytesRead = readStream.EndRead(ae.CompletedAsyncResults[0]); bytesRead > 0; bytesRead = readStream.EndRead(ae.CompletedAsyncResults[1]))
{
ae.AddAsync <IAsyncResult>(writeStream.BeginWrite(buffer[currentBuffer % 2], 0, bytesRead, ae.GetAsyncCallback(), null));
currentBuffer++;
ae.AddAsync <IAsyncResult>(readStream.BeginRead(buffer[currentBuffer % 2], 0, buffer[currentBuffer % 2].Length, ae.GetAsyncCallback(), null));
yield return(2);
writeStream.EndWrite(ae.CompletedAsyncResults[0]);
}
ae.End();
yield break;
}
private static IEnumerator <Int32> CopyStream(AsyncEnumerator <Int64> ae, Stream source, Stream destination, Int32 bufferSize, Action <Int64> reportProgress)
{
Byte[] buffer = new Byte[bufferSize];
Int64 totalBytesRead = 0;
while (true)
{
ae.SetOperationTag("Reading from source stream");
// Read whichever is smaller (number of bytes left to read OR the buffer size)
source.BeginRead(buffer, 0, buffer.Length, ae.End(), null);
yield return(1);
Int32 bytesReadThisTime = source.EndRead(ae.DequeueAsyncResult());
totalBytesRead += bytesReadThisTime;
ae.SetOperationTag("Writing to destination stream");
destination.BeginWrite(buffer, 0, bytesReadThisTime, ae.End(), null);
yield return(1);
destination.EndWrite(ae.DequeueAsyncResult());
if (reportProgress != null)
{
reportProgress(totalBytesRead);
}
if (bytesReadThisTime < buffer.Length)
{
break;
}
}
ae.Result = totalBytesRead;
}
public void StartAsync(HttpContext context, string url)
{
this.m_asyncEnumerator = new AsyncEnumerator();
var asyncTask = GenerateTransferTask(this.m_asyncEnumerator, context, url);
this.m_asyncEnumerator.BeginExecute(asyncTask, this.EndExecuteCallback);
}
private static IEnumerator<Int32> ProcessAllAndEachOps(AsyncEnumerator ae, String[] urls)
{
Int32 numOps = urls.Length;
// Issue all the asynchronous operation(s) so they run concurrently
for (Int32 n = 0; n < numOps; n++) {
WebRequest wr = WebRequest.Create(urls[n]);
wr.BeginGetResponse(ae.End(), wr);
}
// Have AsyncEnumerator wait until ALL operations complete
yield return numOps;
Console.WriteLine("All the operations completed:");
for (Int32 n = 0; n < numOps; n++) {
ProcessCompletedWebRequest(ae.DequeueAsyncResult());
}
Console.WriteLine(); // *** Blank line between demos ***
System.Diagnostics.Debugger.Break();
// Issue all the asynchronous operation(s) so they run concurrently
for (Int32 n = 0; n < numOps; n++) {
WebRequest wr = WebRequest.Create(urls[n]);
wr.BeginGetResponse(ae.End(), wr);
}
for (Int32 n = 0; n < numOps; n++) {
// Have AsyncEnumerator wait until EACH operation completes
yield return 1;
Console.WriteLine("An operation completed:");
ProcessCompletedWebRequest(ae.DequeueAsyncResult());
}
}
public static System.Collections.Generic.IAsyncEnumerable <T> ToResultsAsyncEnumerable <T>(this IEnumerable <Task <T> > tasks)
{
return(AsyncEnumerable.Create(
(token) =>
{
var enumerator = tasks.GetEnumerator();
T current = default;
return AsyncEnumerator.Create(
async() =>
{
if (enumerator.MoveNext())
{
current = await enumerator.Current;
return true;
}
return false;
},
() => current,
() =>
{
enumerator.Dispose();
return new ValueTask();
});
}));
}
public void TestExceptionPropagation()
{
var srcAsyncEnumerator = new AsyncEnumerator <int>();
srcAsyncEnumerator.Consumer.Fail(new TestUtils.SomeTestException());
var cachedEnumerable = new CachingAsyncEnumerable <int>(srcAsyncEnumerator);
for (int i = 0; i < 10; i++)
{
var innerEnumerator = cachedEnumerable.GetEnumerator();
try
{
innerEnumerator.MoveNextAsync().AwaitSynchronously();
Assert.Fail();
}
catch (TestUtils.SomeTestException)
{
}
// CachingAsyncEnumerable is implemented to propagate Exception only once and to return
// false on subsequent calls to MoveNext. Contract also allows to propagate exception
// multiple times
Assert.IsFalse(innerEnumerator.MoveNextAsync().AwaitSynchronously());
}
}
private IEnumerator <Int32> GetImagesFromGoogle(AsyncEnumerator ae, string searchUrl, Int32 imageNumber)
{
InitiateWebRequest(ae, searchUrl);
yield return(1);
String resultPage;
using (WebResponse response = GetWebResponse(ae.DequeueAsyncResult()))
{
resultPage = GetSearchResutlPage(response);
}
IEnumerable <String> imageURIs = GetImageURIFromResultPage(resultPage);
int currentURI = 0;
Int32 _downloaded = 0;
while (_downloaded < imageNumber && currentURI < imageURIs.Count())
{
InitiateWebRequest(ae, imageURIs.ElementAt(currentURI++));
yield return(1);
try
{
using (WebResponse response = GetWebResponse(ae.DequeueAsyncResult()))
{
_GoogledImages.Add(GetImageFromResponse(response));
_downloaded++;
}
}
catch (Exception e)
{
}
}
yield break;
}
public void AddLookups(QuotePage[] pages)
{
// precondition checking
if (pages == null)
{
throw new ArgumentNullException();
}
else if (pages.Length == 0)
{
throw new ArgumentException();
}
foreach (QuotePage page in pages)
{
if (page == null)
{
throw new ArgumentException();
}
else if (!_cultureMapper.Contains(page.Culture))
{
throw new CultureNotSupportedException(page.Culture);
}
}
IsBusy = true;
AsyncEnumerator asyncEnumerator = GetAsyncEnumerator();
asyncEnumerator.BeginExecute(ProcessUpdateLookups(asyncEnumerator, pages), asyncEnumerator.EndExecute);
}
private IEnumerator<Int32> GetImagesFromGoogle(AsyncEnumerator ae,string searchUrl,Int32 imageNumber)
{
InitiateWebRequest(ae,searchUrl);
yield return 1;
String resultPage;
using (WebResponse response = GetWebResponse(ae.DequeueAsyncResult()))
{
resultPage = GetSearchResutlPage(response);
}
IEnumerable<String> imageURIs = GetImageURIFromResultPage(resultPage) ;
int currentURI=0;
Int32 _downloaded=0;
while (_downloaded < imageNumber && currentURI < imageURIs.Count())
{
InitiateWebRequest(ae, imageURIs.ElementAt(currentURI++));
yield return 1;
try
{
using (WebResponse response = GetWebResponse(ae.DequeueAsyncResult()))
{
_GoogledImages.Add(GetImageFromResponse(response));
_downloaded++;
}
}
catch (Exception e)
{
}
}
yield break;
}
public static async Task EnumerateAsync <T>(this AsyncEnumerator <T> enumerator, Func <T, Task> asyncAction)
{
try
{
while (await enumerator.MoveNextAsync())
{
await asyncAction(enumerator.Current);
}
}
catch
{
try
{
while (await enumerator.MoveNextAsync())
{
;
}
}
catch
{
// Ignore
}
throw;
}
}
public IAsyncEnumerable <TDocument> FindAsyncEnumerable <TDocument>(IMongoCollection <TDocument> collection, FilterDefinition <TDocument> filter)
{
IAsyncEnumerable <TDocument> a = AsyncEnumerable.Create(
token =>
{
IAsyncCursor <TDocument>?cursor = null;
async ValueTask <bool> MoveNextAsync()
{
cursor ??= await collection.FindAsync(filter, null, token);
return(await cursor.MoveNextAsync(token));
}
return(AsyncEnumerator.Create(
MoveNextAsync,
() => cursor?.Current ?? ImmutableList <TDocument> .Empty,
() =>
{
cursor?.Dispose();
return default;
}));
})
.SelectMany(x => x.ToAsyncEnumerable());
return(a);
}
private static IEnumerator <Int32> FetchStockQuotesAsyncEnumerator(AsyncEnumerator ae, WebService svc)
{
svc.BeginFetchStockQuotes(ae.End(), null);
yield return(1);
IStockQuote qt = svc.EndFetchStockQuotes(ae.DequeueAsyncResult());
}
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);
}
}
public static IEnumerator <int> ReadBytes(
byte[] buffer, Stream stream, AsyncEnumerator ae, string type, bool expectedToHaveNoData)
{
var totalBytesRead = 0;
while (totalBytesRead < buffer.Length)
{
stream.BeginRead(buffer, totalBytesRead, buffer.Length - totalBytesRead, ae.End(), null);
yield return(1);
int bytesRead = stream.EndRead(ae.DequeueAsyncResult());
if (bytesRead == 0)
{
if (expectedToHaveNoData)
{
yield break;
}
throw new InvalidOperationException("Could not read value for " + type);
}
totalBytesRead += bytesRead;
}
}
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);
}
}
public async Task LambdaIsNotCalledIfSequenceIsEmpty()
{
bool lambdaCalled = false;
await AsyncEnumerator.Empty <int>().ForEach(_ => lambdaCalled = true).ConfigureAwait(true);
lambdaCalled.Should().BeFalse();
}
public void TestCompleteSuccessfullyWithFasterProducer()
{
AsyncEnumerator <int> enumerator = new AsyncEnumerator <int>();
var consumer = enumerator.Consumer;
int cnt = 0;
List <Task> yieldTasks = new List <Task>();
yieldTasks.Add(consumer.YieldAsync(cnt++));
yieldTasks.Add(consumer.YieldAsync(cnt++));
yieldTasks.Add(consumer.YieldAsync(cnt++));
consumer.Complete();
enumerator.ProceedToCompletion();
Task.WaitAll(yieldTasks.ToArray());
try
{
consumer.YieldAsync(1); // must raise exception
}
catch (InvalidOperationException)
{ }
}
/// <summary>
/// remove package from all feeds
/// (feature)
/// </summary>
/// <param name="nuGetPackage"></param>
/// <returns></returns>
internal IEnumerable <bool> Remove(NuGetPackage nuGetPackage)
{
var removeTask = this.nuGetRepository.Remove(nuGetPackage);
var enumerator = new AsyncEnumerator <bool>(removeTask);
return(new AsyncEnumerable <bool>(enumerator));
}
/// <summary>
/// add or update new package to all feeds
/// (feature)
/// </summary>
/// <param name="nuGetPackage"></param>
/// <returns></returns>
internal IEnumerable <bool> Add(NuGetPackage nuGetPackage)
{
var uploadTask = this.nuGetRepository.Upload(nuGetPackage);
var enumerator = new AsyncEnumerator <bool>(uploadTask);
return(new AsyncEnumerable <bool>(enumerator));
}
public void AsyncGetInitData()
{
Debug.Assert(_Token != null, "token can't be null");
IInitDataProvider provider = new InitDataProvider();
provider.Completed += GetInitDataCompletedCallback;
var ae = new AsyncEnumerator();
ae.BeginExecute(provider.AsyncGetInitData(_Token, ae), ae.EndExecute);
}
private static async AsyncEnumerator <int> ExceptionTest1()
{
var yield = await AsyncEnumerator <int> .Capture();
await yield.Return(1);
throw new Exception();
}
protected override async Task ExecuteYield(IAsyncEnumerable <Row> rows, AsyncEnumerator <Row> .Yield yield,
CancellationToken cancellationToken = default)
{
foreach (User user in MySimpleDal.GetUsers())
{
await @yield.ReturnAsync(Row.FromObject(user));
}
}
private static IEnumerator <NuGetPackage> Synchronized(AsyncEnumerator <NuGetPackage> async, Func <IQueryable <NuGetPackage>, IQueryable <NuGetPackage> > getNotEvaluated)
{
var syncList = new AsyncEnumerable <NuGetPackage>(async);
var withFilter = getNotEvaluated(syncList.AsQueryable());
return(withFilter.GetEnumerator());
}
public void AsyncGetLoginData()
{
Token token = SessionManager.Default.GetToken(_LoginInfo.Parameter.Request.ClientInfo.Session);
IInitDataProvider initDataProvider = new InitDataProvider();
initDataProvider.Completed += LoadInitDataCompletedCallback;
AsyncEnumerator ae = new AsyncEnumerator();
ae.BeginExecute(initDataProvider.AsyncGetInitData(token, ae), ae.EndExecute);
}
private void ExecuteWithAsyncEnumerator()
{
SetStatus("Working..", StatusState.Busy);
AsyncEnumerator ae = new AsyncEnumerator();
ae.BeginExecute(ExecuteWithAsyncEnumerator(ae), ae.EndExecute, null);
}
protected override async Task ExecuteYield(IAsyncEnumerable <Row> rows, AsyncEnumerator <Row> .Yield yield,
CancellationToken cancellationToken = default)
{
foreach (Row row in rowsToReturn)
{
await yield.ReturnAsync(row);
}
}
public static IAsyncEnumerable <T> ToAsyncEnumerable <T>(this IEnumerator <T> enumerator)
=>
AsyncEnumerable.Create((cancellationToken)
=> AsyncEnumerator.Create(
() => new ValueTask <bool>(enumerator.MoveNext()),
() => enumerator.Current,
() => new ValueTask())
);
public IEnumerator<int> Login(SerializedObject request, string loginID, string password, string version, int appType, AsyncEnumerator ae)
{
long session = request.Session;
string connectionString = SettingManager.Default.ConnectionString;
IsFailedCountExceed(loginID, password, connectionString);
LoginParameter loginParameter = new LoginParameter();
loginParameter.CompanyName = string.Empty;
if (loginID == String.Empty)
{
AuditHelper.AddIllegalLogin(AppType.TradingConsole, loginID, password, this.GetLocalIP());
Application.Default.TradingConsoleServer.SaveLoginFail(loginID, password, GetLocalIP());
SendErrorResult(request);
yield break;
}
string message = string.Empty;
Application.Default.ParticipantService.BeginLogin(loginID, password, ae.End(), null);
yield return 1;
loginParameter.UserID = Application.Default.ParticipantService.EndLogin(ae.DequeueAsyncResult());
if (loginParameter.UserID == Guid.Empty)
{
_Logger.ErrorFormat("{0} is not a valid user", loginID);
}
else
{
Guid programID = new Guid(SettingManager.Default.GetLoginSetting("TradingConsole"));
Guid permissionID = new Guid(SettingManager.Default.GetLoginSetting("Run"));
Application.Default.SecurityService.BeginCheckPermission(loginParameter.UserID, programID, permissionID, "", "", loginParameter.UserID, ae.End(), null);
yield return 1;
bool isAuthrized = Application.Default.SecurityService.EndCheckPermission(ae.DequeueAsyncResult(), out message);
if (!isAuthrized)
{
_Logger.ErrorFormat("{0} doesn't have the right to login trader", loginID);
loginParameter.UserID = Guid.Empty;
}
else
{
Token token = new Token(Guid.Empty, UserType.Customer, (AppType)appType);
token.UserID = loginParameter.UserID;
token.SessionID = session.ToString();
SessionManager.Default.AddToken(session, token);
Application.Default.StateServer.BeginLogin(token, ae.End(), null);
yield return 1;
bool isStateServerLogined = Application.Default.StateServer.EndLogin(ae.DequeueAsyncResult());
SetLoginParameter(loginParameter, session, password, version, appType, isStateServerLogined, token);
}
}
if (loginParameter.UserID == Guid.Empty)
{
AuditHelper.AddIllegalLogin(AppType.TradingConsole, loginID, password, this.GetLocalIP());
Application.Default.TradingConsoleServer.SaveLoginFail(loginID, password, GetLocalIP());
SendErrorResult(request);
}
else
{
SetResult(request, loginParameter, session, loginID, password, version, appType, connectionString);
}
}
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 IEnumerator<Int32> GetImages(AsyncEnumerator ae)
{
ae.ThrowOnMissingDiscardGroup(true);
// Request all the images asynchronously
WebRequest[] requests = new WebRequest[]
{
WebRequest.Create(_imageUris[0]),
WebRequest.Create(m_chkSimFailure.Checked ? _imageUris[2] : _imageUris[1])
};
for(Int32 n = 0; n < requests.Length; n++)
requests[n].BeginGetResponse(
ae.EndVoid(0, asyncResult => { requests[(Int32) asyncResult.AsyncState].EndGetResponse(asyncResult).Close(); }), n);
// Set timeout if specified.
Int32 timeout;
if(Int32.TryParse(m_txtServerTime.Text, out timeout))
ae.SetCancelTimeout(timeout, null);
// WaitAsync for all operations to complete (or timeout)
yield return requests.Length;
if(ae.IsCanceled())
{
m_lblPic1.Text = "Server couldn't process the request in the specified time.";
yield break;
}
for(Int32 n = 0; n < requests.Length; n++)
{
IAsyncResult result = ae.DequeueAsyncResult();
Int32 reqNum = (Int32) result.AsyncState;
Label lbl = (reqNum == 0) ? m_lblPic1 : m_lblPic2;
WebRequest request = requests[reqNum];
WebResponse response = null;
try
{
response = request.EndGetResponse(result);
lbl.Text = String.Format("Image at {0} is {1:N0} bytes",
response.ResponseUri, response.ContentLength);
}
catch(WebException e)
{
lbl.Text = String.Format("Error obtaining image at {0}: {1}",
request.RequestUri, e.Message);
}
finally
{
if(response != null) response.Close();
}
}
}
public void GetImagesAsync(string searchString,Action<IList<Image>> callback, int count = 5)
{
if (String.IsNullOrEmpty( searchString))
{
throw new ArgumentNullException("searchString");
}
_searchString = searchString;
_totalImages = count;
_callback = callback;
AsyncEnumerator asyncEnumerator = new AsyncEnumerator();
asyncEnumerator.BeginExecute(GetAllImages(asyncEnumerator), EnumeratorExecutionComplete);
}
private IEnumerator<Int32> DownloadString(AsyncEnumerator ae, String uri)
{
var request = WebRequest.Create(uri);
request.BeginGetResponse(ae.End(), null);
yield return 1;
var response = (WebResponse) request.EndGetResponse(ae.DequeueAsyncResult());
Byte[] buffer = new Byte[response.ContentLength];
using (var stream = response.GetResponseStream()) {
stream.BeginRead(buffer, 0, buffer.Length, ae.End(), null);
yield return 1;
stream.EndRead(ae.DequeueAsyncResult());
}
m_textBox.Text = Encoding.UTF8.GetString(buffer, 0, buffer.Length);
}
private static IEnumerator<int> GetAsyncEnumerator(
AsyncEnumerator ae,
string urlIn,
string urlOut,
Action<double> onProgress,
Action<int> onComplete)
{
onProgress(0);
var requestIn = WebRequest.Create(urlIn);
requestIn.BeginGetResponse(ae.End(), null);
yield return 1;
using (var responseIn = requestIn.EndGetResponse(ae.DequeueAsyncResult()))
{
var streamIn = responseIn.GetResponseStream();
var requestOut = WebRequest.Create(urlOut);
requestOut.Method = "POST";
var totalLength = (int)responseIn.ContentLength;
requestOut.BeginGetRequestStream(ae.End(), null);
yield return 1;
using (var streamOut = requestOut.EndGetRequestStream(ae.DequeueAsyncResult()))
{
var totalRead = 0;
var buffer = new byte[10240];
while (totalRead < totalLength)
{
streamIn.BeginRead(buffer, 0, buffer.Length, ae.End(), null);
yield return 1;
var lengthRead = streamIn.EndRead(ae.DequeueAsyncResult());
streamOut.BeginWrite(buffer, 0, lengthRead, ae.End(), null);
yield return 1;
streamOut.EndWrite(ae.DequeueAsyncResult());
totalRead += lengthRead;
onProgress(100.0 * totalRead / totalLength);
}
}
onComplete(totalLength);
}
}
private IEnumerator<Int32> GetAllImages(AsyncEnumerator ae)
{
Int32 CurrentPage=0;
Int32 _totalImagesTemp=_totalImages ;
_GoogledImages = new List<Image>();
while(_totalImagesTemp>0)
{
AsyncEnumerator asyncE = new AsyncEnumerator();
asyncE.BeginExecute(GetImagesFromGoogle(asyncE,
GetGoogleSearchUrl(CurrentPage++),
_totalImagesTemp > _numberOfImagesInAPage ? _numberOfImagesInAPage : _totalImagesTemp), ae.EndVoid(0, DiscardWebRequest));
_totalImagesTemp = _totalImagesTemp - _numberOfImagesInAPage;
yield return 1;
}
}
public static IEnumerator<int> GetInitData(SerializedInfo request,AsyncEnumerator ae)
{
Session session = request.ClientInfo.Session;
Token token = SessionManager.Default.GetToken(session);
Application.Default.StateServer.BeginGetInitData(token, null, ae.End(), null);
yield return 1;
try
{
int sequence;
DataSet initData = Application.Default.StateServer.EndGetInitData(ae.DequeueAsyncResult(), out sequence);
InitAndSendInitDataInPointer(request,initData);
}
catch (Exception ex)
{
SendErrorResult(request, ex);
}
}
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();
}
private void FlickrButton_Click(object sender, RoutedEventArgs e) {
// Initiate a Flickr request
String input = Input.Text.Replace(' ', '+');
#if !AsyncEnumerator
WebRequest request = HttpWebRequest.Create(
new Uri(String.Format("http://api.flickr.com/services/rest/?method=flickr.photos.search&api_key={0}&tags={1}&per_page=10",
FlickrKey.Key, input)));
request.BeginGetResponse(WebRequestComplete, request);
#else
#if DEBUG
AsyncEnumerator.EnableDebugSupport();
#endif
AsyncEnumerator ae = new AsyncEnumerator("Query Flickr Photos");
ae.BeginExecute(GetPhotos(ae, input), ae.EndExecute);
#endif
}
public IEnumerator<int> AsyncGetInitData(Token token,AsyncEnumerator ae)
{
Token currentToken = new Token(token.UserID, token.UserType, AppType.TradingConsole);
Application.Default.StateServer.BeginGetInitData(currentToken, null, ae.End(), null);
yield return 1;
try
{
int commandSequence;
DataSet initData = Application.Default.StateServer.EndGetInitData(ae.DequeueAsyncResult(), out commandSequence);
OnLoadInitDataCompleted(initData);
}
catch (Exception ex)
{
_Logger.Error("async getInitData", ex);
OnLoadInitDataCompleted(null);
yield break;
}
}
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);
}
});
}
private static IEnumerator<Int32> CopyStream(AsyncEnumerator<Int64> ae, Stream source, Stream destination, Int32 bufferSize, Action<Int64> reportProgress) {
Byte[] buffer = new Byte[bufferSize];
Int64 totalBytesRead = 0;
while (true) {
ae.SetOperationTag("Reading from source stream");
// Read whichever is smaller (number of bytes left to read OR the buffer size)
source.BeginRead(buffer, 0, buffer.Length, ae.End(), null);
yield return 1;
Int32 bytesReadThisTime = source.EndRead(ae.DequeueAsyncResult());
totalBytesRead += bytesReadThisTime;
ae.SetOperationTag("Writing to destination stream");
destination.BeginWrite(buffer, 0, bytesReadThisTime, ae.End(), null);
yield return 1;
destination.EndWrite(ae.DequeueAsyncResult());
if (reportProgress != null) reportProgress(totalBytesRead);
if (bytesReadThisTime < buffer.Length) break;
}
ae.Result = totalBytesRead;
}
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 IEnumerator<Int32> GetImagesFromGoogle(AsyncEnumerator ae,string searchUrl,Int32 imageNumber)
{
InitiateWebRequest(ae,searchUrl);
yield return 1;
String resultPage;
_GoogledImages = new List<Image>();
using (WebResponse response = GetWebResponse(ae.DequeueAsyncResult()))
{
resultPage = GetSearchResutlPage(response);
}
IEnumerable<String> imageURIs = GetImageURIFromResultPage(resultPage) ;
int currentURI=0;
Int32 _downloaded=0;
// while (_downloaded < imageNumber && currentURI < imageURIs.Count())
int i=0;
while(i<4)
{
InitiateWebRequest(ae, imageURIs.ElementAt(currentURI++));
yield return 1;
try
{
using (WebResponse response = GetWebResponse(ae.DequeueAsyncResult()))
{
curImage=GetImageFromResponse(response);
_GoogledImages.Add(curImage);
_downloaded++;
}
}
catch (Exception e)
{
Console.WriteLine("caught Webresponse exception" + e);
}
i++;
}
yield break;
}
private IEnumerator<Int32> DownloadImages(AsyncEnumerator ae)
{
ae.ThrowOnMissingDiscardGroup(true);
GetImages.IsEnabled = false;
Cancel.IsEnabled = true;
WebRequest[] requests = new WebRequest[] {
WebRequest.Create(UriHelper.ConvertRelativeUriStringToAbsolute("Images/Wintellect.jpg")),
WebRequest.Create(UriHelper.ConvertRelativeUriStringToAbsolute("Images/JeffreyRichter.jpg")),
};
for (Int32 requestNum = 0; requestNum < requests.Length; requestNum++) {
requests[requestNum].BeginGetResponse(
ae.EndVoid(0, asyncResult => {
requests[requestNum].EndGetResponse(asyncResult).Close();
}), requestNum);
}
for (Int32 resultNum = 0; resultNum < requests.Length; resultNum++) {
yield return 1;
if (ae.IsCanceled()) break;
IAsyncResult asyncResult = ae.DequeueAsyncResult();
Int32 index = (Int32)asyncResult.AsyncState;
try {
using (WebResponse response = requests[index].EndGetResponse(asyncResult)) {
using (Stream stream = response.GetResponseStream()) {
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.SetSource(stream);
m_images[index].Source = bitmapImage;
}
}
}
catch (WebException e) {
m_textboxes[index].Text = "Failed: " + e.Message;
}
}
GetImages.IsEnabled = true;
Cancel.IsEnabled = false;
}
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)
{
}
}
public static IEnumerator<int> ReadBytes(
byte[] buffer, Stream stream, AsyncEnumerator ae, string type, bool expectedToHaveNoData)
{
var totalBytesRead = 0;
while (totalBytesRead < buffer.Length)
{
stream.BeginRead(buffer, totalBytesRead, buffer.Length - totalBytesRead, ae.End(), null);
yield return 1;
int bytesRead = stream.EndRead(ae.DequeueAsyncResult());
if(bytesRead == 0)
{
if (expectedToHaveNoData)
yield break;
throw new InvalidOperationException("Could not read value for " + type);
}
totalBytesRead += bytesRead;
}
}
private XElement GetInitDataAction(SerializedObject request, Token token)
{
XElement result=null;
if (token != null && token.AppType == iExchange.Common.AppType.Mobile)
{
System.Data.DataSet initData = Mobile.Manager.GetInitData(token);
List<string> argList = XmlRequestCommandHelper.GetArguments(request.Content);
Guid selectedAccountId = (argList != null && argList.Count > 0 ? new Guid(argList[0]) : Guid.Empty);
InitDataService.Init(request.Session, initData);
result = Mobile.Manager.Initialize(token, initData, selectedAccountId);
//test:
if (System.Configuration.ConfigurationManager.AppSettings["MobileDebug"]=="true")
{
////test place
//string s = "<PlacingInstruction AccountId=\"cbcdb06f-141a-415f-bdda-a676bd5759b7\" InstrumentId=\"864ac5d7-b872-45a6-887e-7189463beb12\" PlacingType=\"LimitStop\" EndTime=\"2013-05-02 12:19:07.007\" ExpireType=\"GoodTillSession\" ExpireDate=\"2013-05-02 12:19:07.007\" PriceIsQuote=\"false\" PriceTimestamp=\"2013-05-02 12:19:07.007\"><PlacingOrders><PlacingOrder Id=\"e2a72e0d-ddf6-4d83-8a04-9883a0eee84e\" Lot=\"1\" IsOpen=\"true\" IsBuy=\"false\" SetPrice=\"2.0988\" TradeOption=\"Better\" /></PlacingOrders></PlacingInstruction>";
//XmlDocument doc = new XmlDocument();
//doc.LoadXml(s);
//ICollection<Mobile.Server.Transaction> transactionsTest = Mobile.Manager.ConvertPlacingRequest(token, doc.FirstChild);
//foreach (Mobile.Server.Transaction transaction in transactionsTest)
//{
// string tranCode;
// TransactionError error = Application.Default.TradingConsoleServer.Place(token, Application.Default.StateServer, transaction.ToXmlNode(), out tranCode);
//}
//// test quote
//this._Service.Quote(request.Session, "282fa038-1330-43a6-aa87-9d7d01c1a594", 30, 2);
// test order query
//XElement node = Mobile.Manager.QueryOrder(token, new Guid("1DFC557A-3FB5-4A9F-BD08-E165FA6DFCE6"), 10, 4, 3);
//XElement x = new XElement("Result");
//x.Add(node);
//XElement e = XElement.Parse("<Transaction ID=\"ec123d66-77af-4403-b739-0bbfa618a37b\" AccountID=\"cbcdb06f-141a-415f-bdda-a676bd5759b7\" InstrumentID=\"864ac5d7-b872-45a6-887e-7189463beb12\" Type=\"2\" SubType=\"1\" OrderType=\"1\" BeginTime=\"2013-05-02 11:52:22\" EndTime=\"2013-05-03 04:00:00\" ExpireType=\"3\" SubmitTime=\"2013-05-10 09:41:07\" ContractSize=\"10001.0000\" SubmitorID=\"79eb2fa2-4ced-4d0e-a283-85adc0136d05\" AssigningOrderID=\"4F23DE3E-3968-440E-829A-3D78685EAA8C\"><Order ID=\"aca88b2e-7640-4a26-9284-6a8993d420e3\" TradeOption=\"1\" IsOpen=\"true\" IsBuy=\"false\" SetPrice=\"2.102\" SetPrice2=\"\" DQMaxMove=\"0\" Lot=\"1.0000\" OriginalLot=\"1.0000\" /></Transaction>");
//Mobile.Server.Transaction transaction = Mobile.Manager.ConvertModifyRequest(token, new Guid("4F23DE3E-3968-440E-829A-3D78685EAA8C"), "2.3", new Guid("11111111-AEF4-4717-8101-522E284DDA6D"), "2.0", null, null, null, null, true);
//XElement element = new XElement("Result");
//ICollection<XElement> errorCodes = this.GetPlaceResultForMobile(transaction, token);
//XmlNode n = InstrumentManager.Default.UpdateInstrumentSetting(request.Session, new string[] { "27b059c2-1913-44ac-93ec-dc39e9863f1a" });
//string instrumentIds = "6a3fbe21-2e49-46ea-ae93-2be31caa3c6c,babf7daa-af0f-4396-85f2-67e2c97952b7,382be55a-3b33-403e-b9e0-b9eccabd5019,ab98797c-0b0c-427f-8d1b-0de006d153a1,63a02916-28b2-4da1-a65e-59bb1dd4f951,eb82dca7-2625-48df-ac5c-464d160bccbc,282fa038-1330-43a6-aa87-9d7d01c1a594,864ac5d7-b872-45a6-887e-7189463beb12,1bac5d80-7f4a-4b94-98fa-0b76e13fcb1b";
//Dictionary<Guid, Guid> quotePolicyIds = Mobile.Manager.UpdateInstrumentSetting(token, instrumentIds.Split(new char[]{','}));
//var state = Trader.Server.Session.SessionManager.Default.GetTradingConsoleState(request.Session);
//InstrumentManager.Default.UpdateInstrumentSetting(request.Session, quotePolicyIds);
//XElement e= Mobile.Manager.GetChanges(request.Session, true);
Dictionary<Guid, Guid> quotePolicyIds = Mobile.Manager.UpdateInstrumentSetting(token, new string[] { });
}
}
else
{
AsyncEnumerator ae = new AsyncEnumerator();
ae.BeginExecute(InitDataService.GetInitData(request, null, ae),ae.EndExecute);
}
return result;
}
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;
}
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 static IEnumerator<int> GenerateTransferTask(
AsyncEnumerator ae, HttpContext context, string url)
{
WebRequest request = WebRequest.Create(url);
request.BeginGetResponse(ae.End(), null);
yield return 1;
using (WebResponse response = request.EndGetResponse(ae.DequeueAsyncResult()))
{
Stream streamIn = response.GetResponseStream();
Stream streamOut = context.Response.OutputStream;
byte[] buffer = new byte[1024];
while (true)
{
streamIn.BeginRead(buffer, 0, buffer.Length, ae.End(), null);
yield return 1;
int lengthRead = streamIn.EndRead(ae.DequeueAsyncResult());
if (lengthRead <= 0) break;
streamOut.BeginWrite(buffer, 0, lengthRead, ae.End(), null);
yield return 1;
streamOut.EndWrite(ae.DequeueAsyncResult());
}
}
}
public void StartAsync(HttpContext context, string url)
{
this.m_asyncEnumerator = new AsyncEnumerator();
var asyncTask = GenerateTransferTask(this.m_asyncEnumerator, context, url);
this.m_asyncEnumerator.BeginExecute(asyncTask, this.EndExecuteCallback);
}
