private List <ConnectionLock> ReadActiveLocks(DataStore dstore) { var lockList = new List <ConnectionLock>(); try { foreach (var lockRecord in DataFunctions.ReadAllRecords(dstore, connDbName, connDbLocksTableName)) { lockList.Add(new ConnectionLock( lockRecord[connDbLockSourceField] as string, lockRecord[connDbLockRequesterField] as string, lockRecord[connDbLockConnUUIDField] as string, lockRecord[connDbLockDBField] as string, lockRecord[connDbLockTableField] as string, lockRecord[connDbLockRecordKeyField], lockId: lockRecord[connDbLockUUIDField] as string )); } } catch (Exception ex) { // throw an exception if the lock table is not configured throw new Exception( string.Format("Transaction database has not been configured. | {0}", ex.Message) ); } return(lockList); }
public void DropRecord(string dbName, string tableName, object recordKey) { try { TXN_BEGIN(dbName: dbName, tableName: tableName, recordKey: recordKey); DataFunctions.DropRecord(activeDStore, dbName, tableName, recordKey); } finally { TXN_END(); } }
public void CreateTable(string dbName, string tableName, TableDefinition tableDef) { try { TXN_BEGIN(dbName: dbName, tableName: tableName); DataFunctions.CreateTable(activeDStore, dbName, tableName, tableDef); } finally { TXN_END(); } }
// CRUD functions public void CreateDB(string dbName, DatabaseDefinition dbDef = null) { try { TXN_BEGIN(dbName: dbName); DataFunctions.CreateDB(activeDStore, dbName, dbDef); } finally { TXN_END(); } }
public void InsertRecord(string dbName, string tableName, object recordKey, IDictionary <string, object> fieldValues) { try { TXN_BEGIN(dbName: dbName, tableName: tableName, recordKey: recordKey); DataFunctions.InsertRecord(activeDStore, dbName, tableName, recordKey, fieldValues); } finally { TXN_END(); } }
private void VerifyLocksTable(DataStore dstore) { logger.Debug("VerifyLocksTable"); // ensure connection database DatabaseDefinition connDbDef; try { // if db exists we're good connDbDef = DataFunctions.ReadDB(dstore, connDbName); } catch { // otherwise create it var newConnDbDef = new DatabaseDefinition(dbName: connDbName) { Description = "Internal DB" }; // create the connection management database DataFunctions.CreateDB(dstore, connDbName, newConnDbDef); } // ensue locks table TableDefinition locksTableDef; try { // if table exists we're good locksTableDef = DataFunctions.ReadTable(dstore, connDbName, connDbLocksTableName); } catch { // otherwise create it // locks have fields for dbname, tablename and record keys but they're not wired // - to allow implicit locking of nonexisting entries // - to remove the need to update wires when new tables and dbs are created var newlocksTableDef = new TableDefinition() { Fields = new List <Field>() { new UUIDField(connDbLockUUIDField), new TextField(connDbLockSourceField), new TextField(connDbLockRequesterField), new UUIDField(connDbLockConnUUIDField), new TextField(connDbLockDBField), new TextField(connDbLockTableField), new TextField(connDbLockRecordKeyField), }, Description = "Locks Table", IsHidden = true, SupportsHistory = false }; // create transaction locks table DataFunctions.CreateTable(dstore, connDbName, connDbLocksTableName, newlocksTableDef); } }
private void VerifyDataStoreType(DataStore dstore) { logger.Debug("VerifyDataStoreType"); DataStoreType existingDStoreType = null; try { existingDStoreType = DataFunctions.ReadDataStoreType(dstore); if (!existingDStoreType.Equals(dstore.DataStoreType)) { throw new Exception( string.Format("Requested Datastore type \"{0}\" does not match existing \"{1}\"", dstore.DataStoreType, existingDStoreType) ); } } catch (FormatException) { // there is no datastore so there is no point in opening a txn DataFunctions.CreateDataStore(dstore); } }
private void ReleaseLocks() { logger.Debug("RECORD UN-LOCK"); // open datastore for exclusive access using (var dstore = new DataStore(ActiveDataStoreType, exclusive: true)) { try { // get all existing locks // release locks belonging to this connection foreach (ConnectionLock activeLock in ReadActiveLocks(dstore)) { logger.Debug("Lock found: {0}", activeLock); if (activeLock.BelongsTo(this)) { logger.Debug("Dropping lock: {0}", activeLock); DataFunctions.DropRecord(dstore, connDbName, connDbLocksTableName, activeLock.LockId); } } } catch (Exception dropEx) { // finally statement closes the dstore and release the exclusivity if throwing an exception throw new Exception( string.Format("Exception occured when dropping lock records. | {0}", dropEx.Message) ); } finally { try { // write changes dstore.Commit(); } catch (Exception commitEx) { // finally statement closes the dstore and release the exclusivity if throwing an exception throw new Exception( string.Format("Exception occured when commiting released locks. | {0}", commitEx.Message) ); } } } }
private void AcquireLocks(ConnectionLock newLock) { logger.Debug("RECORD LOCK"); // open datastore for exclusive access using (var dstore = new DataStore(ActiveDataStoreType, exclusive: true)) { // get all existing locks // check access, find the highest-level compatible lock ConnectionLock txnLock = newLock; foreach (ConnectionLock activeLock in ReadActiveLocks(dstore)) { logger.Debug("Lock Found: {0}", activeLock); // is existing lock restricting access? if (newLock.IsRestrictedBy(activeLock)) { // does restricting lock belong to this connection? // if yes and it is a higher-level lock, use that if (activeLock.BelongsTo(this) && activeLock.LockType <= newLock.LockType) { logger.Debug("Existing lock {0} is higher than new {1}", activeLock, newLock); txnLock = activeLock; } // does the lock not belong to this connection in which case reject // or is trying to acquire a higher level lock that active lock else { logger.Debug("New lock {0} is restricted by {1}", newLock, activeLock); throw new AccessRestrictedException(newLock, activeLock); } } // if not restricting, does this connection already have a txn block lock of equal level // reject again since the connection need to close its block lock first and then // work on another entry else { if (activeLock.BelongsTo(this)) { logger.Debug("New lock {0} not on the same path as existing {1}", newLock, activeLock); throw new AccessRestrictedByExistingLockException(newLock, activeLock); } } } logger.Debug("Using lock: {0}", txnLock); // at this point, the are no locks that restrict access // but we might be re-using an active compatible lock // so only write the lock if is not existing compatible if (txnLock == newLock) { try { // register the new lock: if target is not locked, lock it DataFunctions.InsertRecord( dstore, connDbName, connDbLocksTableName, newLock.LockId, new Dictionary <string, object>() { { connDbLockSourceField, newLock.LockSource }, { connDbLockRequesterField, newLock.LockRequester }, { connDbLockConnUUIDField, newLock.LockConnId }, { connDbLockDBField, newLock.LockTargetDB }, { connDbLockTableField, newLock.LockTargetTable }, { connDbLockRecordKeyField, newLock.LockTargetRecordKey }, }); } catch (Exception lockEx) { // finally statement closes the dstore and release the exclusivity if throwing an exception throw new Exception( string.Format("Error creating lock: {0} | {1}", newLock, lockEx.Message) ); } finally { try { // write changes dstore.Commit(); } catch (Exception commitEx) { // finally statement closes the dstore and release the exclusivity if throwing an exception throw new Exception( string.Format("Exception occured when commiting new locks. | {0}", commitEx.Message) ); } } } } }
private ConnectionLock AcquireLocks(ConnectionLock newLock) { logger.Debug("RECORD LOCK"); ConnectionLock txnLock = newLock; // open datastore for exclusive access using (var dstore = new DataStore(ActiveDataStoreType, exclusive: true)) { // get all existing locks // check access, find the highest-level compatible lock logger.Debug("Reading existing locks"); foreach (ConnectionLock activeLock in ReadActiveLocks(dstore)) { logger.Debug("Lock Found: {0}", activeLock); txnLock = DetermineHigherLock(activeLock, newLock); } logger.Debug("Using lock: {0}", txnLock); // at this point, the are no locks that restrict access // but we might be re-using an active compatible lock // so only write the lock if is not existing compatible if (txnLock == newLock) { try { // register the new lock: if target is not locked, lock it DataFunctions.InsertRecord( dstore, connDbName, connDbLocksTableName, newLock.LockId, new Dictionary <string, object>() { { connDbLockSourceField, newLock.LockSource }, { connDbLockRequesterField, newLock.LockRequester }, { connDbLockConnUUIDField, newLock.LockConnId }, { connDbLockDBField, newLock.LockTargetDB }, { connDbLockTableField, newLock.LockTargetTable }, { connDbLockRecordKeyField, newLock.LockTargetRecordKey }, }); } catch (Exception lockEx) { // finally statement closes the dstore and release the exclusivity if throwing an exception throw new Exception( string.Format("Error creating lock: {0} | {1}", newLock, lockEx.Message) ); } finally { try { // write changes dstore.Commit(); } catch (Exception commitEx) { // finally statement closes the dstore and release the exclusivity if throwing an exception throw new Exception( string.Format("Exception occured when commiting new locks. | {0}", commitEx.Message) ); } } } } return(txnLock); }
public DatabaseDefinition ReadDB(string dbName) { using (var dstore = new DataStore(ActiveDataStoreType)) return(DataFunctions.ReadDB(dstore, dbName)); }
public List <DatabaseDefinition> ReadAllDBs() { using (var dstore = new DataStore(ActiveDataStoreType)) return(DataFunctions.ReadAllDBs(dstore)); }
public IDictionary <string, object> ReadRecord(string dbName, string tableName, object recordKey) { using (var dstore = new DataStore(ActiveDataStoreType)) return(DataFunctions.ReadRecord(dstore, dbName, tableName, recordKey)); }
public List <Dictionary <string, object> > ReadAllRecords(string dbName, string tableName) { using (var dstore = new DataStore(ActiveDataStoreType)) return(DataFunctions.ReadAllRecords(dstore, dbName, tableName)); }
public DataStoreType ReadDataStoreType() { using (var dstore = new DataStore(ActiveDataStoreType)) return(DataFunctions.ReadDataStoreType(dstore)); }
public TableDefinition ReadTable(string dbName, string tableName) { using (var dstore = new DataStore(ActiveDataStoreType)) return(DataFunctions.ReadTable(dstore, dbName, tableName)); }
public List <TableDefinition> ReadAllTables(string dbName) { using (var dstore = new DataStore(ActiveDataStoreType)) return(DataFunctions.ReadAllTables(dstore, dbName)); }