/// <summary>
/// Setups Global object
/// </summary>
/// <param name="settings">Application config</param>
/// <param name="storage">Permanent storage object</param>
public static async Task Setup(BaseSettings settings, IStorage storage)
{
ExtensionsManager = new ExtensionsManager();
Settings = settings ?? throw new ArgumentNullException(nameof(settings));
DynamicSerializersInitializer.Init();
IsAlpha = Settings is AlphaSettings;
PermanentStorage = storage;
await PermanentStorage.OpenConnection(settings.ConnectionString);
PersistenceManager = new PersistenceManager(PermanentStorage);
StellarNetwork = new StellarNetwork(Settings.NetworkPassphrase, Settings.HorizonUrl);
QuantumProcessor = new QuantumProcessorsStorage();
PendingUpdatesManager = new PendingUpdatesManager();
PendingUpdatesManager.OnBatchSaved += PendingUpdatesManager_OnBatchSaved;
AppState = IsAlpha ? new AlphaStateManager() : (StateManager) new AuditorStateManager();
AppState.StateChanged += AppState_StateChanged;
//try to load last settings, we need it to know current auditors
var lastHash = new byte[] { };
var lastApex = await PersistenceManager.GetLastApex();
if (lastApex >= 0)
{
var lastQuantum = await PersistenceManager.GetQuantum(lastApex);
lastHash = lastQuantum.Message.ComputeHash();
logger.Trace($"Last hash is {Convert.ToBase64String(lastHash)}");
var snapshot = await PersistenceManager.GetSnapshot(lastApex);
await Setup(snapshot);
if (IsAlpha)
{
AppState.State = ApplicationState.Rising;//Alpha should ensure that it has all quanta from auditors
}
else
{
AppState.State = ApplicationState.Running;
}
}
else
{
//if no snapshot, the app is in init state
AppState.State = ApplicationState.WaitingForInit;
}
var lastQuantumApex = lastApex < 0 ? 0 : lastApex;
QuantumStorage = IsAlpha
? (QuantumStorageBase) new AlphaQuantumStorage(lastQuantumApex, lastHash)
: new AuditorQuantumStorage(lastQuantumApex, lastHash);
QuantumHandler = new QuantumHandler(QuantumStorage.CurrentApex);
}
public virtual void Dispose()
{
PendingUpdatesManager?.Stop(TimeSpan.FromMilliseconds(0)); PendingUpdatesManager?.Dispose();
ExtensionsManager?.Dispose();
WithdrawalStorage?.Dispose();
TxListener?.Dispose();
}
public static async Task TearDown()
{
PendingUpdatesManager?.Stop(); PendingUpdatesManager?.Dispose();
AuditLedgerManager?.Dispose();
AuditResultManager?.Dispose();
await DisposeAnalyticsManager();
AuditLedgerManager?.Dispose();
AuditResultManager?.Dispose();
ExtensionsManager?.Dispose();
WithdrawalStorage?.Dispose();
}
public static async Task Setup(Snapshot snapshot)
{
Constellation = snapshot.Settings;
AccountStorage = new AccountStorage(snapshot.Accounts, Constellation.RequestRateLimits);
if (Exchange != null)
{
Exchange.OnUpdates -= Exchange_OnUpdates;
Exchange?.Dispose();
}
Exchange = Exchange.RestoreExchange(snapshot.Settings.Assets, snapshot.Orders, IsAlpha);
WithdrawalStorage?.Dispose(); WithdrawalStorage = new WithdrawalStorage(snapshot.Withdrawals, (!EnvironmentHelper.IsTest && IsAlpha));
TxCursorManager = new TxCursorManager(snapshot.TxCursor);
TxListener?.Dispose(); TxListener = IsAlpha ? (TxListenerBase) new AlphaTxListener(snapshot.TxCursor) : new AuditorTxListener(snapshot.TxCursor);
if (IsAlpha)
{
AuditLedgerManager?.Dispose(); AuditLedgerManager = new AuditLedgerManager();
AuditResultManager?.Dispose(); AuditResultManager = new ResultManager();
await DisposeAnalyticsManager();
AnalyticsManager = new AnalyticsManager(
PermanentStorage,
DepthsSubscription.Precisions.ToList(),
Constellation.Assets.Where(a => !a.IsXlm).Select(a => a.Id).ToList(),
snapshot.Orders.Select(o => o.ToOrderInfo()).ToList()
);
await AnalyticsManager.Restore(DateTime.UtcNow);
AnalyticsManager.StartTimers();
AnalyticsManager.OnError += AnalyticsManager_OnError;
AnalyticsManager.OnUpdate += AnalyticsManager_OnUpdate;
Exchange.OnUpdates += Exchange_OnUpdates;
DisposePerformanceStatisticsManager();
PerformanceStatisticsManager = new PerformanceStatisticsManager();
PerformanceStatisticsManager.OnUpdates += PerformanceStatisticsManager_OnUpdates;
}
ExtensionsManager?.Dispose(); ExtensionsManager = new ExtensionsManager();
ExtensionsManager.RegisterAllExtensions();
}
/// <param name="settings">Application config</param>
/// <param name="storage">Permanent storage object</param>
/// <param name="useLegacyOrderbook"></param>
public ExecutionContext(BaseSettings settings, IStorage storage, StellarDataProviderBase stellarDataProvider, bool useLegacyOrderbook = false)
{
PermanentStorage = storage ?? throw new ArgumentNullException(nameof(storage));
Settings = settings ?? throw new ArgumentNullException(nameof(settings));
StellarDataProvider = stellarDataProvider ?? throw new ArgumentNullException(nameof(settings));
ExtensionsManager = new ExtensionsManager(settings.ExtensionsConfigFilePath);
PersistenceManager = new PersistenceManager(PermanentStorage);
QuantumProcessor = new QuantumProcessorsStorage();
PendingUpdatesManager = new PendingUpdatesManager(this);
PendingUpdatesManager.OnBatchSaved += PendingUpdatesManager_OnBatchSaved;
QuantumStorage = new QuantumStorage();
this.useLegacyOrderbook = useLegacyOrderbook;
}
