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);
}
}
