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();
}
private void retrieveResp()
{
#region Init
result[] results = new result[10];
for (int i = 0; i < 10; i++)
{
results[i] = new result();
}
#endregion
SessionAttachInfo attachInfo = new SessionAttachInfo(Config.headNode, Convert.ToInt32(this.Range["D20", missing].Value2));
using (DurableSession session = DurableSession.AttachSession(attachInfo))
{
using (BrokerClient <IService1> client = new BrokerClient <IService1>(session))
{
foreach (BrokerResponse <PriceAsianOptionsResponse> response in client.GetResponses <PriceAsianOptionsResponse>())
{
cellContext idx = response.GetUserData <cellContext>();
double price = response.Result.PriceAsianOptionsResult;
Interlocked.Increment(ref results[idx.iteration].count);
this.Range[idx.range, missing].Value2 = price;
results[idx.iteration].min = Math.Min(results[idx.iteration].min, price);
results[idx.iteration].max = Math.Max(results[idx.iteration].max, price);
results[idx.iteration].sumPrice += price;
results[idx.iteration].sumSquarePrice += price * price;
results[idx.iteration].stdDev = Math.Sqrt(results[idx.iteration].sumSquarePrice - results[idx.iteration].sumPrice * results[idx.iteration].sumPrice / results[idx.iteration].count) / ((results[idx.iteration].count == 1) ? 1 : results[idx.iteration].count - 1);
results[idx.iteration].stdErr = results[idx.iteration].stdDev / Math.Sqrt(results[idx.iteration].count);
if (results[idx.iteration].count == 100)
{
int i = idx.iteration;
this.Range[string.Format("{0}14", cols[i]), missing].Value2 = results[i].sumPrice / results[i].count;
this.Range[string.Format("{0}15", cols[i]), missing].Value2 = results[i].min;
this.Range[string.Format("{0}16", cols[i]), missing].Value2 = results[i].max;
this.Range[string.Format("{0}17", cols[i]), missing].Value2 = results[i].stdDev;
this.Range[string.Format("{0}18", cols[i]), missing].Value2 = results[i].stdErr;
}
}
}
session.Close();
}
#region Summarize
for (int i = 0; i < 10; i++)
{
this.Range[string.Format("{0}14", cols[i]), missing].Value2 = results[i].sumPrice / results[i].count;
this.Range[string.Format("{0}15", cols[i]), missing].Value2 = results[i].min;
this.Range[string.Format("{0}16", cols[i]), missing].Value2 = results[i].max;
this.Range[string.Format("{0}17", cols[i]), missing].Value2 = results[i].stdDev;
this.Range[string.Format("{0}18", cols[i]), missing].Value2 = results[i].stdErr;
}
#endregion
}
private static void Worker(int sessionId)
{
DurableSession session = DurableSession.AttachSession(new SessionAttachInfo(headnode, sessionId));
int numRequests = 32;
NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport);
string guid = Guid.NewGuid().ToString();
// 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>(guid, 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();
client.Close();
Console.WriteLine("done");
}
using (BrokerClient <IService1> client = new BrokerClient <IService1>(guid, session, binding))
{
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);
}
}
/// <summary>
/// Start a new session using for testing multiple sessions and maxunit parameters
/// </summary>
public Session StartNewSession(SessionStartInfo sessionStartInfo, int max)
{
Session session = Session.CreateSession(sessionStartInfo);
var epr = new EndpointAddress(string.Format(NetTcpEndpointPattern, Server, session.Id));
Info("EPR: {0}", epr);
Info("Begin to send requests");
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;
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);
}
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;
}
return(session);
}
static void Main(string[] args)
{
//Change headnode here
const string headnode = "head.contoso.com";
const string serviceName = "CommonData.PrimeFactorization";
SessionStartInfo info = new SessionStartInfo(headnode, serviceName);
Random random = new Random();
try
{
//create an interactive session
using (Session session = Session.CreateSession(info))
{
Console.WriteLine("Session {0} has been created", session.Id);
using (BrokerClient <IPrimeFactorization> client = new BrokerClient <IPrimeFactorization>(session))
{
//send request
int num = random.Next(1, Int32.MaxValue);
FactorizeRequest request = new FactorizeRequest(num);
client.SendRequest <FactorizeRequest>(request, num);
client.EndRequests();
//get response
foreach (BrokerResponse <FactorizeResponse> response in client.GetResponses <FactorizeResponse>())
{
int number = response.GetUserData <int>();
int[] factors = response.Result.FactorizeResult;
Console.WriteLine("{0} = {1}", number, string.Join <int>(" * ", factors));
}
}
session.Close();
Console.WriteLine("done");
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
catch (System.Exception ex)
{
Console.WriteLine(ex.Message);
}
}
static void Main(string[] args)
{
try
{
//Input sessionId here
int sessionId;
Console.Write("Input the session id : ");
sessionId = Int32.Parse(Console.ReadLine());
//Change the headnode name here
SessionAttachInfo info = new SessionAttachInfo("head.contoso.com", sessionId);
//Attach to session
DurableSession session = DurableSession.AttachSession(info);
Console.WriteLine("Attached to session {0}", sessionId);
int numberResponse = 0;
//Get responses
using (BrokerClient <IPrimeFactorization> client = new BrokerClient <IPrimeFactorization>(session))
{
foreach (BrokerResponse <FactorizeResponse> response in client.GetResponses <FactorizeResponse>())
{
int number = response.GetUserData <int>();
int[] factors = response.Result.FactorizeResult;
Console.WriteLine("{0} = {1}", number, string.Join <int>(" * ", factors));
numberResponse++;
}
}
session.Close(true);
Console.WriteLine("{0} responses have been received", numberResponse);
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
catch (System.Exception ex)
{
Console.WriteLine(ex.Message);
}
}
static void Main(string[] args)
{
//change the head node name here
SessionStartInfo info = new SessionStartInfo("head.contoso.com", "CalculatorService");
//create an interactive session
using (Session session = Session.CreateSession(info))
{
Console.WriteLine("Session {0} has been created", session.Id);
//create a broker client
using (BrokerClient <ICalculator> client = new BrokerClient <ICalculator>(session))
{
//send request
AddRequest request = new AddRequest(1, 2);
client.SendRequest <AddRequest>(request);
client.EndRequests();
//get response
foreach (BrokerResponse <AddResponse> response in client.GetResponses <AddResponse>())
{
double result = response.Result.AddResult;
Console.WriteLine("Add 1 and 2, and we get {0}", result);
}
//This can be omitted if a BrokerClient object
//is created in a "using" clause.
client.Close();
}
//This should be explicitly invoked
session.Close();
}
Console.WriteLine("Done invoking SOA service");
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
public void BvtDurableCase3()
{
Info("Start BVT");
SessionStartInfo sessionStartInfo;
sessionStartInfo = BuildSessionStartInfo(Server, EchoSvcName, null, null, null, null, SessionUnitType.Node, null, null, null);
sessionStartInfo.Secure = false;
sessionStartInfo.ShareSession = true;
Info("Begin to create session");
string serviceJobId;
int clientNum = 2;
AutoResetEvent anotherClient = new AutoResetEvent(false);
using (DurableSession session = DurableSession.CreateSession(sessionStartInfo))
{
serviceJobId = session.Id;
var epr = new EndpointAddress(string.Format(NetTcpEndpointPattern, Server, serviceJobId));
Info("EPR: {0}", epr);
Task[] tasks = new Task[clientNum];
for (int i = 0; i < clientNum; i++)
{
var idx = i;
tasks[i] = Task.Run(
() =>
{
string guid = Guid.NewGuid().ToString();
try
{
Info("Client {0}: Begin to send requests.", guid);
using (BrokerClient <IEchoSvc> client = new BrokerClient <IEchoSvc>(guid, session))
{
for (int j = 0; j < NumberOfCalls; j++)
{
client.SendRequest <EchoRequest>(new EchoRequest(j.ToString()), j + ":" + guid);
}
Info("Client {0}: Begin to call EndOfMessage.", guid);
client.EndRequests();
Info("Client {0}: Begin to get responses.", guid);
int count = 0;
if (idx == 0)
{
foreach (BrokerResponse <EchoResponse> response in client.GetResponses <EchoResponse>())
{
count++;
Info(response.Result.EchoResult);
string[] rtn = response.Result.EchoResult.Split(new[] { ':' });
Assert(
rtn[rtn.Length - 1] == response.GetUserData <string>().Split(new[] { ':' })[0] && response.GetUserData <string>().Split(new[] { ':' })[1] == guid,
"Result is corrupt: expected:computername:{0}, actual:{1}",
response.GetUserData <string>().Split(new[] { ':' })[0],
response.Result.EchoResult);
}
}
else
{
foreach (var response in client.GetResponses())
{
count++;
EchoResponse result = (EchoResponse)response.Result;
Info(result.EchoResult);
string[] rtn = result.EchoResult.Split(new[] { ':' });
Assert(
rtn[rtn.Length - 1] == response.GetUserData <string>().Split(new[] { ':' })[0] && response.GetUserData <string>().Split(new[] { ':' })[1] == guid,
"Result is corrupt: expected:computername:{0}, actual:{1}",
response.GetUserData <string>(),
result.EchoResult);
}
}
if (count == NumberOfCalls)
{
Info("Client {0}: Total {1} calls returned.", guid, count);
}
else
{
Error("Client {0}: Total {1} calls returned, but losing {2} results.", guid, count, NumberOfCalls - count);
}
}
}
catch (Exception e)
{
Error("Unexpected exception of Client {0}", e.ToString());
throw;
}
finally
{
if (Interlocked.Decrement(ref clientNum) <= 0)
{
anotherClient.Set();
}
}
});
}
anotherClient.WaitOne();
Task.WaitAll(tasks);
session.Close(true);
session.Dispose();
}
}
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();
}
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();
}
}
public void BvtDurableCase1()
{
Info("Start BVT");
SessionStartInfo sessionStartInfo;
sessionStartInfo = BuildSessionStartInfo(Server, EchoSvcName, null, null, null, null, SessionUnitType.Node, null, null, null);
sessionStartInfo.Secure = false;
string serviceJobId;
Info("Begin to create Durable Session.");
string guid = Guid.NewGuid().ToString();
using (DurableSession session = DurableSession.CreateSession(sessionStartInfo))
{
serviceJobId = session.Id;
var epr = new EndpointAddress(string.Format(NetTcpEndpointPattern, Server, serviceJobId));
Info("EPR: {0}", epr);
try
{
Info("Client {0}: Begin to send requests.", guid);
using (BrokerClient <IEchoSvc> client = new BrokerClient <IEchoSvc>(guid, session))
{
for (int i = 0; i < NumberOfCalls; i++)
{
client.SendRequest <EchoRequest>(new EchoRequest(i.ToString()), i + ":" + guid);
}
Info("Client {0}: Begin to call EndOfMessage.", guid);
client.EndRequests();
}
}
catch (Exception e)
{
Error("Unexpected exception of Client {0}", e.ToString());
throw;
}
}
// sleep 10 seconds
Info("Client disconnects and sleep 10 seconds");
Thread.Sleep(10000);
SessionAttachInfo sessionAttachInfo = new SessionAttachInfo(Server, serviceJobId);
int count = 0;
Info("Begin to attach Durable Session.");
try
{
using (DurableSession session = DurableSession.AttachSession(sessionAttachInfo))
{
Info("Begin to retrieve results.");
using (BrokerClient <IEchoSvc> client = new BrokerClient <IEchoSvc>(guid, session))
{
foreach (BrokerResponse <EchoResponse> response in client.GetResponses <EchoResponse>())
{
Info(response.Result.EchoResult);
string[] rtn = response.Result.EchoResult.Split(new[] { ':' });
Assert(
rtn[rtn.Length - 1] == response.GetUserData <string>().Split(new[] { ':' })[0] && response.GetUserData <string>().Split(new[] { ':' })[1] == guid,
"Result is corrupt: expected:computername:{0}, actual:{1}",
response.GetUserData <string>().Split(new[] { ':' })[0],
response.Result.EchoResult);
count++;
}
}
session.Close();
}
if (NumberOfCalls == count)
{
Info("Total {0} calls returned.", count);
}
else
{
Error("Total {0} calls returned, but losing {1} results.\n", count, NumberOfCalls - count);
}
}
catch (Exception e)
{
Error("Unexpected exception during attaching and getting response {0}", e.ToString());
throw;
}
}
static void Main(string[] args)
{
// Replace [HeadName] with the real machine name of the HeadNode in your cluster, say "[headnode]"
const string headnode = "[HeadName]";
const string serviceName = "EchoService";
int numOfRequests = 10;
SessionStartInfo sessionStartInfo = new SessionStartInfo(headnode, serviceName);
// UseInprocessBroker indicates what kind of broker session is going to use. True means inprocess broker will be adopted
// while false means a dedicated broker node will be used by the session.
Console.WriteLine("Enable UseInprocessBroker...");
sessionStartInfo.UseInprocessBroker = true;
// Inprocess broker is only supported with non-shared interactive session,
// so please make sure the property ShareSession of SessionStartInfo is set to false.
sessionStartInfo.ShareSession = false;
Console.WriteLine("Creating an interactive session...");
using (Session session = Session.CreateSession(sessionStartInfo))
{
Console.WriteLine("Interactive Session {0} created.", session.Id);
// With inprocess broker, client can directly talk to its service hosts on computer nodes, so the EndPointReference is null.
Console.WriteLine("Session's EndpointReference: {0}.", session.EndpointReference == null ? "NULL": session.EndpointReference.ToString());
// Inprocess broker only support V3 style broker client, so you should create broker client as below instead of
// Service1Client tcpclient = new Service1Client(new NetTcpBinding(SecurityMode.Transport), session.NetTcpEndpointReference);
using (BrokerClient <IService1> client = new BrokerClient <IService1>(session))
{
Console.WriteLine("Sending {0} requests...", numOfRequests);
for (int i = 0; i < numOfRequests; i++)
{
EchoRequest request = new EchoRequest("Hello World " + i.ToString());
client.SendRequest <EchoRequest>(request, i);
}
Console.WriteLine("Calling EndRequests to notify the end of sending requests... ");
client.EndRequests();
Console.WriteLine("Retrieving responses...");
int count = 0;
foreach (BrokerResponse <EchoResponse> response in client.GetResponses <EchoResponse>())
{
string reply = response.Result.EchoResult;
Console.WriteLine("Received response for request {0}: {1}", response.GetUserData <int>(), reply);
count++;
}
if (count != numOfRequests)
{
Console.WriteLine("Error: Responses lost. Expected {0} responses, but actually {1} returned.", numOfRequests, count);
}
Console.WriteLine("Retrieving results done.");
}
session.Close();
}
Console.WriteLine("Session closed.");
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
private static List <ResultData> ClientGetResponse(BrokerClient <IService1> client, string clientId)
{
int faultCalls = 0;
List <ResultData> results = new List <ResultData>();
try
{
foreach (var response in client.GetResponses <ComputeWithInputDataResponse>())
{
try
{
if (common_data_size > 0 && response.Result.ComputeWithInputDataResult.commonDataSize != common_data_size)
{
throw new Exception(string.Format("Common data is corrupted: expected: {0}, actual: {1}", common_data_size, response.Result.ComputeWithInputDataResult.commonDataSize));
}
results.Add(Utils.CreateResultData(response.Result));
}
catch (WebException e)
{
if (e.Response is HttpWebResponse)
{
HttpWebResponse httpresponse = e.Response as HttpWebResponse;
using (StreamReader reader = new StreamReader(httpresponse.GetResponseStream()))
{
Log("Unexpected WebException when client {0} sending requests: {1}", clientId, httpresponse.StatusCode, reader.ReadToEnd());
}
results.Add(Utils.CreateDummyResultData());
Interlocked.Increment(ref faultCalls);
}
else
{
throw e;
}
}
catch (RetryOperationException)
{
if (retryRequestAndIgnoreRetryOperationError)
{
results.Add(Utils.CreateDummyResultData());
}
else
{
throw;
}
}
catch (Exception e)
{
Log(e.ToString());
results.Add(Utils.CreateDummyResultData());
Interlocked.Increment(ref faultCalls);
}
}
}
catch (Exception e)
{
Log("Client {0}: Unexpected Exception thrown from ClientGetResponse(): {1}", clientId, e.ToString());
}
Log("Client {0}: All requests returned.", clientId);
if (DateTime.Now > data.RetrieveEnd)
{
data.RetrieveEnd = DateTime.Now;
}
return(results);
}
static void Main(string[] args)
{
string hostname = "[headnode]";
// DataClient Id used to identify the data, this should be unique across the cluster
string raw_data_id = "raw_data_id";
string dictionary_data_id = "dictionary_data_id";
Console.WriteLine("Start. " + DateTime.Now.ToLongTimeString());
// Create a DataClient to store a Dictionary data
using (DataClient client = DataClient.Create(hostname, dictionary_data_id))
{
Console.WriteLine("Data {0} Created. {1} ", dictionary_data_id, DateTime.Now.ToLongTimeString());
// Here we have a DataClient whose life cycle is not managed by SOA
Dictionary <string, string> objects = new Dictionary <string, string>();
objects.Add("key1", "value1");
objects.Add("key2", "value2");
// WriteAll() can only be called once on a data client.
client.WriteAll <Dictionary <string, string> >(objects);
}
SessionStartInfo sessionStartInfo = new SessionStartInfo(hostname, "CommonDataService");
// Pass DataClient Id in SOA session's environment variable so that it could be read from service code
sessionStartInfo.Environments.Add("DICTIONARY_DATA_ID", dictionary_data_id);
using (Session session = Session.CreateSession(sessionStartInfo))
{
Console.WriteLine("Session {0} Created. {1} ", session.Id, DateTime.Now.ToLongTimeString());
// Create a DataClient to store the raw data read from the file
using (DataClient client = DataClient.Create(hostname, raw_data_id))
{
Console.WriteLine("Data {0} Created {1}. ", client.Id, DateTime.Now.ToLongTimeString());
// Add a data life cycle management so that it'll be deleted when session is done
// Otherwise, the data will have to be cleaned up by client
client.SetDataLifeCycle(new DataLifeCycle(session.Id));
// WriteRawBytesAll() doesn't serialize the object and will write the byte stream directly.
// Use this when you want to transport a file or have non-.Net code that cannot handle .net serialization.
client.WriteRawBytesAll(File.ReadAllBytes("DataFile.txt"));
}
// Send/Receive SOA requests
using (BrokerClient <ICommonDataService> client = new BrokerClient <ICommonDataService>(session))
{
Console.WriteLine("Send Requests. " + DateTime.Now.ToLongTimeString());
client.SendRequest <GetDataRequest>(new GetDataRequest(raw_data_id));
client.EndRequests();
Console.WriteLine("Get Response. " + DateTime.Now.ToLongTimeString());
foreach (BrokerResponse <GetDataResponse> resp in client.GetResponses <GetDataResponse>())
{
string result = resp.Result.GetDataResult;
Console.WriteLine(result);
}
}
Console.WriteLine("Start closing session. " + DateTime.Now.ToLongTimeString());
}
Console.WriteLine("Session Closed. " + DateTime.Now.ToLongTimeString());
Console.WriteLine("Start cleaning up the Data {0}. {1} ", dictionary_data_id, DateTime.Now.ToLongTimeString());
// We should delete the DataClient "dictionary_data_id" here since it's not managed by SOA
DataClient.Delete(hostname, dictionary_data_id);
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
static void Main(string[] args)
{
//change the headnode name here
const string headnode = "[headnode]";
const string serviceName = "EchoService";
const int numRequests = 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();
}
}
static void Main(string[] args)
{
//change the headnode name here
const string headnode = "[headnode]";
const string serviceName = "EchoService";
const int numRequests = 12;
SessionStartInfo info = new SessionStartInfo(headnode, serviceName);
Console.Write("Creating a session for EchoService...");
// Create a durable session
// Request and response messages in a durable session are persisted so that
// in event of failure, no requests nor responses will be lost. Another authorized
// client can attached to a session with the same session Id and retrieve responses
using (DurableSession session = DurableSession.CreateSession(info))
{
Console.WriteLine("done session id = {0}", session.Id);
NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport);
// Create a BrokerClient proxy
// This proxy is able to map One-Way, Duplex message exchange patterns
// with the Request / Reply Services. As such, the client program can send the
// requests, exit and re-attach to the session to retrieve responses (see the
// FireNRecollect project for details
using (BrokerClient <IService1> client = new BrokerClient <IService1>(session, binding))
{
Console.Write("Sending {0} requests...", numRequests);
for (int i = 0; i < numRequests; i++)
{
// EchoRequest are created as you add Service Reference
// EchoService to the project
EchoRequest request = new EchoRequest("hello world!");
client.SendRequest <EchoRequest>(request, i);
}
// Flush the message. After this call, the runtime system
// starts processing the request messages. If this call is not called,
// the system will not process the requests. The client.GetResponses() will return
// with an empty collection
client.EndRequests();
Console.WriteLine("done");
Console.WriteLine("Retrieving responses...");
// GetResponses from the runtime system
// EchoResponse class is created as you add Service Reference "EchoService"
// to the project
foreach (var response in client.GetResponses <EchoResponse>())
{
try
{
string reply = response.Result.EchoResult;
Console.WriteLine("\tReceived response for request {0}: {1}", response.GetUserData <int>(), reply);
}
catch (Exception ex)
{
Console.WriteLine("Error occured while processing {0}-th request: {1}", response.GetUserData <int>(), ex.Message);
}
}
Console.WriteLine("Done retrieving {0} responses", numRequests);
}
//explict close the session to free the resource
session.Close();
}
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
static void Main(string[] args)
{
CmdParser parser = new CmdParser(args);
Config config = new Config(parser);
if (config.HelpInfo)
{
config.PrintHelp();
return;
}
if (config.Verbose)
{
config.PrintUsedParams(parser);
}
if (config.PrintUnusedParams(parser))
{
config.PrintHelp();
return;
}
// TODO: SessionStartInfoFactory
SessionStartInfo info = null;
if (config.IsNoSession)
{
// Start session without session manager
if (config.InprocessBroker)
{
info = new SessionStartInfo(config.ServiceName, config.RegPath, null, config.TargetList?.ToArray());
info.UseInprocessBroker = true;
info.IsNoSession = true;
}
else
{
info = new SessionStartInfo(config.HeadNode, config.ServiceName, config.RegPath, null, config.TargetList?.ToArray());
info.UseInprocessBroker = false;
info.IsNoSession = true;
}
}
else
{
info = new SessionStartInfo(config.HeadNode, config.ServiceName);
info.IsNoSession = false;
info.UseInprocessBroker = config.InprocessBroker;
}
if (!string.IsNullOrEmpty(config.Username))
{
info.Username = config.Username;
}
if (!string.IsNullOrEmpty(config.Password))
{
info.Password = config.Password;
}
if (!string.IsNullOrEmpty(config.JobName))
{
info.ServiceJobName = config.JobName;
}
if (!string.IsNullOrEmpty(config.AzureStorageConnectionString))
{
info.AzureStorageConnectionString = config.AzureStorageConnectionString;
info.BrokerLauncherStorageConnectionString = config.AzureStorageConnectionString;
}
switch (config.ResourceType.ToLowerInvariant())
{
case "core":
info.SessionResourceUnitType = SessionUnitType.Core;
break;
case "node":
info.SessionResourceUnitType = SessionUnitType.Node;
break;
case "socket":
info.SessionResourceUnitType = SessionUnitType.Socket;
break;
case "gpu":
info.SessionResourceUnitType = SessionUnitType.Gpu;
break;
default:
break;
}
if (config.MaxResource > 0)
{
info.MaximumUnits = config.MaxResource;
}
if (config.MinResource > 0)
{
info.MinimumUnits = config.MinResource;
}
switch (config.TransportScheme.ToLowerInvariant())
{
case "nettcp":
info.TransportScheme = TransportScheme.NetTcp;
break;
case "http":
info.TransportScheme = TransportScheme.Http;
break;
case "nethttp":
info.TransportScheme = TransportScheme.NetHttp;
break;
case "custom":
info.TransportScheme = TransportScheme.Custom;
break;
case "azstorage":
info.TransportScheme = TransportScheme.AzureStorage;
break;
default:
break;
}
info.JobTemplate = config.JobTemplate;
info.SessionPriority = config.Priority;
info.NodeGroupList = new List <string>(config.NodeGroups.Split(new char[] { ',' }));
info.RequestedNodesList = new List <string>(config.Nodes.Split(new char[] { ',' }));
info.Secure = !config.Insecure && !config.IsNoSession;
info.UseAzureQueue = config.AzureQueue;
info.ShareSession = config.ShareSession;
info.UseSessionPool = config.SessionPool;
info.ParentJobIds = StringToIntList(config.ParentIds);
info.ServiceHostIdleTimeout = config.ServiceIdleSec == -1 ? config.ServiceIdleSec : config.ServiceIdleSec * 1000;
info.ServiceHangTimeout = config.ServiceHangSec == -1 ? config.ServiceHangSec : config.ServiceHangSec * 1000;
info.UseWindowsClientCredential = config.UseWCC;
info.UseAad = config.UseAad;
if (config.Runtime > 0)
{
info.Runtime = config.Runtime;
}
if (!string.IsNullOrEmpty(config.Environment))
{
foreach (string keyValue in config.Environment.Split(new char[] { ',' }))
{
string[] p = keyValue.Split(new char[] { '=' });
if (p.Length == 2)
{
info.Environments.Add(p[0], p[1]);
}
}
}
Stopwatch watch = new Stopwatch();
int timeoutMilliSec = config.MsgTimeoutSec * 1000;
Dictionary <Guid, Dictionary <Guid, TaskRecord> > brokerClientTaskTimeRecords = new Dictionary <Guid, Dictionary <Guid, TaskRecord> >(config.BrokerClient);
Dictionary <Guid, DateTime> brokerSendRequestStartTime = new Dictionary <Guid, DateTime>(config.BrokerClient);
Dictionary <Guid, DateTime> brokerSendRequestEndTime = new Dictionary <Guid, DateTime>(config.BrokerClient);
Dictionary <Guid, DateTime> brokerGetResponseStartTime = new Dictionary <Guid, DateTime>(config.BrokerClient);
Dictionary <Guid, DateTime> brokerGetResponseEndTime = new Dictionary <Guid, DateTime>(config.BrokerClient);
Random rTimeMS = new Random();
Random rSizeKB = new Random();
int maxTimeMS = 0;
int minTimeMS = 0;
int maxSizeKB = 0;
int minSizeKB = 0;
if (!string.IsNullOrEmpty(config.TimeMSRandom))
{
string[] values = config.TimeMSRandom.Split(new char[] { '_' }, StringSplitOptions.RemoveEmptyEntries);
if (values.Length == 2)
{
int.TryParse(values[0], out minTimeMS);
int.TryParse(values[1], out maxTimeMS);
}
}
if (!string.IsNullOrEmpty(config.SizeKBRandom))
{
string[] values = config.SizeKBRandom.Split(new char[] { '_' }, StringSplitOptions.RemoveEmptyEntries);
if (values.Length == 2)
{
int.TryParse(values[0], out minSizeKB);
int.TryParse(values[1], out maxSizeKB);
}
}
for (int c = 0; c < config.BrokerClient; c++)
{
Dictionary <Guid, TaskRecord> taskTimeReconds = new Dictionary <Guid, TaskRecord>(config.NumberOfRequest);
for (int i = 0; i < config.NumberOfRequest; i++)
{
Guid g = Guid.NewGuid();
TaskRecord t = new TaskRecord()
{
RequestTime = DateTime.MinValue, ResponseTime = DateTime.MinValue
};
if (maxTimeMS > 0)
{
t.CallDurationMS = rTimeMS.Next(minTimeMS, maxTimeMS);
}
else
{
t.CallDurationMS = config.CallDurationMS;
}
if (maxSizeKB > 0)
{
t.MessageSizeByte = rSizeKB.Next(minSizeKB, maxSizeKB) * 1024;
}
else
{
t.MessageSizeByte = config.MessageSizeByte;
}
taskTimeReconds.Add(g, t);
}
Guid clientGuid = Guid.NewGuid();
brokerClientTaskTimeRecords.Add(clientGuid, taskTimeReconds);
brokerSendRequestStartTime.Add(clientGuid, DateTime.MinValue);
brokerSendRequestEndTime.Add(clientGuid, DateTime.MinValue);
brokerGetResponseStartTime.Add(clientGuid, DateTime.MinValue);
brokerGetResponseEndTime.Add(clientGuid, DateTime.MinValue);
}
// Create an interactive or durable session
Logger.Info("Creating a session for CcpEchoSvc service...");
SessionBase session = null;
try
{
watch.Start();
if (config.Durable)
{
session = DurableSession.CreateSession(info);
}
else
{
session = Session.CreateSession(info);
}
watch.Stop();
Logger.Info("{0, -35} : {1}", "Session ID", session.Id);
Logger.Info("{0, -35} : {1:F3} sec", "Session creation time", watch.Elapsed.TotalSeconds);
//session warm up time
if (config.WarmupTimeSec > 0)
{
Logger.Info("Session warming up in {0} seconds...", config.WarmupTimeSec);
Thread.Sleep(config.WarmupTimeSec * 1000);
}
int clientNumber = config.BrokerClient;
int clientCounter = 0;
AutoResetEvent allDone = new AutoResetEvent(false);
foreach (Guid g in brokerClientTaskTimeRecords.Keys)
{
ThreadPool.QueueUserWorkItem((o) =>
{
Guid brokerClientGuid = (Guid)o;
AutoResetEvent done = new AutoResetEvent(false);
int count = 0;
int clientC = Interlocked.Increment(ref clientCounter);
Stopwatch watchT = new Stopwatch();
try
{
// Create a BrokerClient proxy
using (BrokerClient <IEchoSvc> client = new BrokerClient <IEchoSvc>(brokerClientGuid.ToString(), session))
{
if (config.AsyncResponseHandler)
{
//set getresponse handler
Logger.Info("Setting response handler ({0}/{1}) to receive responses async.", clientC, config.BrokerClient);
client.SetResponseHandler <GenerateLoadResponse>((item) =>
{
try
{
Guid gg = item.RequestMessageId;
StatisticInfo si = item.Result.GenerateLoadResult;
if (config.Verbose)
{
Logger.Info("Response async received ({0}/{1}) {2} : {3}. StartTime-EndTime : {4:HH:mm:ss.fff}-{5:HH:mm:ss.fff}", clientC, config.BrokerClient, item.GetUserData <int>(), gg, si.StartTime, si.EndTime);
}
brokerClientTaskTimeRecords[brokerClientGuid][gg].ResponseTime = DateTime.Now;
}
catch (FaultException ex)
{
Logger.Warning("FaultException while getting responses in callback. \n{0}", ex.ToString());
}
catch (RetryOperationException ex)
{
Logger.Warning("RetryOperationException while getting responses in callback. \n{0}", ex.ToString());
}
catch (SessionException ex)
{
Logger.Warning("SessionException while getting responses in callback. \n{0}", ex.ToString());
}
catch (Exception ex)
{
Logger.Warning("Exception while getting responses in callback. \n{0}", ex.ToString());
}
if (Interlocked.Increment(ref count) == config.NumberOfRequest)
{
done.Set();
}
});
}
Logger.Info("Sending {0} requests for broker client ({1}/{2})...", config.NumberOfRequest, clientC, config.BrokerClient);
brokerSendRequestStartTime[brokerClientGuid] = DateTime.Now;
watchT.Restart();
int i = 0;
foreach (Guid requestGuid in brokerClientTaskTimeRecords[brokerClientGuid].Keys)
{
i++;
GenerateLoadRequest request = new GenerateLoadRequest(brokerClientTaskTimeRecords[brokerClientGuid][requestGuid].CallDurationMS, new byte[brokerClientTaskTimeRecords[brokerClientGuid][requestGuid].MessageSizeByte], null);
client.SendRequest <GenerateLoadRequest>(request, i, timeoutMilliSec, new System.Xml.UniqueId(requestGuid));
if (config.Verbose)
{
Logger.Info("Sent request {0} for ({1}/{2}) : {3} : timeMS - {4} sizeByte - {5}", i, clientC, config.BrokerClient, requestGuid, brokerClientTaskTimeRecords[brokerClientGuid][requestGuid].CallDurationMS, brokerClientTaskTimeRecords[brokerClientGuid][requestGuid].MessageSizeByte);
}
brokerClientTaskTimeRecords[brokerClientGuid][requestGuid].RequestTime = DateTime.Now;
if (config.Flush > 0 && i % config.Flush == 0)
{
client.Flush(timeoutMilliSec);
}
}
// Flush the message
client.EndRequests(timeoutMilliSec);
watchT.Stop();
brokerSendRequestEndTime[brokerClientGuid] = DateTime.Now;
double requestElapsedSeconds = watchT.Elapsed.TotalSeconds;
double requestThroughput = config.NumberOfRequest / requestElapsedSeconds;
Logger.Info("{0, -35} : {1:F3} sec", string.Format("Requests sent time ({0}/{1})", clientC, config.BrokerClient), requestElapsedSeconds);
Logger.Info("{0, -35} : {1:F2} /sec", string.Format("Requests throughput ({0}/{1})", clientC, config.BrokerClient), requestThroughput);
if (!config.AsyncResponseHandler)
{
Logger.Info("Retrieving responses for broker client ({0}/{1})...", clientC, config.BrokerClient);
try
{
brokerGetResponseStartTime[brokerClientGuid] = DateTime.Now;
watchT.Restart();
int responseNumber = 0;
foreach (BrokerResponse <GenerateLoadResponse> response in client.GetResponses <GenerateLoadResponse>(timeoutMilliSec))
{
try
{
Guid gg = response.RequestMessageId;
StatisticInfo si = response.Result.GenerateLoadResult;
if (config.Verbose)
{
Logger.Info("Response received ({0}/{1}) {2} : {3}. StartTime-EndTime : {4:HH:mm:ss.fff}-{5:HH:mm:ss.fff}", clientC, config.BrokerClient, response.GetUserData <int>(), gg, si.StartTime, si.EndTime);
}
else
{
Logger.Progress(string.Empty, responseNumber, config.NumberOfRequest);
}
brokerClientTaskTimeRecords[brokerClientGuid][gg].ResponseTime = DateTime.Now;
}
catch (FaultException e)
{
// Application exceptions
Logger.Warning("FaultException when getting responses. \n{0}", e.ToString());
}
catch (RetryOperationException e)
{
// RetryOperationExceptions may or may not be recoverable
Logger.Warning("RetryOperationException when getting responses. \n{0}", e.ToString());
}
catch (SessionException e)
{
// Exception
Logger.Warning("SessionException when getting responses. \n{0}", e.ToString());
}
catch (Exception e)
{
// Exception
Logger.Warning("Exception when getting responses. \n{0}", e.ToString());
}
finally
{
responseNumber++;
}
}
watchT.Stop();
brokerGetResponseEndTime[brokerClientGuid] = DateTime.Now;
double elapsedTimeSec = watchT.Elapsed.TotalSeconds;
Logger.Info("{0, -35} : {1:F3} sec", string.Format("GetResponses time ({0}/{1})", clientC, config.BrokerClient), elapsedTimeSec);
Logger.Info("{0, -35} : {1:F2} /sec", string.Format("GetResponses throughput ({0}/{1})", clientC, config.BrokerClient), responseNumber / elapsedTimeSec);
}
catch (Exception ex)
{
Logger.Error("Error occured getting responses.\n{0}", ex.ToString());
}
}
else
{
//wait for receiving responses async.
done.WaitOne();
}
}
}
catch (Exception e)
{
//swallow the exception in the thread.
Logger.Error("Error occured in broker client thread.\n{0}", e.ToString());
}
if (Interlocked.Decrement(ref clientNumber) == 0)
{
allDone.Set();
}
}, g);
} // for t
Logger.Info("Wait for all broker clients.");
allDone.WaitOne();
}
catch (Exception e)
{
Logger.Error("Error occured.\n{0}", e.ToString());
}
finally
{
if (session != null)
{
//explict close the session to free the resource
session.Close(!config.ShareSession);
session.Dispose();
}
}
//calc the request/response throughput for all broker client
double allRequestsElapsedSeconds = (brokerSendRequestEndTime.Values.Max() - brokerSendRequestStartTime.Values.Min()).TotalSeconds;
double allRequestThroughput = config.NumberOfRequest * config.BrokerClient / allRequestsElapsedSeconds;
Logger.Info("{0, -35} : {1:F3} sec", "All requests sending time", allRequestsElapsedSeconds);
Logger.Info("{0, -35} : {1:F2} /sec", "All requests throughput", allRequestThroughput);
double allResponsesElapsedSeconds = (brokerGetResponseEndTime.Values.Max() - brokerGetResponseStartTime.Values.Min()).TotalSeconds;
double allResponseThroughput = config.NumberOfRequest * config.BrokerClient / allResponsesElapsedSeconds;
Logger.Info("{0, -35} : {1:F3} sec", "All resposnes receiving time", allResponsesElapsedSeconds);
Logger.Info("{0, -35} : {1:F2} /sec", "All responses throughput", allResponseThroughput);
//calc the min/max/average request e2e time
double[] times = new double[config.NumberOfRequest * config.BrokerClient];
DateTime[] dates = new DateTime[config.NumberOfRequest * config.BrokerClient];
DateTime[] dates_req = new DateTime[config.NumberOfRequest * config.BrokerClient];
int k = 0;
foreach (Guid g in brokerClientTaskTimeRecords.Keys)
{
foreach (TaskRecord r in brokerClientTaskTimeRecords[g].Values)
{
times[k] = (r.ResponseTime - r.RequestTime).TotalSeconds;
dates[k] = r.ResponseTime;
dates_req[k] = r.RequestTime;
k++;
}
}
Logger.Info("{0, -35} : {1:F3} sec", "Response time Min", times.Min());
Logger.Info("{0, -35} : {1:F3} sec", "Response time Max", times.Max());
Logger.Info("{0, -35} : {1:F3} sec", "Response time Ave", times.Average());
DateTime first = dates.Min();
DateTime last = dates.Max();
DateTime first_req = dates_req.Min();
double elapsedSec = (last - first).TotalSeconds;
double elapsedSec_req = (last - first_req).TotalSeconds;
Logger.Info("{0, -35} : {1:HH:mm:ss.fff}", "Response first", first);
Logger.Info("{0, -35} : {1:HH:mm:ss.fff}", "Response last", last);
Logger.Info("{0, -35} : {1:F3} sec", "Responses elapsed", elapsedSec);
Logger.Info("{0, -35} : {1:F2} /sec", "Responses throughput", config.NumberOfRequest * config.BrokerClient / elapsedSec);
Logger.Info("{0, -35} : {1:F3} sec", "Request E2E elapsed", elapsedSec_req);
Logger.Info("{0, -35} : {1:F2} /sec", "Request E2E throughput", config.NumberOfRequest * config.BrokerClient / elapsedSec_req);
Logger.Info("Echo Done.");
}
static void Main(string[] args)
{
//change the headnode name here
const string headnode = "localhost";
const string serviceName = "JavaEchoSvc1";
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<IEchoSvc> client = new BrokerClient<IEchoSvc>(session, binding))
{
Console.Write("Sending {0} requests...", numRequests);
for (int i = 0; i < numRequests; i++)
{
// EchoRequest are created as you add Service Reference
// EchoService to the project
EchoRequest request = new EchoRequest("hello world!");
client.SendRequest<EchoRequest>(request, i);
}
// Flush the message. After this call, the runtime system
// starts processing the request messages. If this call is not called,
// the system will not process the requests. The client.GetResponses() will return
// with an empty collection
client.EndRequests();
Console.WriteLine("done");
Console.WriteLine("Retrieving responses...");
// GetResponses from the runtime system
// EchoResponse class is created as you add Service Reference "EchoService"
// to the project
foreach (var response in client.GetResponses<EchoResponse>())
{
try
{
string reply = response.Result.EchoResult;
Console.WriteLine("\tReceived response for request {0}: {1}", response.GetUserData<int>(), reply);
}
catch (Exception ex)
{
Console.WriteLine("Error occured while processing {0}-th request: {1}", response.GetUserData<int>(), ex.Message);
}
}
Console.WriteLine("Done retrieving {0} responses", numRequests);
}
//explict close the session to free the resource
session.Close();
}
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
static void Main(string[] args)
{
// either fill in this value or use the command-line parameter
string headnode = "";
string serviceName = "StaticWorkbookService";
string jobTemplate = "AzureTemplate";
string relativePath = "workbooks";
string spreadsheetName = "StaticWorkbook.xlsx";
// SOA variables
Session session = null;
BrokerClient <IStaticWorkbookService> client = null;
bool sessionCreatedSuccessfully = false;
// parse command-line arguments
for (int i = 0; i < args.Length; i++)
{
if (args[i].Equals("-headnode") && i < args.Length - 1)
{
headnode = args[++i];
}
;
if (args[i].Equals("-serviceName") && i < args.Length - 1)
{
serviceName = args[++i];
}
;
if (args[i].Equals("-jobTemplate") && i < args.Length - 1)
{
jobTemplate = args[++i];
}
;
if (args[i].Equals("-relativePath") && i < args.Length - 1)
{
relativePath = args[++i];
}
;
if (args[i].Equals("-spreadsheetName") && i < args.Length - 1)
{
spreadsheetName = args[++i];
}
;
}
if (null == headnode || headnode.Equals(""))
{
Console.WriteLine("");
Console.WriteLine("Error: call this application with the argument -headnode [name].");
Console.WriteLine("");
Console.WriteLine("Arguments:");
Console.WriteLine("");
Console.WriteLine("-headnode [name] the name of your cluster scheduler");
Console.WriteLine("-serviceName [name] optional, defaults to 'StaticWorkbookService'");
Console.WriteLine("-jobTemplate [name] optional, defaults to 'AzureTemplate'");
Console.WriteLine("-relativePath [name] optional, defaults to 'Workbooks'");
Console.WriteLine("-spreadsheetName [name] optional, defaults to 'StaticWorkbook.xlsx'");
Console.WriteLine("");
return;
}
try
{
// Create the SOA session and client
SessionStartInfo info = new SessionStartInfo(headnode, serviceName);
info.SessionResourceUnitType = SessionUnitType.Core;
info.MinimumUnits = 1;
info.MaximumUnits = 128;
info.Secure = false;
info.JobTemplate = jobTemplate;
Console.WriteLine("Creating session and client");
session = Session.CreateSession(info);
client = new BrokerClient <IStaticWorkbookService>(session);
// The Azure VM nodes use an environment variable to
// describe the root installation path for packages
// uploaded with hpcpack. We used a relative path to
// upload the spreadsheets, so we add that path to
// the environment variable to locate the spreadsheet.
string spreadsheetPath = string.Format(@"%CCP_PACKAGE_ROOT%\{0}\{1}", relativePath, spreadsheetName);
// call the workbook with different sets of parameters.
// we're just pasting values into the spreadsheet, and requesting
// some other cells as the results after the calculation.
// have a look at the spreadsheet to see what cells we
// are updating and what cells we are retrieving after
// the calculation.
// these values are constant, we are varying strike and time
double spotPrice = 100;
double volatility = 0.25;
double riskFreeRate = 0.035;
double dividendYield = 0.02;
for (double strike = 75; strike <= 125; strike += 5)
{
for (double timeInMonths = 1; timeInMonths <= 24; timeInMonths++)
{
double timeInYears = timeInMonths / 12.0;
// the values are passed to the service using the
// Excel range identifiers. we can pass as many as
// necessary. just make sure they're the same length,
// and that they match up (e.g. C5 -> spotPrice).
string[] ranges = { "C5", "C6", "C7", "C8", "C9", "C10" };
object[] values = { spotPrice, strike, timeInYears, volatility, riskFreeRate, dividendYield };
// the output values are the cells we want to retrieve
// when the calculation is complete
string[] outputRanges = { "C15", "C16" };
// to map our results back to the input parameters, we
// can use the index value
CalculateParametersRequest req = new CalculateParametersRequest();
req.spreadsheetPath = spreadsheetPath;
req.inputRanges = ranges;
req.inputValues = values;
req.outputRanges = outputRanges;
// we're passing the strike price and time values as "user data"
// attached to the request. that will let us tie the results
// back to the input data when the calculation completes.
client.SendRequest <CalculateParametersRequest>(req, new double[] { strike, timeInMonths });
}
}
client.EndRequests();
sessionCreatedSuccessfully = true;
}
catch (Exception e)
{
Console.WriteLine("Failed to start session and send requests.\n" +
"Verify that head node is correctly specified and all\n" +
"sample documentation steps have been followed.\n" +
"Error: {0}", e.ToString());
}
if (sessionCreatedSuccessfully)
{
Console.WriteLine("Waiting for response(s)...");
// note that results will be returned in random order, based on which node
// calculates and returns a value first. because the input parameters
// are returned as well, if we wanted we could sort the results before
// printing. for now, we will just output them to the terminal.
try
{
BrokerResponseEnumerator <CalculateParametersResponse> responses = client.GetResponses <CalculateParametersResponse>();
foreach (BrokerResponse <CalculateParametersResponse> response in responses)
{
double[] userData = response.GetUserData <double[]>();
object[] results = response.Result.CalculateParametersResult;
Console.WriteLine("Strike {0:0.00},\tExpiry {1:00} months: Call {2:00.00}, Put {3:00.00}",
userData[0], (int)userData[1], Double.Parse(results[0].ToString()), Double.Parse(results[1].ToString()));
}
}
catch (Exception e)
{
Console.WriteLine("Failed to get responses. Error: {0}", e.ToString());
}
}
// done - clean up
Console.WriteLine("\r\nCleaning up...");
try
{
if (client != null)
{
client.Close();
}
}
catch
{
Console.WriteLine("Failed to close client cleanly.");
}
finally
{
if (client != null)
{
client.Dispose();
}
}
try
{
if (session != null)
{
session.Close();
}
}
catch
{
Console.WriteLine("Failed to close session cleanly. Check for running jobs.");
}
finally
{
if (session != null)
{
session.Dispose();
}
}
}
static void Main(string[] args)
{
const string headnode = "[headnode]";
const string serviceName = "EchoService";
if (args.Length == 1)
{
// attach to the session
int sessionId = Int32.Parse(args[0]);
SessionAttachInfo info = new SessionAttachInfo(headnode, sessionId);
Console.Write("Attaching to session {0}...", sessionId);
// Create attach to a session
using (DurableSession session = DurableSession.AttachSession(info))
{
Console.WriteLine("done.");
// Create a client proxy
using (BrokerClient <IService1> client = new BrokerClient <IService1>(session))
{
Console.WriteLine("Retrieving results...");
// Get all the results
foreach (BrokerResponse <EchoResponse> response in client.GetResponses <EchoResponse>())
{
string reply = response.Result.EchoResult;
Console.WriteLine("\tReceived response for request {0}: {1}", response.GetUserData <int>(), reply);
}
Console.WriteLine("Done retrieving results.");
}
// Close the session to reclaim the system storage
// used to store the results. After the session is closed
// you cannot attatch to the same session again
session.Close();
}
}
else
{
// Create a durable session, fire the requests and exit
SessionStartInfo info = new SessionStartInfo(headnode, serviceName);
Console.Write("Creating a session...");
using (DurableSession session = DurableSession.CreateSession(info))
{
Console.WriteLine("done session id = {0}.", session.Id);
NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport);
using (BrokerClient <IService1> client = new BrokerClient <IService1>(session, binding))
{
Console.Write("Sending requests...");
for (int i = 0; i < 12; i++)
{
EchoRequest request = new EchoRequest("hello world!");
client.SendRequest <EchoRequest>(request, i);
}
client.EndRequests();
Console.WriteLine("done");
}
Console.WriteLine("Type \"FileNRecollect.exe {0}\" to collect the results", session.Id);
}
}
}
static void Main(string[] args)
{
//change the headnode name here
const string headnode = "[headnode]";
const string serviceName = "EchoService";
const int numRequests = 8;
SessionStartInfo info = new SessionStartInfo(headnode, serviceName);
//the sample code needs at least 2 cores in the cluster
info.SessionResourceUnitType = SessionUnitType.Core;
info.MaximumUnits = 2;
info.MinimumUnits = 2;
Console.Write("Creating a session for EchoService...");
using (DurableSession session = DurableSession.CreateSession(info))
{
Console.WriteLine("done session id = {0}", session.Id);
NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport);
using (BrokerClient <IService1> client = new BrokerClient <IService1>(session, binding))
{
Console.Write("Sending {0} requests...", numRequests);
for (int i = 0; i < numRequests; i++)
{
EchoOnExitRequest request = new EchoOnExitRequest(new TimeSpan(0, 0, 5));
client.SendRequest <EchoOnExitRequest>(request, i);
}
client.EndRequests();
Console.WriteLine("done");
// cancel half of the service tasks when processing the requests
ThreadPool.QueueUserWorkItem(delegate
{
//wait 5 seconds to try cancel service tasks.
Thread.Sleep(3 * 1000);
try
{
Scheduler scheduler = new Scheduler();
try
{
scheduler.Connect(headnode);
}
catch (Exception e)
{
Console.WriteLine("Error connecting store.{0}", e.ToString());
return;
}
int jobId = session.GetProperty <int>("HPC_ServiceJobId");
ISchedulerJob job = scheduler.OpenJob(jobId);
job.Refresh();
ISchedulerCollection taskList = job.GetTaskList(null, null, true);
int onFlag = 0;
foreach (ISchedulerTask task in taskList)
{
// cancel half of the service tasks
if (onFlag++ % 2 == 0)
{
try
{
if (task.State == TaskState.Running)
{
Console.WriteLine("Try to cancel task {0}", task.TaskId);
job.CancelTask(task.TaskId);
job.Commit();
}
}
catch (Exception ex)
{
Console.WriteLine("Got exception when trying to cancel task {0}:{1}", task.TaskId, ex.Message);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine("Exception when trying to cancel the service tasks. {0}", ex.Message);
}
});
Console.WriteLine("Retrieving responses...");
try
{
int count = 0;
foreach (var response in client.GetResponses <EchoOnExitResponse>())
{
try
{
string reply = response.Result.EchoOnExitResult;
Console.WriteLine("\tReceived response for request {0}: {1}", response.GetUserData <int>(), reply);
count++;
}
catch (Exception ex)
{
Console.WriteLine("Error occured while processing {0}-th request: {1}", response.GetUserData <int>(), ex.Message);
}
}
Console.WriteLine("Done retrieving responses.{0}/{1} responses retrieved ", count, numRequests);
}
catch (SessionException ex)
{
Console.WriteLine("SessionException while getting responses: {0}", ex.Message);
}
catch (Exception ex)
{
Console.WriteLine("Exception while getting responses: {0}", ex.Message);
}
}
// Close connections and delete messages stored in the system
session.Close();
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
}
static void Main(string[] args)
{
//change the headnode name here
const string headnode = "[headnode]";
const string serviceName = "EchoService";
const int numRequests = 12;
SessionStartInfo startInfo = new SessionStartInfo(headnode, serviceName);
startInfo.BrokerSettings.SessionIdleTimeout = 15 * 60 * 1000;
startInfo.BrokerSettings.ClientIdleTimeout = 15 * 60 * 1000;
Console.Write("Creating a session for EchoService...");
// Create a durable session
int sessionId = 0;
DurableSession session = null;
bool successFlag = false;
int retryCount = 0;
const int retryCountMax = 20;
const int retryIntervalMs = 5000;
while (!successFlag && retryCount++ < retryCountMax)
{
try
{
session = DurableSession.CreateSession(startInfo);
successFlag = true;
}
catch (EndpointNotFoundException e)
{
Console.WriteLine("EndpointNotFoundException {0}", e.ToString());
}
catch (CommunicationException e)
{
Console.WriteLine("CommunicationException {0}", e.ToString());
}
catch (TimeoutException e)
{
Console.WriteLine("TimeoutException {0}", e.ToString());
}
catch (SessionException e)
{
Console.WriteLine("SessionException {0}, error code 0x{1:x}", e.ToString(), e.ErrorCode);
// if session fatal errors happen, no retry
if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.SessionFatalError))
{
Console.WriteLine("SessionExceptionCategory : SessionFatalError {0}", e.ToString());
Console.WriteLine("No retry.");
retryCount = retryCountMax;
continue;
}
}
catch (Exception e)
{
Console.WriteLine("General exception {0}", e.ToString());
}
if (!successFlag)
{
Console.WriteLine("=== Sleep {0} ms to retry. Retry count left {1}. ===", retryIntervalMs, retryCountMax - retryCount);
Thread.Sleep(retryIntervalMs);
}
}
if (!successFlag)
{
Console.WriteLine("Create durable session failed.");
return;
}
sessionId = session.Id;
Console.WriteLine("Done session id = {0}", sessionId);
//send requests
successFlag = false;
retryCount = 0;
const int sendTimeoutMs = 5000;
const int clientPurgeTimeoutMs = 60000;
while (!successFlag && retryCount++ < retryCountMax)
{
using (BrokerClient <IService1> client = new BrokerClient <IService1>(session))
{
Console.Write("Sending {0} requests...", numRequests);
try
{
for (int i = 0; i < numRequests; i++)
{
//client.SendRequest<EchoFaultRequest>(new EchoFaultRequest("dividebyzeroexception"), i, sendTimeoutMs);
client.SendRequest <EchoDelayRequest>(new EchoDelayRequest(5000), i, sendTimeoutMs);
}
client.EndRequests();
successFlag = true;
Console.WriteLine("done");
}
catch (TimeoutException e)
{
// Timeout exceptions
Console.WriteLine("TimeoutException {0}", e.ToString());
}
catch (CommunicationException e)
{
//CommunicationException
Console.WriteLine("CommunicationException {0}", e.ToString());
}
catch (SessionException e)
{
Console.WriteLine("SessionException {0}, error code 0x{1:x}", e.ToString(), e.ErrorCode);
if (SOAFaultCode.Broker_BrokerUnavailable == e.ErrorCode)
{
Console.WriteLine("SessionException : BrokerUnavailable {0}", e.ToString());
}
// Session Exceptions are unrecoverable unless they are application errors
if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.ApplicationError))
{
Console.WriteLine("SessionExceptionCategory : ApplicationError {0}", e.ToString());
}
// if session fatal errors happen, no retry
if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.SessionFatalError))
{
Console.WriteLine("SessionExceptionCategory : SessionFatalError {0}", e.ToString());
Console.WriteLine("No retry.");
retryCount = retryCountMax;
continue;
}
}
catch (Exception e)
{
//general exceptions
Console.WriteLine("Exception {0}", e.ToString());
}
//purge client if not succeeded, needed?
if (!successFlag)
{
try
{
client.Close(true, clientPurgeTimeoutMs);
}
catch (Exception e)
{
Console.WriteLine("Failed to purge the client after send request failure {0}", e.ToString());
}
}
}
if (!successFlag)
{
Console.WriteLine("=== Sleep {0} ms to retry. Retry count left {1}. ===", retryIntervalMs, retryCountMax - retryCount);
Thread.Sleep(retryIntervalMs);
}
}
if (!successFlag)
{
Console.WriteLine("Send requests failed.");
return;
}
//dispose the session here
session.Dispose();
//attach the session
SessionAttachInfo attachInfo = new SessionAttachInfo(headnode, sessionId);
successFlag = false;
retryCount = 0;
const int attachTimeoutMs = 15000;
while (!successFlag && retryCount++ < retryCountMax)
{
try
{
session = DurableSession.AttachSession(attachInfo);
successFlag = true;
}
catch (EndpointNotFoundException e)
{
Console.WriteLine("{0}", e.ToString());
}
catch (CommunicationException e)
{
Console.WriteLine("{0}", e.ToString());
}
catch (SessionException e)
{
Console.WriteLine("SessionException {0}, error code 0x{1:x}", e.ToString(), e.ErrorCode);
// if session fatal errors happen, no retry
if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.SessionFatalError))
{
Console.WriteLine("SessionExceptionCategory : SessionFatalError {0}", e.ToString());
Console.WriteLine("No retry.");
retryCount = retryCountMax;
continue;
}
}
catch (Exception e)
{
Console.WriteLine("General exception {0}", e.ToString());
}
if (!successFlag)
{
Console.WriteLine("=== Sleep {0} ms to retry. Retry count left {1}. ===", retryIntervalMs, retryCountMax - retryCount);
Thread.Sleep(retryIntervalMs);
}
}
if (!successFlag)
{
Console.WriteLine("Attach durable session failed.");
return;
}
successFlag = false;
retryCount = 0;
const int getTimeoutMs = 30000;
const int clientCloseTimeoutMs = 15000;
Console.WriteLine("Retrieving responses...");
while (!successFlag && retryCount++ < retryCountMax)
{
using (BrokerClient <IService1> client = new BrokerClient <IService1>(session))
{
// GetResponses from the runtime system
// EchoResponse class is created as you add Service Reference "EchoService" to the project
try
{
//foreach (var response in client.GetResponses<EchoFaultResponse>(getTimeoutMs))
foreach (var response in client.GetResponses <EchoDelayResponse>(getTimeoutMs))
{
try
{
//string reply = response.Result.EchoFaultResult ;
int reply = response.Result.EchoDelayResult;
Console.WriteLine("\tReceived response for delay request {0}: {1}", response.GetUserData <int>(), reply);
}
catch (FaultException <DivideByZeroException> e)
{
// Application exceptions
Console.WriteLine("FaultException<DivideByZeroException> {0}", e.ToString());
}
catch (FaultException e)
{
// Application exceptions
Console.WriteLine("FaultException {0}", e.ToString());
}
catch (RetryOperationException e)
{
// RetryOperationExceptions may or may not be recoverable
Console.WriteLine("RetryOperationException {0}", e.ToString());
}
}
successFlag = true;
Console.WriteLine("Done retrieving {0} responses", numRequests);
}
catch (TimeoutException e)
{
// Timeout exceptions
Console.WriteLine("TimeoutException {0}", e.ToString());
}
catch (CommunicationException e)
{
//CommunicationException
Console.WriteLine("CommunicationException {0}", e.ToString());
}
catch (SessionException e)
{
Console.WriteLine("SessionException {0}, error code 0x{1:x}", e.ToString(), e.ErrorCode);
if (SOAFaultCode.Broker_BrokerUnavailable == e.ErrorCode)
{
Console.WriteLine("SessionException : BrokerUnavailable {0}", e.ToString());
}
// Session Exceptions are unrecoverable unless they are application errors
if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.ApplicationError))
{
Console.WriteLine("SessionExceptionCategory : ApplicationError {0}", e.ToString());
}
// if session fatal errors happen, no retry
if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.SessionFatalError))
{
Console.WriteLine("SessionExceptionCategory : SessionFatalError {0}", e.ToString());
Console.WriteLine("No retry.");
retryCount = retryCountMax;
continue;
}
}
catch (Exception e)
{
//general exceptions
Console.WriteLine("Exception {0}", e.ToString());
}
try
{
client.Close(false, clientCloseTimeoutMs);
}
catch (Exception e)
{
Console.WriteLine("Exception", e.ToString());
}
}
if (!successFlag)
{
Console.WriteLine("=== Sleep {0} ms to retry. Retry count left {1}. ===", retryIntervalMs, retryCountMax - retryCount);
Thread.Sleep(retryIntervalMs);
}
}
//explict close the session to free the resource
successFlag = false;
retryCount = 0;
Console.WriteLine("Close the session...");
while (!successFlag && retryCount++ < retryCountMax)
{
try
{
session.Close(true);
successFlag = true;
}
catch (SessionException e)
{
Console.WriteLine("SessionException {0}, error code 0x{1:x}", e.ToString(), e.ErrorCode);
// if session fatal errors happen, no retry
if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.SessionFatalError))
{
Console.WriteLine("SessionExceptionCategory : SessionFatalError {0}", e.ToString());
Console.WriteLine("No retry.");
retryCount = retryCountMax;
continue;
}
}
catch (Exception e)
{
Console.WriteLine("{0}", e.ToString());
}
if (!successFlag)
{
Console.WriteLine("=== Sleep {0} ms to retry. Retry count left {1}. ===", retryIntervalMs, retryCountMax - retryCount);
Thread.Sleep(retryIntervalMs);
}
}
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}