Esempio n. 1
0
 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();
        }
Esempio n. 3
0
        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;
        }
Esempio n. 5
0
 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());
        }
Esempio n. 7
0
 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));
 }
Esempio n. 8
0
        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));
            }
        }
Esempio n. 11
0
        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();
        }
Esempio n. 13
0
        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();
            }
        }
Esempio n. 14
0
        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");
     }
 }
Esempio n. 16
0
        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);
        }
Esempio n. 17
0
        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());
            }
        }
Esempio n. 18
0
        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"));
        }
Esempio n. 19
0
        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);
        }
Esempio n. 20
0
        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());
            }
        }
Esempio n. 21
0
        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");
        }
Esempio n. 23
0
        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");
        }
Esempio n. 25
0
        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());
        }
Esempio n. 26
0
        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;
        }
Esempio n. 27
0
        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);
            }
        }
Esempio n. 29
0
        /// <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);
            }
        }
Esempio n. 31
0
        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);
        }
Esempio n. 32
0
        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"));
        }
Esempio n. 33
0
        /// <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");
            }
        }
Esempio n. 34
0
        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);
        }
Esempio n. 35
0
 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);
 }
Esempio n. 37
0
        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;
        }
Esempio n. 39
0
 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;
         }
     );
 }
Esempio n. 40
0
        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
            );
        }
Esempio n. 41
0
 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;
 }
Esempio n. 44
0
        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) { }
            );
        }
Esempio n. 45
0
 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;
 }
Esempio n. 49
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
            );
        }
Esempio n. 52
0
        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;
        }
Esempio n. 53
0
 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);
        }
Esempio n. 55
0
 public IEnumerator<ITask> SubscribeHandler(Subscribe subscribe)
 {
     SubscribeRequestType request = subscribe.Body;
     LogInfo("Subscribe request from: " + request.Subscriber);
     SubscribeHelper(_submgrPort, request, subscribe.ResponsePort);
     yield break;
 }
Esempio n. 56
0
        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");
            });
        }
Esempio n. 59
0
        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
            );
        }
Esempio n. 60
0
        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;
        }