protected MouseListener(Subscribe subscribe) : base(subscribe) { m_PreviousPosition = new Point(-1, -1); m_DoubleDown = new ButtonSet(); m_SingleDown = new ButtonSet(); }
public ActionResult Index(Subscribe subscribe) { var createNewSubscription = new CreateNewSubscription(); var createSubscriptionResponse = _bus.Send<CreateNewSubscription, CreateNewSubscriptionResponse>(createNewSubscription); return View(); }
protected MouseListener(Subscribe subscribe) : base(subscribe) { m_xDragThreshold = NativeMethods.GetXDragThreshold(); m_yDragThreshold = NativeMethods.GetYDragThreshold(); m_IsDragging = false; m_PreviousPosition = m_UninitialisedPoint; m_DragStartPosition = m_UninitialisedPoint; m_DoubleDown = new ButtonSet(); m_SingleDown = new ButtonSet(); }
public bool PostSubscribe(Subscribe subscribe) { bool isSent = false; GetSettings(); object data = subscribe; string to = _subscribeTo; string subject = _subscribeSubject; string template = _subscribeTemplate; isSent = SendForm(to, subject, template, data); return isSent; }
public void DistributedPubSubMediator_must_receive_proper_UnsubscribeAck_message() { Within(TimeSpan.FromSeconds(15), () => { RunOn(() => { var user = CreateChatUser("u111"); var topic = "sample-topic-14"; var s1 = new Subscribe(topic, user); Mediator.Tell(s1); ExpectMsg <SubscribeAck>(x => x.Subscribe.Equals(s1)); var uns = new Unsubscribe(topic, user); Mediator.Tell(uns); ExpectMsg <UnsubscribeAck>(x => x.Unsubscribe.Equals(uns)); }, _first); EnterBarrier("after-15"); }); }
public async Task <ActionResult> RemoveAsync(Subscribe model) { if (!string.IsNullOrWhiteSpace(model.ConfirmEmailAddress)) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } string tenant = AppUsers.GetTenant(); if (EmailSubscriptions.Remove(tenant, model.EmailAddress)) { var email = new SubscriptionRemovedEmail(); await email.SendAsync(tenant, model); } Thread.Sleep(1000); return(this.Ok()); }
public ActionResult Delete(Subscribe subscribe) { try { db.Entry(subscribe).State = EntityState.Deleted; db.SaveChanges(); return(RedirectToAction("Index")); } catch (DbUpdateConcurrencyException) { return(RedirectToAction("Delete", new { concurrencyError = true, id = subscribe.SubscribeID })); } catch (DataException) { ModelState.AddModelError(string.Empty, "Unable to save changes.Try again,and if the problem persists contact your system administrator."); } return(View(subscribe)); }
public async Task <SubscribeResponse> SaveAsync(Subscribe subscribe) { try { //try to add the new subscribe to the database await _subscribeRepository.AddAsync(subscribe); //API try to save it await _unitOfWork.CompleteAsync(); return(new SubscribeResponse(subscribe)); } catch (Exception ex) { //API calls some fictional logging service and return a response indicating failure return(new SubscribeResponse($"An error occurred when saving the subscribe: {ex.Message}")); } }
protected virtual PartialViewResult Index(Guid activityId, Subscribe subscriber, Enum type = null) { var model = new SubscribeViewModel { Id = subscriber?.Id, UserId = _intranetMemberService.GetCurrentMemberId(), ActivityId = activityId, IsSubscribed = subscriber != null, IsNotificationDisabled = subscriber?.IsNotificationDisabled ?? false }; if (type != null) { model.HasNotification = _subscribeService.HasNotification(type); } return(PartialView(IndexViewPath, model)); }
public async Task <IActionResult> Post([FromBody] Subscribe sub) { try { if (await SubRepo.Exists(sub.Id) == false) { throw new Exception("Informação não encontrada na base de dados."); } await SubRepo.Update(sub); return(NoContent()); } catch (Exception ex) { return(StatusCode(400, ex.Message)); } }
public static Payload MakeSubscribePayload( string subscriber, string identifier, string topic, int duration, string meta) { var subscribe = new Subscribe { Subscriber = subscriber.FromHexString(), Identifier = identifier, Topic = topic, Duration = duration, Meta = meta }; return(TransactionFactory.MakePayload(subscribe, PayloadType.Subscribe)); }
public MyMessagingApp() { // Configure handler policies Handlers.DefaultMaximumAttempts = 3; Handlers.OnException <SqlException>().RetryLater(3.Seconds()); // Declare published messages Publish.Message <Message1>().To("tcp://server1:2222"); // Register to receive messages Subscribe.At("tcp://loadbalancer1:2233"); Subscribe.To <Message2>(); Subscribe.To(type => type.IsInNamespace("MyMessagingApp.Incoming")); // Configure the built in transports Transports.Lightweight.ListenOnPort(2233); Transports.Durable.Disable(); }
public async Task FinishHandshakeAsync(CancellationToken cancellationToken) { await InitAsync(cancellationToken).ConfigureAwait(false); if (_finished) { return; } var eos = new Subscribe { Type = SubscriptionType.End }; await _readLock.WaitAsync(cancellationToken).ConfigureAwait(false); try { if (_finished) { return; } _finished = true; using (var stream = new NetworkStream(_socket, false)) using (var writer = new StreamWriter(stream)) using (var reader = new StreamReader(stream)) { var msg = JsonConvert.SerializeObject(eos); await writer.WriteLineAsync(msg).ConfigureAwait(false); LogWritten(msg); cancellationToken.ThrowIfCancellationRequested(); await writer.FlushAsync().ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); msg = await reader.ReadLineAsync().ConfigureAwait(false); LogRead(msg); cancellationToken.ThrowIfCancellationRequested(); } } finally { _readLock.Release(); } }
public Subscribe ToUpdate() { var result = new Subscribe(); if (TopicSettings?.Any() == true) { result.TopicSettings = new ChannelSettings(); foreach (var(key, value) in TopicSettings) { if (value != null) { result.TopicSettings[key] = value.ToDomainObject(); } } } return(result); }
//SubscribeButton public ActionResult subscribeButton(string email) { bool checkEmail = db.Subscribes.Any(w => w.DeletedDate == null && w.Email == email); if (!checkEmail) { var newSubscribe = new Subscribe(); newSubscribe.Email = email; newSubscribe.CreatedDate = DateTime.Now; db.Subscribes.Add(newSubscribe); db.SaveChanges(); MailExtention.SendMail("Subscribe Confirmation", "https://localhost:44354/home/confirmSubscribe/" + newSubscribe.Id, email); return View("Index"); } else { TempData["existsEmailInSubscribe"] = "Bu email mövcuddur!"; return View("Index"); } }
Task <SubscriptionResult> IInstrumentParamsSubscriber.Subscribe(Instrument instrument) { var id = Guid.NewGuid().ToString(); ipInstrumentToId[instrument] = id; ipIdToInstrument[id] = instrument; var tcs = ipSubscriptionResults[id] = new TaskCompletionSource <SubscriptionResult>(); var subscribe = new Subscribe( destination: Securities, id: id, selector: $"TICKER=\"{Prefix}{instrument.Code}\" and LANGUAGE=\"en\"" ); connection.Send(subscribe); return(tcs.Task); }
public IActionResult Create(Subscribe s) { Subscribe tblS = new Subscribe(); var target = _context.tblSubscribe.Where(x => x.email == s.email).FirstOrDefault(); if (target != null) { ViewBag.alreadysub = "We already have your email address on our subscription list. Thanks!"; return(View()); } else { tblS.email = s.email; _context.tblSubscribe.Add(tblS); _context.SaveChanges(); ViewBag.msg = " You are now Subscribed. Thanks!"; return(View()); } }
public async Task <ActionResult> RemoveAsync(Subscribe model) { string token = this.Session[TokenKey].ToString(); if (token != model.TokenHidden || !string.IsNullOrWhiteSpace(model.ConfirmEmailAddress)) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } string catalog = AppUsers.GetCatalog(); if (EmailSubscriptions.Remove(catalog, model.EmailAddress)) { var email = new SubscriptionRemovedEmail(); await email.SendAsync(catalog, model); } return(Json("OK")); }
internal void GivenSubscribe_WhenAlreadySubscribedToBusType_DoesNotDuplicateSubscription() { // Arrange var subscribe = new Subscribe <Type>( typeof(Event), this.receiver.Mailbox, Guid.NewGuid(), StubZonedDateTime.UnixEpoch()); // Act this.messageBus.Endpoint.SendAsync(subscribe).Wait(); this.messageBus.Endpoint.SendAsync(subscribe).Wait(); Task.Delay(TestAssertionsTaskDelay).Wait(); // Allow sending to complete for assertions // Assert Assert.Equal(1, this.messageBus.Subscriptions[typeof(Event)].Count); Assert.Equal(1, this.messageBus.SubscriptionCount); }
public void SetSubScrib() { try { Subscribe sub = new Subscribe(); string str = Function.Comm.clsSocketServer.MyIp(); sub.notificationURI = string.Format("tcp://{0}:{1}", str, intPort); sub.specName = strEcSpecName; //CheckSubscribes(sub); Ale.subscribe(sub); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } }
internal void GivenSubscribe_WhenTypeIsSpecificType_SubscribesCorrectly() { // Arrange var subscribe = new Subscribe <Type>( typeof(MarketOpened), this.receiver.Mailbox, Guid.NewGuid(), StubZonedDateTime.UnixEpoch()); // Act this.messageBus.Endpoint.SendAsync(subscribe).Wait(); Task.Delay(TestAssertionsTaskDelay).Wait(); // Allow sending to complete for assertions // Assert Assert.Contains(typeof(MarketOpened), this.messageBus.Subscriptions); Assert.Equal(1, this.messageBus.Subscriptions[typeof(MarketOpened)].Count); Assert.Equal(1, this.messageBus.Subscriptions.Count); }
public LightweightTransportApp() { // Set up a listener (this is optional) Transports.LightweightListenerAt(4000); // Or, listen by Uri // This directs Jasper to listen for messages at port 2200 // with the lightweight transport Transports.ListenForMessagesFrom("tcp://localhost:2200"); // Registering a subscription to Message1 that should be // delivered to a load balancer Uri at port 2200 and the "important" // queue Subscribe.To <Message1>().At("tcp://loadbalancer:2200/important"); // Publish the message Message2 to the DNS entry "remoteserver" Publish.Message <Message2>().To("tcp://remoteserver:2201"); }
public IEnumerator <ITask> SubscribeHandler(Subscribe subscribe) { SubscribeRequestType request = subscribe.Body; LogInfo("Subscribe request from: " + request.Subscriber); yield return(Arbiter.Choice( SubscribeHelper(_submgrPort, request, subscribe.ResponsePort), delegate(SuccessResult success) { _state.Subscribers++; base.SendNotification <Replace>(_submgrPort, request.Subscriber, _state); }, delegate(Exception e) { LogError(null, "Subscribe failed", e); } )); }
public async Task <Subscribe> UpdateSubscribeAsync(int id, Subscribe Subscribe) { if (id != Subscribe.Id) { throw new InvalidOperationException("URL id needs to be the same as Subscribe id"); } await validateSubscribe(id); Subscribe.Id = id; var SubscribeEntity = mapper.Map <SubscribeEntity>(Subscribe); EcomakRepository.UpdateSubscribe(SubscribeEntity); if (await EcomakRepository.SaveChangesAsync()) { return(mapper.Map <Subscribe>(SubscribeEntity)); } throw new Exception("There were an error with the DB"); }
public async Task <ActionResult> AddAsync(Subscribe model) { //ConfirmEmailAddress is a honeypot field if (!string.IsNullOrWhiteSpace(model.ConfirmEmailAddress)) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } if (await EmailSubscriptions.AddAsync(this.Tenant, model.EmailAddress).ConfigureAwait(false)) { var email = new SubscriptionWelcomeEmail(); await email.SendAsync(this.Tenant, model).ConfigureAwait(false); } await Task.Delay(1000).ConfigureAwait(false); return(this.Ok()); }
private async Task SubscribeTable(Table table) { var msg = new Subscribe { tab_id = table, max_row_id = -1, last_change_id = 0, }; var tcs = new TaskCompletionSource <bool>(); lock (sync) { subscriptions[table] = tcs; } await base.SendRequestAsync(new FTEMessage(MsgType.REQ_SUBSCRIBE, msg)); await tcs.Task; }
public BaseResponse Subscribe([FromBody] Subscribe subscribe) { var storeProduced = "sp_Subscribe_Set"; using (var conn = new SqlConnection(_connectionString)) { try { conn.Open(); var param = new DynamicParameters(); param.Add("@email", subscribe.email); var result = conn.QueryFirst <BaseResponse>(storeProduced, param, commandType: System.Data.CommandType.StoredProcedure); return(result); } catch (Exception ex) { throw ex; } } }
/// <summary> /// Market data request message /// </summary> public bool SubscribeTickData(Subscribe request) { try { if (_isConnected) { // Forward request _levelOneData.Subscribe(request.Security.Symbol); return(true); } return(false); } catch (Exception exception) { _logger.Error(exception, _type.FullName, "SubscribeTickData"); return(false); } }
/// <summary> /// Sends Tick Subscription Request to the Market Data Engine /// </summary> /// <param name="subscribe">TradeHub Subscribe message to be sent</param> public void SendTickSubscriptionRequest(Subscribe subscribe) { try { if (_asyncClassLogger.IsDebugEnabled) { _asyncClassLogger.Debug( "Sending Tick subscription request message for: " + subscribe.Security.Symbol + " on: " + subscribe.MarketDataProvider, _type.FullName, "SendTickSubscriptionRequest"); } // Send message though the Mq Server _mqServer.SendTickSubscriptionMessage(subscribe); } catch (Exception exception) { _asyncClassLogger.Error(exception, _type.FullName, "SendTickSubscriptionRequest"); } }
/// <summary> /// Market data request message /// </summary> public bool SubscribeTickData(Subscribe request) { try { if (_isConnected) { // Send subscription request _priceListener.Subscribe(request.Security.Symbol); return(true); } return(false); } catch (Exception exception) { _logger.Error(exception, _type.FullName, "SubscribeTickData"); return(false); } }
private string GetMessage(string tenant, Subscribe model) { string siteUrl = HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Authority); string domain = HttpContext.Current.Request.Url.Host; string file = HostingEnvironment.MapPath(string.Format(CultureInfo.InvariantCulture, TemplatePath, tenant)); if (file == null || !File.Exists(file)) { return(string.Empty); } string message = File.ReadAllText(file, Encoding.UTF8); message = message.Replace("{{Domain}}", domain); message = message.Replace("{{SiteUrl}}", siteUrl); message = message.Replace("{{Email}}", model.EmailAddress); return(message); }
public IActionResult Edit(int id, Subscribe subscribe) { if (!ModelState.IsValid) { return(View()); } Subscribe existSubscribe = _context.Subscribers.FirstOrDefault(x => x.Id == id); if (existSubscribe == null) { return(RedirectToAction("index")); } existSubscribe.Email = subscribe.Email; _context.SaveChanges(); return(RedirectToAction("index")); }
/// <summary> /// Unsubscribe the selected security from gridview. /// </summary> private void UnsubscribeSecurity() { try { Unsubscribe unsubscribe = new Unsubscribe(); Subscribe subscribe = SecutiryList.Single(s => s.Id == SelectedSecurity.Id); unsubscribe.Security = subscribe.Security; if (Logger.IsInfoEnabled) { Logger.Info(unsubscribe.ToString(), _oType.FullName, "UnsubscribeSecurity"); } unsubscribe.Id = subscribe.Id; unsubscribe.MarketDataProvider = SelectedProvider.ProviderName; var temp = SecurityStatDictionary[SelectedProvider.ProviderName]; var selectedRowOfGrid = temp.Single(x => x.Id == unsubscribe.Id); EventSystem.Publish <Unsubscribe>(unsubscribe); EventSystem.Publish <UnsubscribeBars>(new UnsubscribeBars { UnSubscribeBarDataRequest = new BarDataRequest { Id = unsubscribe.Id, MarketDataProvider = unsubscribe.MarketDataProvider, Security = unsubscribe.Security, BarFormat = selectedRowOfGrid.BarSettingView.BarSettingViewModel.SelectedFormate, BarPriceType = selectedRowOfGrid.BarSettingView.BarSettingViewModel.SelectedType, BarLength = selectedRowOfGrid.BarSettingView.BarSettingViewModel.BarLength, PipSize = selectedRowOfGrid.BarSettingView.BarSettingViewModel.PipSize, } }); SecutiryList.Remove(subscribe); SecurityStatDictionary[SelectedProvider.ProviderName].Remove( SecurityStatDictionary[SelectedProvider.ProviderName].Single(x => x.Id == unsubscribe.Id)); ReloadList(SelectedProvider); } catch (Exception exception) { Logger.Error(exception, _oType.FullName, "UnsubscribeSecurity"); } }
public void Subscribe(string ip, int port) { EventPortTypeClient eptc = OnvifServices.GetEventClient(ip, port); string localIP = GetLocalIp(); // "172.16.5.111"; // Producer client NotificationProducerClient npc = OnvifServices.GetNotificationProducerClient(ip, port); npc.Endpoint.Address = eptc.Endpoint.Address; Subscribe s = new Subscribe(); // Consumer reference tells the device where to Post messages back to (the client) EndpointReferenceType clientEndpoint = new EndpointReferenceType() { Address = new AttributedURIType() { Value = string.Format("http://{0}:8080/subscription-1", localIP) } }; s.ConsumerReference = clientEndpoint; s.InitialTerminationTime = "PT60S"; SubscribeResponse sr = npc.Subscribe(s); // Store the subscription URI for use in Renew SubRenewUri = sr.SubscriptionReference.Address.Value; // Start timer to periodically check if a Renew request needs to be issued // Use PC time for timer in case camera time doesn't match PC time // This works fine because the renew command issues a relative time (i.e. PT60S) so PC/Camera mismatch doesn't matter SubTermTime = DateTime.UtcNow.AddSeconds(50); // sr.TerminationTime; SubRenewTimer.Start(); SubRenewTimer.Interval = 1000; SubRenewTimer.Tick += SubRenewTimer_Tick; listBox1.Items.Add(string.Format("Initial Termination Time: {0} (Current Time: {1})", SubTermTime, DateTime.UtcNow)); SubscriptionManagerClient = OnvifServices.GetSubscriptionManagerClient(SubRenewUri); // oAux1.Address.Value); }
public IEnumerator<ITask> SubscribeHandler(Subscribe subscribe) { yield return Arbiter.Choice( SubscribeHelper(_subMgrPort, subscribe.Body, subscribe.ResponsePort), delegate(SuccessResult success) { _subMgrPort.Post(new submgr.Submit( subscribe.Body.Subscriber, DsspActions.ReplaceRequest, _state, null)); }, null ); }
public void SubscribeHandler(Subscribe subscribe) { SubscribeHelper(_submgrPort, subscribe.Body, subscribe.ResponsePort); }
public IEnumerator<ITask> SubscribeHandler(Subscribe subscribe) { SubscribeRequestType request = subscribe.Body; LogInfo("Subscribe request from: " + request.Subscriber); // Send a notification on successful subscription so that the // subscriber can initialize its own state yield return Arbiter.Choice( SubscribeHelper(_submgrPort, request, subscribe.ResponsePort), success => SendNotificationToTarget<Replace>(request.Subscriber, _submgrPort, _state), exception => LogError("Subscribe failed", exception)); }
public IEnumerator<ITask> SubscribeHandler(Subscribe subscribe) { Tracer.Trace("TrackRoamerBrickProximityBoardService::SubscribeHandler() - subscribe request from '" + subscribe.Body.Subscriber + "' for " + subscribe.Body.TypeFilter.Length + " types."); foreach (string tf in subscribe.Body.TypeFilter) { Tracer.Trace(" =========== subscribe requested for type: " + tf); } SubscribeHelper(_submgrPort, subscribe.Body, subscribe.ResponsePort); yield break; }
public IEnumerator<ITask> SubscribeHandler(Subscribe subscribe) { yield return Arbiter.Choice( SubscribeHelper(_subMgrPort, subscribe.Body, subscribe.ResponsePort), delegate(SuccessResult success) { drive.Update update = new drive.Update(_state); SendNotificationToTarget<drive.Update>(subscribe.Body.Subscriber, _subMgrPort, update); }, delegate(Exception ex) { LogError(ex); throw ex; } ); }
public virtual IEnumerator<ITask> SubscribeHandler(Subscribe subscribe) { SubscribeRequest request = subscribe.Body; submgr.InsertSubscription insert = new submgr.InsertSubscription(request); insert.Body.FilterType = submgr.FilterType.Default; string valid = request.ValidOnly ? "True" : null; List<submgr.QueryType> query = new List<submgr.QueryType>(); if (request.MessageTypes == GpsMessageType.All || request.MessageTypes == GpsMessageType.None) { if (request.ValidOnly) { query.Add(new submgr.QueryType(null, valid)); } } else { if ((request.MessageTypes & GpsMessageType.GPGGA) != 0) { query.Add(new submgr.QueryType(Tag_GpGga, valid)); } if ((request.MessageTypes & GpsMessageType.GPGLL) != 0) { query.Add(new submgr.QueryType(Tag_GpGll, valid)); } if ((request.MessageTypes & GpsMessageType.GPGSA) != 0) { query.Add(new submgr.QueryType(Tag_GpGsa, valid)); } if ((request.MessageTypes & GpsMessageType.GPGSV) != 0) { query.Add(new submgr.QueryType(Tag_GpGsv, valid)); } if ((request.MessageTypes & GpsMessageType.GPRMC) != 0) { query.Add(new submgr.QueryType(Tag_GpRmc, valid)); } if ((request.MessageTypes & GpsMessageType.GPVTG) != 0) { query.Add(new submgr.QueryType(Tag_GpVtg, valid)); } } if (query.Count > 0) { insert.Body.QueryList = query.ToArray(); } _subMgrPort.Post(insert); yield return Arbiter.Choice( insert.ResponsePort, subscribe.ResponsePort.Post, subscribe.ResponsePort.Post ); }
protected KeyListener(Subscribe subscribe) : base(subscribe) { }
public virtual IEnumerator<ITask> SubscribeHandler(Subscribe subscribe) { SubscribeRequestType request = subscribe.Body; LogInfo("TrackRoamerBrickPowerService:SubscribeHandler() -- Subscribe request from: " + request.Subscriber); yield return Arbiter.Choice( SubscribeHelper(_subMgrPort, request, subscribe.ResponsePort), delegate(SuccessResult success) { }, delegate(Exception ex) { LogError(ex); throw ex; } ); //_subMgrPort.Post(new submgr.Submit(request.Subscriber, DsspActions.UpdateRequest, _state.MotorSpeed, null)); //_subMgrPort.Post(new submgr.Submit(request.Subscriber, DsspActions.UpdateRequest, _state.Whiskers, null)); yield break; }
public virtual IEnumerator<ITask> SubscribeHandler(Subscribe subscribe) { base.SubscribeHelper(_subMgrPort, subscribe.Body, subscribe.ResponsePort); yield break; }
public virtual IEnumerator<ITask> SubscribeHandler(Subscribe subscribe) { SubscribeRequestType request = subscribe.Body; yield return Arbiter.Choice( SubscribeHelper(_subMgr, request, subscribe.ResponsePort), delegate(SuccessResult success) { SendNotificationToTarget<Replace>(request.Subscriber, _subMgr, _state); }, delegate(Exception failure) { } ); }
protected BaseListener(Subscribe subscribe) { Handle = subscribe(Callback); }
public virtual IEnumerator<ITask> SubscribeHandler(Subscribe subscribe) { // handle subscriptions from other services yield return Arbiter.Choice( base.SubscribeHelper(_subMgrPort, subscribe.Body, subscribe.ResponsePort), delegate(SuccessResult success) { SendNotification<WiimoteChanged>(_subMgrPort, subscribe.Body.Subscriber, new WiimoteChanged(_state)); }, delegate(Exception fault) { LogError(fault); } ); yield break; }
public IEnumerator<ITask> SubscribeHandler(Subscribe subscribe) { SuccessFailurePort responsePort = SubscribeHelper(this.submgrPort, subscribe.Body, subscribe.ResponsePort); yield return responsePort.Choice(); var success = (SuccessResult)responsePort; if (success != null) { SendNotificationToTarget<Replace>(subscribe.Body.Subscriber, this.submgrPort, this.state); } yield break; }
public void AjaxSubscribe(Subscribe subscribe) { int i = 0; }
public IEnumerator<ITask> SubscribeHandler(Subscribe subscribe) { SubscribeHelper(_submgrPort, subscribe.Body, subscribe.ResponsePort); yield break; }
public void DistributedPubSubMediator_must_publish_to_topic() { Within(TimeSpan.FromSeconds(15), () => { RunOn(() => { var s8 = new Subscribe("topic1", CreateChatUser("u8")); Mediator.Tell(s8); ExpectMsg<SubscribeAck>(x => x.Subscribe.Equals(s8)); var s9 = new Subscribe("topic1", CreateChatUser("u9")); Mediator.Tell(s9); ExpectMsg<SubscribeAck>(x => x.Subscribe.Equals(s9)); }, _first); RunOn(() => { var s10 = new Subscribe("topic1", CreateChatUser("u10")); Mediator.Tell(s10); ExpectMsg<SubscribeAck>(x => x.Subscribe.Equals(s10)); }, _second); // one topic on two nodes AwaitCount(8); EnterBarrier("topic1-registered"); RunOn(() => { ChatUser("u5").Tell(new Shout("topic1", "hello all")); }, _third); RunOn(() => { var names = ReceiveWhile(x => "hello all".Equals(x) ? LastSender.Path.Name : null, msgs: 2); names.All(x => x == "u8" || x == "u9").Should().BeTrue(); }, _first); RunOn(() => { ExpectMsg("hello all"); LastSender.Path.Name.Should().Be("u10"); }, _second); RunOn(() => { ExpectNoMsg(TimeSpan.FromSeconds(2)); }, _third); EnterBarrier("after-7"); }); }
public virtual IEnumerator<ITask> SubscribeHandler(Subscribe subscribe) { SubscribeRequest request = subscribe.Body; Console.WriteLine("SubscribeHandler() received Subscription request from Subscriber=" + subscribe.Body.Subscriber + " for: " + request.MessageTypes); submgr.InsertSubscription insert = new submgr.InsertSubscription(request); insert.Body.FilterType = submgr.FilterType.Default; string valid = request.ValidOnly ? "True" : null; List<submgr.QueryType> query = new List<submgr.QueryType>(); if (request.MessageTypes == ChrMessageType.All || request.MessageTypes == ChrMessageType.None) { if (request.ValidOnly) { query.Add(new submgr.QueryType(null, valid)); } } else { // Subscriber supplied a bitmask requesting certain UM6 messages: if ((request.MessageTypes & ChrMessageType.GYRO_PROC) != 0) { query.Add(new submgr.QueryType(Tag_GYRO_PROC, valid)); } if ((request.MessageTypes & ChrMessageType.ACCEL_PROC) != 0) { query.Add(new submgr.QueryType(Tag_ACCEL_PROC, valid)); } if ((request.MessageTypes & ChrMessageType.MAG_PROC) != 0) { query.Add(new submgr.QueryType(Tag_MAG_PROC, valid)); } if ((request.MessageTypes & ChrMessageType.EULER) != 0) { query.Add(new submgr.QueryType(Tag_EULER, valid)); } if ((request.MessageTypes & ChrMessageType.QUAT) != 0) { query.Add(new submgr.QueryType(Tag_QUAT, valid)); } // add more types here to the query } if (query.Count > 0) { insert.Body.QueryList = query.ToArray(); } _subMgrPort.Post(insert); yield return Arbiter.Choice( insert.ResponsePort, subscribe.ResponsePort.Post, subscribe.ResponsePort.Post ); }
public virtual IEnumerator<ITask> SubscribeHandler(Subscribe subscribe) { SubscribeRequestType request = subscribe.Body; Console.WriteLine("Bumper Detection received subscribe request"); yield return Arbiter.Choice( SubscribeHelper(_subMgrPort, request, subscribe.ResponsePort), delegate(SuccessResult success) { Console.WriteLine("Bumper Detection Subscription confirmed"); //SendNotification<BumperActivated>(_subMgrPort, request.Subscriber, new Bu()); }, delegate(Exception e) { LogError(null, "Bumper Detection Subscribe failed", e); } ); yield break; }
void On(Subscribe x) => observers.Add(x.Observer);
public void SubscribeHandler(Subscribe subscribe) { Tracer.Trace("SubscribeHandler() received Subscription request from Subscriber=" + subscribe.Body.Subscriber); SubscribeHelper(_submgrPort, subscribe.Body, subscribe.ResponsePort); }
public IEnumerator<ITask> SubscribeHandler(Subscribe subscribe) { SubscribeRequestType request = subscribe.Body; LogInfo("Subscribe request from: " + request.Subscriber); SubscribeHelper(_submgrPort, request, subscribe.ResponsePort); yield break; }
public virtual IEnumerator<ITask> SubscribeHandler(Subscribe subscribe) { SubscribeRequestType request = subscribe.Body; yield return Arbiter.Choice( SubscribeHelper(_subMgrPort, request, subscribe.ResponsePort), delegate(SuccessResult success) { SendNotification<IMUNotification>(_subMgrPort, request.Subscriber, _state.Data); }, delegate(Exception e) { LogError(null, "Subscribe failed", e); } ); yield break; }
public void DistributedPubSubMediator_must_receive_proper_UnsubscribeAck_message() { Within(TimeSpan.FromSeconds(15), () => { RunOn(() => { var user = CreateChatUser("u111"); var topic = "sample-topic-14"; var s1 = new Subscribe(topic, user); Mediator.Tell(s1); ExpectMsg<SubscribeAck>(x => x.Subscribe.Equals(s1)); var uns = new Unsubscribe(topic, user); Mediator.Tell(uns); ExpectMsg<UnsubscribeAck>(x => x.Unsubscribe.Equals(uns)); }, _first); EnterBarrier("after-15"); }); }
public void DistributedPubSubMediator_must_get_topics_after_simple_publish() { Within(TimeSpan.FromSeconds(15), () => { RunOn(() => { var s1 = new Subscribe("topic_a1", CreateChatUser("u14")); Mediator.Tell(s1); ExpectMsg<SubscribeAck>(x => x.Subscribe.Equals(s1)); var s2 = new Subscribe("topic_a1", CreateChatUser("u15")); Mediator.Tell(s2); ExpectMsg<SubscribeAck>(x => x.Subscribe.Equals(s2)); var s3 = new Subscribe("topic_a2", CreateChatUser("u16")); Mediator.Tell(s3); ExpectMsg<SubscribeAck>(x => x.Subscribe.Equals(s3)); }, _first); RunOn(() => { var s3 = new Subscribe("topic_a1", CreateChatUser("u17")); Mediator.Tell(s3); ExpectMsg<SubscribeAck>(x => x.Subscribe.Equals(s3)); }, _second); EnterBarrier("topics-registered"); RunOn(() => { Mediator.Tell(GetTopics.Instance); ExpectMsg<CurrentTopics>( x => x.Topics.Contains("topic_a1") && x.Topics.Contains("topic_a2")); }, _first); RunOn(() => { // topics will eventually be replicated AwaitAssert(() => { Mediator.Tell(GetTopics.Instance); var topics = ExpectMsg<CurrentTopics>().Topics; topics.Contains("topic_a1").ShouldBeTrue(); topics.Contains("topic_a2").ShouldBeTrue(); }); }, _second); EnterBarrier("after-get-topics"); }); }
IEnumerator<ITask> SubscribeHandler(Subscribe subscribe) { Tracer.Trace("SickLRF::SubscribeHandler()"); yield return Arbiter.Choice( SubscribeHelper(_subMgrPort, subscribe.Body, subscribe.ResponsePort), delegate(SuccessResult success) { if (_state != null && _state.DistanceMeasurements != null) { _subMgrPort.Post(new submgr.Submit( subscribe.Body.Subscriber, DsspActions.ReplaceRequest, _state, null)); } }, null ); }
public virtual IEnumerator<ITask> SubscribeHandler(Subscribe subscribe) { SubscribeRequestType request = subscribe.Body; Console.WriteLine("GPS received subscribe request"); yield return Arbiter.Choice( SubscribeHelper(_subMgrPort, request, subscribe.ResponsePort), delegate(SuccessResult success) { Console.WriteLine("Subscription confirmed"); SendNotification<UTMNotification>(_subMgrPort, request.Subscriber, _state.Coords); }, delegate(Exception e) { LogError(null, "Subscribe failed", e); } ); yield break; }