public Task ReceiveAsync(IContext context) { switch (context.Message) { case Publish publish: foreach ((PID, object)tuple in _subscriptions.Select(publish.Topic, publish.Message)) { tuple.Item1.Tell(publish); } return(Task.CompletedTask); case Subscribe subscribe: SubscriptionInfo subscriptionInfo = new SubscriptionInfo(Type.GetType(subscribe.Type), subscribe.Topic); _subscriptions.Add(subscriptionInfo, subscribe.ConsumerActor); SubscribeAck subscribeAck = new SubscribeAck { SubscriptionId = ByteString.CopyFrom(subscriptionInfo.SubscriptionId.ToByteArray()) }; context.Respond(subscribeAck); return(Task.CompletedTask); case Unsubscribe unsubscribe: UnsubscribeAck unsubscribeAck = new UnsubscribeAck { Success = _subscriptions.Remove(new Guid(unsubscribe.SubscriptionId.ToByteArray())) }; context.Respond(unsubscribeAck); return(Task.CompletedTask); default: return(Task.CompletedTask); } }
public void Handle(SubscribeAck msg) { _subscriptionWaiter?.Tell(msg); Log.Trace( "Subscription was successfull for topic {Topic} group {Group} path {Path}", msg.Subscribe.Topic, msg.Subscribe.Group, msg.Subscribe.Ref.Path); }
public async Task when_subscribing_new_topics_then_subscriptions_are_created_and_ack_is_sent() { MqttConfiguration configuration = new MqttConfiguration { MaximumQualityOfService = MqttQualityOfService.AtLeastOnce }; Mock <IMqttTopicEvaluator> topicEvaluator = new Mock <IMqttTopicEvaluator>(); Mock <IRepository <ClientSession> > sessionRepository = new Mock <IRepository <ClientSession> >(); IPacketIdProvider packetIdProvider = Mock.Of <IPacketIdProvider>(); IRepository <RetainedMessage> retainedMessageRepository = Mock.Of <IRepository <RetainedMessage> >(); IPublishSenderFlow senderFlow = Mock.Of <IPublishSenderFlow>(); string clientId = Guid.NewGuid().ToString(); ClientSession session = new ClientSession(clientId, clean: false); topicEvaluator.Setup(e => e.IsValidTopicFilter(It.IsAny <string>())).Returns(true); sessionRepository.Setup(r => r.Read(It.IsAny <string>())).Returns(session); MqttQualityOfService fooQoS = MqttQualityOfService.AtLeastOnce; string fooTopic = "test/foo/1"; Subscription fooSubscription = new Subscription(fooTopic, fooQoS); MqttQualityOfService barQoS = MqttQualityOfService.AtMostOnce; string barTopic = "test/bar/1"; Subscription barSubscription = new Subscription(barTopic, barQoS); ushort packetId = (ushort)new Random().Next(0, ushort.MaxValue); Subscribe subscribe = new Subscribe(packetId, fooSubscription, barSubscription); Mock <IMqttChannel <IPacket> > channel = new Mock <IMqttChannel <IPacket> >(); IPacket response = default; channel.Setup(c => c.SendAsync(It.IsAny <IPacket>())) .Callback <IPacket>(p => response = p) .Returns(Task.Delay(0)); Mock <IConnectionProvider> connectionProvider = new Mock <IConnectionProvider>(); connectionProvider .Setup(p => p.GetConnection(It.Is <string>(c => c == clientId))) .Returns(channel.Object); ServerSubscribeFlow flow = new ServerSubscribeFlow(topicEvaluator.Object, sessionRepository.Object, retainedMessageRepository, packetIdProvider, senderFlow, configuration); await flow.ExecuteAsync(clientId, subscribe, channel.Object); sessionRepository.Verify(r => r.Update(It.Is <ClientSession>(s => s.Id == clientId && s.Subscriptions.Count == 2 && s.Subscriptions.All(x => x.TopicFilter == fooTopic || x.TopicFilter == barTopic)))); Assert.NotNull(response); SubscribeAck subscribeAck = response as SubscribeAck; Assert.NotNull(subscribeAck); packetId.Should().Be(subscribeAck.PacketId); 2.Should().Be(subscribeAck.ReturnCodes.Count()); Assert.True(subscribeAck.ReturnCodes.Any(c => c == SubscribeReturnCode.MaximumQoS0)); Assert.True(subscribeAck.ReturnCodes.Any(c => c == SubscribeReturnCode.MaximumQoS1)); }
private void Handle(SubscribeAck msg) { if (msg.Subscribe.Topic.Equals("NamedTopic") && msg.Subscribe.Ref.Equals(Self) && msg.Subscribe.Group == null) { _log.Info($">>> Recevied message : {msg}, Sender: {Sender}"); } }
private void Handle(SubscribeAck msg) { if (msg.Subscribe.Topic.Equals(topicname) && msg.Subscribe.Ref.Equals(Self) && msg.Subscribe.Group.Equals(groupname)) { _log.Info($" Group:{groupname} Recevied message : {msg}, Sender: {Sender}"); } }
public void when_writing_invalid_subscribe_ack_packet_then_fails(string jsonPath) { jsonPath = Path.Combine(Environment.CurrentDirectory, jsonPath); SubscribeAckFormatter formatter = new SubscribeAckFormatter(); SubscribeAck subscribeAck = Packet.ReadPacket <SubscribeAck>(jsonPath); AggregateException ex = Assert.Throws <AggregateException>(() => formatter.FormatAsync(subscribeAck).Wait()); Assert.True(ex.InnerException is MqttProtocolViolationException); }
public async Task when_writing_subscribe_ack_packet_then_succeeds(string jsonPath, string packetPath) { jsonPath = Path.Combine(Environment.CurrentDirectory, jsonPath); packetPath = Path.Combine(Environment.CurrentDirectory, packetPath); byte[] expectedPacket = Packet.ReadAllBytes(packetPath); SubscribeAckFormatter formatter = new SubscribeAckFormatter(); SubscribeAck subscribeAck = Packet.ReadPacket <SubscribeAck>(jsonPath); byte[] result = await formatter.FormatAsync(subscribeAck); expectedPacket.Should().BeEquivalentTo(result); }
public async Task when_reading_subscribe_ack_packet_then_succeeds(string packetPath, string jsonPath) { packetPath = Path.Combine(Environment.CurrentDirectory, packetPath); jsonPath = Path.Combine(Environment.CurrentDirectory, jsonPath); SubscribeAck expectedSubscribeAck = Packet.ReadPacket <SubscribeAck>(jsonPath); SubscribeAckFormatter formatter = new SubscribeAckFormatter(); byte[] packet = Packet.ReadAllBytes(packetPath); IPacket result = await formatter.FormatAsync(packet); expectedSubscribeAck.Should().Be(result); }
public Subscribed(SubscribeAck ack, IActorRef subscriber) { Ack = ack; Subscriber = subscriber; }
private void Process(SubscribeAck eventToProcess) { LoggingAdapter.Debug("Received subscribe ack " + subscriptionMessage.SubscriptionId.Id); }
public ProtoBrokerSubject(PID brokerPid, string topic, string consumerGroup) { if (brokerPid == null) { throw new ArgumentNullException(nameof(brokerPid)); } _topic = topic ?? throw new ArgumentNullException(nameof(topic)); GetPublisherPiDsResponse getPublisherPiDsResponse = brokerPid.RequestAsync <GetPublisherPiDsResponse>(new GetPublisherPiDs()).Result; PID[] publishers = getPublisherPiDsResponse.PIds.ToArray(); int hash = Math.Abs(topic.GetHashCode()); _publisherPid = publishers[hash % publishers.Length]; _observable = Observable.Create <T>(async(observer, cancellationToken) => { try { Props props = Actor.FromProducer(() => new ConsumerActor <T>(observer)); PID consumerActor = Actor.SpawnPrefix(props, $"Consumer_{topic}_{consumerGroup}"); Subscribe addSubscription = new Subscribe { ConsumerActor = consumerActor, Topic = topic, Type = typeof(T).FullName }; List <SubscribeAck> subscriptions = new List <SubscribeAck>(); foreach (PID publisher in publishers.EmptyIfNull()) { SubscribeAck subscribeAck = await publisher .RequestAsync <SubscribeAck>(addSubscription) .ConfigureAwait(false); subscriptions.Add(subscribeAck); } try { await Task.Delay(-1, cancellationToken).ConfigureAwait(false); } finally { foreach (SubscribeAck subscription in subscriptions) { Unsubscribe removeSubscription = new Unsubscribe { SubscriptionId = subscription.SubscriptionId }; await Task.WhenAll(publishers .Select(publisher => publisher.RequestAsync <UnsubscribeAck>(removeSubscription))) .ConfigureAwait(false); } consumerActor.Stop(); } observer.OnCompleted(); } catch (OperationCanceledException) { observer.OnCompleted(); } catch (Exception e) { observer.OnError(e); } }) .Retry() .Publish() .RefCount(); }