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 }
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 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 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); }
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 DatabasePutShouldNotThrowExceptions() { var key = "key"; var value = "value"; _txn.Put(_db, key, value); }
public static void Index(LightningDatabase db, LightningTransaction tx, byte[] key, byte[] value) { // IMPORTANT: // lmdb's DUP_SORT still imposes the MaxKeySizeBytes on the length of the key + value, // so it's less ambiguous if we handle "multiple values for a single key" semantics ourselves // if (key.Length > MaxKeySizeBytes) { // FIXME: localize this var message = $"Index key length is {key.Length} but the maximum key size is {MaxKeySizeBytes}"; throw new InvalidOperationException(message); } tx.Put(db, key, value, PutOptions.NoOverwrite); }
public void DatabasePutShouldNotThrowExceptions() { var key = "key"; var value = 25; //arrange //act _txn.Put(_db, key, value); //assert }
private void MoveToQueue(LightningTransaction tx, string queueName, Message message) { try { var idBytes = message.Id.MessageIdentifier.ToByteArray(); var original = OpenDatabase(tx, message.Queue); var newDb = OpenDatabase(tx, queueName); tx.Delete(original, idBytes).ThrowOnError(); tx.Put(newDb, idBytes, message.Serialize()).ThrowOnError(); } catch (LightningException ex) { tx.Dispose(); if (ex.StatusCode == (int)MDBResultCode.NotFound) { throw new QueueDoesNotExistException("Queue doesn't exist", ex); } throw; } }
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 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); }
private void StoreIncomingMessages(LightningTransaction tx, params Message[] messages) { try { foreach (var messagesByQueue in messages.GroupBy(x => x.Queue)) { var db = OpenDatabase(tx, messagesByQueue.Key); foreach (var message in messagesByQueue) { tx.Put(db, message.Id.MessageIdentifier.ToByteArray(), message.Serialize()).ThrowOnError(); } } } catch (LightningException ex) { if (ex.StatusCode == (int)MDBResultCode.NotFound) { throw new QueueDoesNotExistException("Queue doesn't exist", ex); } throw; } }
public static bool PutVulnerabilities(List <OSSIndexVulnerability> vulnerabilities) { if (!Environment.IsOpened) { Environment.MapSize = 2L * 1024L * 1024L * 1024L; Environment.Open(EnvironmentOpenFlags.None); } using (LightningTransaction tx = Environment.BeginTransaction()) using (LightningDatabase db = tx.OpenDatabase(null, new DatabaseConfiguration { Flags = DatabaseOpenFlags.Create })) { try { foreach (OSSIndexVulnerability v in vulnerabilities) { /* * using (MemoryStream ms = new MemoryStream()) * using (BsonWriter writer = new BsonWriter(ms)) * { * JsonSerializer serializer = new JsonSerializer(); * serializer.Serialize(writer, v); * } */ tx.Put(db, Encoding.UTF8.GetBytes(string.IsNullOrEmpty(v.Vid) ? v.Url : v.Vid + "#" + v.Group), Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(v))); } tx.Commit(); logger.Debug("Committed {0} vulnerabilities to database.", vulnerabilities.Count); return(true); } catch (LightningException e) { logger.Error("Exception thrown attempting to write vulnerabilities to database."); logger.Error(e); return(false); } } }
public static MDBResultCode Put(this LightningTransaction tx, LightningDatabase db, string key, string value) { var enc = System.Text.Encoding.UTF8; return(tx.Put(db, enc.GetBytes(key), enc.GetBytes(value))); }
public void Put(TKey key, T data) => _tx.Put(_db, _settings.SerializeKey(key), _settings.Serialize(data), PutOptions.NoDuplicateData);
private void StoreOutgoing(LightningTransaction tx, OutgoingMessage message) { var db = OpenDatabase(tx, OutgoingQueue); tx.Put(db, message.Id.MessageIdentifier.ToByteArray(), message.Serialize()); }
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 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 Put(byte[] key, byte[] value) { _tx.Put(_db, key, value); }
public static void Put(this LightningTransaction tx, LightningDatabase db, string key, string value) { var enc = System.Text.Encoding.UTF8; tx.Put(db, enc.GetBytes(key), enc.GetBytes(value)); }