/// <summary> /// Subscribe using the client connection. /// </summary> /// <param name="subject">The subject.</param> /// <param name="callback">The callback.</param> /// <param name="opts">Additional options</param> /// <returns>The subscription id</returns> public int Subscribe(string subject, SubscribeCallback callback, Dictionary <string, object> opts) { if (string.IsNullOrEmpty(subject)) { return(0); } int sid = this.ssid += 1; if (opts == null) { opts = new Dictionary <string, object>(); } Subscription sub = this.subscriptions[sid] = new Subscription() { Subject = subject, Callback = callback, Received = 0, Queue = opts.ContainsKey("queue") ? Convert.ToInt32(opts["queue"], CultureInfo.InvariantCulture) : 0, Max = opts.ContainsKey("max") ? Convert.ToInt32(opts["max"], CultureInfo.InvariantCulture) : 0 }; this.SendCommand(string.Format(CultureInfo.InvariantCulture, "SUB {0} {1} {2}{3}", subject, sub.Queue == 0 ? string.Empty : sub.Queue.ToString(CultureInfo.InvariantCulture), sid, Resource.CRLF)); if (sub.Max > 0) { this.Unsubscribe(sid, sub.Max); } return(sid); }
public Listener(string topicRegex, SubscribeCallback callback, bool once = false, bool doSee = true) { TopicRegex = topicRegex; Callback = callback; Once = once; DoSee = doSee; }
/// <summary> /// Send a request and have the response delivered to the supplied callback /// </summary> /// <param name="subject">the subject </param> /// <param name="opts">additional options</param> /// <param name="callback">the callback for the response</param> /// <param name="data">data for the request</param> /// <returns>returns the subscription id</returns> public int Request(string subject, Dictionary <string, object> opts, SubscribeCallback callback, string data) { if (string.IsNullOrEmpty(subject)) { return(0); } Random rand = new Random(); string inbox = string.Format( CultureInfo.InvariantCulture, "_INBOX.{0:x4}{1:x4}{2:x4}{3:x4}{4:x4}{5:x6}", rand.Next(0x0010000), rand.Next(0x0010000), rand.Next(0x0010000), rand.Next(0x0010000), rand.Next(0x0010000), rand.Next(0x1000000)); int s = Subscribe(inbox, callback, opts); this.Publish(subject, null, data, inbox); return(s); }
public string Subscribe(string channel, SubscribeCallback cb) { subscriber.Subscribe(channel); var callbackGuid = genGuid(); if (!subscribeCallbacks.ContainsKey(channel)) { subscribeCallbacks[channel] = new Dictionary <string, SubscribeCallback>(); } subscribeCallbacks[channel][callbackGuid] = cb; if (channels.Contains(channel)) { return(callbackGuid); } channels.Add(channel); var msg = new Message { cmd = Message.Cmd.SUBSCRIBE, source_component_guid = guid, identifier = channel, payload = stringToByteArray(".") }; publisher.Publish(proxyGuid, ref msg); return(callbackGuid); }
public bool RemoveListener(SubscribeCallback listener) { bool ret = false; if (listener != null) { lock (syncLockSubscribeCallback) { try { if (SubscribeCallbackListenerList.ContainsKey(PubnubInstance.InstanceId)) { List <SubscribeCallback> callbackList = SubscribeCallbackListenerList[PubnubInstance.InstanceId]; if (callbackList.Remove(listener)) { ret = true; } SubscribeCallbackListenerList[PubnubInstance.InstanceId] = callbackList; } } catch (Exception ex) { LoggingMethod.WriteToLog(pubnubLog, string.Format("DateTime {0}, ListenerManager RemoveListener => Exception = {1}", DateTime.Now.ToString(CultureInfo.InvariantCulture), ex), pubnubConfig.LogVerbosity); } } } return(ret); }
public void RaiseEvent(EventArgs ea) { if (SubscribeCallback != null) { SubscribeCallback.Raise(typeof(PubNubUnity), ea); } }
public void AddListener(SubscribeCallback listener) { if (listener != null) { lock (syncLockSubscribeCallback) { SubscribeCallbackListenerList.Add(listener); } } }
public void ShouldNotifySubscribedCallbacks() { SubscribeCallback <ParseObject> subscribeCallback = Substitute.For <SubscribeCallback <ParseObject> >(); ParseQuery <ParseObject> query = new ParseQuery <ParseObject>("test"); Subscribe(query, subscribeCallback); subscribeCallback.Received().Invoke(query); }
public void RemoveListener(SubscribeCallback listener) { if (listener != null) { lock (syncLockSubscribeCallback) { SubscribeCallbackListenerList.Remove(listener); } } }
private Subscription <T> Subscribe <T>(ParseQuery <T> parseQuery, SubscribeCallback <T> subscribeCallback = null) where T : ParseObject { Subscription <T> subscription = _parseLiveQueryClient.Subscribe(parseQuery); if (subscribeCallback != null) { subscription.HandleSubscribe(subscribeCallback); } _webSocketClientCallback.OnMessage(MockSubscribedMessage(subscription.RequestId)); return(subscription); }
private void RaiseEvent(EventArgs ea) { if (SubscribeCallback != null) { try{ SubscribeCallback.Raise(typeof(PubNub), ea); }catch (Exception ex) { throw new PubNubUserException(ex.Message, ex); } } }
public void RemoveListener(SubscribeCallback listener) { if (listener != null) { lock (syncLockSubscribeCallback) { if (SubscribeCallbackListenerList.ContainsKey(PubnubInstance.InstanceId)) { List <SubscribeCallback> callbackList = SubscribeCallbackListenerList[PubnubInstance.InstanceId]; callbackList.Remove(listener); SubscribeCallbackListenerList[PubnubInstance.InstanceId] = callbackList; } } } }
public void AddListener(SubscribeCallback listener) { if (listener != null) { lock (syncLockSubscribeCallback) { if (SubscribeCallbackListenerList.ContainsKey(PubnubInstance.InstanceId)) { List <SubscribeCallback> callbackList = SubscribeCallbackListenerList[PubnubInstance.InstanceId]; callbackList.Add(listener); SubscribeCallbackListenerList[PubnubInstance.InstanceId] = callbackList; } else { List <SubscribeCallback> callbackList = new List <SubscribeCallback>(); callbackList.Add(listener); SubscribeCallbackListenerList.Add(PubnubInstance.InstanceId, callbackList); } } } }
public uint UnsubscribeWrap<IObserver>(string key, SubscribeCallback<IObserver> callback) where IObserver : IGrainObserver { if (!observers.ContainsKey(key)) { logger.Error($"{key}don't find observer instance.({nameof(IObserver)})"); return uint.MaxValue; } ObserverInfo info = observers[key]; if (!(info.reference is IObserver)) { logger.Error($"Type of observer isn't {nameof(IObserver)}."); return uint.MaxValue; } --info.cc; if (info.cc <= 0) callback.Invoke((IObserver)info.reference); return info.cc; }
/// <summary> /// Sends greeting message to routers. /// </summary> /// <param name="callback">Callback on reponse.</param> public void SendRouterGreetings(SubscribeCallback callback) { NatsClient.Request("router.greet", null, callback, "{}"); }
private void Subscribe(StompConnectClient client) { if (!_running) return; if (null == client) { TraceLogger.LogWarning(NonLocalizableResource.StompClientNullMessage); return; } SubscribeCallback subscriber = new SubscribeCallback(client.Subscribe); AsyncCallback callback = new AsyncCallback(GetMessages); IAsyncResult result = subscriber.BeginInvoke(callback, subscriber); }
/// <summary> /// Send a request and have the response delivered to the supplied callback /// </summary> /// <param name="subject">the subject </param> /// <param name="opts">additional options</param> /// <param name="callback">the callback for the response</param> /// <param name="data">data for the request</param> /// <returns>returns the subscription id</returns> public int Request(string subject, Dictionary<string, object> opts, SubscribeCallback callback, string data) { if (string.IsNullOrEmpty(subject)) { return 0; } Random rand = new Random(); string inbox = string.Format( CultureInfo.InvariantCulture, "_INBOX.{0:x4}{1:x4}{2:x4}{3:x4}{4:x4}{5:x6}", rand.Next(0x0010000), rand.Next(0x0010000), rand.Next(0x0010000), rand.Next(0x0010000), rand.Next(0x0010000), rand.Next(0x1000000)); int s = Subscribe(inbox, callback, opts); this.Publish(subject, null, data, inbox); return s; }
/// <summary> /// Subscribe using the client connection to a specified subject. /// </summary> /// <param name="subject">The subject.</param> /// <param name="callback">The callback.</param> /// <returns>The subscription id</returns> public int Subscribe(string subject, SubscribeCallback callback) { return(Subscribe(subject, callback, null)); }
/// <summary> /// Register a callback for when a client succesfully subscribes to a query. /// </summary> /// <param name="callback">The subscribe callback to register.</param> /// <returns>The same Subscription, for easy chaining.</returns> public Subscription <T> HandleSubscribe(SubscribeCallback <T> callback) { _subscribeCallbacks.Add(callback); return(this); }
/// <summary> /// Subscribe using the client connection to a specified subject. /// </summary> /// <param name="subject">The subject.</param> /// <param name="callback">The callback.</param> /// <returns>The subscription id</returns> public int Subscribe(string subject, SubscribeCallback callback) { return Subscribe(subject, callback, null); }
/// <summary> /// Subscribe using the client connection. /// </summary> /// <param name="subject">The subject.</param> /// <param name="callback">The callback.</param> /// <param name="opts">Additional options</param> /// <returns>The subscription id</returns> public int Subscribe(string subject, SubscribeCallback callback, Dictionary<string, object> opts) { if (string.IsNullOrEmpty(subject)) { return 0; } int sid = this.ssid += 1; if (opts == null) { opts = new Dictionary<string, object>(); } Subscription sub = this.subscriptions[sid] = new Subscription() { Subject = subject, Callback = callback, Received = 0, Queue = opts.ContainsKey("queue") ? Convert.ToInt32(opts["queue"], CultureInfo.InvariantCulture) : 0, Max = opts.ContainsKey("max") ? Convert.ToInt32(opts["max"], CultureInfo.InvariantCulture) : 0 }; this.SendCommand(string.Format(CultureInfo.InvariantCulture, "SUB {0} {1} {2}{3}", subject, sub.Queue == 0 ? string.Empty : sub.Queue.ToString(CultureInfo.InvariantCulture), sid, Resource.CRLF)); if (sub.Max > 0) { this.Unsubscribe(sid, sub.Max); } return sid; }
public string Subscribe(string channel, SubscribeCallback cb) { subscriber.Subscribe(channel); var callbackGuid = genGuid(); if (!subscribeCallbacks.ContainsKey(channel)) subscribeCallbacks[channel] = new Dictionary<string, SubscribeCallback>(); subscribeCallbacks[channel][callbackGuid] = cb; if (channels.Contains(channel)) return callbackGuid; channels.Add(channel); var msg = new Message { cmd = Message.Cmd.SUBSCRIBE, source_component_guid = guid, identifier = channel, payload = stringToByteArray(".") }; publisher.Publish(proxyGuid, ref msg); return callbackGuid; }