private StorageResult <TValue> UpdateDocumentInternal <TKey, TValue>(ITransaction transaction, string collection, TKey key, TValue update) { StorageResult <TValue> result = new StorageResult <TValue>(); ValidateTransaction(transaction); LightningTransaction lmdbTransaction = (LightningTransaction)transaction.InnerObject; byte[] keyBytes = _environment.ConverterStore.GetToBytes <TKey>().Convert(_collectionTable[collection].Collection, key); byte[] oldValBytes = lmdbTransaction.Get(_collectionTable[collection].Collection, keyBytes); long netSize = 0; netSize = -CaclulateSize(keyBytes, oldValBytes); byte[] valueBytes = _environment.ConverterStore.GetToBytes <TValue>().Convert(_collectionTable[collection].Collection, update); try { lmdbTransaction.Put(_collectionTable[collection].Collection, keyBytes, valueBytes); //Incase of update previous size is not being subtracted at the moment long size = CaclulateSize(keyBytes, valueBytes); netSize += size; ((LMDBTransaction)transaction).ChangeSize(netSize); _collectionTable[collection].IncrementTemporaryStats(netSize); result.Document = update; result.Status = StoreResult.SuccessOverwrite; return(result); } catch (LightningException le) { result.Status = HandleException(le); return(result); } }
private void DbPut(LightningTransaction tx, LightningDatabase db, string key, DurableDataEnvelope data) { var byteKey = Encoding.UTF8.GetBytes(key); var byteValue = _serializer.ToBinary(data); tx.Put(db, byteKey, byteValue); }
private int FailedToSend(LightningTransaction tx, OutgoingMessage message) { var db = OpenDatabase(tx, OutgoingQueue); var value = tx.Get(db, message.Id.MessageIdentifier.ToByteArray()); if (value.resultCode == MDBResultCode.NotFound) { return(int.MaxValue); } var msg = value.value.CopyToNewArray().ToOutgoingMessage(); int attempts = message.SentAttempts; if (attempts >= message.MaxAttempts) { RemoveMessageFromStorage(tx, OutgoingQueue, msg); } else if (msg.DeliverBy.HasValue) { var expire = msg.DeliverBy.Value; if (expire != DateTime.MinValue && DateTime.Now >= expire) { RemoveMessageFromStorage(tx, OutgoingQueue, msg); } } else { tx.Put(db, message.Id.MessageIdentifier.ToByteArray(), message.Serialize()); } return(attempts); }
public static string Get(this LightningTransaction tx, LightningDatabase db, string key) { var enc = System.Text.Encoding.UTF8; var result = tx.Get(db, enc.GetBytes(key)); return(enc.GetString(result.value.CopyToNewArray())); }
private void CommitInternal(ITransaction transaction) { Stopwatch sw = new Stopwatch(); ValidateTransaction(transaction); LightningTransaction lmdbTransaction = (LightningTransaction)transaction.InnerObject; sw.Start(); lmdbTransaction.Commit(); sw.Stop(); ChangeDataSize(((LMDBTransaction)transaction).Size); if (!transaction.IsReadOnly) { if (_readerTransaction != null) { lock (_readerTransactionLock) { if (_readerTransaction != null) { _readerTransaction.MarkForCommit(); //_readerTransaction = null; } } } } if (LoggerManager.Instance.StorageLogger != null) { LoggerManager.Instance.StorageLogger.Debug("LMDBPersistanceProvider", "LMDB Commit Time: " + sw.ElapsedMilliseconds + " (ms)"); } }
IEnumerable <TOut> InternalScan <TOut>(LightningTransaction lt, FdbKeyRange range, Func <Slice, byte[], TOut> convert) { ushort x = 0; using (var c = lt.CreateCursor(_ld)) { if (!c.MoveToFirstAfter(range.Begin.GetBytes())) { yield break; } var pair = c.Current; for (var i = 0; i < int.MaxValue; i++) { var current = Slice.Create(pair.Key); if (!range.Contains(current)) { break; } x += 1; yield return(convert(current, pair.Value)); if (!c.MoveNext()) { break; } pair = c.Current; } } }
private LightningDatabase CreateCollectionInternal(string name, Type keyType) { ITransaction transaction = BeginTransactionInternal(null, TransactionBeginFlags.None); ValidateTransaction(transaction); LightningTransaction lmdbTransaction = (LightningTransaction)transaction.InnerObject; LightningDB.DatabaseConfiguration dbOptions = new LightningDB.DatabaseConfiguration(); dbOptions.Flags = DatabaseOpenFlags.Create; //todo: maybe add other integer types too if (keyType == typeof(long) || keyType == typeof(ulong) || keyType == typeof(int) || keyType == typeof(uint) || keyType == typeof(short) || keyType == typeof(ushort)) { dbOptions.Flags |= DatabaseOpenFlags.IntegerKey; } LightningDatabase collectionInstance = lmdbTransaction.OpenDatabase(name, dbOptions); if (name != METADATA_COLLECTION) { StoreCollectionInfo(name, transaction); } ((LMDBTransaction)transaction).ChangeSize(8192); CommitInternal(transaction); return(collectionInstance); }
public void DropCollection(string name) { if (string.IsNullOrEmpty(name)) { throw new ArgumentException("Collection name cant not be null or empty."); } if (!CollectionExists(name)) { throw new ArgumentException("Specified collection not found in " + GetFileInfo() + " Collection = " + name); } ITransaction transaction = BeginTransactionInternal(null, TransactionBeginFlags.None); ValidateTransaction(transaction); LightningTransaction lmdbTransaction = (LightningTransaction)transaction.InnerObject; LightningDatabase dbInstance = _collectionTable[name].Collection; long dataSize = _collectionTable[name].Stats.DataSize; lmdbTransaction.DropDatabase(dbInstance); _collectionTable.Remove(name); StoreCollectionInfo(null, transaction); //StoreDocument(transaction, _metadataCollection, "collections", _collectionTable.Keys.ToArray()); ((LMDBTransaction)transaction).ChangeSize(-8192); ((LMDBTransaction)transaction).ChangeSize(-dataSize); CommitInternal(transaction); }
private void ValidateTransaction(ITransaction transaction) { if (transaction == null) { throw new TransactionException("Invalid Transaction.Transaction can not be null."); } if (transaction.InnerObject == null) { throw new TransactionException("Invalid Transaction. Inner Transaction can not be null."); } if (transaction.InnerObject.GetType() != typeof(LightningTransaction)) { throw new TransactionException("Invalid Transaction. Inner Transaction type not valid. Expected type = " + typeof(LightningTransaction) + " Type present = " + transaction.InnerObject.GetType()); } LightningTransaction lmdbTransaction = (LightningTransaction)transaction.InnerObject; if (lmdbTransaction.State == LightningTransactionState.Aborted) { throw new TransactionAobrtException("Invalid Transaction. Inner Transaction was aborted. File = " + GetFileInfo()); } if (lmdbTransaction.State == LightningTransactionState.Commited) { throw new TransactionComittedException("Invalid Transaction. Inner Transaction was commited. File = " + GetFileInfo()); } }
public void DatabaseFromCommitedTransactionShouldBeAccessable() { //arrange _env.Open(); LightningDatabase db; using (var committed = _env.BeginTransaction()) { db = committed.OpenDatabase(null, DatabaseOpenFlags.None); committed.Commit(); } //act try { _txn = _env.BeginTransaction(); _txn.Put(db, "key", 1); } finally { db.Close(); } //assert }
public void DatabaseShouldBeDropped() { _env.MaxDatabases = 2; _env.Open(); _txn = _env.BeginTransaction(); var db = _txn.OpenDatabase("notmaster", new DatabaseConfiguration { Flags = DatabaseOpenFlags.Create }); _txn.Commit(); _txn.Dispose(); db.Dispose(); _txn = _env.BeginTransaction(); db = _txn.OpenDatabase("notmaster"); db.Drop(_txn); _txn.Commit(); _txn.Dispose(); _txn = _env.BeginTransaction(); var ex = Assert.Throws <LightningException>(() => _txn.OpenDatabase("notmaster")); Assert.Equal(ex.StatusCode, -30798); }
private StorageResult <TValue> StoreDocumentInternal <TKey, TValue>(ITransaction transaction, string collection, TKey key, TValue value) { StorageResult <TValue> result = new StorageResult <TValue>(); ValidateTransaction(transaction); LightningTransaction lmdbTransaction = (LightningTransaction)transaction.InnerObject; byte[] keyBytes = _environment.ConverterStore.GetToBytes <TKey>().Convert(_collectionTable[collection].Collection, key); byte[] valueBytes = _environment.ConverterStore.GetToBytes <TValue>().Convert(_collectionTable[collection].Collection, value); try { lmdbTransaction.Put(_collectionTable[collection].Collection, keyBytes, valueBytes); long size = CaclulateSize(keyBytes, valueBytes); ((LMDBTransaction)transaction).ChangeSize(size); _collectionTable[collection].IncrementTemporaryStats(size); result.Document = value; result.Status = StoreResult.Success; return(result); } catch (LightningException le) { result.Status = HandleException(le); return(result); } }
private DatabaseHandleCacheEntry OpenDatabaseHandle(string name, LightningTransaction tran, DatabaseOpenFlags flags) { name = FromInternalDatabaseName(name); var handle = default(UInt32); NativeMethods.Execute(lib => lib.mdb_dbi_open(tran._handle, name, flags, out handle)); return new DatabaseHandleCacheEntry(handle, flags); }
public LMDBTransaction(LightningTransaction transaction, bool isReadOnly) { if (transaction == null) { throw new ArgumentException("Parameter transaction can not be null."); } _transaction = transaction; _isReadOnly = isReadOnly; }
private void RemoveMessageFromStorage(LightningTransaction tx, string queueName, params Message[] messages) { var db = OpenDatabase(tx, queueName); foreach (var message in messages) { tx.Delete(db, message.Id.MessageIdentifier.ToByteArray()); } }
public CursorManager(LightningTransaction transaction) { if (transaction == null) throw new ArgumentNullException("transaction"); _transaction = transaction; _cursors = new ConcurrentDictionary<IntPtr, bool>(); }
internal ObjectRepositoryTransaction( ObjectRepositorySettings <TKey, T> settings, LightningTransaction tx, LightningDatabase db) { _settings = settings; _tx = tx; _db = db; }
public void TransactionShouldBeCreated() { //arrange //act _txn = _env.BeginTransaction(); //assert Assert.AreEqual(LightningTransactionState.Active, _txn.State); }
public void Init() { Directory.CreateDirectory(_path); _env = new LightningEnvironment(_path, EnvironmentOpenFlags.None); _env.Open(); _txn = _env.BeginTransaction(); _db = _txn.OpenDatabase(); }
public CursorTests(SharedFileSystem fileSystem) { var path = fileSystem.CreateNewDirectoryForTest(); _env = new LightningEnvironment(path); _env.Open(); _txn = _env.BeginTransaction(); }
public void DatabaseShouldBeClosed() { _env.Open(); _txn = _env.BeginTransaction(); var db = _txn.OpenDatabase(); db.Dispose(); Assert.Equal(false, db.IsOpened); }
public static bool TryGet(this LightningTransaction tx, LightningDatabase db, string key, out string value) { var enc = System.Text.Encoding.UTF8; byte[] result; var found = tx.TryGet(db, enc.GetBytes(key), out result); value = enc.GetString(result); return(found); }
public void DatabaseShouldBeClosed() { _env.Open(); _txn = _env.BeginTransaction(); var db = _txn.OpenDatabase(); db.Dispose(); Assert.False(db.IsOpened); }
public void TransactionShouldBeAbortedIfEnvironmentCloses() { //arrange _txn = _env.BeginTransaction(); //act _env.Close(); //assert Assert.AreEqual(LightningTransactionState.Aborted, _txn.State); }
private LightningDatabase OpenDatabase(LightningTransaction transaction, string database) { if (_databaseCache.ContainsKey(database)) { return(_databaseCache[database]); } var db = transaction.OpenDatabase(database); _databaseCache[database] = db; return(db); }
public void ReadOnlyTransactionShouldChangeStateOnReset() { //arrange _txn = _env.BeginTransaction(TransactionBeginFlags.ReadOnly); //act _txn.Reset(); //assert Assert.AreEqual(LightningTransactionState.Reseted, _txn.State); }
public DatabaseIOTests(SharedFileSystem fileSystem) { var path = fileSystem.CreateNewDirectoryForTest(); _env = new LightningEnvironment(path); _env.MaxDatabases = 2; _env.Open(); _txn = _env.BeginTransaction(); _db = _txn.OpenDatabase(configuration: new DatabaseConfiguration {Flags = DatabaseOpenFlags.Create}); }
public void ChildTransactionShouldBeCreated() { //arrange _txn = _env.BeginTransaction(); //act var subTxn = _txn.BeginTransaction(); //assert Assert.AreEqual(LightningTransactionState.Active, subTxn.State); }
public void TransactionShouldChangeStateOnCommit() { //arrange _txn = _env.BeginTransaction(); //act _txn.Commit(); //assert Assert.AreEqual(LightningTransactionState.Commited, _txn.State); }
public static void TryDelete(this LightningTransaction tx, LightningDatabase db, byte[] key) { try { tx.Delete(db, key); } catch (LightningException ex) { if (ex.StatusCode != Lmdb.MDB_NOTFOUND) { throw; } } }
public StorageResult <TValue> GetDocument <TKey, TValue>(string collection, TKey key) { StorageResult <TValue> result = new StorageResult <TValue>(); if (string.IsNullOrEmpty(collection)) { throw new ArgumentException("Collection name can not be null or empty."); } if (!CollectionExists(collection)) { throw new ArgumentException("Specified collection not found in " + GetFileInfo() + " Collection = " + collection); } ReadTransaction transaction = null; try { if (_readerTransaction != null) { if (_readerTransaction.ShouldRenew) { _readerTransaction.WaitUntillFree(); } } lock (_readerTransactionLock) { if (_readerTransaction == null || !_readerTransaction.Running) { _readerTransaction = new ReadTransaction(BeginTransaction(null, true)); } transaction = _readerTransaction; transaction.Enter(); } ValidateTransaction(transaction.Transaction); LightningTransaction lmdbTransaction = (LightningTransaction)transaction.Transaction.InnerObject; byte[] keyBytes = _environment.ConverterStore.GetToBytes <TKey>().Convert(_collectionTable[collection].Collection, key); byte[] valueBytes = lmdbTransaction.Get(_collectionTable[collection].Collection, keyBytes); result.Document = _environment.ConverterStore.GetFromBytes <TValue>().Convert(_collectionTable[collection].Collection, valueBytes); } finally { if (transaction != null) { transaction.Exit(); } } result.Status = StoreResult.Success; return(result); }
private void SaveKV(LightningTransaction tx, byte[] key, double value) { var byteValue = BitConverter.GetBytes(value); using (var db = tx.OpenDatabase("kv", new DatabaseConfiguration { Flags = DatabaseOpenFlags.Create })) { tx.Put(db, key, byteValue); tx.Commit(); } }
public void ChildTransactionShouldBeAbortedIfParentIsAborted() { //arrange _txn = _env.BeginTransaction(); var child = _txn.BeginTransaction(); //act _txn.Abort(); //assert Assert.AreEqual(LightningTransactionState.Aborted, child.State); }
public void DefaultDatabaseShouldBeOpened() { _env.Open(); _txn = _env.BeginTransaction(); //arrange //act var db = _txn.OpenDatabase(null, DatabaseOpenFlags.None); //assert Assert.AreEqual(true, db.IsOpened); }
public void DefaultDatabaseShouldBeClosed() { _env.Open(); _txn = _env.BeginTransaction(); var db = _txn.OpenDatabase(null, new DatabaseOptions { Flags = DatabaseOpenFlags.None }); //arrange //act db.Close(); //assert Assert.AreEqual(false, db.IsOpened); }
public void DatabaseShouldBeCreated() { var dbName = "test"; _env.MapDatabases = 2; _env.Open(); _txn = _env.BeginTransaction(); //arrange //act _txn.OpenDatabase(dbName, DatabaseOpenFlags.Create); //assert }
public LightningTransaction Create(TransactionBeginFlags beginFlags) { EnsureEnvironmentOpened(); IntPtr handle = default(IntPtr); NativeMethods.Execute(lib => lib.mdb_txn_begin(_environment._handle, _parentHandle, beginFlags, out handle)); var tran = new LightningTransaction(_environment, handle, _parentTransaction, beginFlags); _transactions.TryAdd(tran, true); return tran; }
public TransactionManager(LightningEnvironment environment, LightningTransaction parentTransaction) { if (environment == null) throw new ArgumentNullException("environment"); _environment = environment; _parentTransaction = parentTransaction; _parentHandle = parentTransaction != null ? parentTransaction._handle : IntPtr.Zero; _transactions = new ConcurrentDictionary<LightningTransaction, bool>(); _comparatorsStore = new ConcurrentDictionary<CompareFunction, bool>(); }
public LightningDatabase OpenDatabase(string name, LightningTransaction tran, DatabaseOpenFlags flags, Encoding encoding) { var internalName = ToInternalDatabaseName(name); var cacheEntry = _openedDatabases.AddOrUpdate( internalName, key => { var entry = OpenDatabaseHandle(name, tran, flags); return entry; }, (key, entry) => { if (entry.OpenFlags != flags) entry = OpenDatabaseHandle(name, tran, flags); return entry; }); _databasesForReuse.Add(cacheEntry.Handle); return new LightningDatabase(internalName, tran, cacheEntry, encoding); }
public void WasDiscarded(LightningTransaction tn) { bool value; _transactions.TryRemove(tn, out value); }
public void DatabaseShouldBeDropped() { _env.MaxDatabases = 2; _env.Open(); _txn = _env.BeginTransaction(); var db = _txn.OpenDatabase("notmaster", new DatabaseConfiguration {Flags = DatabaseOpenFlags.Create}); _txn.Commit(); _txn.Dispose(); db.Dispose(); _txn = _env.BeginTransaction(); db = _txn.OpenDatabase("notmaster"); db.Drop(_txn); _txn.Commit(); _txn.Dispose(); _txn = _env.BeginTransaction(); var ex = Assert.Throws<LightningException>(() => _txn.OpenDatabase("notmaster")); Assert.Equal(ex.StatusCode, -30798); }
public void TruncatingTheDatabase() { _env.Open(); _txn = _env.BeginTransaction(); var db = _txn.OpenDatabase(); _txn.Put(db, "hello", "world"); _txn.Commit(); _txn.Dispose(); _txn = _env.BeginTransaction(); db = _txn.OpenDatabase(); db.Truncate(_txn); _txn.Commit(); _txn.Dispose(); _txn = _env.BeginTransaction(); db = _txn.OpenDatabase(); var result = _txn.Get(db, UTF8.GetBytes("hello")); Assert.Null(result); }
public void ChildTransactionShouldBeAbortedIfEnvironmentIsClosed() { //arrange _txn = _env.BeginTransaction(); var child = _txn.BeginTransaction(); //act _env.Close(); //assert Assert.AreEqual(LightningTransacrionState.Aborted, child.State); }
public void ReadOnlyTransactionShouldChangeStateOnRenew() { //arrange _txn = _env.BeginTransaction(TransactionBeginFlags.ReadOnly); _txn.Reset(); //act _txn.Renew(); //assert Assert.AreEqual(LightningTransactionState.Active, _txn.State); }
public void DefaultDatabaseShouldBeDropped() { _txn = _env.BeginTransaction(); var db = _txn.OpenDatabase(null, DatabaseOpenFlags.None); //arrange //act _txn.DropDatabase(db, true); //assert Assert.AreEqual(false, db.IsOpened); }
public void TransactionShouldSupportCustomComparer() { //arrange Func<int, int, int> comparison = (l, r) => -Math.Sign(l - r); _txn = _env.BeginTransaction(); var db = _txn.OpenDatabase( options: new DatabaseOptions { Compare = b => b.FromFunc(comparison) }); var keysUnsorted = new int[] { 2, 10, 5 }; var keysSorted = keysUnsorted.ToArray(); Array.Sort(keysSorted, new Comparison<int>(comparison)); //act for (var i = 0; i < keysUnsorted.Length; i++) _txn.Put(keysUnsorted[i], i); //assert using (var c = _txn.CreateCursor(db)) { int order = 0; KeyValuePair<int, int> pair; while (c.MoveNext(out pair)) Assert.AreEqual(keysSorted[order++], pair.Key); } }
public void CanCountTransactionEntries() { //arrange _txn = _env.BeginTransaction(); var db = _txn.OpenDatabase(null, new DatabaseOptions { Flags = DatabaseOpenFlags.None }); const int entriesCount = 10; for (var i = 0; i < entriesCount; i++) _txn.Put(db, i.ToString(), i.ToString()); //act var count = _txn.GetEntriesCount(db); //assert; Assert.AreEqual(entriesCount, count); }
public void TransactionShouldSupportCustomDupSorter() { //arrange Func<int, int, int> comparison = (l, r) => -Math.Sign(l - r); _txn = _env.BeginTransaction(); var db = _txn.OpenDatabase( options: new DatabaseOptions { Flags = DatabaseOpenFlags.DuplicatesFixed, DuplicatesSort = b => b.FromFunc(comparison) }); var valuesUnsorted = new int[] { 2, 10, 5, 0 }; var valuesSorted = valuesUnsorted.ToArray(); Array.Sort(valuesSorted, new Comparison<int>(comparison)); //act using (var c = _txn.CreateCursor(db)) c.PutMultiple(123, valuesUnsorted); //assert using (var c = _txn.CreateCursor(db)) { int order = 0; KeyValuePair<int, int> pair; while (c.MoveNextDuplicate(out pair)) Assert.AreEqual(valuesSorted[order++], pair.Value); } }