private IEnumerable <ChannelInformation> GetChannelAvailabilityInfo(ChannelInfo[] channelInfoList, int channelStartId, int channelEndId, double powerDBmTransitionPoint) { List <ChannelInformation> channels = new List <ChannelInformation>(); bool anyFreeChannels = channelInfoList != null && channelInfoList.Any(); //// TODO: Little bit of refactoring required below. First get all the channels details and then Free Channels, then create a list of ChannelInformation list. //// As of now, still there is no support for GetAllChannels from the region management api. for (int channelId = channelStartId; channelId <= channelEndId; channelId++) { ChannelInformation channelInformation = new ChannelInformation(); ChannelInfo channel = anyFreeChannels ? channelInfoList.FirstOrDefault(channelInfo => channelInfo.ChannelId == channelId) : null; if (channel == null) { // TODO: channel should be obtained from the GetAllChannels method from the region management api, which is not implemented yet. channel = new ChannelInfo { ChannelId = channelId }; channelInformation.OperationMode = (int)ChannelOperationMode.None; } else { channelInformation.OperationMode = (int)CommonUtility.GetChannelOperationMode(channel.MaxPowerDBm, powerDBmTransitionPoint); } channelInformation.Channel = channel; channels.Add(channelInformation); } return(channels); }
private static void ConfigureServices() { var builder = new ContainerBuilder(); var configRoot = new ConfigurationBuilder() .SetBasePath(Environment.CurrentDirectory) .AddJsonFile("appConfig.json") .AddJsonFile("AlphaVantageAPI.key") .Build(); builder.Register(c => configRoot.Get <Configuration>()) .AsSelf() .SingleInstance(); var channelInfo = new ChannelInformation() .AddChannel <ConsoleConfig>("Logger:Channels:Console") .AddChannel <FileConfig>("Logger:Channels:File"); builder.RegisterJ4JLogging <J4JLoggerConfiguration>( new ChannelFactory(configRoot, channelInfo, "Logger")); builder.RegisterType <DataRetriever>() .AsSelf() .SingleInstance(); _svcProvider = new AutofacServiceProvider(builder.Build()); }
private async Task <IClientChannel> GetChannelAsync(CancellationToken cancellationToken, string operationName) { var channelCreated = false; var clientChannel = _clientChannel; while (ShouldCreateChannel(clientChannel)) { cancellationToken.ThrowIfCancellationRequested(); await _semaphore.WaitAsync(cancellationToken).ConfigureAwait(false); try { clientChannel = _clientChannel; if (ShouldCreateChannel(clientChannel)) { _cts?.Cancel(); _cts?.Dispose(); clientChannel = _clientChannel = await _builder .BuildAndEstablishAsync(cancellationToken) .ConfigureAwait(false); _cts = new CancellationTokenSource(); _finishedSessionTask = clientChannel.ReceiveFinishedSessionAsync(_cts.Token); channelCreated = true; break; } } catch (OperationCanceledException) when(cancellationToken.IsCancellationRequested) { throw; } catch (Exception ex) { var failedChannelInformation = new FailedChannelInformation( null, SessionState.New, null, null, false, ex, operationName); var handlers = ChannelCreationFailedHandlers.ToList(); if (!await InvokeHandlersAsync(handlers, failedChannelInformation, cancellationToken).ConfigureAwait(false)) { throw; } } finally { _semaphore.Release(); } } if (channelCreated && clientChannel != null) { var channelInformation = new ChannelInformation(clientChannel.SessionId, clientChannel.State, clientChannel.LocalNode, clientChannel.RemoteNode); var handlers = ChannelCreatedHandlers.ToList(); await InvokeHandlersAsync(handlers, channelInformation, cancellationToken).ConfigureAwait(false); } return(clientChannel); }
private Task ChannelCreatedAsync(ChannelInformation channelInformation) { _logger.Information("Channel '{SessionId}' created - Local node {LocalNode} - Remote node: {RemoteNode}", channelInformation.SessionId, channelInformation.LocalNode, channelInformation.RemoteNode); return(Task.CompletedTask); }
/// <summary> /// Finds the channel and sends the information /// </summary> private async Task GetChannelInformation(MqClient client, TmqMessage message) { if (_server.AdminAuthorization == null) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } Channel channel = _server.FindChannel(message.Target); if (channel == null) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.NotFound)); return; } bool grant = await _server.AdminAuthorization.CanReceiveChannelInfo(client, channel); if (!grant) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } ChannelInformation information = new ChannelInformation { Name = channel.Name, Queues = channel.QueuesClone.Select(x => x.Id).ToArray(), AllowMultipleQueues = channel.Options.AllowMultipleQueues, AllowedQueues = channel.Options.AllowedQueues, OnlyFirstAcquirer = channel.Options.SendOnlyFirstAcquirer, RequestAcknowledge = channel.Options.RequestAcknowledge, AcknowledgeTimeout = Convert.ToInt32(channel.Options.AcknowledgeTimeout.TotalMilliseconds), MessageTimeout = Convert.ToInt32(channel.Options.MessageTimeout.TotalMilliseconds), WaitForAcknowledge = channel.Options.WaitForAcknowledge, HideClientNames = channel.Options.HideClientNames, QueueLimit = channel.Options.QueueLimit, ClientLimit = channel.Options.ClientLimit, DestroyWhenEmpty = channel.Options.DestroyWhenEmpty, ActiveClients = channel.ClientsCount() }; TmqMessage response = message.CreateResponse(); message.ContentType = KnownContentTypes.ChannelInformation; await response.SetJsonContent(information); await client.SendAsync(response); }
private Task ChannelDiscardedAsync(ChannelInformation channelInformation) { Trace.TraceInformation("Channel '{0}' discarded", channelInformation.SessionId); if (_isDisconnecting) { return(Task.CompletedTask); } return(Task.Delay(ChannelDiscardedDelay)); }
private async void HandleChangeTitleCmd(object sender, OnChatCommandReceivedArgs e) { if (!(sender is TwitchClient senderClient)) { return; } if (!Extensions.IsHost(senderClient.TwitchUsername)) { return; } string newTitle = e.Command.ArgumentsAsString; if (newTitle == null || newTitle.Length <= 0) { return; } GetUsersResponse resp = await LeTwitchBot.BotAPI.Helix.Users.GetUsersAsync(null, new List <string> { senderClient.TwitchUsername }); if (resp.Users.Length <= 0) { return; } User user = resp.Users[0]; if (!user.DisplayName.ToLower().Equals(LeTwitchBot.HostChannelName.ToLower())) { return; } GetChannelInformationResponse existingInfo = await LeTwitchBot.BotAPI.Helix.Channels.GetChannelInformationAsync(user.Id); if (existingInfo.Data.Length <= 0) { return; } ChannelInformation info = existingInfo.Data[0]; ModifyChannelInformationRequest changeReq = new ModifyChannelInformationRequest(); changeReq.BroadcasterLanguage = info.BroadcasterLanguage; changeReq.Title = newTitle; changeReq.GameId = info.GameId; await LeTwitchBot.BotAPI.Helix.Channels.ModifyChannelInformationAsync(user.Id, changeReq, LeTwitchBot.Secrets.HostChannelUserToken); LeTwitchBot.TwitchClient.SendHostChannelMessage($"Broadcaster {user.DisplayName} has changed the title of the stream to '{newTitle}' CoolCat CoolCat CoolCat CoolCat"); }
private async Task DiscardChannelUnsynchronizedAsync(IChannel clientChannel, CancellationToken cancellationToken) { if (ReferenceEquals(clientChannel, _clientChannel)) { _clientChannel = null; clientChannel.DisposeIfDisposable(); var channelInformation = new ChannelInformation(clientChannel.SessionId, clientChannel.State, clientChannel.LocalNode, clientChannel.RemoteNode); var handlers = ChannelDiscardedHandlers.ToList(); await InvokeHandlersAsync(handlers, channelInformation, cancellationToken).ConfigureAwait(false); } }
private Task ChannelDiscardedAsync(ChannelInformation channelInformation) { _logger.Information("Channel '{SessionId}' discarded - Local node: {LocalNode} - Remote node: {RemoteNode}", channelInformation.SessionId, channelInformation.LocalNode, channelInformation.RemoteNode); if (_isStopping) { return(Task.CompletedTask); } return(Task.Delay(ChannelDiscardedDelay)); }
void Awake() { if (channelInfo == null) { channelInfo = this; } else { Destroy(this); } LoadValues(); }
private void OnRegisterServer(InPacket packet) { var serverType = (ServerType)packet.Decode <byte>(); string serverName; ServerType = serverType; switch (serverType) { case ServerType.Login: var loginInformation = new LoginInformation(); loginInformation.Decode(packet); ServerID = loginInformation.ID; serverName = loginInformation.Name; break; case ServerType.Game: var channelInformation = new ChannelInformation(); channelInformation.Decode(packet); _wvsCenter.WorldInformation.Channels.Add(channelInformation); ServerID = channelInformation.ID; serverName = channelInformation.Name; break; default: using (var p = new OutPacket(InteropSendOperations.ServerRegisterResult)) { p.Encode <bool>(true); SendPacket(p); } return; } using (var p = new OutPacket(InteropSendOperations.ServerRegisterResult)) { p.Encode <bool>(false); _wvsCenter.WorldInformation.Encode(p); SendPacket(p); } using (var p = new OutPacket(InteropSendOperations.ServerInformation)) { _wvsCenter.WorldInformation.Encode(p); _wvsCenter.InteropServer.BroadcastPacket(p, new EveryOneBut(Channel.Id)); } Logger.Info($"Registered {Enum.GetName(typeof(ServerType), serverType)} server, {serverName}"); }
private void OnCheckSPWRequest(InPacket packet, bool vac) { var spw = packet.Decode <string>(); var characterID = packet.Decode <int>(); packet.Decode <string>(); // sMacAddress packet.Decode <string>(); // sMacAddressWithHDDSerial if (string.IsNullOrEmpty(Account.SPW)) { return; } if (!BCrypt.Net.BCrypt.Verify(spw, Account.SPW)) { using (var p = new OutPacket(LoginSendOperations.CheckSPWResult)) { p.Encode <bool>(false); // Unused byte SendPacket(p); } return; } if (vac) { var character = Account.Data .SelectMany(a => a.Characters) .Single(c => c.ID == characterID); _selectedWorld = _wvsLogin.InteropClients .Select(c => c.Socket.WorldInformation) .SingleOrDefault(w => w.ID == character.Data.WorldID); _selectedChannel = _selectedWorld.Channels.First(); } var world = _wvsLogin.InteropClients.Single(c => c.Socket.WorldInformation.ID == _selectedWorld.ID); using (var p = new OutPacket(InteropRecvOperations.MigrationRequest)) { p.Encode <byte>((byte)ServerType.Game); p.Encode <byte>(_selectedChannel.ID); p.Encode <string>(SessionKey); p.Encode <int>(characterID); world.Socket.SendPacket(p); } }
private IEnumerable <ChannelInformation> GetChannelInfoList(double latitude, double longitude, string incumbentType, string countryRegion, int channelStartId, int channelEndId, double powerDBmTransitionPoint) { ChannelInfo[] channelInfoList = null; List <ChannelInformation> channels = new List <ChannelInformation>(); try { channelInfoList = this.whitespacesManager.GetChannelList(incumbentType, latitude, longitude, countryRegion); } catch (Exception ex) { System.Diagnostics.Trace.TraceError(ex.ToString()); } bool anyFreeChannels = channelInfoList != null && channelInfoList.Any(); //// TODO: Little bit of refactoring required below. First get all the channels details and then Free Channels, then create a list of ChannelInformation list. //// As of now, still there is no support for GetAllChannels from the region management api. for (int channelId = channelStartId; channelId <= channelEndId; channelId++) { ChannelInformation channelInformation = new ChannelInformation(); ChannelInfo channel = anyFreeChannels ? channelInfoList.FirstOrDefault(channelInfo => channelInfo.ChannelId == channelId) : null; if (channel == null) { // TODO: channel should be obtained from the GetAllChannels method from the region management api, which is not implemented yet. channel = new ChannelInfo { ChannelId = channelId }; channelInformation.OperationMode = (int)ChannelOperationMode.None; } else { channelInformation.OperationMode = (int)CommonUtility.GetChannelOperationMode(channel.MaxPowerDBm, powerDBmTransitionPoint); } channelInformation.Channel = channel; channels.Add(channelInformation); } return(channels); }
private async void HandleSetGame(object sender, OnChatCommandReceivedArgs e) { if (!(sender is TwitchClient senderClient)) { return; } if (!Extensions.IsHost(senderClient.TwitchUsername)) { return; } string newGame = e.Command.ArgumentsAsString; if (newGame == null || newGame.Length <= 0) { return; } GetUsersResponse resp = await LeTwitchBot.BotAPI.Helix.Users.GetUsersAsync(null, new List <string> { senderClient.TwitchUsername }); if (resp.Users.Length <= 0) { return; } User user = resp.Users[0]; if (!user.DisplayName.ToLower().Equals(LeTwitchBot.HostChannelName.ToLower())) { return; } GetChannelInformationResponse existingInfo = await LeTwitchBot.BotAPI.Helix.Channels.GetChannelInformationAsync(user.Id); if (existingInfo.Data.Length <= 0) { return; } ChannelInformation info = existingInfo.Data[0]; GetGamesResponse gameResponse = await LeTwitchBot.BotAPI.Helix.Games.GetGamesAsync(null, new List <string> { newGame }); if (gameResponse.Games.Length <= 0) { LeTwitchBot.TwitchClient.SendHostChannelMessage($"Couldn't locate {newGame} :( :( :( :( "); return; } Game tehGame = gameResponse.Games[0]; ModifyChannelInformationRequest changeReq = new ModifyChannelInformationRequest(); changeReq.BroadcasterLanguage = info.BroadcasterLanguage; changeReq.Title = info.Title; changeReq.GameId = tehGame.Id; await LeTwitchBot.BotAPI.Helix.Channels.ModifyChannelInformationAsync(user.Id, changeReq, LeTwitchBot.Secrets.HostChannelUserToken); LeTwitchBot.TwitchClient.SendHostChannelMessage($"Broadcaster {user.DisplayName} will now be playin' {tehGame.Name} Kappa Kappa Kappa Kappa"); }
private void OnSelectWorld(InPacket packet) { packet.Decode <byte>(); var worldID = packet.Decode <byte>(); var channelID = packet.Decode <byte>() + 1; using (var p = new OutPacket(LoginSendOperations.SelectWorldResult)) { byte result = 0x0; var world = _wvsLogin.InteropClients .Select(c => c.Socket.WorldInformation) .SingleOrDefault(w => w.ID == worldID); var channel = world?.Channels.SingleOrDefault(c => c.ID == channelID); if (world == null) { result = 0x1; } if (channel == null) { result = 0x1; } p.Encode <byte>(result); if (result == 0) { _selectedWorld = world; _selectedChannel = channel; using (var db = _container.GetInstance <DataContext>()) { var data = Account.Data.SingleOrDefault(d => d.WorldID == worldID); if (data == null) { data = new AccountData { WorldID = worldID, SlotCount = 3 }; Account.Data.Add(data); db.Update(Account); db.SaveChanges(); } var characters = data.Characters; p.Encode <byte>((byte)characters.Count); characters.ForEach(c => { c.EncodeStats(p); c.EncodeLook(p); p.Encode <bool>(false); p.Encode <bool>(false); }); p.Encode <bool>(!string.IsNullOrEmpty(Account.SPW)); // bLoginOpt TODO: proper bLoginOpt stuff p.Encode <int>(data.SlotCount); // nSlotCount p.Encode <int>(0); // nBuyCharCount } } SendPacket(p); } }
private static async Task InvokeHandlersAsync(IEnumerable <Func <ChannelInformation, Task> > handlers, ChannelInformation channelInformation, CancellationToken cancellationToken) { var exceptions = new List <Exception>(); foreach (var handler in handlers) { cancellationToken.ThrowIfCancellationRequested(); try { await handler(channelInformation).ConfigureAwait(false); } catch (Exception ex) { exceptions.Add(ex); } } ThrowIfAny(exceptions); }
private Task ChannelCreatedAsync(ChannelInformation channelInformation) { Trace.TraceInformation("Channel '{0}' created", channelInformation.SessionId); return(Task.CompletedTask); }
public async Task Run() { var options = _container.GetInstance <WvsGameOptions>(); var info = options.GameInfo; ChannelInformation = new ChannelInformation { ID = info.ID, WorldID = info.WorldID, Name = info.Name, UserNo = 0, AdultChannel = info.AdultChannel }; CommandRegistry = _container.GetInstance <CommandRegistry>(); ItemNames = _container.GetInstance <ItemNameManager>(); FieldNames = _container.GetInstance <FieldNameManager>(); Logger.Info("Loading template names.."); await Task.WhenAll( ItemNames.LoadAll(), FieldNames.LoadAll() ); Logger.Info("Finished loading template names"); ItemOptions = _container.GetInstance <EagerTemplateManager <ItemOptionTemplate> >(); SetItemInfo = _container.GetInstance <EagerTemplateManager <SetItemInfoTemplate> >(); await Task.WhenAll( Task.Run(async() => { Logger.Info("Loading item options.."); await ItemOptions.LoadAll(); Logger.Info("Finished loading item options"); }), Task.Run(async() => { Logger.Info("Loading set item info.."); await SetItemInfo.LoadAll(); Logger.Info("Finished loading set item info"); }) ); SkillTemplates = _container.GetInstance <LazyTemplateManager <SkillTemplate> >(); ItemTemplates = _container.GetInstance <LazyTemplateManager <ItemTemplate> >(); FieldTemplates = _container.GetInstance <LazyTemplateManager <FieldTemplate> >(); NpcTemplates = _container.GetInstance <LazyTemplateManager <NPCTemplate> >(); MobTemplates = _container.GetInstance <LazyTemplateManager <MobTemplate> >(); FieldFactory = new FieldFactory(FieldTemplates, NpcTemplates, MobTemplates); using (var db = _container.GetInstance <DataContext>()) { Logger.Info("Loading npc shops.."); NPCShops = db.NPCShops .Include(s => s.Items) .ToDictionary(s => s.TemplateID, s => new NPCShopDlg(s)); Logger.Info("Finished loading npc shops"); } UserData.RegisterType <FieldUserSpeaker>(); UserData.RegisterType <FieldNPCSpeaker>(); NPCConversationManager = _container.GetInstance <ConversationManager <FieldUser, FieldNPC> >(); InteropClient = new Client <CenterServerSocket>( options.InteropClientOptions, _container.GetInstance <CenterServerSocketFactory>() ); GameServer = new Server <GameClientSocket>( options.GameServerOptions, _container.GetInstance <GameClientSocketFactory>() ); await InteropClient.Run(); Logger.Info($"Connected to interoperability server on {InteropClient.Channel.RemoteAddress}"); await GameServer.Run(); Logger.Info($"Bounded {ChannelInformation.Name} on {GameServer.Channel.LocalAddress}"); while (InteropClient.Socket == null) { ; } using (var p = new OutPacket(InteropRecvOperations.ServerRegister)) { p.Encode <byte>((byte)ServerType.Game); ChannelInformation.Encode(p); await InteropClient.Socket.SendPacket(p); } }