private async Task <ChannelCredentials> FindAndUpdateCurrentIndexAsync(Seed seed, int index)
{
while (true)
{
var subSeed = new Seed(Converter.TritsToTrytes(this.SigningHelper.GetSubseed(seed, index)));
var channelSeed = new Seed((await this.AddressGenerator.GetAddressAsync(subSeed, SecurityLevel.Low, ChannelSeedIndex)).Value);
var channelKey = (await this.AddressGenerator.GetAddressAsync(subSeed, SecurityLevel.Low, ChannelKeyIndex)).Value;
var rootHash = CurlMerkleTreeFactory.Default.Create(channelSeed, 0, 1, IotaFhirRepository.SecurityLevel).Root.Hash;
var credentials = new ChannelCredentials {
Seed = channelSeed, ChannelKey = channelKey, RootHash = rootHash
};
// Check if the index was used by another application. If not, return the corresponding channel credentials
var subscription = this.SubscriptionFactory.Create(rootHash, Mode.Restricted, channelKey, true);
var message = await subscription.FetchSingle(rootHash);
if (message == null)
{
await this.SetCurrentSubSeedIndexAsync(seed, index);
await this.ImportChannelWriteAccessAsync(credentials);
return(credentials);
}
await this.ImportChannelWriteAccessAsync(credentials);
SubscriptionAdded?.Invoke(this, new SubscriptionAddedEventArgs(rootHash.Value.Substring(0, 64), seed));
// The index is already in use. Increment by one and check that in the next round of the loop
index++;
}
}
public void BecauseOf()
{
var info = new SubscriptionInformation(_clientId, 0, "", "", _dataUri);
var message = new SubscriptionAdded {
Subscription = info
};
var saga = new LegacySubscriptionClientSaga(_clientId);
saga.Bus = new NullServiceBus();
var data = new OldCacheUpdateRequest(_dataUri);
saga.RaiseEvent(LegacySubscriptionClientSaga.OldCacheUpdateRequested, data);
IEnumerable <LegacySubscriptionClientSaga> sagas = new List <LegacySubscriptionClientSaga>
{
saga
};
MockRepo.Stub(r => r.Where(s => s.CurrentState == LegacySubscriptionClientSaga.Active)).IgnoreArguments().Return(sagas);
MockEndpointFactory.Expect(e => e.GetEndpoint(saga.Bus.Endpoint.Uri)).Return(saga.Bus.Endpoint);
Service.Consume(message);
}
public void OnSubscriptionAdded(SubscriptionAdded message)
{
if (_ignoredMessageTypes.Contains(message.MessageName))
{
return;
}
WithTarget(x =>
{
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Send AddPeerSubscription: {0}, {1}", _peerId, message.MessageName);
}
x.Send(new AddPeerSubscriptionMessage
{
PeerId = _peerId,
MessageNumber = ++_messageNumber,
EndpointUri = message.EndpointUri,
MessageName = message.MessageName,
SubscriptionId = message.SubscriptionId,
CorrelationId = message.CorrelationId,
});
});
}
public void Consume(SubscriptionAdded message)
{
_log.Debug(() => string.Format("Subscription Added: {0} [{1}]", message.Subscription, message.Subscription.CorrelationId));
var add = new AddSubscription(message.Subscription);
SendToClients(add);
}
public void Consume(SubscriptionAdded message)
{
_log.InfoFormat("Proxy New to Old Add Subscription: {0}", message.Subscription);
var add = new AddSubscription(message.Subscription.MessageName, message.Subscription.EndpointUri);
SendToClients(add);
}
public void OnSubscriptionAdded(SubscriptionAdded message)
{
_connectionCache[message.SubscriptionId] = _cache.Connect(message.MessageName, message.EndpointUri,
message.CorrelationId);
if (_log.IsInfoEnabled)
_log.InfoFormat("Added: {0} => {1}, {2}", message.MessageName, message.EndpointUri,
message.SubscriptionId);
}
public void OnSubscriptionAdded(SubscriptionAdded message)
{
if (message == null)
throw new ArgumentNullException("message");
var messageName = GetMessageName(message);
_bindings[message.SubscriptionId] = new TopicDescriptionImpl(messageName.ToString());
_bindings.Each(kv => _inboundTransport.SignalBoundSubscription(kv.Key /* subId */, kv.Value /* topic desc */));
}
public void Consume(SubscriptionAdded message)
{
if (_log.IsInfoEnabled)
{
_log.InfoFormat("Subscription Added: {0} [{1}]", message.Subscription, message.Subscription.CorrelationId);
}
var add = new AddSubscription(message.Subscription);
SendToClients(add);
}
public void OnSubscriptionAdded(SubscriptionAdded message)
{
_connectionCache[message.SubscriptionId] = _cache.Connect(message.MessageName, message.EndpointUri,
message.CorrelationId);
if (_log.IsInfoEnabled)
{
_log.InfoFormat("Added: {0} => {1}, {2}", message.MessageName, message.EndpointUri,
message.SubscriptionId);
}
}
public void Subscribe <TEvent>(Action <TEvent> handler) where TEvent : Event
{
if (!_subscriptions.TryGetValue(typeof(TEvent), out var handlers))
{
_subscriptions[typeof(TEvent)] = handlers = new HashSet <Handler>();
}
handlers.Add(new Handler(item => handler.Invoke((TEvent)item)));
SubscriptionAdded?.Invoke(typeof(TEvent), Array.Empty <IEventFilter>());
}
public void Subscribe <TEvent>(Action <TEvent> handler, IEnumerable <IEventFilter> filters) where TEvent : Event
{
if (!_subscriptions.TryGetValue(typeof(TEvent), out var handlers))
{
_subscriptions[typeof(TEvent)] = handlers = new HashSet <Handler>();
}
filters = filters.ToArray();
handlers.Add(new Handler(item => handler.Invoke((TEvent)item), filters));
SubscriptionAdded?.Invoke(typeof(TEvent), filters);
}
public void OnSubscriptionAdded(SubscriptionAdded message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
var messageType = GetMessageType(message);
var messageName = GetMessageName(messageType);
_bindings[message.SubscriptionId] = new TopicDescriptionImpl(messageName.ToString());
_bindings.Each(kv => _inboundTransport.SignalBoundSubscription(kv.Key /* subId */, kv.Value /* topic desc */, messageType));
}
/// <summary>
/// Adds a remote subscription to the route path or a local data or control bus
/// </summary>
/// <param name="message"></param>
public void OnSubscriptionAdded(SubscriptionAdded message)
{
// determine whether the message should be send over the control bus
var isControlMessage = message.EndpointUri.IsControlAddress();
// connect the message to the correct cache
if (!isControlMessage)
_connectionCache[message.SubscriptionId] = _dataBusSubscriptionCache.Connect(message.MessageName, message.EndpointUri, message.CorrelationId);
else
_connectionCache[message.SubscriptionId] = _controlBusSubscriptionCache.Connect(message.MessageName, message.EndpointUri, message.CorrelationId);
if (_log.IsInfoEnabled)
_log.InfoFormat("Added: {0} => {1}, {2}", message.MessageName, message.EndpointUri,
message.SubscriptionId);
}
public void OnSubscriptionAdded(SubscriptionAdded message)
{
Guard.AgainstNull(_inputAddress, "InputAddress", "The input address was not set");
Type messageType = Type.GetType(message.MessageName);
if (messageType == null)
{
_log.InfoFormat("Unknown message type '{0}', unable to add subscription", message.MessageName);
return;
}
MessageName messageName = _messageNameFormatter.GetMessageName(messageType);
_inboundTransport.BindSubscriberExchange(RabbitMqEndpointAddress.Parse(message.EndpointUri), messageName.ToString());
_bindings[message.SubscriptionId] = messageName;
}
public Result <IDisposable> Subscribe(Identity identity, TSubscription subscription)
{
if (subscribed.ContainsKey(identity))
{
return(Result.FailWith <IDisposable>(State.Forbidden, $"Subscriber already contains subscription {identity.Id}."));
}
subscribed.Add(identity, subscription);
SubscriptionAdded?.Invoke(this, new SubscriptionEventArgs <TSubscription>(identity, subscription));
return(Result.Ok(Disposable.For(() =>
{
if (subscribed.ContainsKey(identity))
{
subscribed.Remove(identity);
SubscriptionRemoved?.Invoke(this, new SubscriptionEventArgs <TSubscription>(identity, subscription));
}
})));
}
public void OnSubscriptionAdded(SubscriptionAdded message)
{
long messageNumber = Interlocked.Increment(ref _lastMessageNumber);
var subscription = new SubscriptionInformation(_peerId, messageNumber, message.MessageName, message.CorrelationId,
message.EndpointUri);
subscription.SubscriptionId = message.SubscriptionId;
var add = new AddSubscription(subscription);
if (_log.IsDebugEnabled)
{
_log.DebugFormat("AddSubscription: {0}, {1}", subscription.MessageName, subscription.SubscriptionId);
}
_endpoint.Send(add, SetSendContext);
}
public void OnSubscriptionAdded(SubscriptionAdded message)
{
Guard.AgainstNull(_inputAddress, "InputAddress", "The input address was not set");
Type messageType = Type.GetType(message.MessageName);
if (messageType == null)
{
_log.InfoFormat("Unknown message type '{0}', unable to add subscription", message.MessageName);
return;
}
MessageName messageName = _messageNameFormatter.GetMessageName(messageType);
_inboundTransport.BindSubscriberExchange(messageName.ToString());
_bindings[message.SubscriptionId] = messageName;
}
public void OnSubscriptionAdded(SubscriptionAdded message)
{
if (message == null)
throw new ArgumentNullException("message");
Type messageType = Type.GetType(message.MessageName);
if (messageType == null)
{
_log.InfoFormat("Unknown message type '{0}', unable to add subscription", message.MessageName);
return;
}
MessageName messageName = _formatter.GetMessageName(messageType);
var topicDescription = new TopicDescription(messageName.ToString());
_inboundTransport.AddTopicSubscriber(topicDescription);
_bindings[message.SubscriptionId] = topicDescription;
}
public void OnSubscriptionAdded(SubscriptionAdded message)
{
Guard.AgainstNull(_inputAddress, "InputAddress", "The input address was not set");
Type messageType = Type.GetType(message.MessageName);
if (messageType == null)
{
_log.InfoFormat("Unknown message type '{0}', unable to add subscription", message.MessageName);
return;
}
MessageName messageName = _messageNameFormatter.GetMessageName(messageType);
using (var management = new RabbitMqEndpointManagement(_inputAddress))
{
management.BindExchange(_inputAddress.Name, messageName.ToString(), ExchangeType.Fanout, "");
}
_bindings[message.SubscriptionId] = messageName;
}
public void OnSubscriptionAdded(SubscriptionAdded message)
{
if (_ignoredMessageTypes.Contains(message.MessageName))
return;
WithTarget(x =>
{
if (_log.IsDebugEnabled)
_log.DebugFormat("Send AddPeerSubscription: {0}, {1}", _peerId, message.MessageName);
x.Send(new AddPeerSubscriptionMessage
{
PeerId = _peerId,
MessageNumber = ++_messageNumber,
EndpointUri = message.EndpointUri,
MessageName = message.MessageName,
SubscriptionId = message.SubscriptionId,
});
});
}
/// <summary>
/// Adds a remote subscription to the route path or a local data or control bus
/// </summary>
/// <param name="message"></param>
public void OnSubscriptionAdded(SubscriptionAdded message)
{
// determine whether the message should be send over the control bus
bool isControlMessage = message.EndpointUri.IsControlAddress();
// connect the message to the correct cache
if (!isControlMessage)
{
_connectionCache[message.SubscriptionId] = _dataBusSubscriptionCache.Connect(message.MessageName,
message.EndpointUri, message.CorrelationId);
}
else
{
_connectionCache[message.SubscriptionId] = _controlBusSubscriptionCache.Connect(message.MessageName,
message.EndpointUri, message.CorrelationId);
}
_log.Debug(() => string.Format("Added: {0} => {1}, {2}", message.MessageName, message.EndpointUri,
message.SubscriptionId));
}
public void OnSubscriptionAdded(SubscriptionAdded message)
{
Guard.AgainstNull(_inputAddress, "InputAddress", "The input address was not set");
Type messageType = Type.GetType(message.MessageName);
if (messageType == null)
{
_log.InfoFormat("Unknown message type '{0}', unable to add subscription", message.MessageName);
return;
}
MessageName messageName = _messageNameFormatter.GetMessageName(messageType);
using (var management = new RabbitMqEndpointManagement(_inputAddress))
{
management.BindExchange(_inputAddress.Name, messageName.ToString(), ExchangeType.Fanout, "");
}
_bindings[message.SubscriptionId] = messageName;
}
public void OnSubscriptionAdded(SubscriptionAdded message)
{
long messageNumber = Interlocked.Increment(ref _lastMessageNumber);
var add = new AddPeerSubscriptionMessage
{
PeerId = _peerId,
MessageNumber = messageNumber,
SubscriptionId = message.SubscriptionId,
EndpointUri = message.EndpointUri,
MessageName = message.MessageName,
CorrelationId = message.CorrelationId,
};
if (_log.IsDebugEnabled)
{
_log.DebugFormat("AddSubscription: {0}, {1}", add.MessageName, add.SubscriptionId);
}
_endpoint.Send(add, SetSendContext);
}
public override void BecauseOf()
{
var info = new SubscriptionInformation(_clientId, 0, "", "", _dataUri);
var message = new SubscriptionAdded {Subscription = info};
var saga = new LegacySubscriptionClientSaga(_clientId);
saga.Bus = new NullServiceBus();
var data = new OldCacheUpdateRequest(_dataUri);
saga.RaiseEvent(LegacySubscriptionClientSaga.OldCacheUpdateRequested, data);
IEnumerable<LegacySubscriptionClientSaga> sagas = new List<LegacySubscriptionClientSaga>
{
saga
};
MockRepo.Stub(r => r.Where(s => s.CurrentState == LegacySubscriptionClientSaga.Active)).IgnoreArguments().Return(sagas);
MockEndpointFactory.Expect(e => e.GetEndpoint(saga.Bus.Endpoint.Uri)).Return(saga.Bus.Endpoint);
Service.Consume(message);
}
public void OnSubscriptionAdded(SubscriptionAdded message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
Type messageType = Type.GetType(message.MessageName);
if (messageType == null)
{
_log.InfoFormat("Unknown message type '{0}', unable to add subscription", message.MessageName);
return;
}
MessageName messageName = _formatter.GetMessageName(messageType);
var topicDescription = new TopicDescription(messageName.ToString());
_inboundTransport.AddTopicSubscriber(topicDescription);
_bindings[message.SubscriptionId] = topicDescription;
}
public void Handle(MessageContext c, SubscriptionAdded e)
{
// Insert into the table
}
protected virtual void RaiseSubscriptionAdded(WampSubscriptionAddEventArgs e)
{
SubscriptionAdded?.Invoke(this, e);
}
/// <summary>
/// Event invocator for the <see cref="SubscriptionAdded"/> event
/// </summary>
/// <param name="subscription">The added subscription</param>
private void OnSubscriptionAdded(Subscription subscription)
{
SubscriptionAdded?.Invoke(this, subscription);
}
/// <summary>
/// Raises the <see cref="E:SubscriptionAdded" /> event.
/// </summary>
/// <param name="e">The <see cref="SubscriptionEventArgs"/> instance containing the event data.</param>
protected internal virtual void OnSubscriptionAdded(SubscriptionEventArgs e)
{
SubscriptionAdded?.Invoke(this, e);
}
public void OnSubscriptionAdded(SubscriptionAdded message)
{
lock (_observers)
_observers.Each(x => x.OnSubscriptionAdded(message));
}
public void OnSubscriptionAdded(SubscriptionAdded message)
{
_producer.OnSubscriptionAdded(message);
}
public void Subscribe(Subscription subscription)
{
_subscriptions.TryAdd(subscription.Topic, subscription);
SubscriptionAdded?.Invoke(this, new SubscriptionEventArgs(subscription));
}
public void OnSubscriptionAdded(SubscriptionAdded message)
{
_producer.OnSubscriptionAdded(message);
}
public void OnSubscriptionAdded(SubscriptionAdded message)
{
lock (_observers)
_observers.Each(x => x.OnSubscriptionAdded(message));
}
