public async Task HandleAsync(AddMessagesCommand command) { var newMessages = GetOnlyNewMessages(command.Messages, command.ChannelId).ToList(); using var session = _sessionFactory.Create(); foreach (var message in newMessages) { await session.AddAsync(message); } }
private void AcceptNewChannel(IChannel channel) { var session = _sessionFactory.Create() as AppSession; InitializeSession(session, channel); HandleSession(session).DoNotAwait(); }
public async Task HandleAsync(AddScheduleTaskCommand command) { var scheduleTask = new ScheduleTask(command.CommandName, command.Arguments, command.ExecutionDate); using var session = _sessionFactory.Create(); await session.AddAsync(scheduleTask); }
public GetResponsesQueryResult Handle(GetResponsesQuery query) { using var session = _sessionFactory.Create(); var responses = session.Get <Response>().ToList(); return(new GetResponsesQueryResult(responses)); }
public GetMessagesQueryResult Handle(GetMessagesQuery query) { using var session = _sessionFactory.Create(); var messages = session.Get <Message>(); if (query.ServerId != 0) { messages = TakeOnlyFromOneServer(query.ServerId, messages); } if (query.ChannelId != 0) { messages = TakeOnlyFromChannel(query.ChannelId, messages); } if (query.UserId.HasValue && query.UserId != 0) { messages = TakeOnlyForUser(query.UserId.Value, messages); } var paginated = this.Paginate(query, messages); if (query.UserId.HasValue) { paginated = paginated.Where(x => x.Author.Id == query.UserId.Value); } return(new GetMessagesQueryResult(paginated)); }
public GetResponseQueryResult Handle(GetResponseQuery query) { using var session = _sessionFactory.Create(); var response = session.Get <Response>().FirstOrDefault(x => x.ServerId == query.ServerId && x.OnEvent == query.OnEvent); return(new GetResponseQueryResult(response)); }
private void OnNewChannelAccepted(IChannelListener <TPackage> listener, Channel <TPackage> channel) { _logger.LogInformation($"Channel Accepted"); var session = _sessionFactory.Create(channel); this.HandleSession(session, channel); channel.StartAsync(); }
public GetDiscordServerSafeRolesQueryResult Handle(GetDiscordServerSafeRolesQuery query) { var session = _sessionFactory.Create(); var safeRoles = session.Get <Role>() .Where(x => x.ServerId == query.ServerId); return(new GetDiscordServerSafeRolesQueryResult(safeRoles)); }
public async Task HandleAsync(SetAsExecutedScheduleTaskCommand command) { using var session = _sessionFactory.Create(); var scheduleTask = session.Get <ScheduleTask>(command.ScheduleTaskId); scheduleTask.SetAsExecuted(); await session.UpdateAsync(scheduleTask); }
public async Task HandleAsync(UpdateResponseCommand command) { using var session = _sessionFactory.Create(); var response = session.Get <Response>(command.Id); response.SetMessage(command.Message); await session.UpdateAsync(response); }
public GetInitEventsQueryResults Handle(GetInitEventsQuery query) { using var session = _sessionFactory.Create(); var initEvents = session.Get <InitEvent>() .Where(x => x.ServerId == query.ServerId); return(new GetInitEventsQueryResults(initEvents)); }
public GetServerDayStatisticsQueryResult Handle(GetServerDayStatisticsQuery query) { using var session = _sessionFactory.Create(); var statistics = session.Get <ServerDayStatistic>().AsEnumerable(); statistics = this.Paginate(query, statistics); return(new GetServerDayStatisticsQueryResult(statistics)); }
public async Task HandleAsync(MarkMuteEventAsUnmutedCommand command) { using var session = _sessionFactory.Create(); var muteEvent = session.Get <MuteEvent>(command.MuteEventGuid); muteEvent.Unmuted = true; await session.UpdateAsync(muteEvent); }
public GetMuteEventsQueryResult Handle(GetMuteEventsQuery query) { using var session = _sessionFactory.Create(); var muteEvents = session.Get <MuteEvent>() .Where(x => x.ServerId == query.ServerId); return(new GetMuteEventsQueryResult(muteEvents)); }
public GetHelpInformationQueryResult Handle(GetHelpInformationQuery query) { var session = _sessionFactory.Create(); var allHelpInfos = session.Get <HelpInformation>().ToList(); var defaultHelpInfos = allHelpInfos.Where(x => x.IsDefault); var customHelpInfos = allHelpInfos.Where(x => x.ServerId == query.ServerId).ToList(); customHelpInfos.AddRange(defaultHelpInfos.Where(x => customHelpInfos.All(c => c.MethodFullName != x.MethodFullName))); return(new GetHelpInformationQueryResult(customHelpInfos)); }
public override async void ChannelActive(IChannelHandlerContext context) { var hostId = _hostIdFactory.New(); var session = _sessionFactory.Create(_loggerFactory.CreateLogger <ProudSession>(), hostId, context.Channel); session.State = SessionState.Handshake; context.Channel.GetAttribute(ChannelAttributes.Session).Set(session); _logger?.Debug("New incoming client({HostId}) on {EndPoint}", hostId, context.Channel.RemoteAddress.ToString()); var config = new NetConfigDto { EnableServerLog = _networkOptions.EnableServerLog, FallbackMethod = _networkOptions.FallbackMethod, MessageMaxLength = _networkOptions.MessageMaxLength, TimeoutTimeMs = _networkOptions.IdleTimeout.TotalMilliseconds, DirectP2PStartCondition = _networkOptions.DirectP2PStartCondition, OverSendSuspectingThresholdInBytes = _networkOptions.OverSendSuspectingThresholdInBytes, EnableNagleAlgorithm = _networkOptions.EnableNagleAlgorithm, EncryptedMessageKeyLength = _networkOptions.EncryptedMessageKeyLength, AllowServerAsP2PGroupMember = _networkOptions.AllowServerAsP2PGroupMember, EnableP2PEncryptedMessaging = _networkOptions.EnableP2PEncryptedMessaging, UpnpDetectNatDevice = _networkOptions.UpnpDetectNatDevice, UpnpTcpAddrPortMapping = _networkOptions.UpnpTcpAddrPortMapping, EnablePingTest = _networkOptions.EnablePingTest, EmergencyLogLineCount = _networkOptions.EmergencyLogLineCount }; session.Send(new NotifyServerConnectionHintMessage(config, _rsa.ExportParameters(false))); context.Channel.Pipeline.Context(Constants.Pipeline.CoreMessageHandlerName).Read(); using (var cts = new CancellationTokenSource(_networkOptions.ConnectTimeout)) { try { await session.HandhsakeEvent.WaitAsync(cts.Token); } catch (OperationCanceledException) { if (!session.IsConnected) { return; } _logger.Debug("Client({HostId} - {EndPoint}) handshake timeout", hostId, context.Channel.RemoteAddress.ToString()); session.Send(new ConnectServerTimedoutMessage()); await session.CloseAsync(); return; } } base.ChannelActive(context); }
public GetScheduleTasksQueryResult Handle(GetScheduleTasksQuery query) { using var session = _sessionFactory.Create(); var results = session.Get <ScheduleTask>(); if (query.LoadOnlyActive) { results = results.Where(x => !x.IsExecuted); } return(new GetScheduleTasksQueryResult(results.ToList())); }
public async Task HandleAsync(RemoveResponseCommand command) { using var session = _sessionFactory.Create(); var onEvent = session.Get <Response>() .FirstOrDefault(x => x.ServerId == command.ServerId && x.OnEvent == command.OnEvent); if (onEvent == null) { return; } await session.DeleteAsync(onEvent); }
public async Task FillDatabase(IEnumerable <CommandInfo> commandInfosFromAssembly) { using var session = _sessionFactory.Create(); var commandInfosFromAssemblyList = commandInfosFromAssembly.ToList(); // for not multiple enumerating var helpInfos = session.Get <HelpInformation>().ToList(); var newCommands = FindNewCommands(commandInfosFromAssemblyList, helpInfos).ToList(); await Task.Run(() => CheckIfExistsUselessHelp(commandInfosFromAssemblyList, helpInfos)); var newHelpInfos = newCommands.Select(x => _helpInformationFactory.Create(x)); await session.AddAsync(newHelpInfos); }
private void HandleMixSessionStartSuccess(string swid, Action <IReuseExistingGuestControllerLoginResult> callback) { try { IInternalSession session = sessionFactory.Create(swid); session.Resume(delegate(IResumeSessionResult r) { HandleOfflineSessionResumed(r, session, callback); }); } catch (Exception ex) { logger.Critical("Error creating session: " + ex); callback(new ReuseExistingGuestControllerLoginResult(success: false, null)); } }
public GetMessagesQueryResult Handle(GetMessagesQuery query) { using var session = _sessionFactory.Create(); var messages = session.Get <Message>(); if (query.ServerId != 0) { messages = TakeOnlyFromOneServer(query.ServerId, messages); } var paginated = this.Paginate(query, messages); if (query is GetUserMessagesQuery userQuery) { paginated = paginated.Where(x => x.Author.Id == userQuery.UserId); } return(new GetMessagesQueryResult(paginated)); }
private async Task AcceptClients() { while (true) { var client = _factory.Create(this, await _listener.AcceptSocketAsync(), OnRecv); client.ID = FreeIndex(); if (client.ID == -1) { Logger.Error("All index are in use"); client.Disconnect(); continue; } _clients.Add(client.ID, client); Logger.Information($"New Client added at index {client.ID}"); OnConnect(client); client.Recv(); } }
private void HandleMixSessionStartSuccess(Action <ILoginResult> callback, ILoginResult loginResult, string swid, GuestApiErrorCollection gcErrorCollection, Profile profile, Disney.Mix.SDK.Internal.GuestControllerDomain.DisplayName displayName, IEnumerable <Disney.Mix.SDK.Internal.GuestControllerDomain.MarketingItem> marketing) { try { IInternalSession session = sessionFactory.Create(swid); IInternalLocalUser internalLocalUser = session.InternalLocalUser; internalLocalUser.InternalRegistrationProfile.Update(profile, displayName, marketing); session.Resume(delegate(IResumeSessionResult r) { HandleOfflineSessionResumed(r, session, loginResult, gcErrorCollection, callback); }); } catch (Exception arg) { logger.Critical("Error creating session: " + arg); callback(new LoginResult(success: false, null)); } }
private void HandleMixSessionStartSuccess(IEnumerable <IInvalidProfileItemError> errorList, string swid, Profile profile, Disney.Mix.SDK.Internal.GuestControllerDomain.DisplayName displayName, IEnumerable <Disney.Mix.SDK.Internal.GuestControllerDomain.MarketingItem> marketing, Action <IRegisterResult> callback) { try { IInternalSession session = sessionFactory.Create(swid); IInternalLocalUser internalLocalUser = session.InternalLocalUser; internalLocalUser.InternalRegistrationProfile.Update(profile, displayName, marketing); session.Resume(delegate(IResumeSessionResult r) { HandleOfflineSessionResumed(r, session, errorList, callback); }); } catch (Exception ex) { logger.Critical("Error creating session: " + ex); callback(new RegisterResult(success: false, null, null)); } }
public IInternalOfflineLastSessionResult Create() { try { SessionDocument lastLoggedInSessionDocument = database.GetLastLoggedInSessionDocument(); if (lastLoggedInSessionDocument == null) { return(new OfflineLastSessionNotFoundResult()); } IInternalSession session = sessionFactory.Create(lastLoggedInSessionDocument.Swid); return(new OfflineLastSessionResult(success: true, session)); } catch (CorruptionException arg) { logger.Fatal("Corruption detected during offline session creation: " + arg); return(new OfflineLastSessionCorruptionDetectedResult()); } catch (Exception arg2) { logger.Critical("Error creating session: " + arg2); return(new OfflineLastSessionResult(success: false, null)); } }
protected virtual void OnNewClientAccept(IListener listener, Socket socket) { var session = _sessionFactory.Create() as ServerSession; if (session == null) { // 최대수용유저를 넘어섰음 _logger.LogError("no more create session by sessionFactory"); return; } session.OnPreProcessPacket = OnPreProcessPacket; session.OnReceived = OnSessionReceived; session.OnRequestReceived = OnSessionRequestReceive; session.OnErrored = OnSessionErrored; session.Init(new SessionInitializeInfo() { AcceptedTcpSocket = socket, UdpServiceSocket = _udpSocket }); HandleSession(session).DoNotAwait(); }
/// <summary> /// Initializes session with specified handle /// </summary> /// <param name="factories">Factories to be used by Developer and Pkcs11Interop library</param> /// <param name="pkcs11Library">Low level PKCS#11 wrapper</param> /// <param name="sessionId">PKCS#11 handle of session</param> public ISession Create(Pkcs11InteropFactories factories, LowLevelPkcs11Library pkcs11Library, ulong sessionId) { return(_factory.Create(factories, pkcs11Library, sessionId)); }
private void HandleRefreshSuccess(Action <IRestoreLastSessionResult> callback, GuestControllerResult <RefreshResponse> result, SessionDocument lastSessionDoc) { try { GuestApiErrorCollection error2 = result.Response.error; RefreshData data = result.Response.data; IRestoreLastSessionResult error = GuestControllerErrorParser.GetRestoreLastSessionResult(error2); if (data == null && error != null) { if (error is IRestoreLastSessionFailedInvalidOrExpiredTokenResult && lastSessionDoc.AccountStatus == "AWAIT_PARENT_CONSENT") { callback(new RestoreLastSessionFailedParentalConsentResult()); } else { callback(error); } return; } if (data == null) { if (error2 != null) { logger.Critical("Received unhandled error exception:\n" + JsonParser.ToJson(error2) + "\nResponse headers:\n" + string.Join("\n", result.ResponseHeaders.Select((KeyValuePair <string, string> h) => h.Key + ": " + h.Value).ToArray())); } callback(new RestoreLastSessionResult(success: false, null)); return; } if (!ValidateRefreshData(data)) { logger.Critical("Error parsing the refresh data: " + JsonParser.ToJson(data)); callback(new RestoreLastSessionResult(success: false, null)); return; } Token token = data.token; lastSessionDoc.GuestControllerAccessToken = token.access_token; lastSessionDoc.GuestControllerEtag = data.etag; database.UpdateGuestControllerToken(token, data.etag); try { IInternalSession session = sessionFactory.Create(lastSessionDoc.Swid); session.Resume(delegate(IResumeSessionResult r) { HandleOfflineSessionResumed(r, session, error, callback); }); } catch (Exception ex) { logger.Critical("Error creating session: " + ex); callback(new RestoreLastSessionResult(success: false, null)); } } catch (CorruptionException ex2) { logger.Fatal("Corruption detected during session restoration: " + ex2); callback(new RestoreLastSessionCorruptionDetectedResult()); } catch (Exception ex) { logger.Critical("Unhandled exception: " + ex); callback(new RestoreLastSessionResult(success: false, null)); } }
public async Task HandleAsync(AddMuteEventCommand command) { using var session = _sessionFactory.Create(); await session.AddAsync(command.MuteEvent); }
private ISession LaunchSession(string configPath, bool isDefault, PersistentConfigFileIdMap configFileIdMap) { bool isValidated = !configPath.StartsWith(DefaultConfigPath) && !configPath.StartsWith(ExtraConfigDirPath); try { Guard.ArgumentNotNullOrEmpty(configPath, nameof(configPath)); var startTime = File.GetLastWriteTime(configPath); if (isDefault) { Debug.Assert(configPath == DefaultConfigPath, $"Default config path should be {DefaultConfigPath}, but {configPath} is initialized"); } var id = isDefault ? DefaultSessionId : GetIdOfConfigFile(configPath, configFileIdMap); var config = new ConfigurationBuilder() .AddJsonFile(configPath, optional: false, reloadOnChange: false) .Build(); if (string.IsNullOrWhiteSpace(config[ConfigConstants.CONFIG_DESCRIPTIVE_NAME])) { config[ConfigConstants.CONFIG_DESCRIPTIVE_NAME] = isDefault ? "default" : Path.GetFileNameWithoutExtension(configPath); } // If the configuration has it's own credentials, use them. // Otherwise, use the creds from the default config file. // If this is the default config, set the private field so subsequent configs can use it. var credSection = config.GetSection("Credentials"); var configHasCredentials = credSection.GetChildren().Any(); if (configHasCredentials) { _logger.LogDebug("Configuration {0} has credentials, these will be used for sources.", id); if (isDefault) { _defaultCredentialConfig = credSection; } } else { _logger.LogDebug("Configuration {0} has no credentials, using default credential section for sources.", id); credSection = _defaultCredentialConfig; } var session = _sessionFactory.Create(id, config, startTime, _typeLoader, _parameterStore, _loggerFactory, _defaultNetworkProvider, credSection, isValidated); // start the session _logger.LogDebug("Starting session {0}", id); session.Start(); if (!isDefault) { configFileIdMap[configPath] = id; } return(session); } catch (Exception ex) { throw new SessionLaunchedException(configPath, ex); } }