public void CursorShouldBeCreated()
{
_db = _txn.OpenDatabase(configuration: new DatabaseConfiguration {
Flags = DatabaseOpenFlags.Create
});
_txn.CreateCursor(_db).Dispose();
}
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 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 DatabaseShouldBeClosed()
{
_env.Open();
_txn = _env.BeginTransaction();
var db = _txn.OpenDatabase();
db.Dispose();
Assert.Equal(false, db.IsOpened);
}
public void Init()
{
Directory.CreateDirectory(_path);
_env = new LightningEnvironment(_path, EnvironmentOpenFlags.None);
_env.Open();
_txn = _env.BeginTransaction();
_db = _txn.OpenDatabase();
}
public void DatabaseShouldBeClosed()
{
_env.Open();
_txn = _env.BeginTransaction();
var db = _txn.OpenDatabase();
db.Dispose();
Assert.False(db.IsOpened);
}
public void Init()
{
Directory.CreateDirectory(_path);
_env = new LightningEnvironment(_path, EnvironmentOpenFlags.None);
_env.Open();
_txn = _env.BeginTransaction();
_db = _txn.OpenDatabase();
}
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});
}
private LightningDatabase OpenDatabase(LightningTransaction transaction, string database)
{
if (_databaseCache.ContainsKey(database))
{
return(_databaseCache[database]);
}
var db = transaction.OpenDatabase(database);
_databaseCache[database] = db;
return(db);
}
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 DefaultDatabaseShouldBeOpened()
{
_env.Open();
_txn = _env.BeginTransaction();
//arrange
//act
var db = _txn.OpenDatabase(null, DatabaseOpenFlags.None);
//assert
Assert.AreEqual(true, db.IsOpened);
}
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 DatabaseShouldBeCreated()
{
var dbName = "test";
_env.MapDatabases = 2;
_env.Open();
_txn = _env.BeginTransaction();
//arrange
//act
_txn.OpenDatabase(dbName, DatabaseOpenFlags.Create);
//assert
}
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 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 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 DatabaseShouldBeCreated()
{
var dbName = "test";
_env.MaxDatabases = 2;
_env.Open();
_txn = _env.BeginTransaction();
//arrange
//act
_txn.OpenDatabase(dbName, DatabaseOpenFlags.Create);
//assert
}
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 CanCommitTransactionToNamedDatabase()
{
using (var db = _txn.OpenDatabase("test", new DatabaseConfiguration {
Flags = DatabaseOpenFlags.Create
}))
{
_txn.Put(db, "key1", "value");
_txn.Commit();
}
using (var txn2 = _env.BeginTransaction())
{
using (var db = txn2.OpenDatabase("test"))
{
var value = txn2.Get(db, "key1");
Assert.Equal("value", value);
}
}
}
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);
}
public static void PrintAllVulnerabilities()
{
if (!Environment.IsOpened)
{
Environment.MapSize = 2L * 1024L * 1024L * 1024L;
Environment.Open(EnvironmentOpenFlags.None);
}
using (LightningTransaction tx = Environment.BeginTransaction(TransactionBeginFlags.ReadOnly))
{
LightningDatabase db = tx.OpenDatabase();
using (LightningCursor cursor = tx.CreateCursor(db))
{
foreach (KeyValuePair <byte[], byte[]> r in cursor)
{
string id = Encoding.UTF8.GetString(r.Key);
OSSIndexVulnerability v = JsonConvert.DeserializeObject <OSSIndexVulnerability>(Encoding.UTF8.GetString(r.Value));
logger.Info("Id: {0}), Package: {1}, CVEs: {2}", id, v.Name, string.Join(" ", v.CVEs));
}
}
}
}
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 bool GetVulnerability(string id, out OSSIndexVulnerability v)
{
if (!Environment.IsOpened)
{
Environment.MapSize = 2L * 1024L * 1024L * 1024L;
Environment.Open(EnvironmentOpenFlags.None);
}
using (LightningTransaction tx = Environment.BeginTransaction(TransactionBeginFlags.ReadOnly))
{
LightningDatabase db = tx.OpenDatabase();
byte[] ret = null;
if (!tx.TryGet(db, Encoding.UTF8.GetBytes(id), out ret))
{
v = null;
return(false);
}
else
{
v = JsonConvert.DeserializeObject <OSSIndexVulnerability>(Encoding.UTF8.GetString(ret));
return(true);
}
}
}
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);
}
}
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 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 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);
}
