static void Main(string[] args) { SessionStartInfo info = new SessionStartInfo(headnode, serviceName); Console.Write("Creating a session for EchoService..."); // Create a durable session // Request and response messages in a durable session are persisted so that // in event of failure, no requests nor responses will be lost. Another authorized // client can attached to a session with the same session Id and retrieve responses using (DurableSession session = DurableSession.CreateSession(info)) { Console.WriteLine("done session id = {0}", session.Id); Thread[] threads = new Thread[TotalThread]; for (int i = 0; i < TotalThread; i++) { threads[i] = new Thread(new ThreadStart(() => { Worker(session.Id); })); threads[i].Start(); } for (int i = 0; i < TotalThread; i++) { threads[i].Join(); } session.Close(); } Console.WriteLine("Press any key to exit."); Console.Read(); }
static void Main(string[] args) { //change the headnode name here const string headnode = "[headnode]"; const string serviceName = "EchoService"; const int numRequests = 12; SessionStartInfo info = new SessionStartInfo(headnode, serviceName); //session in the session pool should be a shared session info.ShareSession = true; info.UseSessionPool = true; Console.Write("Creating a session using session pool for EchoService..."); using (DurableSession session = DurableSession.CreateSession(info)) { Console.WriteLine("done session id = {0}", session.Id); NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport); //to make sure the client id is unique among the sessions string clientId = Guid.NewGuid().ToString(); using (BrokerClient <IService1> client = new BrokerClient <IService1>(clientId, session, binding)) { Console.Write("Sending {0} requests...", numRequests); for (int i = 0; i < numRequests; i++) { EchoRequest request = new EchoRequest("hello world!"); client.SendRequest <EchoRequest>(request, i); } client.EndRequests(); Console.WriteLine("done"); Console.WriteLine("Retrieving responses..."); foreach (var response in client.GetResponses <EchoResponse>()) { try { string reply = response.Result.EchoResult; Console.WriteLine("\tReceived response for request {0}: {1}", response.GetUserData <int>(), reply); } catch (Exception ex) { Console.WriteLine("Error occured while processing {0}-th request: {1}", response.GetUserData <int>(), ex.Message); } } Console.WriteLine("Done retrieving {0} responses", numRequests); } //should not purge the session if the session is expected to stay in the session pool //the shared session is kept in the session pool session.Close(false); } Console.WriteLine("Press any key to exit."); Console.ReadKey(); }
static void Main(string[] args) { //change headnode name and service name SessionStartInfo info = new SessionStartInfo("head.contoso.com", "PrimeFactorizationService"); try { //Create a durable session DurableSession session = DurableSession.CreateSession(info); Console.WriteLine("Session {0} has been created", session.Id); //Send batch request Random random = new Random(); const int numRequests = 100; using (BrokerClient <IPrimeFactorization> client = new BrokerClient <IPrimeFactorization>(session)) { Console.WriteLine("Sending {0} requests...", numRequests); for (int i = 0; i < numRequests; i++) { int number = random.Next(1, Int32.MaxValue); FactorizeRequest request = new FactorizeRequest(number); //The second param is used to identify each request. //It can be retrieved from the response. client.SendRequest <FactorizeRequest>(request, number); } client.EndRequests(); Console.WriteLine("All the {0} requests have been sent", numRequests); Console.WriteLine("Press any key to exit"); Console.ReadKey(); } } catch (System.Exception ex) { Console.WriteLine(ex.Message); } }
private static string CreateSession(SessionStartInfo startInfo, bool isDurable) { string sessionId; if (isDurable) { DurableSession session = DurableSession.CreateSession(startInfo); sessionId = session.Id; } else { Session session = Session.CreateSession(startInfo); // session.AutoClose = false; sessionId = session.Id; } Log("Session created."); Environment.ExitCode = sessionId.GetHashCode(); return(sessionId); }
static void Main(string[] args) { //change the headnode name here const string headnode = "[headnode]"; const string serviceName = "Microsoft.Hpc.Excel.XllContainer64"; //Query service versions of Microsoft.Hpc.Excel.XllContainer64 Version[] versions = SessionBase.GetServiceVersions(headnode, serviceName); foreach (Version version in versions) { Console.WriteLine("Microsoft.Hpc.Excel.XllContainer64 version {0} is found in the service registration.", version.ToString()); } //Get the latest version for the versions are already sorted, Version latest = versions[0]; //Here is should be version 1.1 for v3 sp2 Console.WriteLine("The latest version is {0}", latest); //Create a session for Microsoft.Hpc.Excel.XllContainer64 with the latest version SessionStartInfo info = new SessionStartInfo(headnode, serviceName, latest); Console.Write("Creating a session for Microsoft.Hpc.Excel.XllContainer64 version {0} ...", latest); // Create a durable session using (DurableSession session = DurableSession.CreateSession(info)) { Console.WriteLine("done session id = {0}", session.Id); //explict close the session to free the resource session.Close(); } Console.WriteLine("Press any key to exit."); Console.ReadKey(); }
public void BvtDurableCase3() { Info("Start BVT"); SessionStartInfo sessionStartInfo; sessionStartInfo = BuildSessionStartInfo(Server, EchoSvcName, null, null, null, null, SessionUnitType.Node, null, null, null); sessionStartInfo.Secure = false; sessionStartInfo.ShareSession = true; Info("Begin to create session"); string serviceJobId; int clientNum = 2; AutoResetEvent anotherClient = new AutoResetEvent(false); using (DurableSession session = DurableSession.CreateSession(sessionStartInfo)) { serviceJobId = session.Id; var epr = new EndpointAddress(string.Format(NetTcpEndpointPattern, Server, serviceJobId)); Info("EPR: {0}", epr); Task[] tasks = new Task[clientNum]; for (int i = 0; i < clientNum; i++) { var idx = i; tasks[i] = Task.Run( () => { string guid = Guid.NewGuid().ToString(); try { Info("Client {0}: Begin to send requests.", guid); using (BrokerClient <IEchoSvc> client = new BrokerClient <IEchoSvc>(guid, session)) { for (int j = 0; j < NumberOfCalls; j++) { client.SendRequest <EchoRequest>(new EchoRequest(j.ToString()), j + ":" + guid); } Info("Client {0}: Begin to call EndOfMessage.", guid); client.EndRequests(); Info("Client {0}: Begin to get responses.", guid); int count = 0; if (idx == 0) { foreach (BrokerResponse <EchoResponse> response in client.GetResponses <EchoResponse>()) { count++; Info(response.Result.EchoResult); string[] rtn = response.Result.EchoResult.Split(new[] { ':' }); Assert( rtn[rtn.Length - 1] == response.GetUserData <string>().Split(new[] { ':' })[0] && response.GetUserData <string>().Split(new[] { ':' })[1] == guid, "Result is corrupt: expected:computername:{0}, actual:{1}", response.GetUserData <string>().Split(new[] { ':' })[0], response.Result.EchoResult); } } else { foreach (var response in client.GetResponses()) { count++; EchoResponse result = (EchoResponse)response.Result; Info(result.EchoResult); string[] rtn = result.EchoResult.Split(new[] { ':' }); Assert( rtn[rtn.Length - 1] == response.GetUserData <string>().Split(new[] { ':' })[0] && response.GetUserData <string>().Split(new[] { ':' })[1] == guid, "Result is corrupt: expected:computername:{0}, actual:{1}", response.GetUserData <string>(), result.EchoResult); } } if (count == NumberOfCalls) { Info("Client {0}: Total {1} calls returned.", guid, count); } else { Error("Client {0}: Total {1} calls returned, but losing {2} results.", guid, count, NumberOfCalls - count); } } } catch (Exception e) { Error("Unexpected exception of Client {0}", e.ToString()); throw; } finally { if (Interlocked.Decrement(ref clientNum) <= 0) { anotherClient.Set(); } } }); } anotherClient.WaitOne(); Task.WaitAll(tasks); session.Close(true); session.Dispose(); } }
public void BvtDurableCase1() { Info("Start BVT"); SessionStartInfo sessionStartInfo; sessionStartInfo = BuildSessionStartInfo(Server, EchoSvcName, null, null, null, null, SessionUnitType.Node, null, null, null); sessionStartInfo.Secure = false; string serviceJobId; Info("Begin to create Durable Session."); string guid = Guid.NewGuid().ToString(); using (DurableSession session = DurableSession.CreateSession(sessionStartInfo)) { serviceJobId = session.Id; var epr = new EndpointAddress(string.Format(NetTcpEndpointPattern, Server, serviceJobId)); Info("EPR: {0}", epr); try { Info("Client {0}: Begin to send requests.", guid); using (BrokerClient <IEchoSvc> client = new BrokerClient <IEchoSvc>(guid, session)) { for (int i = 0; i < NumberOfCalls; i++) { client.SendRequest <EchoRequest>(new EchoRequest(i.ToString()), i + ":" + guid); } Info("Client {0}: Begin to call EndOfMessage.", guid); client.EndRequests(); } } catch (Exception e) { Error("Unexpected exception of Client {0}", e.ToString()); throw; } } // sleep 10 seconds Info("Client disconnects and sleep 10 seconds"); Thread.Sleep(10000); SessionAttachInfo sessionAttachInfo = new SessionAttachInfo(Server, serviceJobId); int count = 0; Info("Begin to attach Durable Session."); try { using (DurableSession session = DurableSession.AttachSession(sessionAttachInfo)) { Info("Begin to retrieve results."); using (BrokerClient <IEchoSvc> client = new BrokerClient <IEchoSvc>(guid, session)) { foreach (BrokerResponse <EchoResponse> response in client.GetResponses <EchoResponse>()) { Info(response.Result.EchoResult); string[] rtn = response.Result.EchoResult.Split(new[] { ':' }); Assert( rtn[rtn.Length - 1] == response.GetUserData <string>().Split(new[] { ':' })[0] && response.GetUserData <string>().Split(new[] { ':' })[1] == guid, "Result is corrupt: expected:computername:{0}, actual:{1}", response.GetUserData <string>().Split(new[] { ':' })[0], response.Result.EchoResult); count++; } } session.Close(); } if (NumberOfCalls == count) { Info("Total {0} calls returned.", count); } else { Error("Total {0} calls returned, but losing {1} results.\n", count, NumberOfCalls - count); } } catch (Exception e) { Error("Unexpected exception during attaching and getting response {0}", e.ToString()); throw; } }
static int Main(string[] args) { ServicePointManager.ServerCertificateValidationCallback = new System.Net.Security.RemoteCertificateValidationCallback((a, b, c, d) => { return(true); }); ParseArgument(args); if (showhelp) { Console.WriteLine("Usage:"); Console.WriteLine("Interactive Session's Usage: TestClient.exe [-h headnode] [-m max_cores] [-min min_cores] [-n req_count] [-r millisec_for_each_req] [-i bytes_for_each_req] [-c common_data_for_each_req] [-o bytes_for_each_response] [-sleep sleeptime_before_sending] [-cp common_data_path] [-client clientCounts] [-save filename] [-rest]"); Console.WriteLine("Interactive Session's Usage with BrokerClient: TestClient.exe [-h headnode] [-m max_cores] [-min min_cores] [-n req_count] [-r millisec_for_each_req] [-i bytes_for_each_req] [-c common_data_for_each_req] [-o bytes_for_each_response] [-sleep sleeptime_before_sending] [-cp common_data_path] [-client clientCounts] [-save filename] [-rest] -interactiveNew"); Console.WriteLine("Durable Session's Usage: TestClient.exe [-h headnode] [-m max_cores] [-min min_cores] [-n req_count] [-r millisec_for_each_req] [-i bytes_for_each_req] [-c common_data_for_each_req] [-o bytes_for_each_response] [-sleep sleeptime_before_sending] [-cp common_data_path] [-client clientCounts] [-save filename] [-rest] -durable"); Console.WriteLine("The return code of the executable is the session Id which the program creates/attaches"); return(-1); } SessionStartInfo startInfo = new SessionStartInfo(headnode, ServiceName); startInfo.UseInprocessBroker = inproc; startInfo.IsNoSession = standalone; startInfo.RegPath = regPath; startInfo.Secure = false; startInfo.IpAddress = commaSeparatedTargetList.Split(','); if (http) { startInfo.TransportScheme = TransportScheme.Http; } startInfo.SessionResourceUnitType = SessionUnitType.Core; startInfo.MaximumUnits = max_cores; startInfo.MinimumUnits = min_cores; startInfo.BrokerSettings.SessionIdleTimeout = 60 * 60 * 1000; startInfo.BrokerSettings.MaxMessageSize = int.MaxValue; if (rest) { startInfo.TransportScheme = TransportScheme.WebAPI; } if (sleep_before_sending > 60 * 1000) { startInfo.BrokerSettings.SessionIdleTimeout = sleep_before_sending * 2; } if (!String.IsNullOrEmpty(username)) { startInfo.Username = username; } if (!String.IsNullOrEmpty(password)) { startInfo.Password = password; } if (retryRequestAndIgnoreRetryOperationError) { startInfo.Environments.Add("RetryRequest", bool.TrueString); } if (userTraceCount > 0) { startInfo.Environments.Add("UserTraceCount", userTraceCount.ToString()); } //if create session only, create session first and then return exit code as session id if (createSessionOnly) { CreateSession(startInfo, durable); } data.StartInfo = startInfo; data.Count = req_count; data.Milliseconds = millisec_for_each_req; data.InputDataSize = input_data_size; data.CommonDataSize = common_data_size; data.OutputDataSize = output_data_size; data.Client = batchCount; data.IsDurable = durable; data.OnDemand = onDemand; foreach (string arg in args) { data.Command += (" " + arg); } Log("****** Test begin: {0} ******", data.Command); data.SessionStart = DateTime.Now; Log("Begin to create session."); SessionBase session; if (durable) { if (sessionId == "-1") { session = DurableSession.CreateSession(startInfo); } else { session = DurableSession.AttachSession(new SessionAttachInfo(headnode, sessionId)); } } else { if (sessionId == "-1") { session = Session.CreateSession(startInfo); } else { session = Session.AttachSession(new SessionAttachInfo(headnode, sessionId)); } } Log("Session created: {0}.", session.Id); data.SessionCreated = DateTime.Now; data.SessionId = session.Id; data.StartSendRequest = DateTime.Now; RunTest(session, !v2Client); Log("Begin to close session."); data.CloseSessionStart = DateTime.Now; // if sessionId is set by user, it's mostly used by multi-client-one-session, so do not close it if (sessionId == "-1") { try { session.Close(true, 10 * 60 * 1000); } catch (Exception e) { Log("Close session failed: {0}", e.ToString()); } finally { Log("Session closed."); } } data.SessionEnd = DateTime.Now; data.ProcessData(); foreach (string str in Utils.GetOuputString(data)) { Console.WriteLine(str); } if (string.IsNullOrEmpty(filename)) { filename = "result" + DateTime.Now.ToString("yyyyMdHms"); } if (detail) { Utils.SaveDetail(data, filename); } if (!no_log) { Utils.LogOutput(data, filename); } if (!no_chart) { Utils.DrawChart(data, filename); } //return data.SessionId; return(0); }
private void submitReq() { #region Initialization double initial = (double)rngInitial.Value2; double exercise = (double)rngInitial.Value2; double up = (double)rngUp.Value2; double down = (double)rngDown.Value2; double interest = (double)rngInterest.Value2; int periods = Convert.ToInt32(rngPeriods.Value2); int runs = Convert.ToInt32(rngRuns.Value2); double interestStart = (double)rngInterestStart.Value2; double interestEnd = (double)rngInterestEnd.Value2; double interestStep = (double)rngStep.Value2; #endregion #region fire request SessionStartInfo info = new SessionStartInfo(Config.headNode, "AsianOptionsService"); info.Secure = false; info.BrokerSettings.SessionIdleTimeout = 12 * 60 * 60; // 12 hours DurableSession.SetInterfaceMode(false, IntPtr.Zero); //set interface mode to non console using (DurableSession session = DurableSession.CreateSession(info)) { this.Range["C20", missing].Value2 = "Session Created. SessionId"; this.Range["D20", missing].Value2 = session.Id; Thread.Sleep(1000); this.Range["C21", missing].Value2 = " Sending Req..."; NetTcpBinding binding; binding = new NetTcpBinding(SecurityMode.None); using (BrokerClient <IService1> client = new BrokerClient <IService1>(session, binding)) { int count = 0; int reqCount = 0; for (double interestIdx = interestStart; interestIdx < interestEnd; interestIdx += interestStep, count++) { this.Range["C21", missing].Value2 = string.Format("Sending Req Batch {0}", count); bool batch_succeed = false; int batch_retrycount = 0; while (!batch_succeed && batch_retrycount < 3) { for (int j = 0; j < cols.Length; j++) { string col = cols[j]; for (int i = 2; i <= 11; i++) { PriceAsianOptionsRequest priceRequest = new PriceAsianOptionsRequest(initial, exercise, up, down, interestIdx, periods, runs); cellContext ctx = new cellContext(); ctx.range = string.Format("{0}{1}", col, i); ctx.iteration = count; bool i_succeed = false; int i_retrycount = 0; while (!i_succeed && i_retrycount < 3) { try { client.SendRequest <PriceAsianOptionsRequest>(priceRequest, ctx); i_succeed = true; this.Range["D21", missing].Value2 = string.Format("{0} Req sent.", ++reqCount); } catch (Exception) { // Populate the cell with an error message this.Range[ctx.range, missing].Value2 = "#SendErr#"; i_retrycount++; } } if (!i_succeed) { this.Range["C22", missing].Value2 = "Session failed."; this.Range["D20", missing].Clear(); session.Close(); return; } } } try { client.Flush(); this.Range["C22", missing].Value2 = string.Format("Req Batch {0} Flushed.", count); batch_succeed = true; } catch (Exception) { // Populate the cell with an error message this.Range["C22", missing].Value2 = "ClientFlush failed."; batch_retrycount++; } if (!batch_succeed) { this.Range["C22", missing].Value2 = "Session failed."; this.Range["D20", missing].Clear(); session.Close(); return; } } } client.EndRequests(); this.Range["C21", missing].Value2 = "Closing."; } } this.Range["C21", missing].Value2 = "Request sent."; this.Range["C22", missing].Value2 = "Request flushed."; #endregion }
static void Main(string[] args) { //change the headnode name here const string headnode = "[headnode]"; const string serviceName = "EchoService"; const int numRequests = 12; SessionStartInfo startInfo = new SessionStartInfo(headnode, serviceName); startInfo.BrokerSettings.SessionIdleTimeout = 15 * 60 * 1000; startInfo.BrokerSettings.ClientIdleTimeout = 15 * 60 * 1000; Console.Write("Creating a session for EchoService..."); // Create a durable session int sessionId = 0; const int retryCountMax = 20; const int retryIntervalMs = 5000; DurableSession session = DurableSession.CreateSession(startInfo); sessionId = session.Id; Console.WriteLine("Done session id = {0}", sessionId); //send requests with reliable broker client bool successFlag = false; int retryCount = 0; using (BrokerClient <IService1> client = new BrokerClient <IService1>(session)) { Console.Write("Sending {0} requests...", numRequests); while (!successFlag && retryCount++ < retryCountMax) { try { for (int i = 0; i < numRequests; i++) { client.SendRequest <EchoRequest>(new EchoRequest(i.ToString()), i); } client.EndRequests(); successFlag = true; Console.WriteLine("done"); } catch (Exception e) { //general exceptions Console.WriteLine("Exception {0}", e.ToString()); Thread.Sleep(retryIntervalMs); } } } //attach the session SessionAttachInfo attachInfo = new SessionAttachInfo(headnode, sessionId); successFlag = false; retryCount = 0; Console.WriteLine("Retrieving responses..."); using (BrokerClient <IService1> client = new BrokerClient <IService1>(session)) { int responseCount = 0; retryCount = 0; while (responseCount < numRequests && retryCount++ < retryCountMax) { try { foreach (var response in client.GetResponses <EchoResponse>()) { Console.WriteLine("\tReceived response for request {0}: {1}", response.GetUserData <int>(), response.Result.EchoResult); responseCount++; } } catch (Exception e) { Console.WriteLine(e.ToString()); Thread.Sleep(retryIntervalMs); } } } Console.WriteLine("Close the session..."); session.Close(true); Console.WriteLine("Press any key to exit."); Console.ReadKey(); }
static void Main(string[] args) { CmdParser parser = new CmdParser(args); Config config = new Config(parser); if (config.HelpInfo) { config.PrintHelp(); return; } if (config.Verbose) { config.PrintUsedParams(parser); } if (config.PrintUnusedParams(parser)) { config.PrintHelp(); return; } // TODO: SessionStartInfoFactory SessionStartInfo info = null; if (config.IsNoSession) { // Start session without session manager if (config.InprocessBroker) { info = new SessionStartInfo(config.ServiceName, config.RegPath, null, config.TargetList?.ToArray()); info.UseInprocessBroker = true; info.IsNoSession = true; } else { info = new SessionStartInfo(config.HeadNode, config.ServiceName, config.RegPath, null, config.TargetList?.ToArray()); info.UseInprocessBroker = false; info.IsNoSession = true; } } else { info = new SessionStartInfo(config.HeadNode, config.ServiceName); info.IsNoSession = false; info.UseInprocessBroker = config.InprocessBroker; } if (!string.IsNullOrEmpty(config.Username)) { info.Username = config.Username; } if (!string.IsNullOrEmpty(config.Password)) { info.Password = config.Password; } if (!string.IsNullOrEmpty(config.JobName)) { info.ServiceJobName = config.JobName; } if (!string.IsNullOrEmpty(config.AzureStorageConnectionString)) { info.AzureStorageConnectionString = config.AzureStorageConnectionString; info.BrokerLauncherStorageConnectionString = config.AzureStorageConnectionString; } switch (config.ResourceType.ToLowerInvariant()) { case "core": info.SessionResourceUnitType = SessionUnitType.Core; break; case "node": info.SessionResourceUnitType = SessionUnitType.Node; break; case "socket": info.SessionResourceUnitType = SessionUnitType.Socket; break; case "gpu": info.SessionResourceUnitType = SessionUnitType.Gpu; break; default: break; } if (config.MaxResource > 0) { info.MaximumUnits = config.MaxResource; } if (config.MinResource > 0) { info.MinimumUnits = config.MinResource; } switch (config.TransportScheme.ToLowerInvariant()) { case "nettcp": info.TransportScheme = TransportScheme.NetTcp; break; case "http": info.TransportScheme = TransportScheme.Http; break; case "nethttp": info.TransportScheme = TransportScheme.NetHttp; break; case "custom": info.TransportScheme = TransportScheme.Custom; break; case "azstorage": info.TransportScheme = TransportScheme.AzureStorage; break; default: break; } info.JobTemplate = config.JobTemplate; info.SessionPriority = config.Priority; info.NodeGroupList = new List <string>(config.NodeGroups.Split(new char[] { ',' })); info.RequestedNodesList = new List <string>(config.Nodes.Split(new char[] { ',' })); info.Secure = !config.Insecure && !config.IsNoSession; info.UseAzureQueue = config.AzureQueue; info.ShareSession = config.ShareSession; info.UseSessionPool = config.SessionPool; info.ParentJobIds = StringToIntList(config.ParentIds); info.ServiceHostIdleTimeout = config.ServiceIdleSec == -1 ? config.ServiceIdleSec : config.ServiceIdleSec * 1000; info.ServiceHangTimeout = config.ServiceHangSec == -1 ? config.ServiceHangSec : config.ServiceHangSec * 1000; info.UseWindowsClientCredential = config.UseWCC; info.UseAad = config.UseAad; if (config.Runtime > 0) { info.Runtime = config.Runtime; } if (!string.IsNullOrEmpty(config.Environment)) { foreach (string keyValue in config.Environment.Split(new char[] { ',' })) { string[] p = keyValue.Split(new char[] { '=' }); if (p.Length == 2) { info.Environments.Add(p[0], p[1]); } } } Stopwatch watch = new Stopwatch(); int timeoutMilliSec = config.MsgTimeoutSec * 1000; Dictionary <Guid, Dictionary <Guid, TaskRecord> > brokerClientTaskTimeRecords = new Dictionary <Guid, Dictionary <Guid, TaskRecord> >(config.BrokerClient); Dictionary <Guid, DateTime> brokerSendRequestStartTime = new Dictionary <Guid, DateTime>(config.BrokerClient); Dictionary <Guid, DateTime> brokerSendRequestEndTime = new Dictionary <Guid, DateTime>(config.BrokerClient); Dictionary <Guid, DateTime> brokerGetResponseStartTime = new Dictionary <Guid, DateTime>(config.BrokerClient); Dictionary <Guid, DateTime> brokerGetResponseEndTime = new Dictionary <Guid, DateTime>(config.BrokerClient); Random rTimeMS = new Random(); Random rSizeKB = new Random(); int maxTimeMS = 0; int minTimeMS = 0; int maxSizeKB = 0; int minSizeKB = 0; if (!string.IsNullOrEmpty(config.TimeMSRandom)) { string[] values = config.TimeMSRandom.Split(new char[] { '_' }, StringSplitOptions.RemoveEmptyEntries); if (values.Length == 2) { int.TryParse(values[0], out minTimeMS); int.TryParse(values[1], out maxTimeMS); } } if (!string.IsNullOrEmpty(config.SizeKBRandom)) { string[] values = config.SizeKBRandom.Split(new char[] { '_' }, StringSplitOptions.RemoveEmptyEntries); if (values.Length == 2) { int.TryParse(values[0], out minSizeKB); int.TryParse(values[1], out maxSizeKB); } } for (int c = 0; c < config.BrokerClient; c++) { Dictionary <Guid, TaskRecord> taskTimeReconds = new Dictionary <Guid, TaskRecord>(config.NumberOfRequest); for (int i = 0; i < config.NumberOfRequest; i++) { Guid g = Guid.NewGuid(); TaskRecord t = new TaskRecord() { RequestTime = DateTime.MinValue, ResponseTime = DateTime.MinValue }; if (maxTimeMS > 0) { t.CallDurationMS = rTimeMS.Next(minTimeMS, maxTimeMS); } else { t.CallDurationMS = config.CallDurationMS; } if (maxSizeKB > 0) { t.MessageSizeByte = rSizeKB.Next(minSizeKB, maxSizeKB) * 1024; } else { t.MessageSizeByte = config.MessageSizeByte; } taskTimeReconds.Add(g, t); } Guid clientGuid = Guid.NewGuid(); brokerClientTaskTimeRecords.Add(clientGuid, taskTimeReconds); brokerSendRequestStartTime.Add(clientGuid, DateTime.MinValue); brokerSendRequestEndTime.Add(clientGuid, DateTime.MinValue); brokerGetResponseStartTime.Add(clientGuid, DateTime.MinValue); brokerGetResponseEndTime.Add(clientGuid, DateTime.MinValue); } // Create an interactive or durable session Logger.Info("Creating a session for CcpEchoSvc service..."); SessionBase session = null; try { watch.Start(); if (config.Durable) { session = DurableSession.CreateSession(info); } else { session = Session.CreateSession(info); } watch.Stop(); Logger.Info("{0, -35} : {1}", "Session ID", session.Id); Logger.Info("{0, -35} : {1:F3} sec", "Session creation time", watch.Elapsed.TotalSeconds); //session warm up time if (config.WarmupTimeSec > 0) { Logger.Info("Session warming up in {0} seconds...", config.WarmupTimeSec); Thread.Sleep(config.WarmupTimeSec * 1000); } int clientNumber = config.BrokerClient; int clientCounter = 0; AutoResetEvent allDone = new AutoResetEvent(false); foreach (Guid g in brokerClientTaskTimeRecords.Keys) { ThreadPool.QueueUserWorkItem((o) => { Guid brokerClientGuid = (Guid)o; AutoResetEvent done = new AutoResetEvent(false); int count = 0; int clientC = Interlocked.Increment(ref clientCounter); Stopwatch watchT = new Stopwatch(); try { // Create a BrokerClient proxy using (BrokerClient <IEchoSvc> client = new BrokerClient <IEchoSvc>(brokerClientGuid.ToString(), session)) { if (config.AsyncResponseHandler) { //set getresponse handler Logger.Info("Setting response handler ({0}/{1}) to receive responses async.", clientC, config.BrokerClient); client.SetResponseHandler <GenerateLoadResponse>((item) => { try { Guid gg = item.RequestMessageId; StatisticInfo si = item.Result.GenerateLoadResult; if (config.Verbose) { Logger.Info("Response async received ({0}/{1}) {2} : {3}. StartTime-EndTime : {4:HH:mm:ss.fff}-{5:HH:mm:ss.fff}", clientC, config.BrokerClient, item.GetUserData <int>(), gg, si.StartTime, si.EndTime); } brokerClientTaskTimeRecords[brokerClientGuid][gg].ResponseTime = DateTime.Now; } catch (FaultException ex) { Logger.Warning("FaultException while getting responses in callback. \n{0}", ex.ToString()); } catch (RetryOperationException ex) { Logger.Warning("RetryOperationException while getting responses in callback. \n{0}", ex.ToString()); } catch (SessionException ex) { Logger.Warning("SessionException while getting responses in callback. \n{0}", ex.ToString()); } catch (Exception ex) { Logger.Warning("Exception while getting responses in callback. \n{0}", ex.ToString()); } if (Interlocked.Increment(ref count) == config.NumberOfRequest) { done.Set(); } }); } Logger.Info("Sending {0} requests for broker client ({1}/{2})...", config.NumberOfRequest, clientC, config.BrokerClient); brokerSendRequestStartTime[brokerClientGuid] = DateTime.Now; watchT.Restart(); int i = 0; foreach (Guid requestGuid in brokerClientTaskTimeRecords[brokerClientGuid].Keys) { i++; GenerateLoadRequest request = new GenerateLoadRequest(brokerClientTaskTimeRecords[brokerClientGuid][requestGuid].CallDurationMS, new byte[brokerClientTaskTimeRecords[brokerClientGuid][requestGuid].MessageSizeByte], null); client.SendRequest <GenerateLoadRequest>(request, i, timeoutMilliSec, new System.Xml.UniqueId(requestGuid)); if (config.Verbose) { Logger.Info("Sent request {0} for ({1}/{2}) : {3} : timeMS - {4} sizeByte - {5}", i, clientC, config.BrokerClient, requestGuid, brokerClientTaskTimeRecords[brokerClientGuid][requestGuid].CallDurationMS, brokerClientTaskTimeRecords[brokerClientGuid][requestGuid].MessageSizeByte); } brokerClientTaskTimeRecords[brokerClientGuid][requestGuid].RequestTime = DateTime.Now; if (config.Flush > 0 && i % config.Flush == 0) { client.Flush(timeoutMilliSec); } } // Flush the message client.EndRequests(timeoutMilliSec); watchT.Stop(); brokerSendRequestEndTime[brokerClientGuid] = DateTime.Now; double requestElapsedSeconds = watchT.Elapsed.TotalSeconds; double requestThroughput = config.NumberOfRequest / requestElapsedSeconds; Logger.Info("{0, -35} : {1:F3} sec", string.Format("Requests sent time ({0}/{1})", clientC, config.BrokerClient), requestElapsedSeconds); Logger.Info("{0, -35} : {1:F2} /sec", string.Format("Requests throughput ({0}/{1})", clientC, config.BrokerClient), requestThroughput); if (!config.AsyncResponseHandler) { Logger.Info("Retrieving responses for broker client ({0}/{1})...", clientC, config.BrokerClient); try { brokerGetResponseStartTime[brokerClientGuid] = DateTime.Now; watchT.Restart(); int responseNumber = 0; foreach (BrokerResponse <GenerateLoadResponse> response in client.GetResponses <GenerateLoadResponse>(timeoutMilliSec)) { try { Guid gg = response.RequestMessageId; StatisticInfo si = response.Result.GenerateLoadResult; if (config.Verbose) { Logger.Info("Response received ({0}/{1}) {2} : {3}. StartTime-EndTime : {4:HH:mm:ss.fff}-{5:HH:mm:ss.fff}", clientC, config.BrokerClient, response.GetUserData <int>(), gg, si.StartTime, si.EndTime); } else { Logger.Progress(string.Empty, responseNumber, config.NumberOfRequest); } brokerClientTaskTimeRecords[brokerClientGuid][gg].ResponseTime = DateTime.Now; } catch (FaultException e) { // Application exceptions Logger.Warning("FaultException when getting responses. \n{0}", e.ToString()); } catch (RetryOperationException e) { // RetryOperationExceptions may or may not be recoverable Logger.Warning("RetryOperationException when getting responses. \n{0}", e.ToString()); } catch (SessionException e) { // Exception Logger.Warning("SessionException when getting responses. \n{0}", e.ToString()); } catch (Exception e) { // Exception Logger.Warning("Exception when getting responses. \n{0}", e.ToString()); } finally { responseNumber++; } } watchT.Stop(); brokerGetResponseEndTime[brokerClientGuid] = DateTime.Now; double elapsedTimeSec = watchT.Elapsed.TotalSeconds; Logger.Info("{0, -35} : {1:F3} sec", string.Format("GetResponses time ({0}/{1})", clientC, config.BrokerClient), elapsedTimeSec); Logger.Info("{0, -35} : {1:F2} /sec", string.Format("GetResponses throughput ({0}/{1})", clientC, config.BrokerClient), responseNumber / elapsedTimeSec); } catch (Exception ex) { Logger.Error("Error occured getting responses.\n{0}", ex.ToString()); } } else { //wait for receiving responses async. done.WaitOne(); } } } catch (Exception e) { //swallow the exception in the thread. Logger.Error("Error occured in broker client thread.\n{0}", e.ToString()); } if (Interlocked.Decrement(ref clientNumber) == 0) { allDone.Set(); } }, g); } // for t Logger.Info("Wait for all broker clients."); allDone.WaitOne(); } catch (Exception e) { Logger.Error("Error occured.\n{0}", e.ToString()); } finally { if (session != null) { //explict close the session to free the resource session.Close(!config.ShareSession); session.Dispose(); } } //calc the request/response throughput for all broker client double allRequestsElapsedSeconds = (brokerSendRequestEndTime.Values.Max() - brokerSendRequestStartTime.Values.Min()).TotalSeconds; double allRequestThroughput = config.NumberOfRequest * config.BrokerClient / allRequestsElapsedSeconds; Logger.Info("{0, -35} : {1:F3} sec", "All requests sending time", allRequestsElapsedSeconds); Logger.Info("{0, -35} : {1:F2} /sec", "All requests throughput", allRequestThroughput); double allResponsesElapsedSeconds = (brokerGetResponseEndTime.Values.Max() - brokerGetResponseStartTime.Values.Min()).TotalSeconds; double allResponseThroughput = config.NumberOfRequest * config.BrokerClient / allResponsesElapsedSeconds; Logger.Info("{0, -35} : {1:F3} sec", "All resposnes receiving time", allResponsesElapsedSeconds); Logger.Info("{0, -35} : {1:F2} /sec", "All responses throughput", allResponseThroughput); //calc the min/max/average request e2e time double[] times = new double[config.NumberOfRequest * config.BrokerClient]; DateTime[] dates = new DateTime[config.NumberOfRequest * config.BrokerClient]; DateTime[] dates_req = new DateTime[config.NumberOfRequest * config.BrokerClient]; int k = 0; foreach (Guid g in brokerClientTaskTimeRecords.Keys) { foreach (TaskRecord r in brokerClientTaskTimeRecords[g].Values) { times[k] = (r.ResponseTime - r.RequestTime).TotalSeconds; dates[k] = r.ResponseTime; dates_req[k] = r.RequestTime; k++; } } Logger.Info("{0, -35} : {1:F3} sec", "Response time Min", times.Min()); Logger.Info("{0, -35} : {1:F3} sec", "Response time Max", times.Max()); Logger.Info("{0, -35} : {1:F3} sec", "Response time Ave", times.Average()); DateTime first = dates.Min(); DateTime last = dates.Max(); DateTime first_req = dates_req.Min(); double elapsedSec = (last - first).TotalSeconds; double elapsedSec_req = (last - first_req).TotalSeconds; Logger.Info("{0, -35} : {1:HH:mm:ss.fff}", "Response first", first); Logger.Info("{0, -35} : {1:HH:mm:ss.fff}", "Response last", last); Logger.Info("{0, -35} : {1:F3} sec", "Responses elapsed", elapsedSec); Logger.Info("{0, -35} : {1:F2} /sec", "Responses throughput", config.NumberOfRequest * config.BrokerClient / elapsedSec); Logger.Info("{0, -35} : {1:F3} sec", "Request E2E elapsed", elapsedSec_req); Logger.Info("{0, -35} : {1:F2} /sec", "Request E2E throughput", config.NumberOfRequest * config.BrokerClient / elapsedSec_req); Logger.Info("Echo Done."); }
static void Main(string[] args) { //change the headnode name here const string headnode = "[headnode]"; const string serviceName = "EchoService"; const int numRequests = 100; SessionStartInfo info = new SessionStartInfo(headnode, serviceName); //the cluster need to have a minimum 2 cores to run this sample code info.SessionResourceUnitType = SessionUnitType.Core; info.MaximumUnits = 2; info.MinimumUnits = 2; Console.Write("Creating a session for EchoService..."); using (DurableSession session = DurableSession.CreateSession(info)) { Console.WriteLine("done session id = {0}", session.Id); NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport); int sessionId = session.Id; using (BrokerClient <IService1> client = new BrokerClient <IService1>(session, binding)) { Console.Write("Sending {0} requests...", numRequests); for (int i = 0; i < numRequests; i++) { EchoOnExitRequest request = new EchoOnExitRequest(new TimeSpan(0, 0, 1)); client.SendRequest <EchoOnExitRequest>(request, i); } client.EndRequests(); Console.WriteLine("done"); //separate a work thread to purge the client when the requests are processing ThreadPool.QueueUserWorkItem(delegate { //wait 30 seconds to try cancel service tasks. Console.Write("Will cancel the requests in 30 seconds."); Thread.Sleep(30 * 1000); try { client.Close(true); Console.WriteLine("The broker client is purged."); } catch (Exception ee) { Console.WriteLine("Exception in callback when purging the client. {0}", ee.ToString()); } }); // retieving the responses Console.WriteLine("Retrieving responses..."); try { int count = 0; foreach (var response in client.GetResponses <EchoOnExitResponse>()) { try { string reply = response.Result.EchoOnExitResult; Console.WriteLine("\tReceived response for request {0}: {1}", response.GetUserData <int>(), reply); count++; } catch (Exception ex) { Console.WriteLine("Error occured while processing {0}-th request: {1}", response.GetUserData <int>(), ex.Message); } } Console.WriteLine("Done retrieving responses.{0}/{1} responses retrieved ", count, numRequests); } catch (SessionException ex) { Console.WriteLine("SessionException while getting responses: {0}", ex.Message); } catch (Exception ex) { Console.WriteLine("Exception while getting responses: {0}", ex.Message); } } // Close the session. session.Close(); Console.WriteLine("Press any key to exit."); Console.ReadKey(); } }
private static void V3ClientSample(SessionStartInfo startInfo) { using (DurableSession session = DurableSession.CreateSession(startInfo)) { using (BrokerClient <IGenericServiceV3> client = new BrokerClient <IGenericServiceV3>(session)) { GenericServiceRequest request1 = new GenericServiceRequest(); using (MemoryStream ms = new MemoryStream()) { using (BinaryWriter writer = new BinaryWriter(ms)) { writer.Write((int)0); writer.Write((int)123); } request1.Data = Convert.ToBase64String(ms.ToArray()); } // Use user data to differentiate operations // 0 stands for GetData() // 1 stands for GetDataUsingDataContract() client.SendRequest <GenericServiceRequest>(request1, 0); GenericServiceRequest request2 = new GenericServiceRequest(); using (MemoryStream ms = new MemoryStream()) { using (BinaryWriter writer = new BinaryWriter(ms)) { writer.Write((int)1); writer.Write(true); writer.Write("DataData"); } request2.Data = Convert.ToBase64String(ms.ToArray()); } client.SendRequest <GenericServiceRequest>(request2, 1); client.EndRequests(); foreach (BrokerResponse <GenericServiceResponse> response in client.GetResponses <GenericServiceResponse>()) { int operationIndex = response.GetUserData <int>(); switch (operationIndex) { case 0: // GetData Console.WriteLine("GetDataResult: {0}", response.Result.Data); break; case 1: // GetDataUsingDataContract CompositeType result; using (MemoryStream ms = new MemoryStream(Convert.FromBase64String(response.Result.Data))) using (BinaryReader reader = new BinaryReader(ms)) { result = new CompositeType(); result.BoolValue = reader.ReadBoolean(); result.StringValue = reader.ReadString(); } Console.WriteLine("GetDataUsingDataContractResult: BoolValue={0}\tStringValue={1}", result.BoolValue, result.StringValue); break; } } } session.Close(); } }
static void Main(string[] args) { //change the headnode name here const string headnode = "[headnode]"; const string serviceName = "EchoService"; const int numRequests = 12; SessionStartInfo info = new SessionStartInfo(headnode, serviceName); Console.Write("Creating a session for EchoService..."); // Create a durable session // Request and response messages in a durable session are persisted so that // in event of failure, no requests nor responses will be lost. Another authorized // client can attached to a session with the same session Id and retrieve responses using (DurableSession session = DurableSession.CreateSession(info)) { Console.WriteLine("done session id = {0}", session.Id); NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport); // Create a BrokerClient proxy // This proxy is able to map One-Way, Duplex message exchange patterns // with the Request / Reply Services. As such, the client program can send the // requests, exit and re-attach to the session to retrieve responses (see the // FireNRecollect project for details using (BrokerClient <IService1> client = new BrokerClient <IService1>(session, binding)) { Console.Write("Sending {0} requests...", numRequests); for (int i = 0; i < numRequests; i++) { // EchoRequest are created as you add Service Reference // EchoService to the project EchoRequest request = new EchoRequest("hello world!"); client.SendRequest <EchoRequest>(request, i); } // Flush the message. After this call, the runtime system // starts processing the request messages. If this call is not called, // the system will not process the requests. The client.GetResponses() will return // with an empty collection client.EndRequests(); Console.WriteLine("done"); Console.WriteLine("Retrieving responses..."); // GetResponses from the runtime system // EchoResponse class is created as you add Service Reference "EchoService" // to the project foreach (var response in client.GetResponses <EchoResponse>()) { try { string reply = response.Result.EchoResult; Console.WriteLine("\tReceived response for request {0}: {1}", response.GetUserData <int>(), reply); } catch (Exception ex) { Console.WriteLine("Error occured while processing {0}-th request: {1}", response.GetUserData <int>(), ex.Message); } } Console.WriteLine("Done retrieving {0} responses", numRequests); } //explict close the session to free the resource session.Close(); } Console.WriteLine("Press any key to exit."); Console.ReadKey(); }
static void Main(string[] args) { const string headnode = "[headnode]"; const string serviceName = "EchoService"; if (args.Length == 1) { // attach to the session int sessionId = Int32.Parse(args[0]); SessionAttachInfo info = new SessionAttachInfo(headnode, sessionId); Console.Write("Attaching to session {0}...", sessionId); // Create attach to a session using (DurableSession session = DurableSession.AttachSession(info)) { Console.WriteLine("done."); // Create a client proxy using (BrokerClient <IService1> client = new BrokerClient <IService1>(session)) { Console.WriteLine("Retrieving results..."); // Get all the results foreach (BrokerResponse <EchoResponse> response in client.GetResponses <EchoResponse>()) { string reply = response.Result.EchoResult; Console.WriteLine("\tReceived response for request {0}: {1}", response.GetUserData <int>(), reply); } Console.WriteLine("Done retrieving results."); } // Close the session to reclaim the system storage // used to store the results. After the session is closed // you cannot attatch to the same session again session.Close(); } } else { // Create a durable session, fire the requests and exit SessionStartInfo info = new SessionStartInfo(headnode, serviceName); Console.Write("Creating a session..."); using (DurableSession session = DurableSession.CreateSession(info)) { Console.WriteLine("done session id = {0}.", session.Id); NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport); using (BrokerClient <IService1> client = new BrokerClient <IService1>(session, binding)) { Console.Write("Sending requests..."); for (int i = 0; i < 12; i++) { EchoRequest request = new EchoRequest("hello world!"); client.SendRequest <EchoRequest>(request, i); } client.EndRequests(); Console.WriteLine("done"); } Console.WriteLine("Type \"FileNRecollect.exe {0}\" to collect the results", session.Id); } } }
static void Main(string[] args) { //change the headnode name here const string headnode = "[headnode]"; const string serviceName = "EchoService"; const int numRequests = 8; SessionStartInfo info = new SessionStartInfo(headnode, serviceName); //the sample code needs at least 2 cores in the cluster info.SessionResourceUnitType = SessionUnitType.Core; info.MaximumUnits = 2; info.MinimumUnits = 2; Console.Write("Creating a session for EchoService..."); using (DurableSession session = DurableSession.CreateSession(info)) { Console.WriteLine("done session id = {0}", session.Id); NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport); using (BrokerClient <IService1> client = new BrokerClient <IService1>(session, binding)) { Console.Write("Sending {0} requests...", numRequests); for (int i = 0; i < numRequests; i++) { EchoOnExitRequest request = new EchoOnExitRequest(new TimeSpan(0, 0, 5)); client.SendRequest <EchoOnExitRequest>(request, i); } client.EndRequests(); Console.WriteLine("done"); // cancel half of the service tasks when processing the requests ThreadPool.QueueUserWorkItem(delegate { //wait 5 seconds to try cancel service tasks. Thread.Sleep(3 * 1000); try { Scheduler scheduler = new Scheduler(); try { scheduler.Connect(headnode); } catch (Exception e) { Console.WriteLine("Error connecting store.{0}", e.ToString()); return; } int jobId = session.GetProperty <int>("HPC_ServiceJobId"); ISchedulerJob job = scheduler.OpenJob(jobId); job.Refresh(); ISchedulerCollection taskList = job.GetTaskList(null, null, true); int onFlag = 0; foreach (ISchedulerTask task in taskList) { // cancel half of the service tasks if (onFlag++ % 2 == 0) { try { if (task.State == TaskState.Running) { Console.WriteLine("Try to cancel task {0}", task.TaskId); job.CancelTask(task.TaskId); job.Commit(); } } catch (Exception ex) { Console.WriteLine("Got exception when trying to cancel task {0}:{1}", task.TaskId, ex.Message); } } } } catch (Exception ex) { Console.WriteLine("Exception when trying to cancel the service tasks. {0}", ex.Message); } }); Console.WriteLine("Retrieving responses..."); try { int count = 0; foreach (var response in client.GetResponses <EchoOnExitResponse>()) { try { string reply = response.Result.EchoOnExitResult; Console.WriteLine("\tReceived response for request {0}: {1}", response.GetUserData <int>(), reply); count++; } catch (Exception ex) { Console.WriteLine("Error occured while processing {0}-th request: {1}", response.GetUserData <int>(), ex.Message); } } Console.WriteLine("Done retrieving responses.{0}/{1} responses retrieved ", count, numRequests); } catch (SessionException ex) { Console.WriteLine("SessionException while getting responses: {0}", ex.Message); } catch (Exception ex) { Console.WriteLine("Exception while getting responses: {0}", ex.Message); } } // Close connections and delete messages stored in the system session.Close(); Console.WriteLine("Press any key to exit."); Console.ReadKey(); } }
static void Main(string[] args) { //change the headnode name here const string headnode = "[headnode]"; const string serviceName = "EchoService"; const int numRequests = 12; SessionStartInfo startInfo = new SessionStartInfo(headnode, serviceName); startInfo.BrokerSettings.SessionIdleTimeout = 15 * 60 * 1000; startInfo.BrokerSettings.ClientIdleTimeout = 15 * 60 * 1000; Console.Write("Creating a session for EchoService..."); // Create a durable session int sessionId = 0; DurableSession session = null; bool successFlag = false; int retryCount = 0; const int retryCountMax = 20; const int retryIntervalMs = 5000; while (!successFlag && retryCount++ < retryCountMax) { try { session = DurableSession.CreateSession(startInfo); successFlag = true; } catch (EndpointNotFoundException e) { Console.WriteLine("EndpointNotFoundException {0}", e.ToString()); } catch (CommunicationException e) { Console.WriteLine("CommunicationException {0}", e.ToString()); } catch (TimeoutException e) { Console.WriteLine("TimeoutException {0}", e.ToString()); } catch (SessionException e) { Console.WriteLine("SessionException {0}, error code 0x{1:x}", e.ToString(), e.ErrorCode); // if session fatal errors happen, no retry if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.SessionFatalError)) { Console.WriteLine("SessionExceptionCategory : SessionFatalError {0}", e.ToString()); Console.WriteLine("No retry."); retryCount = retryCountMax; continue; } } catch (Exception e) { Console.WriteLine("General exception {0}", e.ToString()); } if (!successFlag) { Console.WriteLine("=== Sleep {0} ms to retry. Retry count left {1}. ===", retryIntervalMs, retryCountMax - retryCount); Thread.Sleep(retryIntervalMs); } } if (!successFlag) { Console.WriteLine("Create durable session failed."); return; } sessionId = session.Id; Console.WriteLine("Done session id = {0}", sessionId); //send requests successFlag = false; retryCount = 0; const int sendTimeoutMs = 5000; const int clientPurgeTimeoutMs = 60000; while (!successFlag && retryCount++ < retryCountMax) { using (BrokerClient <IService1> client = new BrokerClient <IService1>(session)) { Console.Write("Sending {0} requests...", numRequests); try { for (int i = 0; i < numRequests; i++) { //client.SendRequest<EchoFaultRequest>(new EchoFaultRequest("dividebyzeroexception"), i, sendTimeoutMs); client.SendRequest <EchoDelayRequest>(new EchoDelayRequest(5000), i, sendTimeoutMs); } client.EndRequests(); successFlag = true; Console.WriteLine("done"); } catch (TimeoutException e) { // Timeout exceptions Console.WriteLine("TimeoutException {0}", e.ToString()); } catch (CommunicationException e) { //CommunicationException Console.WriteLine("CommunicationException {0}", e.ToString()); } catch (SessionException e) { Console.WriteLine("SessionException {0}, error code 0x{1:x}", e.ToString(), e.ErrorCode); if (SOAFaultCode.Broker_BrokerUnavailable == e.ErrorCode) { Console.WriteLine("SessionException : BrokerUnavailable {0}", e.ToString()); } // Session Exceptions are unrecoverable unless they are application errors if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.ApplicationError)) { Console.WriteLine("SessionExceptionCategory : ApplicationError {0}", e.ToString()); } // if session fatal errors happen, no retry if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.SessionFatalError)) { Console.WriteLine("SessionExceptionCategory : SessionFatalError {0}", e.ToString()); Console.WriteLine("No retry."); retryCount = retryCountMax; continue; } } catch (Exception e) { //general exceptions Console.WriteLine("Exception {0}", e.ToString()); } //purge client if not succeeded, needed? if (!successFlag) { try { client.Close(true, clientPurgeTimeoutMs); } catch (Exception e) { Console.WriteLine("Failed to purge the client after send request failure {0}", e.ToString()); } } } if (!successFlag) { Console.WriteLine("=== Sleep {0} ms to retry. Retry count left {1}. ===", retryIntervalMs, retryCountMax - retryCount); Thread.Sleep(retryIntervalMs); } } if (!successFlag) { Console.WriteLine("Send requests failed."); return; } //dispose the session here session.Dispose(); //attach the session SessionAttachInfo attachInfo = new SessionAttachInfo(headnode, sessionId); successFlag = false; retryCount = 0; const int attachTimeoutMs = 15000; while (!successFlag && retryCount++ < retryCountMax) { try { session = DurableSession.AttachSession(attachInfo); successFlag = true; } catch (EndpointNotFoundException e) { Console.WriteLine("{0}", e.ToString()); } catch (CommunicationException e) { Console.WriteLine("{0}", e.ToString()); } catch (SessionException e) { Console.WriteLine("SessionException {0}, error code 0x{1:x}", e.ToString(), e.ErrorCode); // if session fatal errors happen, no retry if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.SessionFatalError)) { Console.WriteLine("SessionExceptionCategory : SessionFatalError {0}", e.ToString()); Console.WriteLine("No retry."); retryCount = retryCountMax; continue; } } catch (Exception e) { Console.WriteLine("General exception {0}", e.ToString()); } if (!successFlag) { Console.WriteLine("=== Sleep {0} ms to retry. Retry count left {1}. ===", retryIntervalMs, retryCountMax - retryCount); Thread.Sleep(retryIntervalMs); } } if (!successFlag) { Console.WriteLine("Attach durable session failed."); return; } successFlag = false; retryCount = 0; const int getTimeoutMs = 30000; const int clientCloseTimeoutMs = 15000; Console.WriteLine("Retrieving responses..."); while (!successFlag && retryCount++ < retryCountMax) { using (BrokerClient <IService1> client = new BrokerClient <IService1>(session)) { // GetResponses from the runtime system // EchoResponse class is created as you add Service Reference "EchoService" to the project try { //foreach (var response in client.GetResponses<EchoFaultResponse>(getTimeoutMs)) foreach (var response in client.GetResponses <EchoDelayResponse>(getTimeoutMs)) { try { //string reply = response.Result.EchoFaultResult ; int reply = response.Result.EchoDelayResult; Console.WriteLine("\tReceived response for delay request {0}: {1}", response.GetUserData <int>(), reply); } catch (FaultException <DivideByZeroException> e) { // Application exceptions Console.WriteLine("FaultException<DivideByZeroException> {0}", e.ToString()); } catch (FaultException e) { // Application exceptions Console.WriteLine("FaultException {0}", e.ToString()); } catch (RetryOperationException e) { // RetryOperationExceptions may or may not be recoverable Console.WriteLine("RetryOperationException {0}", e.ToString()); } } successFlag = true; Console.WriteLine("Done retrieving {0} responses", numRequests); } catch (TimeoutException e) { // Timeout exceptions Console.WriteLine("TimeoutException {0}", e.ToString()); } catch (CommunicationException e) { //CommunicationException Console.WriteLine("CommunicationException {0}", e.ToString()); } catch (SessionException e) { Console.WriteLine("SessionException {0}, error code 0x{1:x}", e.ToString(), e.ErrorCode); if (SOAFaultCode.Broker_BrokerUnavailable == e.ErrorCode) { Console.WriteLine("SessionException : BrokerUnavailable {0}", e.ToString()); } // Session Exceptions are unrecoverable unless they are application errors if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.ApplicationError)) { Console.WriteLine("SessionExceptionCategory : ApplicationError {0}", e.ToString()); } // if session fatal errors happen, no retry if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.SessionFatalError)) { Console.WriteLine("SessionExceptionCategory : SessionFatalError {0}", e.ToString()); Console.WriteLine("No retry."); retryCount = retryCountMax; continue; } } catch (Exception e) { //general exceptions Console.WriteLine("Exception {0}", e.ToString()); } try { client.Close(false, clientCloseTimeoutMs); } catch (Exception e) { Console.WriteLine("Exception", e.ToString()); } } if (!successFlag) { Console.WriteLine("=== Sleep {0} ms to retry. Retry count left {1}. ===", retryIntervalMs, retryCountMax - retryCount); Thread.Sleep(retryIntervalMs); } } //explict close the session to free the resource successFlag = false; retryCount = 0; Console.WriteLine("Close the session..."); while (!successFlag && retryCount++ < retryCountMax) { try { session.Close(true); successFlag = true; } catch (SessionException e) { Console.WriteLine("SessionException {0}, error code 0x{1:x}", e.ToString(), e.ErrorCode); // if session fatal errors happen, no retry if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.SessionFatalError)) { Console.WriteLine("SessionExceptionCategory : SessionFatalError {0}", e.ToString()); Console.WriteLine("No retry."); retryCount = retryCountMax; continue; } } catch (Exception e) { Console.WriteLine("{0}", e.ToString()); } if (!successFlag) { Console.WriteLine("=== Sleep {0} ms to retry. Retry count left {1}. ===", retryIntervalMs, retryCountMax - retryCount); Thread.Sleep(retryIntervalMs); } } Console.WriteLine("Press any key to exit."); Console.ReadKey(); }