Exemple #1
0
        public void DatabaseGetShouldNotThrowExceptions()
        {
            var key = "key";

            //arrange

            //act
            _txn.Get(_db, key);

            //assert
        }
Exemple #2
0
        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 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 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 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);
        }
        public StorageResult <TValue> DeleteDocument <TKey, TValue>(ITransaction transaction, 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);
            }

            ValidateTransaction(transaction);
            LightningTransaction lmdbTransaction = (LightningTransaction)transaction.InnerObject;

            byte[] keyBytes   = _environment.ConverterStore.GetToBytes <TKey>().Convert(_collectionTable[collection].Collection, key);
            byte[] valueBytes = lmdbTransaction.Get(_collectionTable[collection].Collection, keyBytes);

            long size = CaclulateSize(keyBytes, valueBytes);

            result.Document = _environment.ConverterStore.GetFromBytes <TValue>().Convert(_collectionTable[collection].Collection, valueBytes);
            try
            {
                lmdbTransaction.Delete(_collectionTable[collection].Collection, keyBytes);
                ((LMDBTransaction)transaction).ChangeSize(-size);
                _collectionTable[collection].DecrementTemporaryStats(size);

                result.Status = StoreResult.Success;
                return(result);
            }
            catch (LightningException le)
            {
                //todo temp fix consider success if doc not found
                if (le.StatusCode == LMDBErrorCodes.MDB_NOTFOUND)
                {
                    if (LoggerManager.Instance.StorageLogger != null && LoggerManager.Instance.StorageLogger.IsWarnEnabled)
                    {
                        LoggerManager.Instance.StorageLogger.Warn("LMDB.DeleteDocument", "Error Deleting Document." + GetFileInfo() + le);
                    }
                    result.Status = StoreResult.Success;
                    return(result);
                }
                result.Status = HandleException(le);
                return(result);
            }
        }
        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.Equal(MDBResultCode.NotFound, result.resultCode);
        }
Exemple #8
0
        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);
        }
Exemple #9
0
 public byte[] Get(byte[] key)
 {
     return(_tx.Get(_db, key));
 }
 public void DatabaseGetShouldNotThrowExceptions()
 {
     _txn.Get(_db, UTF8.GetBytes("key"));
 }
        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);
        }