public static void Initialize(IServiceProvider serviceProvider)
{
using var context = new Context(serviceProvider.GetRequiredService <DbContextOptions <Context> >());
context.Database.EnsureCreated();
if (context.Users.Any() && context.Projects.Any() && context.Channels.Any() && context.ChannelUser.Any() &&
context.ProjectChannels.Any() &&
context.TaskComment.Any() && context.Tasks.Any() && context.ChannelMessages.Any() &&
context.ProjectUser.Any() && context.UserTask.Any())
{
return;
}
IUserHandler userHandler = new UserHandler(context);
IProjectHandler projectHandler = new ProjectHandler(context);
ITaskHandler taskHandler = new TaskHandler(context);
IChannelHandler channelHandler = new ChannelHandler(context);
// CreateUsers(userHandler);
// CreateProjects(projectHandler);
// CreatePendingInvitations(projectHandler);
// CreateRandomTasks(taskHandler);
// CreateChannels(channelHandler);
// AddUsersToChannels(channelHandler);
// CreateMessages(channelHandler);
// CreateSubTasks(taskHandler);
// CreateComments(taskHandler);
}
public override void PrintConsoleOptions()
{
Console.WriteLine(" D - Set store primary dataspace name");
DiscoveryHandler.PrintConsoleOptions();
ChannelHandler.PrintConsoleOptions();
ObjectHandler.PrintConsoleOptions();
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="pipeline"></param>
/// <param name="name"></param>
/// <param name="handler"></param>
public DefaultChannelHandlerContext(ChannelPipeline pipeline, string name, ChannelHandler handler, bool async)
{
ChannelPipeline = pipeline;
Name = name;
ChannelHandler = handler;
Async = async;
}
private void HandleModelShutdown(string channelName, List <MessageQueue> queues)
{
if (!_Terminate)
{
ChannelHandler handler = null;
lock (_ChannelHandlers)
{
if (_ChannelHandlers.TryGetValue(channelName, out handler))
{
lock (_Queues)
{
foreach (MessageQueue item in queues)
{
_SubscriptionToAdd.Enqueue(item);
}
}
_ChannelHandlers.Remove(channelName);
}
}
_TriggerSubscriptionRequest.Set();
}
int openChannel = Interlocked.Decrement(ref _OpenChannels);
if (openChannel == 0)
{
ApplicationEventLog.WriteEntry("Flow", string.Concat("RabbitMQSubscription - HandleModelShutdown recovery, channel = ", channelName), System.Diagnostics.EventLogEntryType.Warning);
_ConnectionShutdown = true;
_TriggerSubscriptionRequest.Set();
}
}
private static void AddUsersToChannels(ChannelHandler channelHandler)
{
channelHandler.AddUserToChannel(3, "Andrei111");
channelHandler.AddUserToChannel(3, "Deivydas111");
channelHandler.AddUserToChannel(2, "Andrei111");
channelHandler.AddUserToChannel(2, "Deivydas111");
}
private void OnUserLeft(ChannelMember member)
{
var changeOwner = member.IsOwner;
member.User.ChatChannels.Remove(this);
m_members.Remove(member.User.EntityId.Low);
if (changeOwner)
{
member = m_members.Values.FirstOrDefault();
if (member != null)
{
if (Announces)
{
ChannelHandler.SendLeftReplyToEveryone(this, member.User.EntityId);
}
Owner = member;
}
else
{
m_group.DeleteChannel(this);
m_owner = null;
}
}
}
string generateName(ChannelHandler _handler)
{
Type handlerType = _handler.GetType();
string name;
nameCaches.TryGetValue(handlerType, out name);
if (name == null)
{
name = generateName0(handlerType);
nameCaches.Add(handlerType, name);
}
if (this.context0(name) != null)
{
string baseName = name.Substring(0, name.Length - 1); // Strip the trailing '0'.
for (int i = 1; ; i++)
{
string newName = baseName + i;
if (this.context0(newName) == null)
{
name = newName;
break;
}
}
}
return(name);
}
/// <summary>
/// Retrieve the given two ChannelMembers and the Channel they are on, if they
/// are all on the channel. If not, sends corresponding error messages to user.
/// </summary>
/// <param name="user"></param>
/// <param name="channelName"></param>
/// <param name="targetName"></param>
/// <param name="userMember"></param>
/// <param name="targetMember"></param>
/// <returns></returns>
public static ChatChannel EnsurePresence(IUser user, string channelName, string targetName,
out ChannelMember userMember, out ChannelMember targetMember)
{
if (!string.IsNullOrEmpty(targetName))
{
ChatChannel chatChannel = ChatChannelGroup.RetrieveChannel(user, channelName);
if (chatChannel != null)
{
uint low = user.EntityId.Low;
if (!chatChannel.Members.TryGetValue(low, out userMember))
{
ChannelHandler.SendNotOnChannelReply((IPacketReceiver)user, channelName);
}
else
{
IUser namedEntity = World.GetNamedEntity(targetName, false) as IUser;
if (namedEntity == null ||
!chatChannel.Members.TryGetValue(namedEntity.EntityId.Low, out targetMember))
{
ChannelHandler.SendTargetNotOnChannelReply((IPacketReceiver)user, channelName, targetName);
}
else if (namedEntity != user)
{
return(chatChannel);
}
}
}
}
userMember = (ChannelMember)null;
targetMember = (ChannelMember)null;
return((ChatChannel)null);
}
private void ClearSong(ChannelHandler channel, Song song)
{
LogTo.Debug("[{0}] Clearing song {1}", channel.Name, song.track.Name);
CancellationTokenSource value;
if (tokens.TryGetValue(channel.Name + song.SongID, out value))
{
tokens.Remove(channel.Name + song.SongID);
if (value.IsCancellationRequested)
{
return;
}
}
channel.ClearVotes(song.SongID);
var model = new SongModel()
{
SongID = song.SongID,
Votes = 0,
Voters = "",
Votetime = Time.Timestamp()
};
Publish(string.Format("/{0}/playlist/{1}", channel.Name, song.SongID), JsonConvert.SerializeObject(model), true);
}
void Start()
{
channelHandler = GetComponent <ChannelHandler> ();
aSource = GetComponent <AudioSource> ();
aSource.clip = songs [channelHandler.currentChannel];
userPause = true;
}
protected virtual void RegisterChannelHandler()
{
IDictionary <string, object> [] caps;
int channel_count;
lock (supported_channels) {
channel_count = supported_channels.Count;
if (channel_count == 0)
{
return;
}
caps = new Dictionary <string, object> [channel_count];
int counter = 0;
foreach (Data.ChannelInfo channel in supported_channels)
{
caps[counter] = new Dictionary <string, object> ();
if (channel.Type == ChannelType.DBusTube)
{
DBusTubeChannelInfo tube_info = channel as DBusTubeChannelInfo;
if (tube_info != null)
{
caps[counter].Add("org.freedesktop.Telepathy.Channel.ChannelType", Constants.CHANNEL_TYPE_DBUSTUBE);
caps[counter].Add(Constants.CHANNEL_TYPE_DBUSTUBE + ".ServiceName", tube_info.Service);
}
//Log.DebugFormat ("{0} adding service {1}", this.account_id, service.Service);
}
else if (channel.Type == ChannelType.StreamTube)
{
StreamTubeChannelInfo tube_info = channel as StreamTubeChannelInfo;
if (tube_info != null)
{
caps[counter].Add("org.freedesktop.Telepathy.Channel.ChannelType", Constants.CHANNEL_TYPE_STREAMTUBE);
caps[counter].Add(Constants.CHANNEL_TYPE_STREAMTUBE + ".Service", tube_info.Service);
}
}
else if (channel.Type == ChannelType.FileTransfer)
{
FileTransferChannelInfo transfer_info = channel as FileTransferChannelInfo;
if (transfer_info != null)
{
caps[counter].Add("org.freedesktop.Telepathy.Channel.ChannelType", Constants.CHANNEL_TYPE_FILETRANSFER);
caps[counter].Add(Constants.CHANNEL_TYPE_FILETRANSFER + ".ContentType", transfer_info.ContentType);
caps[counter].Add(Constants.CHANNEL_TYPE_FILETRANSFER + ".Description", transfer_info.Description);
}
}
caps[counter].Add("org.freedesktop.Telepathy.Channel.TargetHandleType", channel.TargetHandleType);
counter++;
}
}
if (ChannelHandler == null)
{
channel_handler = ChannelHandler.Create(ClientName, caps);
}
}
public void UpgradesPipelineInSameMethodInvocation()
{
var httpServerCodec = new HttpServerCodec();
var factory = new UpgradeFactory();
var testInStackFrame = new ChannelHandler();
var upgradeHandler = new HttpServerUpgradeHandler(httpServerCodec, factory);
var channel = new EmbeddedChannel(testInStackFrame, httpServerCodec, upgradeHandler);
const string UpgradeString = "GET / HTTP/1.1\r\n" +
"Host: example.com\r\n" +
"Connection: Upgrade, HTTP2-Settings\r\n" +
"Upgrade: nextprotocol\r\n" +
"HTTP2-Settings: AAMAAABkAAQAAP__\r\n\r\n";
IByteBuffer upgrade = Unpooled.CopiedBuffer(Encoding.ASCII.GetBytes(UpgradeString));
Assert.False(channel.WriteInbound(upgrade));
//Assert.Null(channel.Pipeline.Get<HttpServerCodec>());
//Assert.NotNull(channel.Pipeline.Get("marker"));
channel.Flush();
Assert.Null(channel.Pipeline.Get <HttpServerCodec>());
Assert.NotNull(channel.Pipeline.Get("marker"));
var upgradeMessage = channel.ReadOutbound <IByteBuffer>();
const string ExpectedHttpResponse = "HTTP/1.1 101 Switching Protocols\r\n" +
"connection: upgrade\r\n" +
"upgrade: nextprotocol\r\n\r\n";
Assert.Equal(ExpectedHttpResponse, upgradeMessage.ToString(Encoding.ASCII));
Assert.True(upgradeMessage.Release());
Assert.False(channel.FinishAndReleaseAll());
}
public async Task ShouldReturnErrorWhenAdministratorIdDoesNotMatch()
{
Guid adminstratorId = Guid.NewGuid();
Guid commandAdministratorId = Guid.NewGuid();
var fakeUserRepository = new Mock <IUserRepository>();
var fakeChannelRepository = new Mock <IChannelRepository>();
fakeChannelRepository
.Setup(repository => repository.GetById(It.IsAny <Guid>()))
.ReturnsAsync((Guid id) => new GetChannelByIdQueryResult
{
Id = id,
Name = "channelOne",
Description = "The first channel",
AdministratorId = adminstratorId
});
var command = new DeleteChannelCommand
{
ChannelId = Guid.NewGuid(),
AdministratorId = commandAdministratorId
};
var handler = new ChannelHandler(fakeChannelRepository.Object, fakeUserRepository.Object);
ICommandResult result = await handler.HandleAsync(command);
result.Success.Should().BeFalse();
result.Errors.Should().HaveCountGreaterThan(0);
handler.Invalid.Should().BeTrue();
}
public async Task ShouldReturnSuccessWhenCommandIsValid()
{
Guid administratorId = Guid.NewGuid();
var fakeUserRepository = new Mock <IUserRepository>();
var fakeChannelRepository = new Mock <IChannelRepository>();
fakeChannelRepository
.Setup(repository => repository.GetById(It.IsAny <Guid>()))
.ReturnsAsync((Guid id) => new GetChannelByIdQueryResult
{
Id = id,
Name = "channelOne",
Description = "The first channel",
AdministratorId = administratorId
});
var command = new DeleteChannelCommand
{
ChannelId = Guid.NewGuid(),
AdministratorId = administratorId
};
var handler = new ChannelHandler(fakeChannelRepository.Object, fakeUserRepository.Object);
ICommandResult result = await handler.HandleAsync(command);
result.Success.Should().BeTrue();
result.Errors.Should().BeNullOrEmpty();
handler.Valid.Should().BeTrue();
fakeChannelRepository.Verify(
repository => repository.DeleteChannel(It.Is <Guid>(id => id == command.ChannelId)),
Times.Once());
}
protected AbstractBootstrap(AbstractBootstrap <B, C> bootstrap)
{
_group = bootstrap.group();
_channelFactory = bootstrap.channelFactory();
_handler = bootstrap.handler();
_localAddress = bootstrap.localAddress();
}
// TODO: This should be refactored away from a thread-per-channel design, this won't scale well
private void StartChannelScheduler(ChannelHandler channelHandler)
{
lock (schedulerlock)
{
if (runningScheduler.ContainsKey(channelHandler) && runningScheduler[channelHandler])
{
LogTo.Debug("Already running scheduler for {0}", channelHandler.Name);
return;
}
runningScheduler[channelHandler] = true;
}
var channel = channelHandler.Name;
var playlist = (ISortedPlaylistProvider)channels[channel].Playlist;
LogTo.Debug("[{0}] Starting track scheduler", channel);
Task.Run(() =>
{
while (true)
{
OneLoop(channelHandler, playlist, channel);
}
});
}
/// <summary>
/// Ensures that the given user is on the channel and has mod status.
/// If not, sends corresponding error messages to user.
/// </summary>
/// <param name="user"></param>
/// <param name="channelName"></param>
/// <returns></returns>
public static ChatChannel EnsureModerator(IUser user, string channelName)
{
ChatChannel chatChannel = ChatChannelGroup.RetrieveChannel(user, channelName);
if (chatChannel == null)
{
return((ChatChannel)null);
}
uint low = user.EntityId.Low;
ChannelMember channelMember;
if (!chatChannel.Members.TryGetValue(low, out channelMember))
{
ChannelHandler.SendNotOnChannelReply((IPacketReceiver)user, channelName);
}
else
{
if (channelMember.IsModerator)
{
return(chatChannel);
}
ChannelHandler.SendNotModeratorReply((IPacketReceiver)user, channelName);
}
return((ChatChannel)null);
}
/// <summary>
/// Retrieve the given two ChannelMembers and the Channel they are on, if they
/// are all on the channel. If not, sends corresponding error messages to user.
/// </summary>
/// <param name="user"></param>
/// <param name="channelName"></param>
/// <param name="targetName"></param>
/// <param name="userMember"></param>
/// <param name="targetMember"></param>
/// <returns></returns>
public static ChatChannel EnsurePresence(IUser user, string channelName, string targetName, out ChannelMember userMember, out ChannelMember targetMember)
{
if (!string.IsNullOrEmpty(targetName))
{
var chan = ChatChannelGroup.RetrieveChannel(user, channelName);
if (chan != null)
{
var chatterLowId = user.EntityId.Low;
if (!chan.Members.TryGetValue(chatterLowId, out userMember))
{
ChannelHandler.SendNotOnChannelReply(user, channelName);
}
else
{
var targetUser = World.GetNamedEntity(targetName, false) as IUser;
if (targetUser == null || !chan.Members.TryGetValue(targetUser.EntityId.Low, out targetMember))
{
ChannelHandler.SendTargetNotOnChannelReply(user, channelName, targetName);
}
else if (targetUser != user)
{
return(chan);
}
}
}
}
userMember = null;
targetMember = null;
return(null);
}
/// <summary>
/// Checks for whether the given member can perform a beneficial or harmful action on the targetMember
/// within this channel.
/// </summary>
/// <param name="member"></param>
/// <param name="targetMember"></param>
/// <param name="beneficial"></param>
/// <returns></returns>
public bool CheckPrivs(ChannelMember member, ChannelMember targetMember, bool beneficial)
{
if (beneficial)
{
if (!member.IsModerator || member.User.Role.IsStaff)
{
ChannelHandler.SendNotModeratorReply((IPacketReceiver)member.User, this.m_name);
return(false);
}
}
else if (targetMember > member)
{
if (targetMember.IsModerator)
{
ChannelHandler.SendNotOwnerReply((IPacketReceiver)member.User, this.m_name);
}
else
{
ChannelHandler.SendNotModeratorReply((IPacketReceiver)member.User, this.m_name);
}
return(false);
}
return(true);
}
private void OnUserLeft(ChannelMember member)
{
bool isOwner = member.IsOwner;
member.User.ChatChannels.Remove(this);
this.m_members.Remove(member.User.EntityId.Low);
if (!isOwner)
{
return;
}
member = this.m_members.Values.FirstOrDefault <ChannelMember>();
if (member != null)
{
if (this.Announces)
{
ChannelHandler.SendLeftReplyToEveryone(this, member.User.EntityId);
}
this.Owner = member;
}
else
{
this.m_group.DeleteChannel(this);
this.m_owner = (ChannelMember)null;
}
}
/// <summary>Sends a message to this channel.</summary>
/// <param name="sender">the chatter saying the message</param>
public void SendMessage(IChatter sender, string message)
{
ChannelMember channelMember;
if (!this.Members.TryGetValue(sender.EntityId.Low, out channelMember))
{
ChannelHandler.SendNotOnChannelReply((IPacketReceiver)sender, this.m_name);
}
else if (channelMember.IsMuted)
{
ChannelHandler.SendMutedReply((IPacketReceiver)sender, this.m_name);
}
else if (this.IsModerated && !channelMember.IsModerator)
{
ChannelHandler.SendNotOnChannelReply((IPacketReceiver)sender, this.m_name);
}
else
{
if (sender is IUser &&
RealmCommandHandler.HandleCommand((IUser)sender, message, (IGenericChatTarget)this))
{
return;
}
ChannelHandler.SendPacketToChannel(this,
ChatMgr.CreateNormalChatMessagePacket(sender.Name, message, Locale.Start, (Character)null));
}
}
public static Action On(string channelName, ChannelHandler handler)
{
var channel = GetChannelFromName(channelName);
if (ChannelInfo.InvalidChannel == channel)
{
throw new Exception("Channel doesn't exists or is not open.");
}
List <ChannelHandler> handlers = null;
if (!s_Handlers.TryGetValue(channel.channelId, out handlers))
{
handlers = new List <ChannelHandler> {
handler
};
s_Handlers.Add(channel.channelId, handlers);
}
else if (handlers.Contains(handler))
{
throw new Exception("Cannot add already existing channel handler for channel: " + channelName);
}
else
{
handlers.Add(handler);
}
return(() =>
{
Off(channelName, handler);
});
}
/// <summary>
/// Ensures that the given user is on the channel and has mod status.
/// If not, sends corresponding error messages to user.
/// </summary>
/// <param name="user"></param>
/// <param name="channelName"></param>
/// <returns></returns>
public static ChatChannel EnsureModerator(IUser user, string channelName)
{
var chan = ChatChannelGroup.RetrieveChannel(user, channelName);
if (chan != null)
{
var chatterLowId = user.EntityId.Low;
ChannelMember member;
if (!chan.Members.TryGetValue(chatterLowId, out member))
{
ChannelHandler.SendNotOnChannelReply(user, channelName);
}
else
{
if (!member.IsModerator)
{
ChannelHandler.SendNotModeratorReply(user, channelName);
}
else
{
return(chan);
}
}
return(null);
}
return(null);
}
/// <summary>
/// Adds a player to this channel.
/// </summary>
public void TryJoin(IUser user, string password, bool silent)
{
if (IsTrade)
{
return;
}
if (RequiresUnguilded)
{
return;
}
if (IsLFG)
{
// TODO: Add looking-for-group support
// don't join since they aren't lfg, since we have no lfg stuff!
return;
}
var lowId = user.EntityId.Low;
if (IsBanned(lowId) || (m_joinValidator != null && !m_joinValidator(this, user)))
{
ChannelHandler.SendBannedReply(user, Name);
return;
}
if (IsPresent(lowId))
{
if (!IsConstant)
{
ChannelHandler.SendAlreadyOnChannelReply(user, Name, user.EntityId);
}
return;
}
if (Password.Length > 0 && Password != password)
{
ChannelHandler.SendWrongPassReply(user, Name);
return;
}
ChannelHandler.SendYouJoinedReply(user, this);
var member = user.Role.IsStaff ? new ChannelMember(user, ChannelMemberFlags.Moderator) : new ChannelMember(user);
if (Announces)
{
ChannelHandler.SendJoinedReplyToEveryone(this, member);
}
if (!IsConstant && m_owner == null)
{
Owner = member;
}
m_members.Add(lowId, member);
user.ChatChannels.Add(this);
}
static void Main(string[] args)
{
ChannelHandler h = new ChannelHandler();
var t = h.GetBot;
t.Wait();
Console.ReadKey();
}
public void SetMuted(ChannelMember member, ChannelMember targetMember, bool muted)
{
if (targetMember.IsMuted != muted && CheckPrivs(member, targetMember, !muted))
{
targetMember.IsMuted = muted;
ChannelHandler.SendMuteStatusToEveryone(this, member.User.EntityId, targetMember.User.EntityId, muted);
}
}
internal static Action GetOrCreateChannel(string channelName, ChannelHandler handler)
{
Debug.Log($"Channel {channelName} ready");
var getOrCreateChannelFunction = s_ChannelServiceType.GetMethod("GetOrCreateChannel", BindingFlags.Public | BindingFlags.Static);
var properTypeHandler = ConvertDelegate(handler, s_ChannelHandlerType);
return(getOrCreateChannelFunction.Invoke(null, new object[] { channelName, properTypeHandler }) as Action);
}
public static Action GetOrCreateChannel(string channelName, ChannelHandler handler)
{
if (Internal_GetOrCreateChannel(channelName) == -1)
{
throw new Exception("Cannot create channel: " + channelName);
}
return(On(channelName, handler));
}
private void OneLoop(ChannelHandler channelHandler, ISortedPlaylistProvider playlist, string channel)
{
Song song = playlist.GetTopSong();
if (song == null)
{
LogTo.Debug("[{0}] No songs in channel, waiting for a song", channel);
while (playlist.GetTopSong() == null)
{
Thread.Sleep(1000);
}
LogTo.Debug("[{0}] Got a song", channel);
return;
}
if (!song.track.Loaded)
{
if (playlist.Songs.Count == 1)
{
LogTo.Warn("[{0}] Only one song in channel, waiting for it to load: {1}", channel, song.SongID);
song.track.onLoad = () => { LogTo.Debug("Got it!"); };
while ((!song.track.Loaded) && playlist.Songs.Count == 1)
{
Thread.Sleep(1000);
}
LogTo.Debug("[{0}] Song loaded or another was added", channel);
return;
}
LogTo.Warn("[{0}] Skipping song: track not loaded {1}", channel, song.SongID);
ClearSong(channelHandler, song);
Thread.Sleep(1000);
return;
}
CancellationTokenSource token = new CancellationTokenSource();
tokens[channelHandler.Name + song.SongID] = token;
var songtime = song.track.Seconds;
PlaySong(channelHandler, song);
var time = DateTime.Now.AddMilliseconds((int)Math.Ceiling(songtime * 1000));
while ((DateTime.Now < time) && !token.IsCancellationRequested)
{
Thread.Sleep(100);
}
ClearSong(channelHandler, song);
tokens.Remove(channelHandler.Name + song.SongID);
token.Dispose();
}
public TThriftClient(TProtocol protocol, IMessageSender messageSender, IMessageListener messageListener, ChannelHandler channelHandler, ILogger logger) : base(protocol, protocol)
{
_diagnosticListener = new DiagnosticListener(DiagnosticListenerExtensions.DiagnosticListenerName);
_messageSender = messageSender;
_channelHandler = channelHandler;
_logger = logger;
_protocol = protocol;
messageListener.Received += MessageListener_Received;
}
public void CanHandleChannelMessages()
{
var handler = new ChannelHandler();
bool result = false;
var messageTestCases = new List<EventMessageBase>
{
new ChannelArchive { Type = EventType.ChannelArchive },
new ChannelCreated { Type = EventType.ChannelCreated },
new ChannelDeleted { Type = EventType.ChannelDeleted },
new ChannelJoined { Type = EventType.ChannelJoined },
new ChannelLeft { Type = EventType.ChannelLeft },
new ChannelMarked { Type = EventType.ChannelMarked },
new ChannelRename { Type = EventType.ChannelRename },
new ChannelUnarchive { Type = EventType.ChannelUnarchive },
};
foreach (var messageTestCase in messageTestCases)
{
result = handler.CanHandle(messageTestCase);
Assert.True(result);
}
}
private async void RunHandler(EventMessageBase message, Mock<IBotState> mockState)
{
var handler = new ChannelHandler();
handler.BotState = mockState.Object;
var result = await handler.HandleMessageAsync(message);
mockState.Verify();
}
private void ProcessSubscriptionRequests()
{
bool connectionError = false;
DateTime? nextErrorLogTime = null;
while (!_Terminate)
{
try
{
connectionError = false;
_ConnectionShutdown = false;
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.uri = _Server.Uri;
if (!string.IsNullOrEmpty(_Server.Username))
connectionFactory.UserName = _Server.Username;
if (!string.IsNullOrEmpty(_Server.Password))
connectionFactory.Password = _Server.Password;
_OpenChannels = 0;
using (IConnection connection = connectionFactory.CreateConnection())
{
while (!_Terminate && !_ConnectionShutdown)
{
_TriggerSubscriptionRequest.Reset();
while (_SubscriptionToAdd.Count > 0)
{
lock (_ChannelHandlers)
{
ChannelHandler handler;
IModel channel;
MessageQueue queue;
lock (_Queues)
{
queue = _SubscriptionToAdd.Dequeue();
}
if (queue != null)
{
if (!_ChannelHandlers.TryGetValue(queue.ChannelName, out handler))
{
channel = connection.CreateModel();
channel.BasicQos(0, 1, false);
channel.ExchangeDeclare(DALRabbitMQ.EXCHANGE_NAME, ExchangeType.Topic, true, false, null);
handler = new ChannelHandler(queue.ChannelName, channel, connectionFactory, this);
_ChannelHandlers.Add(queue.ChannelName, handler);
Interlocked.Increment(ref _OpenChannels);
}
channel = handler.Channel;
queue.Channel = channel;
handler.AddQueue(queue);
channel.QueueDeclare(queue.QueueName, queue.Durable, queue.Temporary, false, null);
channel.QueueBind(queue.QueueName, DALRabbitMQ.EXCHANGE_NAME, queue.RoutingKey);
channel.BasicConsume(queue.QueueName, false, queue.QueueName, handler);
}
}
}
_TriggerSubscriptionRequest.WaitOne();
}
// Handle shutdown
lock (_ChannelHandlers)
{
foreach (ChannelHandler item in _ChannelHandlers.Values)
{
item.StopProcessingMessages();
item.WaitForIdle(TimeSpan.FromSeconds(10));
if (item.Channel.IsOpen)
item.Channel.Close(200, "Goodbye");
}
_ChannelHandlers.Clear();
}
if (connection.IsOpen)
connection.Close();
}
if (_ConnectionShutdown)
connectionError = true;
}
catch (ThreadAbortException)
{
break;
}
catch (Exception ex)
{
connectionError = true;
if (!nextErrorLogTime.HasValue || nextErrorLogTime.Value < DateTime.UtcNow)
{
StringBuilder errorMessage = new StringBuilder();
errorMessage.AppendLine(ex.ToString());
if (ex.InnerException != null)
{
errorMessage.AppendLine("\r\nInnerException:");
errorMessage.AppendLine(ex.InnerException.ToString());
}
ApplicationEventLog.WriteEntry("Flow", string.Concat("ProcessSubscriptionRequests (", _Server.Uri.DnsSafeHost, "):\r\n", errorMessage.ToString()), System.Diagnostics.EventLogEntryType.Error);
nextErrorLogTime = DateTime.UtcNow.Add(TimeSpan.FromSeconds(60));
}
}
if (connectionError)
{
lock (_Queues)
{
_SubscriptionToAdd.Clear();
foreach (KeyValuePair<string, MessageQueue> item in _Queues)
{
_SubscriptionToAdd.Enqueue(item.Value);
}
}
lock (_ChannelHandlers)
{
_ChannelHandlers.Clear();
}
Thread.Sleep(500);
}
}
}
void Start()
{
channelHandler = GetComponent<ChannelHandler> ();
aSource = GetComponent<AudioSource> ();
aSource.clip = songs [channelHandler.currentChannel];
userPause = true;
}