/// <summary>
/// Display element properties
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void treeViewSchema_AfterSelect(object sender, TreeViewEventArgs e)
{
TreeNode node = e.Node;
SchemaElementDefinition def = null;
// clear properties list
listViewProperties.Items.Clear();
richTextBoxDescription.Text = string.Empty;
if (node.Tag != null)
{
// get element definition
def = node.Tag as SchemaElementDefinition;
// get description
if (def.Description != null)
{
richTextBoxDescription.Text = def.Description;
}
// add properties to list
ListViewItem property = listViewProperties.Items.Add("Name:");
property.SubItems.Add(def.Name.ToString());
property = listViewProperties.Items.Add("Status:");
property.SubItems.Add(def.Status.ToString());
property = listViewProperties.Items.Add("Type:");
property.SubItems.Add(def.TypeDefinition.Datatype.ToString());
if (def.TypeDefinition.IsEnumerationType)
{
foreach (Constant item in def.TypeDefinition.Enumeration.Values)
{
ListViewItem enumDisplay = listViewProperties.Items.Add("");
enumDisplay.SubItems.Add(item.GetValueAsString());
}
}
property = listViewProperties.Items.Add("Minimal Occurence:");
property.SubItems.Add(def.MinValues.ToString());
property = listViewProperties.Items.Add("Maximal Occurence:");
property.SubItems.Add(def.MaxValues.ToString());
property = listViewProperties.Items.Add("Constraints:");
if (def.Constraints != null)
{
foreach (Constraint item in def.Constraints.Values)
{
ListViewItem enumDisplay = listViewProperties.Items.Add("");
enumDisplay.SubItems.Add(item.ConstraintType.ToString());
}
}
}
}
public void run(String[] args)
{
Session session = null;
if (!ParseCommandLine(args))
{
return;
}
try
{
session = CreateSession();
if (!session.Start())
{
System.Console.Error.WriteLine("Failed to start session.");
return;
}
if (!session.OpenService(serviceName))
{
System.Console.Error.WriteLine("Failed to open service :" + serviceName);
return;
}
Service service = session.GetService(serviceName);
// Dump schema for the service
Console.WriteLine("Schema for service:" + serviceName + "\n\n");
for (int i = 0; i < service.NumEventDefinitions; ++i)
{
SchemaElementDefinition eventDefinition = service.GetEventDefinition(i);
Console.WriteLine(eventDefinition);
}
Console.WriteLine("");
}
catch (Exception ex)
{
Console.WriteLine("Failed to send Subscription due to error :" + ex.Message);
}
finally
{
session.Stop();
}
}
public void Run(String[] args)
{
if (!ParseCommandLine(args))
{
return;
}
SessionOptions.ServerAddress[] servers
= new SessionOptions.ServerAddress[d_hosts.Count];
for (int i = 0; i < d_hosts.Count; ++i)
{
servers[i] = new SessionOptions.ServerAddress(d_hosts[i], d_port);
}
SessionOptions sessionOptions = new SessionOptions();
sessionOptions.ServerAddresses = servers;
sessionOptions.AuthenticationOptions = d_authOptions;
sessionOptions.AutoRestartOnDisconnection = true;
sessionOptions.NumStartAttempts = servers.Length;
Console.Write("Connecting to");
foreach (SessionOptions.ServerAddress server in sessionOptions.ServerAddresses)
{
Console.Write(" " + server);
}
Console.WriteLine();
ProviderSession session = new ProviderSession(sessionOptions, ProcessEvent);
if (!session.Start())
{
Console.Error.WriteLine("Failed to start session");
return;
}
Identity identity = null;
if (d_authOptions != null)
{
bool isAuthorized = false;
identity = session.CreateIdentity();
if (session.OpenService("//blp/apiauth"))
{
Service authService = session.GetService("//blp/apiauth");
if (Authorize(authService, identity, session, new CorrelationID()))
{
isAuthorized = true;
}
}
if (!isAuthorized)
{
System.Console.Error.WriteLine("No authorization");
return;
}
}
ServiceRegistrationOptions serviceRegistrationOptions
= new ServiceRegistrationOptions();
serviceRegistrationOptions.GroupId = d_groupId;
serviceRegistrationOptions.ServicePriority = d_priority;
if (d_useSsc)
{
Console.WriteLine(
String.Format(
"Activating sub service code range [{0}, {1}] "
+ "@ priority: {2}",
d_sscBegin,
d_sscEnd,
d_sscPriority));
try {
serviceRegistrationOptions.AddActiveSubServiceCodeRange(
d_sscBegin,
d_sscEnd,
d_sscPriority);
} catch (Exception e) {
Console.WriteLine(
"FAILED to add active sub service codes. Exception " + e);
}
}
bool wantAsyncRegisterService = true;
if (wantAsyncRegisterService)
{
Object registerServiceResponseMonitor = new Object();
CorrelationID registerCID = new CorrelationID(registerServiceResponseMonitor);
lock (registerServiceResponseMonitor)
{
if (d_verbose > 0)
{
Console.WriteLine("start registerServiceAsync, cid = " + registerCID);
}
session.RegisterServiceAsync(
d_service,
identity,
registerCID,
serviceRegistrationOptions);
for (int i = 0; d_registerServiceResponse == null && i < 10; ++i)
{
Monitor.Wait(registerServiceResponseMonitor, 1000);
}
}
}
else
{
bool result = session.RegisterService(
d_service,
identity,
serviceRegistrationOptions);
d_registerServiceResponse = result;
}
Service service = session.GetService(d_service);
if (service != null && d_registerServiceResponse == true)
{
Console.WriteLine("Service registered: " + d_service);
}
else
{
Console.Error.WriteLine("Service registration failed: " + d_service);
return;
}
// Dump schema for the service
if (d_verbose > 1)
{
Console.WriteLine("Schema for service:" + d_service);
for (int i = 0; i < service.NumEventDefinitions; ++i)
{
SchemaElementDefinition eventDefinition = service.GetEventDefinition(i);
Console.WriteLine(eventDefinition);
}
}
// Now we will start publishing
int eventCount = 0;
long tickCount = 1;
while (d_running)
{
Event eventObj;
lock (d_topicSet)
{
if (d_topicSet.Count == 0)
{
Monitor.Wait(d_topicSet, 100);
}
if (d_topicSet.Count == 0)
{
continue;
}
eventObj = service.CreatePublishEvent();
EventFormatter eventFormatter = new EventFormatter(eventObj);
bool publishNull = false;
if (d_clearInterval > 0 && eventCount == d_clearInterval)
{
eventCount = 0;
publishNull = true;
}
foreach (Topic topic in d_topicSet.Keys)
{
if (!topic.IsActive())
{
System.Console.WriteLine("[WARNING] Publishing on an inactive topic.");
}
eventFormatter.AppendMessage("MarketDataEvents", topic);
if (publishNull)
{
eventFormatter.SetElementNull("HIGH");
eventFormatter.SetElementNull("LOW");
}
else
{
++eventCount;
if (1 == tickCount)
{
eventFormatter.SetElement("BEST_ASK", 100.0);
}
else if (2 == tickCount)
{
eventFormatter.SetElement("BEST_BID", 99.0);
}
eventFormatter.SetElement("HIGH", 100 + tickCount * 0.01);
eventFormatter.SetElement("LOW", 100 - tickCount * 0.005);
++tickCount;
}
}
}
foreach (Message msg in eventObj)
{
Console.WriteLine(msg);
}
session.Publish(eventObj);
Thread.Sleep(10 * 1000);
if (tickCount % 3 == 0)
{
Deactivate(session);
Thread.Sleep(10 * 1000);
Activate(session);
}
}
session.Stop();
}
public void Run(String[] args)
{
if (!ParseCommandLine(args))
{
return;
}
SessionOptions.ServerAddress[] servers = new SessionOptions.ServerAddress[d_hosts.Count];
for (int i = 0; i < d_hosts.Count; ++i)
{
servers[i] = new SessionOptions.ServerAddress(d_hosts[i], d_port);
}
SessionOptions sessionOptions = new SessionOptions();
sessionOptions.ServerAddresses = servers;
sessionOptions.AuthenticationOptions = d_authOptions;
sessionOptions.AutoRestartOnDisconnection = true;
sessionOptions.NumStartAttempts = servers.Length;
System.Console.Write("Connecting to");
foreach (SessionOptions.ServerAddress server in sessionOptions.ServerAddresses)
{
System.Console.Write(" " + server);
}
System.Console.WriteLine();
ProviderSession session = new ProviderSession(sessionOptions, ProcessEvent);
if (!session.Start())
{
System.Console.Error.WriteLine("Failed to start session");
return;
}
Identity identity = null;
if (d_authOptions.Length != 0)
{
Object tokenResponseMonitor = new Object();
lock (tokenResponseMonitor)
{
session.GenerateToken(new CorrelationID(tokenResponseMonitor));
long waitTime = 10 * 1000;
long tokenResponseTimeout = System.DateTime.Now.Ticks / 10000 + waitTime;
while (d_tokenGenerationResponse == null && waitTime > 0)
{
Monitor.Wait(tokenResponseMonitor, (int)waitTime);
waitTime = tokenResponseTimeout - System.DateTime.Now.Ticks / 10000;
}
if (d_tokenGenerationResponse == null)
{
System.Console.Error.WriteLine("Timeout waiting for token");
System.Environment.Exit(1);
}
else if (d_tokenGenerationResponse == false || d_token == null)
{
System.Console.Error.WriteLine("Token generation failed");
System.Environment.Exit(1);
}
}
Object authorizationResponseMonitor = new Object();
if (session.OpenService("//blp/apiauth"))
{
Service authService = session.GetService("//blp/apiauth");
Request authRequest = authService.CreateAuthorizationRequest();
authRequest.Set("token", d_token);
identity = session.CreateIdentity();
d_authorizationResponseCorrelationId =
new CorrelationID(authorizationResponseMonitor);
lock (authorizationResponseMonitor)
{
session.SendAuthorizationRequest(
authRequest,
identity,
d_authorizationResponseCorrelationId);
long waitTime = 60 * 1000;
long authorizationResponseTimeout = System.DateTime.Now.Ticks / 10000 + waitTime;
while (d_authorizationResponse == null && waitTime > 0)
{
Monitor.Wait(authorizationResponseMonitor, 1000);
waitTime = authorizationResponseTimeout - System.DateTime.Now.Ticks / 10000;
}
if (d_authorizationResponse == null)
{
System.Console.Error.WriteLine("Timeout waiting for authorization");
System.Environment.Exit(1);
}
else if (d_authorizationResponse == false)
{
System.Console.Error.WriteLine("Authorization failed");
System.Environment.Exit(1);
}
}
}
}
ServiceRegistrationOptions serviceRegistrationOptions = new ServiceRegistrationOptions();
serviceRegistrationOptions.GroupId = d_groupId;
serviceRegistrationOptions.ServicePriority = d_priority;
bool wantAsyncRegisterService = true;
if (wantAsyncRegisterService)
{
Object registerServiceResponseMonitor = new Object();
CorrelationID registerCID = new CorrelationID(registerServiceResponseMonitor);
lock (registerServiceResponseMonitor)
{
if (d_verbose > 0)
{
System.Console.WriteLine("start registerServiceAsync, cid = " + registerCID);
}
session.RegisterServiceAsync(d_service, identity, registerCID, serviceRegistrationOptions);
for (int i = 0; d_registerServiceResponse == null && i < 10; ++i)
{
Monitor.Wait(registerServiceResponseMonitor, 1000);
}
}
}
else
{
bool result = session.RegisterService(d_service, identity, serviceRegistrationOptions);
d_registerServiceResponse = result;
}
Service service = session.GetService(d_service);
if (service != null && d_registerServiceResponse == true)
{
System.Console.WriteLine("Service registered: " + d_service);
}
else
{
System.Console.Error.WriteLine("Service registration failed: " + d_service);
System.Environment.Exit(1);
}
// Dump schema for the service
if (d_verbose > 1)
{
System.Console.WriteLine("Schema for service:" + d_service);
for (int i = 0; i < service.NumEventDefinitions; ++i)
{
SchemaElementDefinition eventDefinition = service.GetEventDefinition(i);
System.Console.WriteLine(eventDefinition);
}
}
// Now we will start publishing
long tickCount = 1;
while (g_running)
{
Event eventObj;
lock (d_topicSet)
{
if (d_topicSet.Count == 0)
{
Monitor.Wait(d_topicSet, 100);
}
if (d_topicSet.Count == 0)
{
continue;
}
eventObj = service.CreatePublishEvent();
EventFormatter eventFormatter = new EventFormatter(eventObj);
foreach (Topic topic in d_topicSet.Keys)
{
if (!topic.IsActive())
{
continue;
}
eventFormatter.AppendMessage("MarketDataEvents", topic);
if (1 == tickCount)
{
eventFormatter.SetElement("BEST_ASK", 100.0);
}
else if (2 == tickCount)
{
eventFormatter.SetElement("BEST_BID", 99.0);
}
eventFormatter.SetElement("HIGH", 100 + tickCount * 0.01);
eventFormatter.SetElement("LOW", 100 - tickCount * 0.005);
++tickCount;
}
}
foreach (Message msg in eventObj)
{
System.Console.WriteLine(msg);
}
session.Publish(eventObj);
Thread.Sleep(10 * 1000);
}
session.Stop();
}
