/// <summary>
/// Indicates whether is subscribed to a channel.
/// </summary>
/// <param name="channel">The channel name.</param>
/// <returns>
/// <c>true</c> if subscribed to the channel; otherwise, <c>false</c>.
/// </returns>
public bool IsSubscribed(string channel)
{
bool result = false;
if (!IsConnected)
{
DelegateExceptionCallback(new OrtcNotConnectedException("Not connected"));
}
else if (String.IsNullOrEmpty(channel))
{
DelegateExceptionCallback(new OrtcEmptyFieldException("Channel is null or empty"));
}
else if (!channel.OrtcIsValidInput())
{
DelegateExceptionCallback(new OrtcInvalidCharactersException("Channel has invalid characters"));
}
else
{
result = false;
if (_client._subscribedChannels.ContainsKey(channel))
{
ChannelSubscription channelSubscription = null;
_client._subscribedChannels.TryGetValue(channel, out channelSubscription);
if (channelSubscription != null && channelSubscription.IsSubscribed)
{
result = true;
}
}
}
return(result);
}
public async Task ItShouldRequestSnapshotAfterUpdate()
{
await this.DatabaseTestAsync(async testDatabase =>
{
var trackingDatabase = new TrackingConnectionFactory(testDatabase);
this.target = new UnsubscribeFromChannelDbStatement(trackingDatabase, this.requestSnapshot);
await this.CreateDataAsync(testDatabase);
await testDatabase.TakeSnapshotAsync();
this.requestSnapshot.VerifyConnectionDisposed(trackingDatabase);
await this.target.ExecuteAsync(UserId, Subscriptions[0].ChannelId);
this.requestSnapshot.VerifyCalledWith(UserId, SnapshotType.SubscriberChannels);
var deletion = new ChannelSubscription(
Subscriptions[0].ChannelId.Value,
null,
UserId.Value,
null,
Subscriptions[0].AcceptedPrice.Value,
PriceLastAcceptedDate,
SubscriptionStartDate);
return(new ExpectedSideEffects {
Delete = deletion
});
});
}
public async Task WhenTheSubscriptionExists_ItShouldUpdateTheSubscription()
{
await this.DatabaseTestAsync(async testDatabase =>
{
this.target = new UpdateChannelSubscriptionDbStatement(testDatabase, this.requestSnapshot);
await this.CreateDataAsync(testDatabase);
await testDatabase.TakeSnapshotAsync();
await this.target.ExecuteAsync(UserId, Subscriptions[0].ChannelId, NewAcceptedPrice, Now);
var update = new ChannelSubscription(
Subscriptions[0].ChannelId.Value,
null,
UserId.Value,
null,
NewAcceptedPrice.Value,
Now,
SubscriptionStartDate);
return(new ExpectedSideEffects {
Update = update
});
});
}
public async Task WhenTheSubscriptionExists_ItShouldDeleteTheSubscription()
{
await this.DatabaseTestAsync(async testDatabase =>
{
this.target = new UnsubscribeFromChannelDbStatement(testDatabase, this.requestSnapshot);
await this.CreateDataAsync(testDatabase);
await testDatabase.TakeSnapshotAsync();
await this.target.ExecuteAsync(UserId, Subscriptions[0].ChannelId);
var deletion = new ChannelSubscription(
Subscriptions[0].ChannelId.Value,
null,
UserId.Value,
null,
Subscriptions[0].AcceptedPrice.Value,
PriceLastAcceptedDate,
SubscriptionStartDate);
return(new ExpectedSideEffects {
Delete = deletion
});
});
}
public void PubSubWithDedicatedThreadWithFilter()
{
using (var fiber = new ThreadFiber())
{
fiber.Start();
var channel = new Channel <int>();
var reset = new AutoResetEvent(false);
Action <int> onMsg = x =>
{
Assert.IsTrue(x % 2 == 0);
if (x == 4)
{
reset.Set();
}
};
var sub = new ChannelSubscription <int>(fiber, onMsg);
sub.FilterOnProducerThread = x => x % 2 == 0;
channel.SubscribeOnProducerThreads(sub);
channel.Publish(1);
channel.Publish(2);
channel.Publish(3);
channel.Publish(4);
Assert.IsTrue(reset.WaitOne(5000, false));
}
}
private void OnSubscribe(BitfinexWebSocketWrapper webSocket, ChannelSubscription data)
{
try
{
lock (_locker)
{
var channel = new Channel(data.Channel, _symbolMapper.GetLeanSymbol(data.Symbol, SecurityType.Crypto, Market.Bitfinex));
BitfinexWebSocketChannels channels;
if (!_channelsByWebSocket.TryGetValue(webSocket, out channels))
{
_onSubscribeEvent.Set();
return;
}
channels.TryAdd(data.ChannelId, channel);
Log.Trace($"BitfinexSubscriptionManager.OnSubscribe(): Channel subscribed: Id:{data.ChannelId} {channel.Symbol}/{channel.Name}");
_onSubscribeEvent.Set();
webSocket.ConnectionHandler.EnableMonitoring(true);
}
}
catch (Exception e)
{
Log.Error(e);
throw;
}
}
public async Task <IActionResult> NewSubscriber()
{
ChannelSubscription sub = new ChannelSubscription("{'displayName':'WilliamGates'}");
await _hubContext.Clients.All.SendAsync("ReceiveNewSubscriber", sub);
return(RedirectToAction("test"));
}
public override void Unsubscribe(string channel)
{
#region Sanity Checks
bool sanityChecked = true;
if (!IsConnected)
{
RaiseOnException(new OrtcException("Not connected"));
sanityChecked = false;
}
else if (String.IsNullOrEmpty(channel))
{
RaiseOnException(new OrtcException("Channel is null or empty"));
sanityChecked = false;
}
else if (!channel.OrtcIsValidInput())
{
RaiseOnException(new OrtcException("Channel has invalid characters"));
sanityChecked = false;
}
else if (!_subscribedChannels.ContainsKey(channel))
{
RaiseOnException(new OrtcException(String.Format("Not subscribed to the channel {0}", channel)));
sanityChecked = false;
}
else if (_subscribedChannels.ContainsKey(channel))
{
ChannelSubscription channelSubscription = null;
_subscribedChannels.TryGetValue(channel, out channelSubscription);
if (channelSubscription != null && !channelSubscription.IsSubscribed)
{
RaiseOnException(new OrtcException(String.Format("Not subscribed to the channel {0}", channel)));
sanityChecked = false;
}
}
else
{
byte[] channelBytes = Encoding.UTF8.GetBytes(channel);
if (channelBytes.Length > MAX_CHANNEL_SIZE)
{
RaiseOnException(new OrtcException(String.Format("Channel size exceeds the limit of {0} characters", MAX_CHANNEL_SIZE)));
sanityChecked = false;
}
}
#endregion
if (sanityChecked)
{
Task.RunOnMain(() =>
{
IosOrtcClientFactory.Unsubscribe(_id, channel);
});
}
}
private void CreateSubscriptions(FifthweekUser user)
{
var subscriptionIndicies = this.GenerageUniqueIndexes(this.channels.Count, Random.Next(0, SubscriptionsPerUser + 1));
foreach (var channelIndex in subscriptionIndicies)
{
var subscription = new ChannelSubscription(this.channels[channelIndex].Id, null, user.Id, null, Random.Next(1, 500), DateTime.UtcNow.AddDays(-10 - Random.Next(0, 5)), DateTime.UtcNow.AddDays(Random.Next(1, 5)));
this.subscriptions.Add(subscription);
}
}
private async Task AddUsersToChannelAsync(List <int> userIds, int channelId, int workspaceId)
{
userIds.ForEach(id =>
{
var channelSubscription = new ChannelSubscription(channelId, id);
_context.ChannelSubscriptions.Add(channelSubscription);
});
await _context.SaveChangesAsync();
await _messageCommandService.PostJoinChannelSystemMessageAsync(channelId, userIds, workspaceId);
}
public async Task ExecuteAsync(UserId userId, BlogId blogId, IReadOnlyList <AcceptedChannelSubscription> channels, DateTime now)
{
userId.AssertNotNull("userId");
blogId.AssertNotNull("blogId");
if (channels == null || channels.Count == 0)
{
channels = new List <AcceptedChannelSubscription>();
}
using (var transaction = TransactionScopeBuilder.CreateAsync())
{
using (var connection = this.connectionFactory.CreateConnection())
{
await connection.ExecuteAsync(
DeleteStatement,
new
{
BlogId = blogId.Value,
SubscriberId = userId.Value,
KeepChannelIds = channels.Select(v => v.ChannelId.Value).ToList()
});
foreach (var item in channels)
{
var channelSubscription = new ChannelSubscription(
item.ChannelId.Value,
null,
userId.Value,
null,
item.AcceptedPrice.Value,
now,
now);
const ChannelSubscription.Fields UpdateFields
= ChannelSubscription.Fields.AcceptedPrice
| ChannelSubscription.Fields.PriceLastAcceptedDate;
await connection.UpsertAsync(
channelSubscription,
UpdateFields);
}
}
await this.requestSnapshot.ExecuteAsync(userId, SnapshotType.SubscriberChannels);
transaction.Complete();
}
}
public async Task WhenTheSubscriptionHasChangedChanged_ItShouldUpdateTheSubscription()
{
await this.DatabaseTestAsync(async testDatabase =>
{
this.target = new UpdateBlogSubscriptionsDbStatement(testDatabase, this.requestSnapshot);
await this.CreateDataAsync(testDatabase);
await testDatabase.TakeSnapshotAsync();
await this.target.ExecuteAsync(UserId, Blog3Id, AcceptedBlog3Subscriptions2, Now);
var expectedUpdate = new ChannelSubscription(
AcceptedBlog3Subscriptions2[0].ChannelId.Value,
null,
UserId.Value,
null,
AcceptedBlog3Subscriptions2[0].AcceptedPrice.Value,
Now,
SubscriptionStartDate);
var expectedInsert = new ChannelSubscription(
AcceptedBlog3Subscriptions2[1].ChannelId.Value,
null,
UserId.Value,
null,
AcceptedBlog3Subscriptions2[1].AcceptedPrice.Value,
Now,
Now);
var expectedDelete = new ChannelSubscription(
AcceptedBlog3Subscriptions1[1].ChannelId.Value,
null,
UserId.Value,
null,
AcceptedBlog3Subscriptions1[1].AcceptedPrice.Value,
PriceLastAcceptedDate,
SubscriptionStartDate);
return(new ExpectedSideEffects
{
Update = expectedUpdate,
Insert = expectedInsert,
Delete = expectedDelete
});
});
}
/// <summary>
/// Subscribes to a channel.
/// </summary>
/// <param name="channel">Channel name.</param>
/// <param name="subscribeOnReconnected">Subscribe to the specified channel on reconnect.</param>
/// <param name="onMessage"><see cref="OnMessageDelegate"/> callback.</param>
/// <example>
/// <code>
/// ortcClient.Subscribe("channelName", true, OnMessageCallback);
/// private void OnMessageCallback(object sender, string channel, string message)
/// {
/// // Do something
/// }
/// </code>
/// </example>
public void Subscribe(string channel, bool subscribeOnReconnected, OnMessageDelegate onMessage)
{
if (!IsConnected)
{
DelegateExceptionCallback(new OrtcNotConnectedException("Not connected"));
}
else if (String.IsNullOrEmpty(channel))
{
DelegateExceptionCallback(new OrtcEmptyFieldException("Channel is null or empty"));
}
else if (!channel.OrtcIsValidInput())
{
DelegateExceptionCallback(new OrtcInvalidCharactersException("Channel has invalid characters"));
}
else if (channel.Length > Constants.MAX_CHANNEL_SIZE)
{
DelegateExceptionCallback(new OrtcMaxLengthException(String.Format("Channel size exceeds the limit of {0} characters", Constants.MAX_CHANNEL_SIZE)));
}
else if (_client._subscribedChannels.ContainsKey(channel))
{
ChannelSubscription channelSubscription = null;
_client._subscribedChannels.TryGetValue(channel, out channelSubscription);
if (channelSubscription != null)
{
if (channelSubscription.IsSubscribing)
{
DelegateExceptionCallback(new OrtcSubscribedException(String.Format("Already subscribing to the channel {0}", channel)));
}
else if (channelSubscription.IsSubscribed)
{
DelegateExceptionCallback(new OrtcSubscribedException(String.Format("Already subscribed to the channel {0}", channel)));
}
else
{
_client.subscribe(channel, subscribeOnReconnected, onMessage);
}
}
}
else
{
_client.subscribe(channel, subscribeOnReconnected, onMessage);
}
}
public void PubSubFilterTest()
{
Channel <int> channel = new Channel <int>();
SynchronousCommandQueue queue = new SynchronousCommandQueue();
int received = 0;
Action <int> onReceive = delegate(int data)
{
Assert.IsTrue(data % 2 == 0);
received++;
};
ChannelSubscription <int> subber = new ChannelSubscription <int>(queue, onReceive);
subber.FilterOnProducerThread = delegate(int msg) { return(msg % 2 == 0); };
channel.SubscribeOnProducerThreads(subber);
for (int i = 0; i <= 4; i++)
{
channel.Publish(i);
}
Assert.AreEqual(3, received);
}
/// <summary>
/// Creates a client that listens to the newly created channel according to the specified filter
/// </summary>
/// <param name="filter">Filter to apply</param>
/// <returns></returns>
public static ILogClient CreateReliableClient(FilterBase filter)
{
if (Configuration == null || Configuration.endpoint == null ||
string.IsNullOrEmpty(Configuration.endpoint.basePath))
{
throw new InvalidOperationException("Logbus is not configured for default client");
}
string mgmEndpoint = FormatScriptPath("LogbusManagement", Configuration.endpoint.basePath,
Configuration.endpoint.suffix),
subEndpoint = FormatScriptPath("LogbusSubscription", Configuration.endpoint.basePath,
Configuration.endpoint.suffix);
IChannelManagement mgmObject = new ChannelManagement {
Url = mgmEndpoint, UserAgent = UserAgent
};
IChannelSubscription subObject = new ChannelSubscription {
Url = subEndpoint, UserAgent = UserAgent
};
return(new SyslogTlsClient(filter, mgmObject, subObject));
}
public async Task ExecuteAsync(
UserId userId,
ChannelId channelId,
ValidAcceptedChannelPrice acceptedPrice,
DateTime now)
{
userId.AssertNotNull("userId");
channelId.AssertNotNull("channelId");
acceptedPrice.AssertNotNull("acceptedPrice");
using (var transaction = TransactionScopeBuilder.CreateAsync())
{
using (var connection = this.connectionFactory.CreateConnection())
{
var channelSubscription = new ChannelSubscription(
channelId.Value,
null,
userId.Value,
null,
acceptedPrice.Value,
now,
now);
const ChannelSubscription.Fields UpdateFields
= ChannelSubscription.Fields.AcceptedPrice
| ChannelSubscription.Fields.PriceLastAcceptedDate;
await connection.UpsertAsync(
channelSubscription,
UpdateFields);
}
await this.requestSnapshot.ExecuteAsync(userId, SnapshotType.SubscriberChannels);
transaction.Complete();
}
}
/// <summary>
/// Wrapper for using all the prebuilt subscriptions. Not recommended for performance but makes the library easier to
/// use for some quick testing.
/// </summary>
/// <param name="logFile"></param>
public SubscriptionWrapper(LogFile logFile)
{
var tellSubscription = new TellSubscription(logFile);
tellSubscription.Matched += TellSubscription_Matched;
Subscriptions.Add(tellSubscription);
var saySubscription = new SaySubscription(logFile);
saySubscription.Matched += SaySubscription_Matched;
Subscriptions.Add(saySubscription);
var shoutSubscription = new ShoutSubscription(logFile);
shoutSubscription.Matched += ShoutSubscription_Matched;
Subscriptions.Add(shoutSubscription);
var oocSubscription = new OocSubscription(logFile);
oocSubscription.Matched += OocSubscription_Matched;
Subscriptions.Add(oocSubscription);
var groupChatSubscription = new GroupChatSubscription(logFile);
groupChatSubscription.Matched += GroupChatSubscription_Matched;
Subscriptions.Add(groupChatSubscription);
var guildChatSubscription = new GuildChatSubscription(logFile);
guildChatSubscription.Matched += GuildChatSubscription_Matched;
Subscriptions.Add(guildChatSubscription);
var auctionSubscription = new AuctionSubscription(logFile);
auctionSubscription.Matched += AuctionSubscription_Matched;
Subscriptions.Add(auctionSubscription);
var channelSubscription = new ChannelSubscription(logFile);
channelSubscription.Matched += ChannelSubscription_Matched;
Subscriptions.Add(channelSubscription);
var factionSubscription = new FactionSubscription(logFile);
factionSubscription.Matched += FactionSubscription_Matched;
Subscriptions.Add(factionSubscription);
var physicalHitSubscription = new PhysicalHitSubscription(logFile);
physicalHitSubscription.Matched += PhysicalHitSubscription_Matched;
Subscriptions.Add(physicalHitSubscription);
var physicalMissSubscription = new PhysicalMissSubscription(logFile);
physicalMissSubscription.Matched += PhysicalMissSubscription_Matched;
Subscriptions.Add(physicalMissSubscription);
var fizzleSubscription = new FizzleSubscription(logFile);
fizzleSubscription.Matched += FizzleSubscription_Matched;
Subscriptions.Add(fizzleSubscription);
var spellWornSubscription = new WornOffSubscription(logFile);
spellWornSubscription.Matched += SpellWornSubscription_Matched;
Subscriptions.Add(spellWornSubscription);
var dotSubscription = new DotSubscription(logFile);
dotSubscription.Matched += DotSubscription_Matched;
Subscriptions.Add(dotSubscription);
var spellImmunitySubscription = new ImmunitySubscription(logFile);
spellImmunitySubscription.Matched += SpellImmunitySubscription_Matched;
Subscriptions.Add(spellImmunitySubscription);
var spellDamageSubscription = new SpellDamageSubscription(logFile);
spellDamageSubscription.Matched += SpellDamageSubscription_Matched;
Subscriptions.Add(spellDamageSubscription);
//create death sub last to make sure it comes after combat subscriptions for most common use cases
var deathSubscription = new DeathSubscription(logFile);
deathSubscription.Matched += DeathSubscription_Matched;
Subscriptions.Add(deathSubscription);
var experienceSubscription = new ExperienceSubscription(logFile);
experienceSubscription.Matched += ExperienceSubscription_Matched;
Subscriptions.Add(experienceSubscription);
var levelSubscription = new LevelSubscription(logFile);
levelSubscription.Matched += LevelSubscription_Matched;
Subscriptions.Add(levelSubscription);
var zoneSubscription = new ZoneSubscription(logFile);
zoneSubscription.Matched += ZoneSubscription_Matched;
Subscriptions.Add(zoneSubscription);
var skillUpSubscription = new SkillUpSubscription(logFile);
skillUpSubscription.Matched += SkillUpSubscription_Matched;
Subscriptions.Add(skillUpSubscription);
}
public void PubSubFilterTest()
{
Channel<int> channel = new Channel<int>();
SynchronousCommandQueue queue = new SynchronousCommandQueue();
int received = 0;
Action<int> onReceive = delegate(int data)
{
Assert.IsTrue(data%2 == 0);
received++;
};
ChannelSubscription<int> subber = new ChannelSubscription<int>(queue, onReceive);
subber.FilterOnProducerThread = delegate(int msg) { return msg%2 == 0; };
channel.SubscribeOnProducerThreads(subber);
for (int i = 0; i <= 4; i++)
{
channel.Publish(i);
}
Assert.AreEqual(3, received);
}
/// <summary>
/// Broadcasts the last subscriber to listening clients
/// </summary>
/// <param name="newChannelSubscription">Last subscriber to the stream</param>
private async Task BroadcastNewSubscriber(ChannelSubscription newChannelSubscription)
{
await _alertHubConnection.InvokeAsync("BroadcastNewSubscriber", newChannelSubscription);
}
/// <summary>
/// Selects the best IP address to use for listening
/// </summary>
/// <returns></returns>
protected IPAddress GetIpAddress()
{
/*
* If client is using OUR proxy, ie. no one re-implemented the
* subscription interface with another mechanism like CORBA or
* Remoting, we know where the Logbus web listener is located.
*
* By creating a fake UDP client, we want C# to activate the
* system's routing tables (unavailable from language) to find
* the interface that is used to connect to Logbus. In scenarios
* in which a machine is connected both to LAN(s) and WAN, Logbus
* might either be in one of the LANs or in the WAN. If we chose
* the WAN address (see below) as favourite address, we might
* do an error, as that address won't work in the case Logbus
* server has only LAN access.
*
* This method to find the local address doesn't work in the
* following scenario:
* Logbus HTTP listener and the node that will actually send
* the Syslog messages are deployed into different machines
* that run in different subnets, especially if they have WAN
* access. We will fix this situation too, but it's very rare.
*/
if (ChannelSubscriber is ChannelSubscription)
{
try
{
ChannelSubscription cs = ChannelSubscriber as ChannelSubscription;
string hostname =
Regex.Match(cs.Url,
"^(?<protocol>https?)://(?<host>[-A-Z0-9.]+)(?<port>:[0-9]{1,5})?(?<file>/[-A-Z0-9+&@#/%=~_|!:,.;]*)?(?<parameters>\\?[-A-Z0-9+&@#/%=~_|!:,.;]*)?",
RegexOptions.IgnoreCase).Groups["host"].Value;
IPAddress hostIp = Dns.GetHostAddresses(hostname)[0];
//If we are contacting a local host, tell to use loopback
if (hostIp.Equals(IPAddress.Loopback))
{
return(IPAddress.Loopback);
}
//Just force a routing table lookup, we don't need more
UdpClient fakeClient = new UdpClient();
fakeClient.Connect(hostname, 65534);
return(((IPEndPoint)fakeClient.Client.LocalEndPoint).Address);
}
catch
{
} //Never mind...
}
//Else try to find the best WAN address to use
/*
* The following mechanism might not work in the following scenario:
* -Client node is connected to LAN and WAN with 2 network cards
* -Logbus is listening on a computer that can access only LAN
*
* In this case, client tries to use WAN address for listening,
* but Logbus won't be able to send datagrams to it.
* This is a structural bug in the getIPAddress logic that may be
* solved by the above commented code, but...
*
* The above code, that implements a backup choice algorithm
* that forces the system's routing table to be activated, works
* by assuming that Logbus HTTP endpoint coincides with the host
* that actually sends UDP datagrams. While this happens 99% of
* times, it's not the only possible scenario.
*/
return(NetworkUtils.GetMyIPAddress());
}
public async Task BroadcastSubscription(ChannelSubscription subscription)
{
await UpdateLastSubscriberAsync();
await Clients.All.SendAsync("ReceiveNewSubscription", _lastSubscriber);
}
public async Task BroadcastNewSubscriber(ChannelSubscription newChannelSubscription)
{
await Clients.All.ReceiveNewSubscriber(newChannelSubscription);
}
internal void subscribe(string channel, bool subscribeOnReconnected, OrtcClient.OnMessageDelegate onMessage)
{
var domainChannelCharacterIndex = channel.IndexOf(':');
var channelToValidate = channel;
if (domainChannelCharacterIndex > 0)
{
channelToValidate = channel.Substring(0, domainChannelCharacterIndex + 1) + "*";
}
string hash = _permissions.Where(c => c.Key == channel || c.Key == channelToValidate).FirstOrDefault().Value;
if (_permissions != null && _permissions.Count > 0 && String.IsNullOrEmpty(hash))
{
context.DelegateExceptionCallback(new OrtcNotConnectedException(String.Format("No permission found to subscribe to the channel '{0}'", channel)));
}
else
{
if (!_subscribedChannels.ContainsKey(channel))
{
_subscribedChannels.TryAdd(channel,
new ChannelSubscription {
IsSubscribing = true,
IsSubscribed = false,
SubscribeOnReconnected = subscribeOnReconnected,
OnMessage = onMessage
});
}
try {
if (_subscribedChannels.ContainsKey(channel))
{
ChannelSubscription channelSubscription = null;
_subscribedChannels.TryGetValue(channel, out channelSubscription);
channelSubscription.IsSubscribing = true;
channelSubscription.IsSubscribed = false;
channelSubscription.SubscribeOnReconnected = subscribeOnReconnected;
channelSubscription.OnMessage = onMessage;
}
string s = String.Format("subscribe;{0};{1};{2};{3}", context._applicationKey, context._authenticationToken, channel, hash);
DoSend(s);
} catch (Exception ex) {
string exName = null;
if (ex.InnerException != null)
{
exName = ex.InnerException.GetType().Name;
}
switch (exName)
{
case "OrtcNotConnectedException":
// Server went down
if (context.IsConnected)
{
DoDisconnect();
}
break;
default:
context.DelegateExceptionCallback(new OrtcGenericException(String.Format("Unable to subscribe: {0}", ex)));
break;
}
}
}
}
public void PubSubWithDedicatedThreadWithFilter()
{
using (var fiber = new ThreadFiber())
{
fiber.Start();
var channel = new Channel<int>();
var reset = new AutoResetEvent(false);
Action<int> onMsg = x =>
{
Assert.IsTrue(x % 2 == 0);
if (x == 4)
{
reset.Set();
}
};
var sub = new ChannelSubscription<int>(fiber, onMsg);
sub.FilterOnProducerThread = x => x % 2 == 0;
channel.SubscribeOnProducerThreads(sub);
channel.Publish(1);
channel.Publish(2);
channel.Publish(3);
channel.Publish(4);
Assert.IsTrue(reset.WaitOne(5000, false));
}
}
private void parseMessage(string message)
{
string type = JObject.Parse(message).SelectToken("type")?.ToString();
switch (type.ToLower())
{
case "response":
Models.PubSub.Responses.Response resp = new Models.PubSub.Responses.Response(message);
if (previousRequest != null && previousRequest.Nonce.ToLower() == resp.Nonce.ToLower())
{
OnListenResponse?.Invoke(this, new OnListenResponseArgs {
Response = resp, Topic = previousRequest.Topic, Successful = resp.Successful
});
return;
}
break;
case "message":
Models.PubSub.Responses.Message msg = new Models.PubSub.Responses.Message(message);
switch (msg.Topic.Split('.')[0])
{
case "channel-subscribe-events-v1":
ChannelSubscription subscription = (ChannelSubscription)msg.messageData;
OnChannelSubscription?.Invoke(this, new OnChannelSubscriptionArgs {
Subscription = subscription
});
return;
case "whispers":
Whisper whisper = (Whisper)msg.messageData;
OnWhisper?.Invoke(this, new OnWhisperArgs {
Whisper = whisper
});
return;
case "chat_moderator_actions":
ChatModeratorActions cMA = (ChatModeratorActions)msg.messageData;
string reason = "";
switch (cMA.ModerationAction.ToLower())
{
case "timeout":
if (cMA.Args.Count > 2)
{
reason = cMA.Args[2];
}
OnTimeout?.Invoke(this, new OnTimeoutArgs {
TimedoutBy = cMA.CreatedBy, TimedoutUser = cMA.Args[0],
TimeoutDuration = TimeSpan.FromSeconds(int.Parse(cMA.Args[1])), TimeoutReason = reason
});
return;
case "ban":
if (cMA.Args.Count > 1)
{
reason = cMA.Args[1];
}
OnBan?.Invoke(this, new OnBanArgs {
BannedBy = cMA.CreatedBy, BannedUser = cMA.Args[0], BanReason = reason
});
return;
case "unban":
OnUnban?.Invoke(this, new OnUnbanArgs {
UnbannedBy = cMA.CreatedBy, UnbannedUser = cMA.Args[0]
});
return;
case "untimeout":
OnUntimeout?.Invoke(this, new OnUntimeoutArgs {
UntimeoutedBy = cMA.CreatedBy, UntimeoutedUser = cMA.Args[0]
});
return;
case "host":
OnHost?.Invoke(this, new OnHostArgs {
HostedChannel = cMA.Args[0], Moderator = cMA.CreatedBy
});
return;
case "subscribers":
OnSubscribersOnly?.Invoke(this, new OnSubscribersOnlyArgs {
Moderator = cMA.CreatedBy
});
return;
case "subscribersoff":
OnSubscribersOnlyOff?.Invoke(this, new OnSubscribersOnlyOffArgs {
Moderator = cMA.CreatedBy
});
return;
case "clear":
OnClear?.Invoke(this, new OnClearArgs {
Moderator = cMA.CreatedBy
});
return;
case "emoteonly":
OnEmoteOnly?.Invoke(this, new OnEmoteOnlyArgs {
Moderator = cMA.CreatedBy
});
return;
case "emoteonlyoff":
OnEmoteOnlyOff?.Invoke(this, new OnEmoteOnlyOffArgs {
Moderator = cMA.CreatedBy
});
return;
case "r9kbeta":
OnR9kBeta?.Invoke(this, new OnR9kBetaArgs {
Moderator = cMA.CreatedBy
});
return;
case "r9kbetaoff":
OnR9kBetaOff?.Invoke(this, new OnR9kBetaOffArgs {
Moderator = cMA.CreatedBy
});
return;
}
break;
case "channel-bits-events-v1":
ChannelBitsEvents cBE = (ChannelBitsEvents)msg.messageData;
OnBitsReceived?.Invoke(this, new OnBitsReceivedArgs {
BitsUsed = cBE.BitsUsed, ChannelId = cBE.ChannelId, ChannelName = cBE.ChannelName,
ChatMessage = cBE.ChatMessage, Context = cBE.Context, Time = cBE.Time, TotalBitsUsed = cBE.TotalBitsUsed, UserId = cBE.UserId, Username = cBE.Username
});
return;
case "video-playback":
VideoPlayback vP = (VideoPlayback)msg.messageData;
switch (vP.Type)
{
case Enums.VideoPlaybackType.StreamDown:
OnStreamDown?.Invoke(this, new OnStreamDownArgs {
PlayDelay = vP.PlayDelay, ServerTime = vP.ServerTime
});
return;
case Enums.VideoPlaybackType.StreamUp:
OnStreamUp?.Invoke(this, new OnStreamUpArgs {
PlayDelay = vP.PlayDelay, ServerTime = vP.ServerTime
});
return;
case Enums.VideoPlaybackType.ViewCount:
OnViewCount?.Invoke(this, new OnViewCountArgs {
ServerTime = vP.ServerTime, Viewers = vP.Viewers
});
return;
}
break;
}
break;
}
if (logging)
{
unaccountedFor(message);
}
}
public override void Subscribe(string channel, OnMessageDelegate onMessage)
{
#region Sanity Checks
bool sanityChecked = true;
if (!IsConnected)
{
RaiseOnException(new OrtcException("Not connected"));
sanityChecked = false;
}
else if (String.IsNullOrEmpty(channel))
{
RaiseOnException(new OrtcException("Channel is null or empty"));
sanityChecked = false;
}
else if (!channel.OrtcIsValidInput())
{
RaiseOnException(new OrtcException("Channel has invalid characters"));
sanityChecked = false;
}
else if (_subscribedChannels.ContainsKey(channel))
{
ChannelSubscription channelSubscription = null;
_subscribedChannels.TryGetValue(channel, out channelSubscription);
if (channelSubscription != null)
{
if (channelSubscription.IsSubscribing)
{
RaiseOnException(new OrtcException(String.Format("Already subscribing to the channel {0}", channel)));
sanityChecked = false;
}
else if (channelSubscription.IsSubscribed)
{
RaiseOnException(new OrtcException(String.Format("Already subscribed to the channel {0}", channel)));
sanityChecked = false;
}
}
}
else
{
byte[] channelBytes = Encoding.UTF8.GetBytes(channel);
if (channelBytes.Length > MAX_CHANNEL_SIZE)
{
if (_subscribedChannels.ContainsKey(channel))
{
ChannelSubscription channelSubscription = null;
_subscribedChannels.TryGetValue(channel, out channelSubscription);
if (channelSubscription != null)
{
channelSubscription.IsSubscribing = false;
}
}
RaiseOnException(new OrtcException(String.Format("Channel size exceeds the limit of {0} characters", MAX_CHANNEL_SIZE)));
sanityChecked = false;
}
}
#endregion
if (sanityChecked)
{
if (!_subscribedChannels.ContainsKey(channel))
{
_subscribedChannels.Add(channel,
new ChannelSubscription
{
IsSubscribing = true,
IsSubscribed = false,
SubscribeOnReconnected = true,
OnMessage = onMessage
});
}
if (_subscribedChannels.ContainsKey(channel))
{
ChannelSubscription channelSubscription = null;
_subscribedChannels.TryGetValue(channel, out channelSubscription);
channelSubscription.IsSubscribing = true;
channelSubscription.IsSubscribed = false;
channelSubscription.SubscribeOnReconnected = true;
channelSubscription.OnMessage = onMessage;
}
TaskManager.RunOnMainThread(() =>
{
_javaObject.Call("Subscribe", channel, true);
});
}
}
