/// <summary>
/// The database file name
/// </summary>
public StorageEngine(IDbIdentification parameters)
{
_reflectionService = DependencyContainer.Resolve <IReflectionService>();
try
{
var metaModelCompabilityChecker = DependencyContainer.Resolve <IMetaModelCompabilityChecker>();
DbIdentification = parameters;
IsDbClosed = false;
var isNewDatabase = DbIdentification.IsNew();
_session = DependencyContainer.Resolve <ISession>(this);
// Object Writer must be created before object Reader
_objectWriter = DependencyContainer.Resolve <IObjectWriter>(this);
ObjectReader = DependencyContainer.Resolve <IObjectReader>(this);
// Associate current session to the fsi -> all transaction writes
// will be applied to this FileSystemInterface
_session.SetFileSystemInterfaceToApplyTransaction(_objectWriter.FileSystemProcessor.FileSystemInterface);
_objectIntrospectionDataProvider = new SessionDataProvider(_session);
if (isNewDatabase)
{
_objectWriter.CreateEmptyDatabaseHeader(OdbTime.GetCurrentTimeInTicks());
}
else
{
GetObjectReader().ReadDatabaseHeader();
}
_objectWriter.AfterInit();
_objectIntrospector = new ObjectIntrospector(GetClassInfoProvider());
_triggerManager = GetLocalTriggerManager();
// This forces the initialization of the meta model
var metaModel = GetMetaModel();
var shouldUpdate = metaModelCompabilityChecker.Check(ClassIntrospector.Instrospect(metaModel.GetAllClasses()), GetMetaModel());
if (shouldUpdate)
{
UpdateMetaModel();
}
_objectWriter.SetTriggerManager(_triggerManager);
_introspectionCallbackForInsert = new InstrumentationCallbackForStore(_triggerManager, false);
_introspectionCallbackForUpdate = new InstrumentationCallbackForStore(_triggerManager, true);
}
catch
{
if (parameters is FileIdentification)
{
Monitor.Exit(string.Intern(Path.GetFullPath(parameters.FileName)));
}
throw;
}
}
public MaintainProductConfigurationTests()
{
var mockSession = new Mock<ISessionState>();
mockSession.Setup(x => x.Store(It.IsAny<string>(), It.IsAny<object>())).Callback<string, object>(
(x, y) => _sessionStore[x] = y);
mockSession.Setup(x => x.Get(It.IsAny<string>())).Returns<string>(x =>
{
object result = null;
_sessionStore.TryGetValue(x, out result);
return result;
});
var provider = new SessionDataProvider<ProductConfigSessionData>(mockSession.Object);
_container = new Container();
_container.Configure(x => x.For<ISessionDataProvider<ProductConfigSessionData>>().Use(() => provider));
}
/// <summary>
/// Create a and setup a dataDelivery provider for this sourceSourceId, and to the given sessionInformation.
/// </summary>
/// <param name="sourceSourceId"></param>
/// <returns></returns>
public SessionDataProvider CreateSessionDataProvider(ComponentId sourceId, PlatformExpertSession session /*, bool isBackTest*/)
{
// Create dataDelivery delivery (mandatory).
ISourceDataDelivery dataDelivery = ObtainDataDelivery(sourceId);
if (dataDelivery == null)
{
SystemMonitor.OperationError("Failed to create data delivery.");
return(null);
}
SessionDataProvider dataProvider = new SessionDataProvider();
// Setup the provider with the delivery.
if (dataProvider.SetInitialParameters(this, sourceId, session) == false)
{
SystemMonitor.OperationError("Failed to create session data provider.");
return(null);
}
return(dataProvider);
}
public async Task <ActionResult <Session> > Start([FromBody] StartBody body)
{
var sessionDataProvider = new SessionDataProvider();
var playerDataProvider = new PlayerDataProvider();
var elementDataProvider = new ElementDataProvider();
var addedSession = await sessionDataProvider.Add(body.RoomId);
if (addedSession == null)
{
return(NotFound());
}
var players = await playerDataProvider.GetPlayersByRoom(body.RoomId);
players.ForEach(async p =>
await elementDataProvider.AddSentence(p.Id, p.Id, 1, addedSession.Id));
await _websocketHandler.SendMessageToSockets(
JsonSerializer.Serialize(
new BaseWebsocketEvent(WebsocketEvent.SessionStart)), body.RoomId);
return(addedSession);
}
public PlatformExpertSession CreateExpertSession(DataSessionInfo?selectedSession,
ComponentId dataSourceId, ComponentId?orderExecuteId, bool isBackTest, out string operationResultMessage)
{
// Create sessionInformation (mandatory)
PlatformExpertSession session = new PlatformExpertSession(selectedSession.Value);
ComponentId actualDataSourceId = dataSourceId;
if (isBackTest)
{// We shall create a special backtesting data delivery for this session, and register it
// and use its componentId.
BackTestDataDelivery delivery = new BackTestDataDelivery();
if (delivery.SetInitialParameters(this, dataSourceId, session) == false ||
delivery.Initialize() == false)
{
operationResultMessage = "Failed to create and setup back test data delivery.";
return(null);
}
// Register the new delivery with its own ID.
this.AddElement(delivery.SourceId, delivery);
actualDataSourceId = delivery.SourceId;
}
// Create dataDelivery provider (mandatory).
SessionDataProvider dataProvider = CreateSessionDataProvider(actualDataSourceId, session);
if (dataProvider == null)
{// Failed to create data provider.
// When using back test data delivery, data provider creation not expected to fail so no need to handle this case.
operationResultMessage = "Failed to create required session data provider for this source and session.";
return(null);
}
dataProvider.Initialize(selectedSession.Value);
// Create order executor and order history (optional).
ISourceOrderExecution executionProvider = null;
if (orderExecuteId.HasValue)
{
executionProvider = ObtainOrderExecutionProvider(orderExecuteId.Value, actualDataSourceId);
}
if (session.SetInitialParameters(dataProvider, executionProvider) == false)
{
operationResultMessage = "Failed to set sessin initial parameters.";
return(null);
}
if (session.Initialize(selectedSession.Value) == false)
{
operationResultMessage = "Failed to initialize session.";
session.Dispose();
return(null);
}
operationResultMessage = string.Empty;
return(session);
}
