Exemplo n.º 1
0
        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();
        }
Exemplo n.º 2
0
        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();
        }
Exemplo n.º 3
0
        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);
            }
        }
Exemplo n.º 4
0
        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);
        }
Exemplo n.º 5
0
        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();
        }
Exemplo n.º 6
0
        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();
            }
        }
Exemplo n.º 7
0
        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;
            }
        }
Exemplo n.º 8
0
        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);
        }
Exemplo n.º 9
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
        }
Exemplo n.º 10
0
        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();
        }
Exemplo n.º 11
0
        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.");
        }
Exemplo n.º 12
0
        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();
            }
        }
Exemplo n.º 13
0
        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();
            }
        }
Exemplo n.º 14
0
        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();
        }
Exemplo n.º 15
0
        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);
                }
            }
        }
Exemplo n.º 16
0
        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();
            }
        }
Exemplo n.º 17
0
        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();
        }