public PutManager(ITransactionLog transactionLog, IFeedSessionManager sessionManager, DataStore dataStore, ILog log)
{
_transactionLog = transactionLog;
SessionManager = sessionManager;
_dataStore = dataStore;
_log = log;
}
/// <summary>
/// Creates a new server core that uses a specific IStoreManager implementation
/// rather than getting one from the StoreManagerFactory
/// </summary>
/// <param name="baseLocation"></param>
/// <param name="storeName"></param>
/// <param name="storeManager"></param>
public StoreWorker(string baseLocation, string storeName, IStoreManager storeManager)
{
_storeName = storeName;
_storeLocation = Path.Combine(baseLocation, storeName);
Logging.LogInfo("StoreWorker created with location {0}", _storeLocation);
_jobs = new ConcurrentQueue <Job>();
_jobExecutionStatus = new ConcurrentDictionary <string, JobExecutionStatus>();
_storeManager = storeManager;
_transactionLog = _storeManager.GetTransactionLog(_storeLocation);
}
private void SyncronizeTable(BaseSqlToCS table)
{
if (table.Mode != EditMode.None)
{
ITransactionLog create = table as ITransactionLog;
if (create != null)
{
create.TransactionId = TransactionId;
}
}
}
/// <summary>
/// Creates a new server core
/// </summary>
/// <param name="baseLocation">Path to the stores directory</param>
/// <param name="storeName">Name of store</param>
public StoreWorker(string baseLocation, string storeName)
{
_storeName = storeName;
_storeLocation = Path.Combine(baseLocation, storeName);
Logging.LogInfo("StoreWorker created with location {0}", _storeLocation);
_jobs = new ConcurrentQueue<Job>();
// _jobStatus = new ConcurrentDictionary<string, JobStatus>();
_jobExecutionStatus = new ConcurrentDictionary<string, JobExecutionStatus>();
_storeManager = StoreManagerFactory.GetStoreManager();
_transactionLog = _storeManager.GetTransactionLog(_storeLocation);
}
public void Update(ITransactionLog entity)
{
TransactionLog dbTLog = dbContext.TransactionLogs.Where(s => s.Id == entity.Id).FirstOrDefault();
dbTLog.StockId = entity.StockId;
dbTLog.StockSymbol = entity.StockSymbol;
dbTLog.Quantity = entity.Quantity;
dbTLog.Price = entity.Price;
dbTLog.Purchased = entity.Purchased;
dbTLog.TransactionDate = entity.TransactionDate;
dbContext.SaveChanges();
}
public void Update(ITransactionLog entity)
{
TransactionLog dbTLog = dbContext.TransactionLogs.Where(s => s.Id == entity.Id).FirstOrDefault();
dbTLog.StockId = entity.StockId;
dbTLog.StockSymbol = entity.StockSymbol;
dbTLog.Quantity = entity.Quantity;
dbTLog.Price = entity.Price;
dbTLog.Purchased = entity.Purchased;
dbTLog.TransactionDate = entity.TransactionDate;
dbContext.SaveChanges();
}
public AtomicLogScope(Transaction transaction, IDatabase database)
{
this.transaction = transaction;
this.log = database
.DatabaseEngine
.TransactionHandler
.GetTransactionLog(this.transaction);
this.logPosition = this.log.CurrentPosition;
this.transaction.EnterAtomicSection();
this.completed = false;
}
public AtomicLogScope(Transaction transaction, IDatabase database)
{
this.transaction = transaction;
this.log = database
.DatabaseEngine
.TransactionHandler
.GetTransactionLog(this.transaction);
this.logPosition = this.log.CurrentPosition;
this.transaction.EnterAtomicSection();
this.completed = false;
}
/// <summary>
/// Creates a new server core
/// </summary>
/// <param name="baseLocation">Path to the stores directory</param>
/// <param name="storeName">Name of store</param>
public StoreWorker(string baseLocation, string storeName)
{
_baseLocation = baseLocation;
_storeName = storeName;
_storeLocation = Path.Combine(baseLocation, storeName);
Logging.LogInfo("StoreWorker created with location {0}", _storeLocation);
_jobs = new ConcurrentQueue <Job>();
_jobExecutionStatus = new ConcurrentDictionary <string, JobExecutionStatus>();
_storeManager = StoreManagerFactory.GetStoreManager();
_transactionLog = _storeManager.GetTransactionLog(_storeLocation);
_storeStatisticsLog = _storeManager.GetStatisticsLog(_storeLocation);
_statsMonitor = new StatsMonitor();
InitializeStatsMonitor();
_shutdownCompleted = new ManualResetEvent(false);
}
private async Task EnsureInitializedAsync()
{
if (_transactionLog == null)
{
using (await _lock.EnterAsync().ConfigureAwait(false))
{
if (_transactionLog == null)
{
if (!_recoveryHappened)
{
_initializeBeforeRecovery = true;
}
var tlog = new TransactionLog(_keyValueStore, _policy, _latest + 1);
using (var tx = _keyValueStore.CreateTransaction())
{
var metadata = _metadataTable.Enter(tx);
if (metadata.Contains(LatestKey))
{
metadata.Update(LatestKey, (_latest + 1).ToString(CultureInfo.InvariantCulture));
metadata.Update(ActiveCountKey, (_activeCount + 1).ToString(CultureInfo.InvariantCulture));
metadata.Update(HeldCountKey, (_heldCount + 1).ToString(CultureInfo.InvariantCulture));
}
else
{
metadata.Add(LatestKey, "1");
metadata.Add(ActiveCountKey, "1");
metadata.Add(HeldCountKey, "1");
}
await tx.CommitAsync().ConfigureAwait(false);
}
_latest++;
_activeCount++;
_heldCount++;
_transactionLog = tlog;
_versionedLogs.Enqueue(_transactionLog);
}
}
}
AssertInvariants();
}
public static TransactionLogData ToModel(this ITransactionLog log, bool withDetails = false)
{
if (log == null)
{
return(null);
}
var data = new TransactionLogData()
{
Duration = log.Duration, RecordCount = log.RecordCount
};
if (withDetails)
{
data.Changes = log.Changes;
}
data.AssignCommon(log);
return(data);
}
private static void AppendToLog(ITransactionLog <Guid, TestInfo> log, IEnumerable <KeyValuePair <Guid, TestInfo> > keyValuePairs)
{
using (var items = keyValuePairs.GetEnumerator())
{
bool more = items.MoveNext();
while (more)
{
var tx = log.BeginTransaction();
int count = 1000;
do
{
log.AddValue(ref tx, items.Current.Key, items.Current.Value);
more = items.MoveNext();
} while (more && --count > 0);
log.CommitTransaction(ref tx);
}
}
}
/// <summary>
/// Starts the transaction manager.
/// </summary>
/// <param name="resource">The <see cref="ITransactedResource" /> to be managed.</param>
/// <param name="log">The unopened <see cref="ITransactionLog" /> implementation to be used.</param>
/// <param name="recoverCorrupt">Pass as <c>true</c> if recovery of corrupt transaction logs should be attempted.</param>
public void Start(ITransactedResource resource, ITransactionLog log, bool recoverCorrupt)
{
using (TimedLock.Lock(this))
{
if (running)
{
throw new TransactionException("Transaction manager has already started for [{0}].", resource.Name);
}
switch (log.Open(this))
{
case LogStatus.Ready:
break;
case LogStatus.Recover:
this.resource = resource;
this.log = log;
Recover();
break;
case LogStatus.Corrupt:
if (!recoverCorrupt)
{
throw new TransactionException("Transaction log for [{0]] is corrupt.", resource.Name);
}
SysLog.LogWarning("Corrupt transaction log detected for [{0}]. Best efforts are being taken to recover.", resource.Name);
Recover();
break;
}
this.running = true;
this.resource = resource;
this.log = log;
this.transactions = new Dictionary <Guid, BaseTransaction>();
this.threadTransMap = new Dictionary <int, BaseTransaction>();
}
}
/// <summary>
/// Snapshots the current transaction log. The returned <see cref="SnapshotCleanup"/> object can be used to trigger truncation after
/// a checkpoint succeeds.
/// </summary>
/// <returns>Task completing after the snapshot succeeds (merely updating some metadata), and returning a cleanup object.</returns>
public async Task <SnapshotCleanup> SnapshotAsync()
{
AssertInvariants();
using (var t = _keyValueStore.CreateTransaction())
{
var tx = _metadataTable.Enter(t);
if (tx.Contains(LatestKey))
{
tx.Update(LatestKey, (_latest + 1).ToString(CultureInfo.InvariantCulture));
tx.Update(ActiveCountKey, (_activeCount + 1).ToString(CultureInfo.InvariantCulture));
tx.Update(HeldCountKey, (_heldCount + 1).ToString(CultureInfo.InvariantCulture));
}
else
{
tx.Add(LatestKey, "1");
tx.Add(ActiveCountKey, "1");
tx.Add(HeldCountKey, "1");
}
await t.CommitAsync().ConfigureAwait(false);
}
_latest++;
_activeCount++;
_heldCount++;
_transactionLog = new TransactionLog(_keyValueStore, _policy, _latest);
_versionedLogs.Enqueue(_transactionLog);
Tracing.Transaction_Log_Snapshot(null, _engineId, _latest, _activeCount, _heldCount);
AssertInvariants();
return(new SnapshotCleanup(this));
}
public ScopedTransactionLog(ITransactionLog transactionLog, IKeyValueStoreTransaction transaction)
{
_transactionLog = transactionLog;
_transaction = transaction;
}
internal TransactionInfoEnumerator(ITransactionLog log)
{
_transactionLog = log;
_transactionNumber = 0;
}
/// <summary> Sets the transaction log to use </summary>
protected void SetLogFile(ITransactionLog <TKey, TValue> logFile)
{
LogFile = logFile;
}
public static void WriteEntityUpdate <TEntity>(this ITransactionLog log, EntityPropertyCloner <TEntity> propertyCloner, TEntity storedEntity, TEntity oldEntity)
where TEntity : class
{
log.Write(new UpdateEntityLogItem <TEntity>(propertyCloner, storedEntity, oldEntity));
}
public static void WriteIndexDelete <TEntity>(this ITransactionLog log, IIndex <TEntity> index, TEntity entity)
where TEntity : class
{
log.Write(new IndexDeleteTransactionLogItem <TEntity>(index, entity));
}
private static void AppendToLog(ITransactionLog<Guid, TestInfo> log, IEnumerable<KeyValuePair<Guid, TestInfo>> keyValuePairs)
{
using(var items = keyValuePairs.GetEnumerator())
{
bool more = items.MoveNext();
while (more)
{
var tx = log.BeginTransaction();
int count = 1000;
do
{
log.AddValue(ref tx, items.Current.Key, items.Current.Value);
more = items.MoveNext();
} while (more && --count > 0);
log.CommitTransaction(ref tx);
}
}
}
public DeleteManager(DataStore dataStore, ITransactionLog transactionLog)
{
_dataStore = dataStore;
_transactionLog = transactionLog;
}
public TransactionManager(ILockManager lockManager, ITransactionLog transactionLog)
{
_lockManager = lockManager;
_transactionLog = transactionLog;
}
/// <summary>
/// Creates a new server core
/// </summary>
/// <param name="baseLocation">Path to the stores directory</param>
/// <param name="storeName">Name of store</param>
public StoreWorker(string baseLocation, string storeName)
{
_baseLocation = baseLocation;
_storeName = storeName;
_storeLocation = Path.Combine(baseLocation, storeName);
Logging.LogInfo("StoreWorker created with location {0}", _storeLocation);
_jobs = new ConcurrentQueue<Job>();
_jobExecutionStatus = new ConcurrentDictionary<string, JobExecutionStatus>();
_storeManager = StoreManagerFactory.GetStoreManager();
_transactionLog = _storeManager.GetTransactionLog(_storeLocation);
_storeStatisticsLog = _storeManager.GetStatisticsLog(_storeLocation);
_statsMonitor = new StatsMonitor();
InitializeStatsMonitor();
_shutdownCompleted = new ManualResetEvent(false);
}
