public void CanAddMultiValuesUnderTheSameKeyToBatch()
{
using (var env = new StorageEnvironment(StorageEnvironmentOptions.CreateMemoryOnly()))
{
var rand = new Random();
var testBuffer = new byte[168];
rand.NextBytes(testBuffer);
CreateTrees(env, 1, "multitree");
var batch = new WriteBatch();
batch.MultiAdd("key", "value1", "multitree0");
batch.MultiAdd("key", "value2", "multitree0");
env.Writer.Write(batch);
using (var tx = env.NewTransaction(TransactionFlags.Read))
{
var tree = tx.Environment.State.GetTree(tx, "multitree0");
using (var it = tree.MultiRead("key"))
{
Assert.True(it.Seek(Slice.BeforeAllKeys));
Assert.Equal("value1", it.CurrentKey.ToString());
Assert.True(it.MoveNext());
Assert.Equal("value2", it.CurrentKey.ToString());
}
}
}
}
public void CanProperlySnapshot()
{
using (var state = new PersistentState("self", StorageEnvironmentOptions.CreateMemoryOnly(), CancellationToken.None)
{
CommandSerializer = new JsonCommandSerializer()
})
{
state.UpdateTermTo(null, 1);
state.AppendToLeaderLog(new NopCommand());
for (int i = 0; i < 5; i++)
{
state.AppendToLeaderLog(new DictionaryCommand.Set
{
Key = i.ToString(),
Value = i
});
}
state.MarkSnapshotFor(6, 1, 5);
state.AppendToLeaderLog(new DictionaryCommand.Set
{
Key = "1",
Value = 4
});
var lastLogEntry = state.LastLogEntry();
Assert.Equal(7, lastLogEntry.Index);
}
}
public void CanQueryUsingSingleTerm()
{
using (var fullTextIndex = new FullTextIndex(StorageEnvironmentOptions.CreateMemoryOnly(), new DefaultAnalyzer()))
{
using (var indexer = fullTextIndex.CreateIndexer())
{
indexer.NewIndexEntry();
indexer.AddField("Name", "Oren Eini");
indexer.AddField("Email", "*****@*****.**");
indexer.NewIndexEntry();
indexer.AddField("Name", "Arava Eini");
indexer.AddField("Email", "*****@*****.**");
indexer.Flush();
}
using (var searcher = fullTextIndex.CreateSearcher())
{
Assert.Equal(1, searcher.Query(new TermQuery("Name", "oren")).Count());
Assert.Equal(0, searcher.Query(new TermQuery("Name", "rahien")).Count());
}
}
}
public void CanQueryUsingBooleanQuery()
{
using (var fullTextIndex = new FullTextIndex(StorageEnvironmentOptions.CreateMemoryOnly(), new DefaultAnalyzer()))
{
using (var indexer = fullTextIndex.CreateIndexer())
{
indexer.NewIndexEntry();
indexer.AddField("Name", "Oren");
indexer.AddField("Email", "*****@*****.**");
indexer.NewIndexEntry();
indexer.AddField("Name", "Oren");
indexer.AddField("Email", "*****@*****.**");
indexer.Flush();
}
using (var searcher = fullTextIndex.CreateSearcher())
{
Assert.Equal(1, searcher.Query(new BooleanQuery(QueryOperator.And,
new TermQuery("Name", "oren"),
new TermQuery("Email", "*****@*****.**"))).Count());
Assert.Equal(2, searcher.Query(new BooleanQuery(QueryOperator.Or,
new TermQuery("Name", "oren"),
new TermQuery("Email", "*****@*****.**"))).Count());
}
}
}
public void CanQueryWithInQuery()
{
using (var fullTextIndex = new FullTextIndex(StorageEnvironmentOptions.CreateMemoryOnly(), new DefaultAnalyzer()))
{
using (var indexer = fullTextIndex.CreateIndexer())
{
indexer.NewIndexEntry();
indexer.AddField("Name", "David Boike");
indexer.NewIndexEntry();
indexer.AddField("Name", "Oren Eini");
indexer.NewIndexEntry();
indexer.AddField("Name", "Arava Eini");
indexer.NewIndexEntry();
indexer.AddField("Name", "Sean Epping");
indexer.NewIndexEntry();
indexer.AddField("Name", "Joe DeCock");
indexer.Flush();
}
using (var searcher = fullTextIndex.CreateSearcher())
{
var results = searcher.QueryTop(new InQuery("Name", "joe", "epping", "boike"), 5);
Assert.Equal(3, results.Results.Length);
}
}
}
public unsafe void Scratch_file_is_aware_of_potentialy_active_readers()
{
var numberOfPages = 20;
var handle = NativeMemory.AllocateMemory(numberOfPages * Constants.Storage.PageSize);
using (var env = StorageEnvironmentOptions.CreateMemoryOnly())
using (var pager = env.CreateScratchPager("temp", 65 * 1024))
using (var file = new ScratchBufferFile(pager, 0))
{
Assert.False(file.HasActivelyUsedBytes(2));
file.Allocate(null, 1, 1);
file.Allocate(null, 1, 1);
file.Allocate(null, 1, 1);
file.Allocate(null, 1, 1);
file.Allocate(null, 1, 1);
file.Free(0, 1);
file.Free(1, 3);
file.Free(2, 4);
file.Free(3, 7);
file.Free(4, 9);
for (int i = 0; i <= 9; i++)
{
Assert.True(file.HasActivelyUsedBytes(i));
}
Assert.False(file.HasActivelyUsedBytes(10));
Assert.False(file.HasActivelyUsedBytes(20));
}
}
public void AllScratchPagesShouldBeReleased()
{
var options = StorageEnvironmentOptions.CreateMemoryOnly();
options.ManualFlushing = true;
using (var env = new StorageEnvironment(options))
{
using (var txw = env.NewTransaction(TransactionFlags.ReadWrite))
{
env.CreateTree(txw, "test");
txw.Commit();
}
using (var txw = env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = txw.Environment.State.GetTree(txw, "test");
tree.Add("key/1", new MemoryStream(new byte[100]));
tree.Add("key/1", new MemoryStream(new byte[200]));
txw.Commit();
}
env.FlushLogToDataFile(); // non read nor write transactions, so it should flush and release everything from scratch
Assert.Equal(0, env.ScratchBufferPool.GetNumberOfAllocations(0));
}
}
public void IterationShouldNotFindAnyRecordsAndShouldNotThrowWhenNumberOfEntriesOnPageIs1AndKeyDoesNotMatch()
{
using (var env = new StorageEnvironment(StorageEnvironmentOptions.CreateMemoryOnly()))
{
using (var tx = env.NewTransaction(TransactionFlags.ReadWrite))
{
env.CreateTree(tx, "tree");
tx.Commit();
}
using (var tx = env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = tx.ReadTree("tree");
tree.Add(@"Raven\Database\1", StreamFor("123"));
tx.Commit();
}
using (var snapshot = env.CreateSnapshot())
using (var iterator = snapshot.Iterate("tree"))
{
Assert.False(iterator.Seek(@"Raven\Filesystem\"));
}
}
}
protected StorageTest()
{
DeleteDirectory(DataDir);
_options = StorageEnvironmentOptions.CreateMemoryOnly();
Configure(_options);
}
public void ShouldWork()
{
using (var env = new StorageEnvironment(StorageEnvironmentOptions.CreateMemoryOnly()))
{
using (var tx = env.WriteTransaction())
{
var s = new string('0', 500);
var tree = tx.CreateTree("data");
for (int i = 0; i < 10; i++)
{
tree.Add("users-" + i + "-" + s, new byte[0]);
}
tx.Commit();
}
using (var tx = env.ReadTransaction())
{
var tree = tx.ReadTree("data");
using (var it = tree.Iterate(false))
{
Slice key;
Slice.From(tx.Allocator, "users-7", out key);
Assert.True(it.Seek(key));
for (int i = 0; i < 10; i++)
{
Slice.From(tx.Allocator, "users-" + i, out key);
Assert.True(it.Seek(key), i.ToString());
}
}
}
}
}
public void StorageEnvironment_CreateTree_Should_be_shipped_properly()
{
var transactionsToShip = new ConcurrentBag <TransactionToShip>();
Env.Journal.OnTransactionCommit += tx =>
{
tx.CreatePagesSnapshot();
transactionsToShip.Add(tx);
};
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "TestTree");
tree.Add("ABC", "Foo");
tx.Commit();
}
using (var shippingDestinationEnv = new StorageEnvironment(StorageEnvironmentOptions.CreateMemoryOnly()))
{
foreach (var tx in transactionsToShip)
{
shippingDestinationEnv.Journal.Shipper.ApplyShippedLog(tx.PagesSnapshot);
}
using (var snaphsot = shippingDestinationEnv.CreateSnapshot())
{
Assert.DoesNotThrow(() => //if tree doesn't exist --> throws InvalidOperationException
{
var result = snaphsot.Read("TestTree", "ABC");
Assert.Equal(1, result.Version);
Assert.Equal("Foo", result.Reader.ToStringValue());
});
}
}
}
public ConfigurationStorage(DocumentDatabase db)
{
var path = db.Configuration.Core.DataDirectory.Combine("Configuration");
var options = db.Configuration.Core.RunInMemory
? StorageEnvironmentOptions.CreateMemoryOnly(path.FullPath, db.Configuration.Storage.TempPath?.FullPath, db.IoChanges, db.CatastrophicFailureNotification)
: StorageEnvironmentOptions.ForPath(path.FullPath, db.Configuration.Storage.TempPath?.FullPath, null, db.IoChanges, db.CatastrophicFailureNotification);
options.OnNonDurableFileSystemError += db.HandleNonDurableFileSystemError;
options.OnRecoveryError += db.HandleOnRecoveryError;
options.CompressTxAboveSizeInBytes = db.Configuration.Storage.CompressTxAboveSize.GetValue(SizeUnit.Bytes);
options.SchemaVersion = Constants.Schemas.ConfigurationVersion;
options.ForceUsing32BitsPager = db.Configuration.Storage.ForceUsing32BitsPager;
options.TimeToSyncAfterFlashInSec = (int)db.Configuration.Storage.TimeToSyncAfterFlash.AsTimeSpan.TotalSeconds;
options.NumOfConcurrentSyncsPerPhysDrive = db.Configuration.Storage.NumberOfConcurrentSyncsPerPhysicalDrive;
Sodium.CloneKey(out options.MasterKey, db.MasterKey);
Environment = new StorageEnvironment(options);
NotificationsStorage = new NotificationsStorage(db.Name);
OperationsStorage = new OperationsStorage();
ContextPool = new TransactionContextPool(Environment);
}
public RaftNode(int port)
{
_name = "node-" + port;
_url = string.Format("http://{0}:{1}", Environment.MachineName, port);
var nodeTransport = new HttpTransport(_name);
var node1 = new NodeConnectionInfo {
Name = _name, Uri = new Uri(_url)
};
var engineOptions = new RaftEngineOptions(
node1,
StorageEnvironmentOptions.CreateMemoryOnly(),
nodeTransport,
new DictionaryStateMachine());
engineOptions.ElectionTimeout *= 2;
engineOptions.HeartbeatTimeout *= 2;
_raftEngine = new RaftEngine(engineOptions);
_server = WebApp.Start(new StartOptions
{
Urls = { string.Format("http://+:{0}/", port) }
}, builder =>
{
var httpConfiguration = new HttpConfiguration();
RaftWebApiConfig.Load();
httpConfiguration.MapHttpAttributeRoutes();
httpConfiguration.Properties[typeof(HttpTransportBus)] = nodeTransport.Bus;
builder.UseWebApi(httpConfiguration);
});
}
public void PageSplitterShouldCalculateSeparatorKeyCorrectly2()
{
var ids = ReadIds("data2.txt");
StorageEnvironmentOptions storageEnvironmentOptions = StorageEnvironmentOptions.CreateMemoryOnly();
storageEnvironmentOptions.MaxScratchBufferSize *= 2;
using (var env = new StorageEnvironment(storageEnvironmentOptions))
{
var rand = new Random();
var testBuffer = new byte[69];
rand.NextBytes(testBuffer);
var trees = CreateTrees(env, 1, "tree");
foreach (var id in ids)
{
using (var tx = env.NewTransaction(TransactionFlags.ReadWrite))
{
foreach (var treeName in trees)
{
var tree = tx.Environment.State.GetTree(tx, treeName);
tree.Add(id, new MemoryStream(testBuffer));
}
tx.Commit();
}
}
ValidateRecords(env, trees, ids);
}
}
public void IterationShouldNotFindAnyRecordsAndShouldNotThrowWhenNumberOfEntriesOnPageIs1AndKeyDoesNotMatch()
{
using (var env = new StorageEnvironment(StorageEnvironmentOptions.CreateMemoryOnly()))
{
using (var tx = env.WriteTransaction())
{
tx.CreateTree("tree");
tx.Commit();
}
using (var tx = env.WriteTransaction())
{
var tree = tx.ReadTree("tree");
tree.Add(@"Raven\Database\1", StreamFor("123"));
tx.Commit();
}
using (var snapshot = env.ReadTransaction())
using (var iterator = snapshot.ReadTree("tree").Iterate(false))
{
Slice v;
Slice.From(snapshot.Allocator, @"Raven\Filesystem\", out v);
Assert.False(iterator.Seek(v));
}
}
}
public void DataIsKeptAfterRestart()
{
using (var pureMemoryPager = StorageEnvironmentOptions.CreateMemoryOnly())
{
pureMemoryPager.OwnsPagers = false;
using (var env = new StorageEnvironment(pureMemoryPager))
{
using (var tx = env.NewTransaction(TransactionFlags.ReadWrite))
{
tx.State.Root.Add("test/1", new MemoryStream());
tx.Commit();
}
using (var tx = env.NewTransaction(TransactionFlags.ReadWrite))
{
tx.State.Root.Add("test/2", new MemoryStream());
tx.Commit();
}
}
using (var env = new StorageEnvironment(pureMemoryPager))
{
using (var tx = env.NewTransaction(TransactionFlags.Read))
{
Assert.NotNull(tx.State.Root.Read("test/1"));
Assert.NotNull(tx.State.Root.Read("test/2"));
tx.Commit();
}
}
}
}
public void DataIsKeptAfterRestart()
{
using (var pureMemoryPager = StorageEnvironmentOptions.CreateMemoryOnly())
{
pureMemoryPager.OwnsPagers = false;
using (var env = new StorageEnvironment(pureMemoryPager))
{
using (var tx = env.WriteTransaction())
{
var tree = tx.CreateTree("foo");
tree.Add("test/1", new MemoryStream());
tx.Commit();
}
using (var tx = env.WriteTransaction())
{
var tree = tx.CreateTree("foo");
tree.Add("test/2", new MemoryStream());
tx.Commit();
}
}
using (var env = new StorageEnvironment(pureMemoryPager))
{
using (var tx = env.ReadTransaction())
{
var tree = tx.CreateTree("foo");
Assert.NotNull(tree.Read("test/1"));
Assert.NotNull(tree.Read("test/2"));
tx.Commit();
}
}
}
}
public HttpTransportPingTest()
{
_node1Transport = new HttpTransport("node1", _requestsTimeout, CancellationToken.None);
var node1 = new NodeConnectionInfo {
Name = "node1", Uri = new Uri("http://localhost:9079")
};
var engineOptions = new RaftEngineOptions(node1, StorageEnvironmentOptions.CreateMemoryOnly(), _node1Transport, new DictionaryStateMachine())
{
ElectionTimeout = 60 * 1000,
HeartbeatTimeout = 10 * 1000
};
_raftEngine = new RaftEngine(engineOptions);
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(9079);
_server = WebApp.Start(new StartOptions
{
Urls = { "http://+:9079/" }
}, builder =>
{
var httpConfiguration = new HttpConfiguration();
RaftWebApiConfig.Load();
httpConfiguration.MapHttpAttributeRoutes();
httpConfiguration.Properties[typeof(HttpTransportBus)] = _node1Transport.Bus;
builder.UseWebApi(httpConfiguration);
});
}
public void StorageEnvironment_should_be_able_to_accept_transactionsToShip_with_LOTS_of_transactions()
{
var transactionsToShip = new ConcurrentBag <TransactionToShip>();
Env.Journal.OnTransactionCommit += transactionsToShip.Add;
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
Env.CreateTree(tx, "TestTree");
Env.CreateTree(tx, "TestTree2");
tx.Commit();
}
WriteLotsOfTestDataForTree("TestTree");
WriteLotsOfTestDataForTree("TestTree2");
using (var shippingDestinationEnv = new StorageEnvironment(StorageEnvironmentOptions.CreateMemoryOnly()))
{
Assert.DoesNotThrow(() => shippingDestinationEnv.Journal.Shipper.ApplyShippedLogs(transactionsToShip));
using (var snapshot = shippingDestinationEnv.CreateSnapshot())
{
ValidateLotsOfTestDataForTree(snapshot, "TestTree");
ValidateLotsOfTestDataForTree(snapshot, "TestTree2");
}
}
}
public void ShouldWork()
{
using (var env = new StorageEnvironment(StorageEnvironmentOptions.CreateMemoryOnly()))
{
using (var tx = env.NewTransaction(TransactionFlags.ReadWrite))
{
var s = new string('0', 500);
var tree = env.CreateTree(tx, "data");
for (int i = 0; i < 10; i++)
{
tree.Add("users-" + i + "-" + s, new byte[0]);
}
tx.Commit();
}
using (var tx = env.NewTransaction(TransactionFlags.Read))
{
var tree = tx.ReadTree("data");
using (var it = tree.Iterate())
{
Assert.True(it.Seek("users-7"));
for (int i = 0; i < 10; i++)
{
Assert.True(it.Seek("users-" + i), i.ToString());
}
}
}
}
}
public void StorageEnvironment_should_be_able_to_accept_transactionsToShip_with_new_trees_no_flushing()
{
var transactionsToShip = new ConcurrentBag <TransactionToShip>();
using (var shippingSourceEnv = new StorageEnvironment(StorageEnvironmentOptions.CreateMemoryOnly()))
{
shippingSourceEnv.Journal.OnTransactionCommit += tx =>
{
tx.CreatePagesSnapshot();
transactionsToShip.Add(tx);
};
using (var tx = shippingSourceEnv.NewTransaction(TransactionFlags.ReadWrite))
{
shippingSourceEnv.CreateTree(tx, "TestTree");
tx.Commit();
}
}
var storageEnvironmentOptions = StorageEnvironmentOptions.CreateMemoryOnly();
storageEnvironmentOptions.ManualFlushing = true;
using (var shippingDestinationEnv = new StorageEnvironment(storageEnvironmentOptions))
{
foreach (var tx in transactionsToShip)
{
shippingDestinationEnv.Journal.Shipper.ApplyShippedLog(tx.PagesSnapshot);
}
using (var snapshot = shippingDestinationEnv.CreateSnapshot())
{
snapshot.Read("TestTree", "Foo");
}
}
}
public void Initialize(UuidGenerator generator, OrderedPartCollection <AbstractFileCodec> codecs)
{
if (codecs == null)
{
throw new ArgumentNullException("codecs");
}
fileCodecs = codecs;
uuidGenerator = generator;
bool runInMemory;
bool.TryParse(settings[Constants.RunInMemory], out runInMemory);
var persistenceSource = runInMemory ? StorageEnvironmentOptions.CreateMemoryOnly() :
CreateStorageOptionsFromConfiguration(path, settings);
tableStorage = new TableStorage(persistenceSource, bufferPool);
var schemaCreator = new SchemaCreator(configuration, tableStorage, Output, Log);
schemaCreator.CreateSchema();
schemaCreator.SetupDatabaseIdAndSchemaVersion();
schemaCreator.UpdateSchemaIfNecessary();
SetupDatabaseId();
idGenerator = new IdGenerator(tableStorage);
}
public void CanCleanExpiredMetrics()
{
var files = new List <string>(new[] { "file1.txt", "file2.txt", "file3.txt" });
using (var env = new StorageEnvironment(StorageEnvironmentOptions.CreateMemoryOnly()))
{
var envWithType = new StorageEnvironmentWithType("test", StorageEnvironmentWithType.StorageEnvironmentType.Documents, env);
foreach (var fileName in files)
{
for (var i = 0; i < 2 * 256; i++)
{
var now = DateTime.UtcNow.AddHours(-7);
var meterIoRate = env.Options.IoMetrics.MeterIoRate(fileName, IoMetrics.MeterType.JournalWrite, i + 1);
var durationMeasurement = new IoMeterBuffer.DurationMeasurement(meterIoRate.Parent, IoMetrics.MeterType.JournalWrite, i + 1, 0, null)
{
Start = now,
End = now.AddMilliseconds(2)
};
meterIoRate.Parent.Mark(ref durationMeasurement);
}
}
CheckMetricFiles(env, files, checkForNull: false);
IEnumerable <StorageEnvironmentWithType> environments = new[] { envWithType };
IoMetricsUtil.CleanIoMetrics(environments, DateTime.UtcNow.Ticks);
CheckMetricFiles(env, files, checkForNull: true);
}
}
public void Follower_as_a_single_node_becomes_leader_automatically()
{
var hub = new InMemoryTransportHub();
var storageEnvironmentOptions = StorageEnvironmentOptions.CreateMemoryOnly();
storageEnvironmentOptions.OwnsPagers = false;
var raftEngineOptions = new RaftEngineOptions(
new NodeConnectionInfo {
Name = "node1"
},
storageEnvironmentOptions,
hub.CreateTransportFor("node1"),
new DictionaryStateMachine()
)
{
ElectionTimeout = 1000,
HeartbeatTimeout = 1000 / 6
};
PersistentState.ClusterBootstrap(raftEngineOptions);
storageEnvironmentOptions.OwnsPagers = true;
using (var raftNode = new RaftEngine(raftEngineOptions))
{
Assert.Equal(RaftEngineState.Leader, raftNode.State);
}
}
public void CanQueryAndSort()
{
using (var fullTextIndex = new FullTextIndex(StorageEnvironmentOptions.CreateMemoryOnly(), new DefaultAnalyzer()))
{
using (var indexer = fullTextIndex.CreateIndexer())
{
indexer.NewIndexEntry();
indexer.AddField("Name", "Oren Eini");
indexer.AddField("Email", "*****@*****.**");
indexer.NewIndexEntry();
indexer.AddField("Name", "Arava Eini");
indexer.AddField("Email", "*****@*****.**");
indexer.Flush();
}
using (var searcher = fullTextIndex.CreateSearcher())
{
var results = searcher.QueryTop(new TermQuery("Name", "eini"), 5, sortBy: new Sorter("Email"));
Assert.Equal(2, results.Results[0].DocumentId);
Assert.Equal(1, results.Results[1].DocumentId);
}
}
}
public ConfigurationStorage(DocumentDatabase db)
{
var path = db.Configuration.Core.DataDirectory.Combine("Configuration");
var options = db.Configuration.Core.RunInMemory
? StorageEnvironmentOptions.CreateMemoryOnly(path.FullPath, db.Configuration.Storage.TempPath?.FullPath, db.IoChanges, db.CatastrophicFailureNotification)
: StorageEnvironmentOptions.ForPath(path.FullPath, db.Configuration.Storage.TempPath?.FullPath, null, db.IoChanges, db.CatastrophicFailureNotification);
options.OnNonDurableFileSystemError += db.HandleNonDurableFileSystemError;
options.OnRecoveryError += db.HandleOnConfigurationRecoveryError;
options.CompressTxAboveSizeInBytes = db.Configuration.Storage.CompressTxAboveSize.GetValue(SizeUnit.Bytes);
options.SchemaVersion = SchemaUpgrader.CurrentVersion.ConfigurationVersion;
options.SchemaUpgrader = SchemaUpgrader.Upgrader(SchemaUpgrader.StorageType.Configuration, this, null);
options.ForceUsing32BitsPager = db.Configuration.Storage.ForceUsing32BitsPager;
options.TimeToSyncAfterFlashInSec = (int)db.Configuration.Storage.TimeToSyncAfterFlash.AsTimeSpan.TotalSeconds;
options.NumOfConcurrentSyncsPerPhysDrive = db.Configuration.Storage.NumberOfConcurrentSyncsPerPhysicalDrive;
options.MasterKey = db.MasterKey?.ToArray();
options.DoNotConsiderMemoryLockFailureAsCatastrophicError = db.Configuration.Security.DoNotConsiderMemoryLockFailureAsCatastrophicError;
if (db.Configuration.Storage.MaxScratchBufferSize.HasValue)
{
options.MaxScratchBufferSize = db.Configuration.Storage.MaxScratchBufferSize.Value.GetValue(SizeUnit.Bytes);
}
Environment = LayoutUpdater.OpenEnvironment(options);
NotificationsStorage = new NotificationsStorage(db.Name);
OperationsStorage = new OperationsStorage();
ContextPool = new TransactionContextPool(Environment);
}
public void AllScratchPagesShouldBeReleased()
{
var options = StorageEnvironmentOptions.CreateMemoryOnly();
options.ManualFlushing = true;
using (var env = new StorageEnvironment(options))
{
using (var txw = env.WriteTransaction())
{
txw.CreateTree("test");
txw.Commit();
}
using (var txw = env.WriteTransaction())
{
var tree = txw.CreateTree("test");
tree.Add("key/1", new MemoryStream(new byte[100]));
tree.Add("key/1", new MemoryStream(new byte[200]));
txw.Commit();
}
env.FlushLogToDataFile(); // non read nor write transactions, so it should flush and release everything from scratch
// we keep track of the pages in scratch for one additional transaction, to avoid race
// condition with FlushLogToDataFile concurrently with new read transactions
Assert.Equal(2, env.ScratchBufferPool.GetNumberOfAllocations(0));
}
}
public void StorageEnvironment_should_be_able_to_accept_transactionsToShip()
{
var transactionsToShip = new ConcurrentBag <TransactionToShip>();
Env.Journal.OnTransactionCommit += transactionsToShip.Add;
WriteTestDataToEnv();
using (var shippingDestinationEnv = new StorageEnvironment(StorageEnvironmentOptions.CreateMemoryOnly()))
{
shippingDestinationEnv.Journal.Shipper.ApplyShippedLogs(transactionsToShip);
using (var snapshot = shippingDestinationEnv.CreateSnapshot())
{
var fooReadResult = snapshot.Read("TestTree", "foo");
Assert.NotNull(fooReadResult);
var fooValue = Encoding.UTF8.GetString(fooReadResult.Reader.AsStream().ReadData());
Assert.Equal("bar", fooValue);
var barReadResult = snapshot.Read("TestTree", "bar");
Assert.NotNull(barReadResult);
var barValue = Encoding.UTF8.GetString(barReadResult.Reader.AsStream().ReadData());
Assert.Equal("foo", barValue);
}
}
}
protected StorageTest(ITestOutputHelper output) : base(output)
{
IOExtensions.DeleteDirectory(DataDir);
Options = StorageEnvironmentOptions.CreateMemoryOnly();
Configure(Options);
_storageEnvironment = new Lazy <StorageEnvironment>(() => new StorageEnvironment(Options), LazyThreadSafetyMode.ExecutionAndPublication);
}
private static StorageEnvironmentOptions CreateMemoryStorageOptionsFromConfiguration(InMemoryRavenConfiguration configuration)
{
var options = StorageEnvironmentOptions.CreateMemoryOnly();
options.InitialFileSize = configuration.VoronInitialFileSize;
return(options);
}