public void IncorrectWriteOfOverflowPagesFromJournalsToDataFile_RavenDB_2806()
{
RequireFileBasedPager();
const int testedOverflowSize = 20000;
var overflowValue = new byte[testedOverflowSize];
new Random(1).NextBytes(overflowValue);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "test");
var itemBytes = new byte[16000];
new Random(2).NextBytes(itemBytes);
tree.Add("items/1", itemBytes);
new Random(3).NextBytes(itemBytes);
tree.Add("items/2", itemBytes);
tree.Delete("items/1");
tree.Delete("items/2");
tree.Add("items/3", overflowValue);
tx.Commit();
}
BackupMethods.Incremental.ToFile(Env, IncrementalBackupTestUtils.IncrementalBackupFile(0));
var options = StorageEnvironmentOptions.ForPath(IncrementalBackupTestUtils.RestoredStoragePath);
options.MaxLogFileSize = Env.Options.MaxLogFileSize;
BackupMethods.Incremental.Restore(options, new[]
{
IncrementalBackupTestUtils.IncrementalBackupFile(0)
});
using (var env = new StorageEnvironment(options))
{
using (var tx = env.NewTransaction(TransactionFlags.Read))
{
var tree = tx.ReadTree("test");
var readResult = tree.Read("items/3");
var readBytes = new byte[testedOverflowSize];
readResult.Reader.Read(readBytes, 0, testedOverflowSize);
Assert.Equal(overflowValue, readBytes);
}
}
}
private static void Clean()
{
if (Directory.Exists("Data"))
{
Directory.Delete("Data", true);
}
IncrementalBackupTestUtils.Clean();
}
public void CanBackupAndRestoreOnEmptyStorage()
{
RequireFileBasedPager();
var random = new Random();
var buffer = new byte[8192];
random.NextBytes(buffer);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
for (int i = 0; i < 500; i++)
{
tx.State.Root.Add("items/" + i, new MemoryStream(buffer));
}
tx.Commit();
}
BackupMethods.Incremental.ToFile(Env, IncrementalBackupTestUtils.IncrementalBackupFile(0));
var options = StorageEnvironmentOptions.ForPath(IncrementalBackupTestUtils.RestoredStoragePath);
options.MaxLogFileSize = Env.Options.MaxLogFileSize;
BackupMethods.Incremental.Restore(options, new[] { IncrementalBackupTestUtils.IncrementalBackupFile(0) });
using (var env = new StorageEnvironment(options))
{
using (var tx = env.NewTransaction(TransactionFlags.Read))
{
for (int i = 0; i < 500; i++)
{
var readResult = tx.State.Root.Read("items/" + i);
Assert.NotNull(readResult);
var memoryStream = new MemoryStream();
readResult.Reader.CopyTo(memoryStream);
Assert.Equal(memoryStream.ToArray(), buffer);
}
}
}
}
public void ShouldCorrectlyLoadAfterRestartIfIncrementalBackupWasDone()
{
var bytes = new byte[1024];
new Random().NextBytes(bytes);
using (var env = new StorageEnvironment(ModifyOptions(StorageEnvironmentOptions.ForPath("Data"))))
{
using (var tx = env.NewTransaction(TransactionFlags.ReadWrite))
{
env.CreateTree(tx, "items");
tx.Commit();
}
for (int j = 0; j < 100; j++)
{
using (var tx = env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = tx.ReadTree("items");
for (int i = 0; i < 100; i++)
{
tree.Add("items/" + i, bytes);
}
tx.Commit();
}
}
BackupMethods.Incremental.ToFile(env, IncrementalBackupTestUtils.IncrementalBackupFile(0));
}
// restart
using (var env = new StorageEnvironment(ModifyOptions(StorageEnvironmentOptions.ForPath("Data"))))
{
}
}
public void CanDoMultipleIncrementalBackupsAndRestoreOneByOne()
{
RequireFileBasedPager();
var random = new Random();
var buffer = new byte[1024];
random.NextBytes(buffer);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
for (int i = 0; i < 300; i++)
{
tx.State.Root.Add("items/" + i, new MemoryStream(buffer));
}
tx.Commit();
}
BackupMethods.Incremental.ToFile(Env, IncrementalBackupTestUtils.IncrementalBackupFile(0));
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
for (int i = 300; i < 600; i++)
{
tx.State.Root.Add("items/" + i, new MemoryStream(buffer));
}
tx.Commit();
}
BackupMethods.Incremental.ToFile(Env, IncrementalBackupTestUtils.IncrementalBackupFile(1));
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
for (int i = 600; i < 1000; i++)
{
tx.State.Root.Add("items/" + i, new MemoryStream(buffer));
}
tx.Commit();
}
Env.FlushLogToDataFile(); // make sure that incremental backup will work even if we flushed journals to the data file
BackupMethods.Incremental.ToFile(Env, IncrementalBackupTestUtils.IncrementalBackupFile(2));
var options = StorageEnvironmentOptions.ForPath(IncrementalBackupTestUtils.RestoredStoragePath);
options.MaxLogFileSize = Env.Options.MaxLogFileSize;
BackupMethods.Incremental.Restore(options, new[]
{
IncrementalBackupTestUtils.IncrementalBackupFile(0),
IncrementalBackupTestUtils.IncrementalBackupFile(1),
IncrementalBackupTestUtils.IncrementalBackupFile(2)
});
using (var env = new StorageEnvironment(options))
{
using (var tx = env.NewTransaction(TransactionFlags.Read))
{
for (int i = 0; i < 1000; i++)
{
var readResult = tx.State.Root.Read("items/" + i);
Assert.NotNull(readResult);
var memoryStream = new MemoryStream();
readResult.Reader.CopyTo(memoryStream);
Assert.Equal(memoryStream.ToArray(), buffer);
}
}
}
}
public override void Dispose()
{
base.Dispose();
IncrementalBackupTestUtils.Clean();
}
public Incremental()
{
IncrementalBackupTestUtils.Clean();
}
public void IncrementalBackupShouldAcceptEmptyIncrementalBackups()
{
RequireFileBasedPager();
var random = new Random();
var buffer = new byte[100];
random.NextBytes(buffer);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
for (int i = 0; i < 5; i++)
{
tx.State.Root.Add("items/" + i, new MemoryStream(buffer));
}
tx.Commit();
}
var usedPagesInJournal = Env.Journal.CurrentFile.WritePagePosition;
var backedUpPages = BackupMethods.Incremental.ToFile(Env, IncrementalBackupTestUtils.IncrementalBackupFile(0));
Assert.Equal(usedPagesInJournal, backedUpPages);
// We don't modify anything between backups - to create empty incremental backup
var writePos = Env.Journal.CurrentFile.WritePagePosition;
var usedByLastTransaction = Env.Journal.CurrentFile.WritePagePosition - writePos;
Assert.Equal(0, usedByLastTransaction);
backedUpPages = BackupMethods.Incremental.ToFile(Env, IncrementalBackupTestUtils.IncrementalBackupFile(1));
Assert.Equal(usedByLastTransaction, backedUpPages);
var options = StorageEnvironmentOptions.ForPath(IncrementalBackupTestUtils.RestoredStoragePath);
options.MaxLogFileSize = Env.Options.MaxLogFileSize;
BackupMethods.Incremental.Restore(options, new[]
{
IncrementalBackupTestUtils.IncrementalBackupFile(0),
IncrementalBackupTestUtils.IncrementalBackupFile(1)
});
using (var env = new StorageEnvironment(options))
{
using (var tx = env.NewTransaction(TransactionFlags.Read))
{
for (int i = 0; i < 5; i++)
{
var readResult = tx.State.Root.Read("items/" + i);
Assert.NotNull(readResult);
var memoryStream = new MemoryStream();
readResult.Reader.CopyTo(memoryStream);
Assert.Equal(memoryStream.ToArray(), buffer);
}
}
}
}
public void ShouldExplicitlyErrorThatTurningOnIncrementalBackupAfterInitializingTheStorageIsntAllowed()
{
RequireFileBasedPager();
var random = new Random();
var buffer = new byte[4000];
random.NextBytes(buffer);
for (int i = 0; i < 300; i++)
{
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
tx.Root.Add("items/" + i, new MemoryStream(buffer));
tx.Commit();
}
}
Env.FlushLogToDataFile();
Env.Options.IncrementalBackupEnabled = true;
var exception = Assert.Throws <InvalidOperationException>(() => BackupMethods.Incremental.ToFile(Env, IncrementalBackupTestUtils.IncrementalBackupFile(0)));
Assert.Equal("The first incremental backup creation failed because the first journal file " + StorageEnvironmentOptions.JournalName(0) + " was not found. Did you turn on the incremental backup feature after initializing the storage? In order to create backups incrementally the storage must be created with IncrementalBackupEnabled option set to 'true'.", exception.Message);
}
public RavenDB_2939()
{
IncrementalBackupTestUtils.Clean();
}
