private void CreateDocumentOnEachNode(SubscriptionMessage subscription)
{
foreach (var member in cluster.ReadView.Members)
{
var props =
Props.Create(
() =>
new EventSubscribingAtomDocumentActor(new AtomDocumentSettings()));
var nameOfActorToDeployOnNode = $"atomActor_{member.Address.GetHashCode()}_{subscriptionMessage.SubscriptionId.Id}";
LogTraceInfo($"About to deploy actor with name {nameOfActorToDeployOnNode} onto node {member.Address}");
var atomDocument =
Context.ActorOf(
props
.WithDeploy(
new Deploy(
new RemoteScope(member.Address))), nameOfActorToDeployOnNode);
atomDocument.Tell(
new CreateAtomDocumentCommand(
"", "", headDocumentIdForFeed, Context.Self));
documentActors.Add(atomDocument);
LogTraceInfo($"Subscription Actor deployed with address {atomDocument.Path} ");
}
}
/// <summary>
/// Initializes the connection.
/// </summary>
/// <param name="brokerAddress">The brokerAddress<see cref="string"/></param>
/// <param name="user">The user<see cref="string"/></param>
/// <param name="pass">The pass<see cref="string"/></param>
/// <param name="secret">The secret<see cref="string"/></param>
private static async Task InitBrokerConnection(string brokerAddress, string user, string pass, string secret)
{
try
{
client = NanomiteClient.CreateGrpcClient(brokerAddress, user);
client.OnConnected = async() =>
{
var subscriptionMessage = new SubscriptionMessage()
{
Topic = "SetLogLevel"
};
await client.SendCommandAsync(subscriptionMessage, StaticCommandKeys.Subscribe);
};
client.OnCommandReceived = (cmd, c) =>
{
switch (cmd.Topic)
{
case "SetLogLevel":
var level = cmd.Data[0].CastToModel <LogLevelInfo>()?.Level;
LoggingLevel = (int)(LogLevel)System.Enum.Parse(typeof(LogLevel), level);
break;
}
};
await client.ConnectAsync(user, pass, secret, true);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Checks the subscription type, and if it is 'Add', then adds the subscriber.
/// </summary>
/// <param name="msg">The message to handle.</param>
/// <param name="messageType">The message type being subscribed to.</param>
/// <param name="subMessage">A subscription message.</param>
/// <param name="updateQueue">Whether or not to update the subscription persistence store.</param>
private void HandleAddSubscription(TransportMessage msg, Type messageType, SubscriptionMessage subMessage, bool updateQueue)
{
if (subMessage.SubscriptionType == SubscriptionType.Add)
{
lock (this.locker)
{
// if already subscribed, do nothing
foreach (Entry e in this.entries)
{
if (e.Matches(messageType) && e.Subscriber == msg.ReturnAddress)
{
return;
}
}
if (updateQueue)
{
this.Add(msg.ReturnAddress, subMessage.TypeName);
}
this.entries.Add(new Entry(messageType, msg));
log.Debug("Subscriber " + msg.ReturnAddress + " added for message " + messageType.FullName + ".");
}
}
}
/// <summary>
/// Sends tick data unsubscription request to Market Data Service using the base class
/// </summary>
public void UnsubscribeTickData()
{
try
{
// Get new ID to be used
var id = (_tickDataId++).ToString("X");
// Get new Security object
Security security = new Security {
Symbol = _symbol
};
// Get Tick subscription message
var subscribe = SubscriptionMessage.TickUnsubscription(id, security, _marketDataProvider);
if (Logger.IsInfoEnabled)
{
Logger.Info("Sending tick data unsubscription request for: " + subscribe, _type.FullName,
"UnsubscribeTickData");
}
// Send unsubscription request
Unsubscribe(subscribe);
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "UnsubscribeTickData");
}
}
internal void SendSubscriptionMessage(Type messageType, string destinationQueue, SubscribeAction subscribeAction)
{
if (messageType == null)
{
throw new ArgumentNullException("messageType", "A message type must be specified in order to subscribe/unsubscribe");
}
if (configureAdditionalBehavior.OneWayClientMode)
{
throw new InvalidOperationException(
"You cannot Subscribe/Unsubscribe when running in one-way client mode, because" +
" there's no way for the bus to receive anything from the publisher.");
}
var message = new SubscriptionMessage
{
Type = messageType.AssemblyQualifiedName,
Action = subscribeAction,
};
InternalSend(new List <string> {
destinationQueue
}, new List <object> {
message
});
}
/// <summary>
/// This method is used by <see cref="IReceiveDataProcessor" /> to dispatch received messages
/// </summary>
/// <param name="topicMessage">Message received from server</param>
public void OnMessageReceived(TopicMessage topicMessage)
{
try
{
ThrowIfDisposed();
var subscriptionMessage = new SubscriptionMessage
{
MessageId = topicMessage.Id,
Data = topicMessage.Data,
TopicRoute = topicMessage.Route,
TopicName = topicMessage.TopicName
};
subscriptionMessage.OnMessageProcessedByClient += OnMessageProcessedByClient;
MessageReceived?.Invoke(subscriptionMessage);
}
// if message process failed then mark it as nacked
catch
{
var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromMinutes(1));
OnMessageProcessedByClient(topicMessage.Id, false, cancellationTokenSource.Token);
}
}
/// <summary>
/// Sends subscription request to Market Data Server
/// </summary>
/// <param name="security">Contains symbol information</param>
/// <param name="providerName">Name of the provider on which to subscribe</param>
public void Subscribe(Security security, string providerName)
{
// Create subscription message
Subscribe subscribe = SubscriptionMessage.TickSubscription(_idGenerator.NextTickId(), security, providerName);
_marketDataService.Subscribe(subscribe);
}
private void MutateInternalState(SubscriptionMessage message)
{
this.subscriptionMessage = message;
LoggingAdapter.Debug("Persist finished " + subscriptionMessage.SubscriptionId.Id);
SubscribeToClusterWideBroadcastDomainEvent();
}
/// <summary>
/// Sends un-subscription request to Market Data Server
/// </summary>
/// <param name="security">Contains symbol information</param>
/// <param name="providerName">Name of the provider on which to unsubscribe</param>
public void Unsubscribe(Security security, string providerName)
{
// Create unsubscription message
Unsubscribe unsubscribe = SubscriptionMessage.TickUnsubscription("", security, providerName);
_marketDataService.Unsubscribe(unsubscribe);
}
public void TicksMarketDataTestCase()
{
_dataHandler = new DataHandler();
bool tickArrived = false;
ManualResetEvent tickArrivedEvent = new ManualResetEvent(false);
// Get new Security object
Security security = new Security {
Symbol = "ERX"
};
// Get Tick subscription message
var subscribe = SubscriptionMessage.TickSubscription("001", security, "SimulatedExchange");
_dataHandler.TickReceived += delegate(Tick obj)
{
tickArrived = true;
tickArrivedEvent.Set();
};
_dataHandler.SubscribeSymbol(subscribe);
tickArrivedEvent.WaitOne(2000);
Assert.IsTrue(tickArrived);
}
public void ShouldExposeMessageIntentForSubscriptionMessages()
{
var message = new SubscriptionMessage(new EndpointAddress("recipient"), typeof(ValueCommand).FullName);
var testee = this.CreateTestee(message);
testee.MessageIntent.Should().Be(MessageIntent.SubscriptionMessage);
}
/// <summary>
/// Sends live bar subscription request to Market Data Service using the base class
/// </summary>
public void SubscribeLiveBars()
{
try
{
// Get new ID to be used
var id = (_liveBarId++).ToString("X");
// Get new Security object
Security security = new Security {
Symbol = _symbol
};
// Get Bar subscription message
_barSubscribeRequest = SubscriptionMessage.LiveBarSubscription(id, security, _barFormat, _barPriceType,
BarLength, 0.0001M, 0, _marketDataProvider);
if (Logger.IsInfoEnabled)
{
Logger.Info("Sending live bar subscription request for: " + _barSubscribeRequest, _type.FullName,
"SubscribeLiveBars");
}
// Send subscription request
Subscribe(_barSubscribeRequest);
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "SubscribeLiveBars");
}
}
public void LiveBarsMarketDataTestCase()
{
_dataHandler = new DataHandler();
bool barArrived = false;
ManualResetEvent barArrivedEvent = new ManualResetEvent(false);
// Get new Security object
Security security = new Security {
Symbol = "ERX"
};
// Get Bar subscription message
BarDataRequest barSubscribeRequest = SubscriptionMessage.LiveBarSubscription("001", security, BarFormat.TIME,
BarPriceType.LAST, 60, 0.0001M,
0, "SimulatedExchange");
_dataHandler.BarReceived += delegate(Bar obj)
{
barArrived = true;
barArrivedEvent.Set();
};
_dataHandler.SubscribeSymbol(barSubscribeRequest);
barArrivedEvent.WaitOne(2000);
Assert.IsTrue(barArrived);
}
private void MutateInternalState(SubscriptionMessage subscription)
{
this.subscriptionMessage = subscription;
headDocumentIdForFeed = new DocumentId(subscription.SubscriptionId.Id, 0);
CreateFeedActor(subscription);
}
/// <summary>
/// Overriden to provides additional funtionality for base class function 'Stop()'
/// </summary>
protected override void OnStop()
{
foreach (var subscribe in _subscriptionList)
{
Unsubscribe unsubscribe = SubscriptionMessage.TickUnsubscription(_idGenerator.NextTickId(), subscribe.Security, subscribe.MarketDataProvider);
Unsubscribe(unsubscribe);
}
}
/// <summary>
/// Sends request for live tick data
/// </summary>
/// <param name="id">Unique ID to distinguish the request</param>
/// <param name="security">Contains symbol information</param>
private void RequestTickData(string id, Security security)
{
// Get Tick subscription message
Subscribe subscribe = SubscriptionMessage.TickSubscription(id, security, _marketDataProvider);
// Send subscription request
this.Subscribe(subscribe);
}
/// <summary>
/// Sends bar un-subscription request to Market Data Server
/// </summary>
/// <param name="security">Contains symbol information</param>
/// <param name="barDetail">Contains parameter information for the bar to be subscribed</param>
/// <param name="providerName">Name of the provider on which to subscribe</param>
public void UnsubscribeBar(Security security, BarParameters barDetail, string providerName)
{
// Create bar un-subscription message
BarDataRequest unsubscribe = SubscriptionMessage.LiveBarUnsubscription(_idGenerator.NextBarId(), security,
barDetail.Format, barDetail.PriceType, barDetail.BarLength, barDetail.PipSize, 0, providerName);
_marketDataService.Unsubscribe(unsubscribe);
}
/// <summary>
/// Sends request for live tick data
/// </summary>
/// <param name="id">Unique ID to distinguish the request</param>
/// <param name="security">Contains symbol information</param>
/// <param name="marketDataProider">Market Data Provider from which to receive data</param>
private void RequestTickData(string id, Security security, string marketDataProider)
{
Subscribe subscribe = SubscriptionMessage.TickSubscription(id, security, marketDataProider);
_subscriptionList.Add(subscribe);
base.Subscribe(subscribe);
}
public async Task SubscribeToOrders()
{
_requestId++;
var subscriptionMessage = new SubscriptionMessage("orderSubscription", _requestId);
await Writer.WriteLineAsync(subscriptionMessage.ToJson());
_subscriptionMessages.Add(_requestId, subscriptionMessage);
}
public void SendMessage(SubscriptionMessage message)
{
StringContent messageAsString = new StringContent(JsonConvert.SerializeObject(message));
foreach (string uri in callbackUris)
{
var r = sender.PostAsync(uri, messageAsString);
}
}
/// <summary>
/// Sends request to receive live bars
/// </summary>
/// <param name="id">Unique ID to distinguish the request</param>
/// <param name="security">Contains symbol information</param>
/// <param name="length">Bar length in seconds</param>
/// <param name="pipSize">Smallest pip size for the bars</param>
/// <param name="barSeed">Seed value to be used for bar generation</param>
private void RequestLiveBars(string id, Security security, decimal length, decimal pipSize, decimal barSeed)
{
// Create Live Bar request message
BarDataRequest barDataRequest = SubscriptionMessage.LiveBarSubscription(id, security, BarFormat.TIME,
BarPriceType.LAST, length, pipSize, barSeed, _marketDataProvider);
// Send live bar request
base.Subscribe(barDataRequest);
}
/// <summary>
/// Sends request for live tick data
/// </summary>
/// <param name="id">Unique ID to distinguish the request</param>
/// <param name="security">Contains symbol information</param>
private void RequestTickData(string id, Security security)
{
Console.WriteLine("#############################################CW->Symbol Value Tick Data=" + security.Symbol);
// Get Tick subscription message
Subscribe subscribe = SubscriptionMessage.TickSubscription(id, security, _marketDataProvider);
// Send subscription request
this.Subscribe(subscribe);
}
public async Task ShouldInvokeGivenFinalActionForSubscriptionMessage()
{
var message = new SubscriptionMessage(new EndpointAddress("recipient"), typeof(ValueCommand).FullName);
var incommingMessageContext = CreateIncommingMessageContext(message);
await this.testee.InvokeAsync(incommingMessageContext, null).ConfigureAwait(false);
A.CallTo(() => this.finalActionForSubscriptionMessage.Invoke(message)).MustHaveHappened();
}
public void Subscribe(string destination)
{
var message = new SubscriptionMessage
{
Topic = destination
};
_websocket.Send(_serializer.Serialize(message));
}
/// <summary>
/// Sends Historical bar data request to Market Data Server
/// </summary>
/// <param name="security">Contains symbol information</param>
/// <param name="barDetail">Contains parameter information for the historical bars to be fetched</param>
/// <param name="providerName">Name of the provider on which to subscribe</param>
public void SubscribeHistoricalData(Security security, HistoricalBarParameters barDetail, string providerName)
{
// Create bar subscription message
HistoricDataRequest subscribe =
SubscriptionMessage.HistoricDataSubscription(_idGenerator.NextHistoricalDataId(), security,
barDetail.StartDate, barDetail.EndDate, barDetail.Interval, barDetail.Type, providerName);
_historicalDataService.Subscribe(subscribe);
}
private string ProcessDiscountMessage(string message)
{
SubscriptionMessage response = JsonConvert.DeserializeObject <SubscriptionMessage>(message);
double discount = response.discountData.Discount;
List <Merchandise> responseProducts = response.discountData.Merchandises.FromCommModel();
_repository.RefreshMerchandises(responseProducts);
return("discount: " + Math.Round(discount * 100.0, 2).ToString() + " %");
}
/// <summary>
/// Sends request to retrieve historical bar data
/// </summary>
/// <param name="id">Unique ID to distinguish the request</param>
/// <param name="security">Contains symbol information</param>
/// <param name="startTime">Time from which to start the historical bar data</param>
/// <param name="endTime">Time at which the historical bar data should end</param>
/// <param name="interval">Bar interval</param>
private void RequestHistoricalBarData(string id, Security security, DateTime startTime, DateTime endTime, uint interval)
{
// Create Historical Bar request message
HistoricDataRequest historicBarDataRequest = SubscriptionMessage.HistoricDataSubscription(id, security,
startTime, endTime, interval, BarPriceType.LAST, _historicalDataProvider);
// Send historical bar request
this.Subscribe(historicBarDataRequest);
}
private static void CreateSubscriptionMessageEnvelope(
SubscriptionMessage subscriptionMessage,
IHavePipelineConfiguration configuration,
Action <EndpointAddress> createEnvelope)
{
var endpointAddress = configuration.GetPublishingEndpointAddress(subscriptionMessage.MessageType);
createEnvelope(endpointAddress);
}
void InternalSubscribe <TMessage>(string publisherInputQueue)
{
var message = new SubscriptionMessage {
Type = typeof(TMessage).AssemblyQualifiedName
};
InternalSend(publisherInputQueue, new List <object> {
message
});
}
public async Task Subscribe(MarketFilter marketFilter, MarketDataFilter dataFilter)
{
_requestId++;
var subscriptionMessage = new SubscriptionMessage("marketSubscription", _requestId)
.WithMarketFilter(marketFilter)
.WithMarketDataFilter(dataFilter);
await Writer.WriteLineAsync(subscriptionMessage.ToJson());
_subscriptionMessages.Add(_requestId, subscriptionMessage);
}
public void CreateSubscriptionFOrTestRun()
{
subscriptionMessage = new SubscriptionMessage(
new AtomNotificationChannel(),
new SubscriptionId(Guid.NewGuid().ToString()),
new AllEventMatcher());
atomNotifiers[0].Create(subscriptionMessage);
Thread.Sleep(TimeSpan.FromSeconds(1));
}
public static void SetupActorSystem()
{
var actorSystem = factory.GetActorSystem();
ShardedAtomDocumentFactory atomDocumentFactory = new ShardedAtomDocumentFactory(actorSystem);
ShardedAtomFeedFactory actorFactory = new ShardedAtomFeedFactory(actorSystem, atomDocumentFactory, new ConfigurableAtomDocumentSettings(10));
_notifier = new AtomEventNotifier(actorFactory);
_retriever = new AtomDocumentRetriever(actorFactory, atomDocumentFactory);
subscriptionMessage = new SubscriptionMessage(
new AtomNotificationChannel(),
new SubscriptionId(Guid.NewGuid().ToString()),
new AllEventMatcher());
_notifier.Create(subscriptionMessage);
}
public void Subscribe(string subscribingEndpointName)
{
var subscriptions = Config.SubscriptionSection.Section.Subscriptions;
foreach (Config.SubscriptionElement subscription in subscriptions)
{
var subscriptionMessage = new SubscriptionMessage
{
Endpoint = $"{subscribingEndpointName}@{Environment.MachineName}"
};
var destination = EndpointAddress.Parse(subscription.Endpoint);
log.VerboseFormat("Subscribing to: {0}", destination);
var serializer = new XmlMessageSerializer();
var sendingChannel = SendingChannelResolver.GetChannel();
sendingChannel.Send(destination, ChannelMessageFactory.CreateChannelMessage(subscriptionMessage, serializer));
}
}
