public async Task <PublishSchemaPayload> PublishSchemaAsync(
PublishSchemaInput input,
[Service] IMessageSender <PublishDocumentMessage> messageSender,
[Service] IFileStorage fileStorage,
[Service] ISessionCreator sessionCreator,
[DataLoader] SchemaByNameDataLoader schemaDataLoader,
[DataLoader] EnvironmentByNameDataLoader environmentDataLoader,
CancellationToken cancellationToken)
{
Schema schema = await schemaDataLoader.LoadAsync(
input.SchemaName, cancellationToken)
.ConfigureAwait(false);
Environment environment = await environmentDataLoader.LoadAsync(
input.EnvironmentName, cancellationToken)
.ConfigureAwait(false);
if (input.ExternalId == null && string.IsNullOrEmpty(input.SourceText))
{
throw new GraphQLException(
Resources.SchemaMutations_HashAndSourceTextAreNull);
}
string sessionId = await sessionCreator.CreateSessionAsync(cancellationToken)
.ConfigureAwait(false);
if (input.SourceText is { })
public void ResetMakesFixedRandomNumberGeneratorToUseNextRandomNumber()
{
// given
var target = CreateSessionCreator();
ISessionCreator targetExplicit = target;
var randomNumberBeforeReset = target.RandomNumberGenerator.NextPositiveLong();
// when
for (var i = 0; i < 5; i++)
{
// then
Assert.That(target.RandomNumberGenerator.NextPositiveLong(), Is.EqualTo(randomNumberBeforeReset));
}
// and when
targetExplicit.Reset();
var randomNumberAfterReset = target.RandomNumberGenerator.NextPositiveLong();
// then
Assert.That(randomNumberBeforeReset, Is.Not.EqualTo(randomNumberAfterReset));
for (var i = 0; i < 5; i++)
{
Assert.That(target.RandomNumberGenerator.NextPositiveLong(), Is.EqualTo(randomNumberAfterReset));
}
}
public PlayerItemDaoImpl(
ISessionCreator sessionCreator,
IDatabaseItemStatDao databaseItemStatDao,
SqlDialect dialect) : base(sessionCreator, dialect)
{
_databaseItemStatDao = databaseItemStatDao;
}
public static bool Migrate(ISessionCreator factory)
{
string[] files =
{
Path.Combine(GlobalPaths.UserdataFolder, GlobalPaths.USERDATA_FILE),
Path.Combine(GlobalPaths.UserdataFolder, "userdata-hc.db")
};
foreach (var dbfile in files)
{
if (!File.Exists(dbfile))
{
logger.Info("Migration requested but already performed. Halted.");
return(true);
}
if (!Migrator <PlayerItem> .Execute(factory, CreateLegacySessionFactory(dbfile), dbfile.Contains("-hc")))
{
logger.Warn("Failed to items");
return(false);
}
else
{
// Rename it, so its not migrated again.
if (File.Exists(string.Format("{0}.legacy", dbfile)))
{
File.Delete(string.Format("{0}.legacy", dbfile));
}
File.Move(dbfile, string.Format("{0}.legacy", dbfile));
logger.Info("Migration successful, old database renamed to .legacy");
}
}
return(true);
}
public async Task <PublishClientPayload> PublishClientAsync(
PublishClientInput input,
[Service] IMessageSender <PublishDocumentMessage> messageSender,
[Service] IFileStorage fileStorage,
[Service] ISessionCreator sessionCreator,
[DataLoader] SchemaByNameDataLoader schemaDataLoader,
[DataLoader] ClientByNameDataLoader clientDataLoader,
[DataLoader] EnvironmentByNameDataLoader environmentDataLoader,
CancellationToken cancellationToken)
{
if (input.Files.Count == 0)
{
throw new GraphQLException("You have to provide at least one query file.");
}
Schema schema = await schemaDataLoader.LoadAsync(
input.SchemaName, cancellationToken)
.ConfigureAwait(false);
Client client = await clientDataLoader.LoadAsync(
input.ClientName, cancellationToken)
.ConfigureAwait(false);
Environment environment = await environmentDataLoader.LoadAsync(
input.EnvironmentName, cancellationToken)
.ConfigureAwait(false);
string sessionId = await sessionCreator.CreateSessionAsync(cancellationToken)
.ConfigureAwait(false);
IFileContainer container = await fileStorage.CreateContainerAsync(
sessionId, cancellationToken)
.ConfigureAwait(false);
foreach (QueryFile file in input.Files)
{
await container.CreateTextFileAsync(
file.Name, file.SourceText, cancellationToken)
.ConfigureAwait(false);
}
await messageSender.SendAsync(
new PublishDocumentMessage(
sessionId,
environment.Id,
schema.Id,
client.Id,
input.ExternalId,
input.Format == QueryFileFormat.GraphQL
? DocumentType.Query
: DocumentType.Schema,
input.Tags is null
? Array.Empty <Tag>()
: input.Tags.Select(t => new Tag(t.Key, t.Value)).ToArray()),
cancellationToken)
.ConfigureAwait(false);
return(new PublishClientPayload(sessionId, input.ClientMutationId));
}
public GameManager(Settings settings, ISessionCreator sessionCreator, IGameSession session, IGameController gameController, ISessionHolder sessionHolder, IObsController obsController, ReplayFileWriter replayFileWriter)
{
this.settings = settings;
this.sessionCreater = sessionCreator;
this.session = session;
this.gameController = gameController;
this.sessionHolder = sessionHolder;
this.obsController = obsController;
this.replayFileWriter = replayFileWriter;
}
/// <summary>
/// When the hash field got introduced, some users ended up with a NULL value, causing issues when later on fetching using "record || hash"
/// </summary>
/// <param name="sessionCreator"></param>
public void Migrate(ISessionCreator sessionCreator)
{
using (ISession session = sessionCreator.OpenSession()) {
using (ITransaction transaction = session.BeginTransaction()) {
session.CreateSQLQuery(
$"UPDATE {DatabaseItemTable.Table} SET {DatabaseItemTable.Hash} = 0 WHERE {DatabaseItemTable.Hash} IS NULL"
).ExecuteUpdate();
transaction.Commit();
}
}
}
public async Task <PublishSchemaPayload> PublishSchemaAsync(
PublishSchemaInput input,
[Service] IMessageSender <PublishDocumentMessage> messageSender,
[Service] IFileStorage fileStorage,
[Service] ISessionCreator sessionCreator,
[DataLoader] SchemaByNameDataLoader schemaDataLoader,
[DataLoader] EnvironmentByNameDataLoader environmentDataLoader,
CancellationToken cancellationToken)
{
Schema schema = await schemaDataLoader.LoadAsync(
input.SchemaName, cancellationToken)
.ConfigureAwait(false);
Environment environment = await environmentDataLoader.LoadAsync(
input.EnvironmentName, cancellationToken)
.ConfigureAwait(false);
if (string.IsNullOrEmpty(input.SourceText))
{
throw new GraphQLException(
Resources.SchemaMutations_HashAndSourceTextAreNull);
}
string sessionId = await sessionCreator.CreateSessionAsync(cancellationToken)
.ConfigureAwait(false);
IFileContainer container = await fileStorage.CreateContainerAsync(
sessionId, cancellationToken)
.ConfigureAwait(false);
using (Stream stream = await container.CreateFileAsync(
"schema.graphql", cancellationToken)
.ConfigureAwait(false))
{
byte[] buffer = Encoding.UTF8.GetBytes(input.SourceText);
await stream.WriteAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
}
await messageSender.SendAsync(
new PublishDocumentMessage(
sessionId,
environment.Id,
schema.Id,
input.ExternalId,
input.Tags is null
? Array.Empty <Tag>()
: input.Tags.Select(t => new Tag(t.Key, t.Value)).ToArray()),
cancellationToken)
.ConfigureAwait(false);
return(new PublishSchemaPayload(sessionId, input.ClientMutationId));
}
public void Migrate(ISessionCreator sessionCreator)
{
Logger.Debug("Executing migration");
using (ISession session = sessionCreator.OpenSession()) {
using (ITransaction transaction = session.BeginTransaction()) {
foreach (var line in Sql)
{
session.CreateSQLQuery(line).ExecuteUpdate();
}
transaction.Commit();
}
}
}
public static bool Execute(ISessionCreator factory, ISessionFactory legacySessionFactory, bool isHardcore)
{
try {
IList <T> elements;
using (var legacy = legacySessionFactory.OpenSession()) {
elements = legacy.CreateCriteria <T>().List <T>();
}
using (var session = factory.OpenSession()) {
using (var transaction = session.BeginTransaction()) {
session.CreateQuery("DELETE FROM PlayerItemStat").ExecuteUpdate();
session.CreateQuery("DELETE FROM PlayerItem").ExecuteUpdate();
foreach (var item in elements)
{
PlayerItem copy = new PlayerItem {
BaseRecord = item.BaseRecord,
EnchantmentRecord = item.EnchantmentRecord,
EnchantmentSeed = item.EnchantmentSeed,
MateriaCombines = item.MateriaCombines,
MateriaRecord = item.MateriaRecord,
ModifierRecord = item.ModifierRecord,
PrefixRecord = item.PrefixRecord,
RelicCompletionBonusRecord = item.RelicCompletionBonusRecord,
RelicSeed = item.RelicSeed,
Seed = item.Seed,
StackCount = Math.Max(1, item.StackCount),
SuffixRecord = item.SuffixRecord,
TransmuteRecord = item.TransmuteRecord,
UNKNOWN = item.UNKNOWN,
Mod = item.Mod,
IsHardcore = isHardcore,
//IsExpansion1 = item.IsExpansion1
};
session.Save(copy);
}
transaction.Commit();
}
}
return(true);
} catch (Exception ex) {
logger.Warn(ex.Message);
logger.Warn(ex.StackTrace);
return(false);
}
}
internal SessionLifecycleHandler(
ISessionLoader sessionLoader,
ISessionCreator sessionCreator,
ISessionWriter sessionWriter,
WrapSession wrapSession,
ICookieWriter cookieWriter,
IExpirationRetriever expirationRetriever)
{
_sessionLoader = sessionLoader;
_sessionCreator = sessionCreator;
_sessionWriter = sessionWriter;
_wrapSession = wrapSession;
_cookieWriter = cookieWriter;
_expirationRetriever = expirationRetriever;
}
/// <summary>
/// When the hash field got introduced, some users ended up with a NULL value, causing issues when later on fetching using "record || hash"
/// </summary>
/// <param name="sessionCreator"></param>
public void Migrate(ISessionCreator sessionCreator)
{
try {
using (ISession session = sessionCreator.OpenSession()) {
using (ITransaction transaction = session.BeginTransaction()) {
session.CreateSQLQuery($"ALTER TABLE {PlayerItemTable.Table} ADD COLUMN CreatedAt BIGINT").ExecuteUpdate();
session.CreateSQLQuery($"UPDATE {PlayerItemTable.Table} SET CreatedAt = 0").ExecuteUpdate();
transaction.Commit();
}
}
}
catch (Exception ex) {
// Probably okay, without version control of the db, nothing to do.
}
}
public void CreateSessionGivesSessionsWithSameRandomizedDeviceId()
{
// given
mockPrivacyConfiguration.IsDeviceIdSendingAllowed.Returns(false);
var target = CreateSessionCreator();
ISessionCreator targetExplicit = target;
var randomizedDeviceId = target.RandomNumberGenerator.NextPositiveLong();
// when
var obtainedOne = targetExplicit.CreateSession(mockParent);
var obtainedTwo = targetExplicit.CreateSession(mockParent);
var obtainedThree = targetExplicit.CreateSession(mockParent);
// then
Assert.That(obtainedOne.Beacon.DeviceId, Is.EqualTo(randomizedDeviceId));
Assert.That(obtainedTwo.Beacon.DeviceId, Is.EqualTo(randomizedDeviceId));
Assert.That(obtainedThree.Beacon.DeviceId, Is.EqualTo(randomizedDeviceId));
}
internal SessionProxy(
ILogger logger,
IOpenKitComposite parent,
ISessionCreator sessionCreator,
ITimingProvider timingProvider,
IBeaconSender beaconSender,
ISessionWatchdog sessionWatchdog)
{
this.logger = logger;
this.parent = parent;
this.sessionCreator = sessionCreator;
this.timingProvider = timingProvider;
this.beaconSender = beaconSender;
this.sessionWatchdog = sessionWatchdog;
var currentServerConfig = beaconSender.LastServerConfiguration;
CreateInitialSessionAndMakeCurrent(currentServerConfig);
}
public void CreateSessionIncreasesSessionSequenceNumber()
{
// given
var target = CreateSessionCreator();
ISessionCreator targetExplicit = target;
Assert.That(target.SessionSequenceNumber, Is.EqualTo(0));
// when
targetExplicit.CreateSession(mockParent);
// then
Assert.That(target.SessionSequenceNumber, Is.EqualTo(1));
// and when
targetExplicit.CreateSession(mockParent);
// then
Assert.That(target.SessionSequenceNumber, Is.EqualTo(2));
}
public void ResetResetsSessionSequenceNumber()
{
// given
var target = CreateSessionCreator();
ISessionCreator targetExplicit = target;
for (var i = 0; i < 5; i++)
{
// when
var session = targetExplicit.CreateSession(mockParent);
// then
Assert.That(session.Beacon.SessionSequenceNumber, Is.EqualTo(i));
}
// and when
targetExplicit.Reset();
// then
Assert.That(target.SessionSequenceNumber, Is.EqualTo(0));
}
public void ResetMakesFixedSessionIdProviderToUseNextSessionId()
{
// given
const int sessionIdBeforeReset = 17;
const int sessionIdAfterReset = 42;
mockSessionIdProvider.GetNextSessionId().Returns(sessionIdBeforeReset, sessionIdAfterReset);
mockPrivacyConfiguration.IsSessionNumberReportingAllowed.Returns(true);
var target = CreateSessionCreator();
ISessionCreator targetExplicit = target;
// when
for (var i = 0; i < 5; i++)
{
var session = targetExplicit.CreateSession(mockParent);
var beacon = session.Beacon;
// then
Assert.That(beacon.SessionNumber, Is.EqualTo(sessionIdBeforeReset));
Assert.That(beacon.SessionSequenceNumber, Is.EqualTo(i));
}
// and when
targetExplicit.Reset();
// then
for (var i = 0; i < 5; i++)
{
var session = targetExplicit.CreateSession(mockParent);
var beacon = session.Beacon;
// then
Assert.That(beacon.SessionNumber, Is.EqualTo(sessionIdAfterReset));
Assert.That(beacon.SessionSequenceNumber, Is.EqualTo(i));
}
}
public DatabaseItemDaoImpl(ISessionCreator sessionCreator) : base(sessionCreator)
{
}
public BuddyItemRepo(ThreadExecuter threadExecuter, ISessionCreator sessionCreator) : base(threadExecuter, sessionCreator)
{
_repo = new BuddyItemDaoImpl(sessionCreator);
this.BaseRepo = _repo;
}
public DatabaseItemRepo(ThreadExecuter threadExecuter, ISessionCreator sessionCreator) : base(threadExecuter, sessionCreator)
{
this._repo = new DatabaseItemDaoImpl(sessionCreator);
this.BaseRepo = _repo;
}
public DatabaseSettingRepo(ThreadExecuter threadExecuter, ISessionCreator sessionCreator) : base(threadExecuter, sessionCreator)
{
this.repo = new DatabaseSettingDaoImpl(sessionCreator);
this.BaseRepo = repo;
}
public PlayerItemDaoImpl(ISessionCreator sessionCreator, IDatabaseItemStatDao databaseItemStatDao) : base(sessionCreator)
{
_databaseItemStatDao = databaseItemStatDao;
}
public AugmentationItemDaoImpl(ISessionCreator sessionCreator, IDatabaseItemStatDao databaseItemStatDao) : base(sessionCreator)
{
_databaseItemStatDao = databaseItemStatDao;
}
public BuddySubscriptionRepo(ThreadExecuter threadExecuter, ISessionCreator sessionCreator, SqlDialect dialect) : base(threadExecuter, sessionCreator)
{
repo = new BuddySubscriptionDaoImpl(sessionCreator, dialect);
this.BaseRepo = repo;
}
public BuddyItemDaoImpl(ISessionCreator sessionCreator) : base(sessionCreator)
{
//
}
public RecipeItemRepo(ThreadExecuter threadExecuter, ISessionCreator sessionCreator) : base(threadExecuter, sessionCreator)
{
this.repo = new RecipeItemDaoImpl(sessionCreator);
this.BaseRepo = repo;
}
public PlayerItemRepo(ThreadExecuter threadExecuter, ISessionCreator sessionCreator) : base(threadExecuter, sessionCreator)
{
this.repo = new PlayerItemDaoImpl(sessionCreator, new DatabaseItemStatDaoImpl(sessionCreator));
this.BaseRepo = repo;
}
public ReplicaItemDaoImpl(ISessionCreator sessionCreator, SqlDialect dialect) : base(sessionCreator, dialect)
{
}
protected BaseDao(ISessionCreator sessionCreator)
{
this.SessionCreator = sessionCreator;
}
public MigrationHandler(ISessionCreator sessionCreator)
{
this._sessionCreator = sessionCreator;
}
