static void TestEnqueue(CAsyncQueue aq) { Console.WriteLine("Going to enqueue 1024 messages ......"); for (int n = 0; n < 1024; ++n) { string str = n + " Object test"; ushort idMessage; switch (n % 3) { case 0: idMessage = idMessage0; break; case 1: idMessage = idMessage1; break; default: idMessage = idMessage2; break; } //System.Threading.Thread.Sleep(100); //enqueue two unicode strings and one int if (!aq.Enqueue(TEST_QUEUE_KEY, idMessage, "SampleName", str, n)) { aq.raise(CAsyncQueue.idEnqueue); } } }
static void EnqueueToServerBatch(CAsyncQueue sq, string message, int cycles, uint batchSize = 8 * 1024) { Console.WriteLine("Going to enqueue " + cycles + " messages ......"); using (CScopeUQueue sb = new CScopeUQueue()) { CUQueue q = sb.UQueue; byte[] utf8 = Encoding.UTF8.GetBytes(message); System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); sw.Start(); for (int n = 0; n < cycles; ++n) { CAsyncQueue.BatchMessage(idMessage, utf8, q); if (q.GetSize() >= batchSize) { sq.EnqueueBatch(TEST_QUEUE_KEY, q); } } if (q.GetSize() > 0) { sq.EnqueueBatch(TEST_QUEUE_KEY, q); } sq.WaitAll(); sw.Stop(); Console.WriteLine(cycles + " messages sent to server and enqueued within " + sw.ElapsedMilliseconds + " ms"); } }
static void EnqueueToServerBatch(CAsyncQueue sq, string message, int cycles, uint batchSize = 16 * 1024) { Console.WriteLine("Going to enqueue " + cycles + " messages ......"); using (CScopeUQueue sb = new CScopeUQueue()) { CUQueue q = sb.UQueue; byte[] utf8 = Encoding.UTF8.GetBytes(message); System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); sw.Start(); for (int n = 0; n < cycles; ++n) { CAsyncQueue.BatchMessage(idMessage, utf8, q); if (q.GetSize() >= batchSize) { sq.EnqueueBatch(TEST_QUEUE_KEY, q, (res) => { }); } } if (q.GetSize() > 0) { sq.EnqueueBatch(TEST_QUEUE_KEY, q, (res) => { }); } sq.WaitAll(); sw.Stop(); Console.WriteLine(cycles + " messages sent to server and enqueued within " + sw.ElapsedMilliseconds + " ms"); } }
static bool TestEnqueue(CAsyncQueue aq) { bool ok = true; Console.WriteLine("Going to enqueue 1024 messages ......"); for (int n = 0; n < 1024; ++n) { string str = n + " Object test"; ushort idMessage; switch (n % 3) { case 0: idMessage = idMessage0; break; case 1: idMessage = idMessage1; break; default: idMessage = idMessage2; break; } //enqueue two unicode strings and one int ok = aq.Enqueue(TEST_QUEUE_KEY, idMessage, "SampleName", str, n); if (!ok) { break; } } return(ok); }
static Task <CAsyncQueue.DeqInfo> TestDequeue(CAsyncQueue aq) { //prepare callback for parsing messages dequeued from server side aq.ResultReturned += (sender, idReq, q) => { bool processed = true; switch (idReq) { case idMessage0: case idMessage1: case idMessage2: Console.Write("message id={0}", idReq); { string name, str; int index; //parse a dequeued message which should be the same as the above enqueued message (two unicode strings and one int) q.Load(out name).Load(out str).Load(out index); Console.WriteLine(", name={0}, str={1}, index={2}", name, str, index); } break; default: processed = false; break; } return(processed); }; TaskCompletionSource <CAsyncQueue.DeqInfo> tcs = new TaskCompletionSource <CAsyncQueue.DeqInfo>(); CAsyncQueue.DDiscarded aborted = CAsyncQueue.get_aborted(tcs, CAsyncQueue.idDequeue); CAsyncQueue.DOnExceptionFromServer se = CAsyncQueue.get_se(tcs); //prepare a callback for processing returned result of dequeue request CAsyncQueue.DDequeue d = (asyncq, messageCount, fileSize, messages, bytes) => { if (messages > 0) { Console.WriteLine("Total message count={0}, queue file size={1}, messages dequeued={2}, message bytes dequeued={3}", messageCount, fileSize, messages, bytes); } if (messageCount > 0) { //there are more messages left at server queue, we re-send a request to dequeue asyncq.Dequeue(TEST_QUEUE_KEY, asyncq.LastDequeueCallback, 0, aborted, se); } else { tcs.TrySetResult(new CAsyncQueue.DeqInfo(messageCount, fileSize, messages, bytes)); } }; Console.WriteLine("Going to dequeue messages ......"); //optionally, add one extra to improve processing concurrency at both client and server sides for better performance and through-output if (!(aq.Dequeue(TEST_QUEUE_KEY, d, 0, aborted, se) && aq.Dequeue(TEST_QUEUE_KEY, d, 0, aborted, se))) { aq.raise(CAsyncQueue.idDequeue); } return(tcs.Task); }
static void Main(string[] args) { Console.WriteLine("Remote host: "); string host = Console.ReadLine(); CConnectionContext cc = new CConnectionContext(host, 20901, "async_queue_client", "pwd_for_async_queue"); using (CSocketPool <CAsyncQueue> spAq = new CSocketPool <CAsyncQueue>()) { if (!spAq.StartSocketPool(cc, 1, 1)) { Console.WriteLine("Failed in connecting to remote async queue server"); Console.WriteLine("Press any key to close the application ......"); Console.Read(); return; } CAsyncQueue aq = spAq.Seek(); //Optionally, you can enqueue messages with transaction style by calling the methods StartQueueTrans and EndQueueTrans in pair aq.StartQueueTrans(TEST_QUEUE_KEY, (errCode) => { //error code could be one of CAsyncQueue.QUEUE_OK, CAsyncQueue.QUEUE_TRANS_ALREADY_STARTED, ...... }); TestEnqueue(aq); //test message batching using (CScopeUQueue sb = new CScopeUQueue()) { CUQueue q = sb.UQueue; CAsyncQueue.BatchMessage(idMessage3, "Hello", "World", q); CAsyncQueue.BatchMessage(idMessage4, true, 234.456, "MyTestWhatever", q); aq.EnqueueBatch(TEST_QUEUE_KEY, q, (res) => { System.Diagnostics.Debug.Assert(res == 2); }); } aq.EndQueueTrans(false); TestDequeue(aq); aq.WaitAll(); //get a queue key two parameters, message count and queue file size by default option oMemoryCached aq.FlushQueue(TEST_QUEUE_KEY, (messageCount, fileSize) => { Console.WriteLine("Total message count={0}, queue file size={1}", messageCount, fileSize); }); aq.GetKeys((keys) => { keys = null; }); aq.CloseQueue(TEST_QUEUE_KEY, (errCode) => { //error code could be one of CAsyncQueue.QUEUE_OK, CAsyncQueue.QUEUE_TRANS_ALREADY_STARTED, ...... }); Console.WriteLine("Press any key to close the application ......"); Console.Read(); } }
static void EnqueueToServer(CAsyncQueue sq, string message, int cycles) { Console.WriteLine("Going to enqueue " + cycles + " messages ......"); byte[] utf8 = Encoding.UTF8.GetBytes(message); System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); sw.Start(); for (int n = 0; n < cycles; ++n) { sq.Enqueue(TEST_QUEUE_KEY, idMessage, utf8); } sq.WaitAll(); sw.Stop(); Console.WriteLine(cycles + " messages sent to server and enqueued within " + sw.ElapsedMilliseconds + " ms"); }
static void DequeueFromServer(CAsyncQueue sq) { uint messages_dequeued = 0; System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); CAsyncQueue.DDequeue d = (aq, messageCount, fileSize, messages, bytes) => { if (messageCount > 0) { //there are more messages left at server queue, we re-send a request to dequeue aq.Dequeue(TEST_QUEUE_KEY, sq.LastDequeueCallback); } else { //set dequeue callback to null and stop dequeuing aq.LastDequeueCallback = null; } }; CAsyncServiceHandler.DOnResultReturned rr = (sender, reqId, q) => { bool processed = false; switch (reqId) { case idMessage: { byte[] utf8 = q.IntenalBuffer; string s = CUQueue.ToString(utf8, (int)q.GetSize()); ++messages_dequeued; } processed = true; break; default: break; } return(processed); }; sq.ResultReturned += rr; Console.WriteLine("Going to dequeue message ......"); sw.Start(); bool ok = sq.Dequeue(TEST_QUEUE_KEY, d); //optionally, add one or two extra to improve processing concurrency at both client and server sides for better performance and throughput ok = sq.Dequeue(TEST_QUEUE_KEY, d); ok = sq.Dequeue(TEST_QUEUE_KEY, d); sq.WaitAll(); sq.ResultReturned -= rr; sw.Stop(); Console.WriteLine(messages_dequeued + " messages dequeued from server within " + sw.ElapsedMilliseconds + " ms"); }
static void TestDequeue(CAsyncQueue aq) { //prepare callback for parsing messages dequeued from server side aq.ResultReturned += (sender, idReq, q) => { bool processed = true; switch (idReq) { case idMessage0: case idMessage1: case idMessage2: Console.Write("message id={0}", idReq); { string name, str; int index; //parse a dequeued message which should be the same as the above enqueued message (two unicode strings and one int) q.Load(out name).Load(out str).Load(out index); Console.WriteLine(", name={0}, str={1}, index={2}", name, str, index); } break; default: processed = false; break; } return(processed); }; //prepare a callback for processing returned result of dequeue request CAsyncQueue.DDequeue d = (messageCount, fileSize, messages, bytes) => { Console.WriteLine("Total message count={0}, queue file size={1}, messages dequeued={2}, message bytes dequeued={3}", messageCount, fileSize, messages, bytes); if (messageCount > 0) { //there are more messages left at server queue, we re-send a request to dequeue aq.Dequeue(TEST_QUEUE_KEY, aq.LastDequeueCallback); } }; Console.WriteLine("Going to dequeue messages ......"); bool ok = aq.Dequeue(TEST_QUEUE_KEY, d); //optionally, add one extra to improve processing concurrency at both client and server sides for better performance and through-output ok = aq.Dequeue(TEST_QUEUE_KEY, d); }
static void TestDequeue(CAsyncQueue aq) { //prepare callback for parsing messages dequeued from server side aq.ResultReturned += (sender, idReq, q) => { bool processed = true; switch (idReq) { case idMessage0: case idMessage1: case idMessage2: Console.Write("message id={0}", idReq); { string name, str; int index; //parse a dequeued message which should be the same as the above enqueued message (two unicode strings and one int) q.Load(out name).Load(out str).Load(out index); Console.WriteLine(", name={0}, str={1}, index={2}", name, str, index); } break; default: processed = false; break; } return processed; }; //prepare a callback for processing returned result of dequeue request CAsyncQueue.DDequeue d = (messageCount, fileSize, messages, bytes) => { Console.WriteLine("Total message count={0}, queue file size={1}, messages dequeued={2}, message bytes dequeued={3}", messageCount, fileSize, messages, bytes); if (messageCount > 0) { //there are more messages left at server queue, we re-send a request to dequeue aq.Dequeue(TEST_QUEUE_KEY, aq.LastDequeueCallback); } }; Console.WriteLine("Going to dequeue messages ......"); bool ok = aq.Dequeue(TEST_QUEUE_KEY, d); //optionally, add one extra to improve processing concurrency at both client and server sides for better performance and through-output ok = aq.Dequeue(TEST_QUEUE_KEY, d); }
static void Main(string[] args) { Console.WriteLine("Remote host: "); string host = Console.ReadLine(); CConnectionContext cc = new CConnectionContext(host, 20901, "async_queue_client", "pwd_for_async_queue"); using (CSocketPool <CAsyncQueue> spAq = new CSocketPool <CAsyncQueue>()) { //spAq.QueueName = "qname"; if (!spAq.StartSocketPool(cc, 1)) { Console.WriteLine("Failed in connecting to remote async queue server"); Console.WriteLine("Press key ENTER to close the application ......"); Console.ReadLine(); return; } CAsyncQueue aq = spAq.Seek(); try { TestEnqueue(aq); Console.WriteLine(TestDequeue(aq).Result); } catch (AggregateException ex) { foreach (Exception e in ex.InnerExceptions) { //An exception from server (CServerError), Socket closed after sending a request (CSocketError) or request canceled (CSocketError), Console.WriteLine(e); } } catch (CSocketError ex) { //Socket is already closed before sending a request Console.WriteLine(ex); } catch (Exception ex) { //bad operations such as invalid arguments, bad operations and de-serialization errors, and so on Console.WriteLine(ex); } Console.WriteLine("Press key ENTER to close the application ......"); Console.ReadLine(); } }
static void DequeueFromServer(CAsyncQueue sq) { uint messages_dequeued = 0; System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); CAsyncQueue.DDequeue d = (messageCount, fileSize, messages, bytes) => { if (messageCount > 0) { //there are more messages left at server queue, we re-send a request to dequeue sq.Dequeue(TEST_QUEUE_KEY, sq.LastDequeueCallback); } }; sq.ResultReturned += (sender, reqId, q) => { bool processed = false; switch (reqId) { case idMessage: { byte[] utf8 = q.IntenalBuffer; string s = CUQueue.ToString(utf8, (int)q.GetSize()); ++messages_dequeued; } processed = true; break; default: break; } return processed; }; Console.WriteLine("Going to dequeue message ......"); sw.Start(); bool ok = sq.Dequeue(TEST_QUEUE_KEY, d); //optionally, add one or two extra to improve processing concurrency at both client and server sides for better performance and through-output ok = sq.Dequeue(TEST_QUEUE_KEY, d); ok = sq.Dequeue(TEST_QUEUE_KEY, d); sq.WaitAll(); sw.Stop(); Console.WriteLine(messages_dequeued + " messages dequeued from server within " + sw.ElapsedMilliseconds + " ms"); }
static void Main(string[] args) { Console.WriteLine("Remote host: "); string host = Console.ReadLine(); CConnectionContext cc = new CConnectionContext(host, 20901, "async_queue_client", "pwd_for_async_queue"); using (CSocketPool <CAsyncQueue> spAq = new CSocketPool <CAsyncQueue>()) { if (!spAq.StartSocketPool(cc, 1, 1)) { Console.WriteLine("Failed in connecting to remote async queue server"); Console.WriteLine("Press key ENTER to close the application ......"); Console.ReadLine(); return; } CAsyncQueue aq = spAq.Seek(); TestEnqueue(aq); TestDequeue(aq); Console.WriteLine("Press key ENTER to close the application ......"); Console.ReadLine(); } }
static void Main(string[] args) { Console.WriteLine("Remote host: "); string host = Console.ReadLine(); CConnectionContext cc = new CConnectionContext(host, 20901, "async_queue_client", "pwd_for_async_queue"); using (CSocketPool <CAsyncQueue> spAq = new CSocketPool <CAsyncQueue>()) { if (!spAq.StartSocketPool(cc, 1)) { Console.WriteLine("Failed in connecting to remote async queue server"); Console.WriteLine("Press any key to close the application ......"); Console.Read(); return; } CAsyncQueue aq = spAq.Seek(); try { //Optionally, you can enqueue messages with transaction style by calling the methods StartQueueTrans and EndQueueTrans in pair var fsqt = aq.startQueueTrans(TEST_QUEUE_KEY); TestEnqueue(aq); //test message batching using (CScopeUQueue sb = new CScopeUQueue()) { CUQueue q = sb.UQueue; CAsyncQueue.BatchMessage(idMessage3, "Hello", "World", q); CAsyncQueue.BatchMessage(idMessage4, true, 234.456, "MyTestWhatever", q); if (!aq.EnqueueBatch(TEST_QUEUE_KEY, q)) { throw new CSocketError(CAsyncQueue.SESSION_CLOSED_BEFORE, "Socket already closed before sending the request EnqueueBatch", CAsyncQueue.idEnqueueBatch, true); } } var feqt = aq.endQueueTrans(false); TestDequeue(aq); aq.WaitAll(); //get a queue key two parameters, message count and queue file size by default option oMemoryCached var ffq = aq.flushQueue(TEST_QUEUE_KEY); var fgk = aq.getKeys(); var fcq = aq.closeQueue(TEST_QUEUE_KEY); Console.WriteLine("StartQueueTrans/res: " + fsqt.Result); Console.WriteLine("EndQueueTrans/res: " + feqt.Result); Console.WriteLine(ffq.Result); int index = 0; Console.Write("["); string[] keys = fgk.Result; foreach (string k in keys) { if (index != 0) { Console.Write(","); } Console.Write(k); } Console.WriteLine("]"); Console.WriteLine("CloseQueue/res: " + fcq.Result); } catch (AggregateException ex) { foreach (Exception e in ex.InnerExceptions) { //An exception from server (CServerError), Socket closed after sending a request (CSocketError) or request canceled (CSocketError), Console.WriteLine(e); } } catch (CSocketError ex) { //Socket is already closed before sending a request Console.WriteLine(ex); } catch (Exception ex) { //bad operations such as invalid arguments, bad operations and de-serialization errors, and so on Console.WriteLine(ex); } Console.WriteLine("Press any key to close the application ......"); Console.Read(); } }
static bool TestEnqueue(CAsyncQueue aq) { bool ok = true; Console.WriteLine("Going to enqueue 1024 messages ......"); for (int n = 0; n < 1024; ++n) { string str = n + " Object test"; ushort idMessage; switch (n % 3) { case 0: idMessage = idMessage0; break; case 1: idMessage = idMessage1; break; default: idMessage = idMessage2; break; } //enqueue two unicode strings and one int ok = aq.Enqueue(TEST_QUEUE_KEY, idMessage, "SampleName", str, n); if (!ok) break; } return ok; }
static void Main(string[] args) { Console.WriteLine("Remote host: "); string host = Console.ReadLine(); CConnectionContext cc = new CConnectionContext(host, 20901, "root", "Smash123"); using (CSocketPool <CAsyncQueue> spAq = new CSocketPool <CAsyncQueue>()) { if (!spAq.StartSocketPool(cc, 1, 1)) { Console.WriteLine("Failed in connecting to remote async queue server, and press any key to close the application ......"); Console.Read(); return; } CAsyncQueue sq = spAq.Seek(); string s4 = "Sock"; EnqueueToServer(sq, s4, 200000000); DequeueFromServer(sq); //Manually batching messages improves throughput for high volume of tiny messages EnqueueToServerBatch(sq, s4, 200000000, 8 * 1024); DequeueFromServer(sq); string s32 = "SocketPro is a world-leading pac"; EnqueueToServer(sq, s32, 200000000); DequeueFromServer(sq); //Manually batching messages improves throughput for high volume of small messages EnqueueToServerBatch(sq, s32, 200000000, 8 * 1024); DequeueFromServer(sq); //a string having 200 chars string s = "SocketPro is a world-leading package of secured communication software components written with request batching, asynchrony and parallel computation in mind. It offers superior performance and scalabi"; EnqueueToServer(sq, s, 50000000); DequeueFromServer(sq); //Batching messages improves throughput for high volume of middle size massages EnqueueToServerBatch(sq, s, 50000000, 8 * 1024); DequeueFromServer(sq); string s1024 = ""; for (int n = 0; n < 6; ++n) { s1024 += s; } s1024 = s1024.Substring(0, 1024); EnqueueToServer(sq, s1024, 10000000); DequeueFromServer(sq); string s10240 = ""; for (int n = 0; n < 10; ++n) { s10240 += s1024; } EnqueueToServer(sq, s10240, 1000000); DequeueFromServer(sq); Console.WriteLine("Press key ENTER to complete the application ......"); Console.ReadLine(); } }