/// <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;
}
/// <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, "{}");
}
