/// <exception cref="System.IO.IOException"></exception>
private void RunDefrag(string testFileName)
{
IConfiguration config = Db4oFactory.NewConfiguration();
config.AllowVersionUpdates(true);
ConfigureForTest(config);
IObjectContainer oc = Db4oFactory.OpenFile(config, testFileName);
oc.Close();
string backupFileName = Path.GetTempFileName();
try
{
DefragmentConfig defragConfig = new DefragmentConfig(testFileName, backupFileName
);
defragConfig.ForceBackupDelete(true);
ConfigureForTest(defragConfig.Db4oConfig());
defragConfig.ReadOnly(!DefragmentInReadWriteMode());
Db4objects.Db4o.Defragment.Defragment.Defrag(defragConfig);
}
finally
{
File4.Delete(backupFileName);
}
}
/// <exception cref="System.IO.IOException"></exception>
private void Defrag(string dbFile)
{
DefragmentConfig config = new DefragmentConfig(dbFile);
config.UpgradeFile(dbFile + ".upgraded");
Db4objects.Db4o.Defragment.Defragment.Defrag(config);
}
private void Defrag(IConfiguration config)
{
Sharpen.IO.File origFile = new Sharpen.IO.File(GetAbsolutePath());
if (origFile.Exists())
{
try
{
string backupFile = GetAbsolutePath() + ".defrag.backup";
IIdMapping mapping = new InMemoryIdMapping();
// new
// BTreeIDMapping(getAbsolutePath()+".defrag.mapping",4096,1,1000);
DefragmentConfig defragConfig = new DefragmentConfig(GetAbsolutePath(), backupFile
, mapping);
defragConfig.ForceBackupDelete(true);
// FIXME Cloning is ugly - wrap original in Decorator within
// DefragContext instead?
IConfiguration clonedConfig = (IConfiguration)((IDeepClone)config).DeepClone(null
);
defragConfig.Db4oConfig(clonedConfig);
Db4objects.Db4o.Defragment.Defragment.Defrag(defragConfig, new _IDefragmentListener_64
());
}
catch (IOException e)
{
Sharpen.Runtime.PrintStackTrace(e);
}
}
}
/// <exception cref="System.IO.IOException"></exception>
private void Defragment(bool registerTranslator)
{
DefragmentConfig defragConfig = new DefragmentConfig(TempFile());
defragConfig.Db4oConfig(Config(registerTranslator));
defragConfig.ForceBackupDelete(true);
Db4objects.Db4o.Defragment.Defragment.Defrag(defragConfig);
}
void DefragDatabase()
{
if (!File.Exists(DatabaseFile))
{
return;
}
DateTime start = DateTime.UtcNow, stop;
var backupFile = String.Format(
"{0}.bak_{1}.{2}",
DatabaseFile,
Db4oVersion.Major,
Db4oVersion.Minor
);
var defragConfig = new DefragmentConfig(
DatabaseFile,
backupFile
);
defragConfig.ForceBackupDelete(true);
Defragment.Defrag(defragConfig);
stop = DateTime.UtcNow;
#if LOG4NET
Logger.Debug(
String.Format(
"DefragDatabase(): defrag took: {0:0.0} ms",
(stop - start).TotalMilliseconds
)
);
#endif
}
protected override IObjectContainer CreateDatabase(IConfiguration config)
{
var origFile = new File(GetAbsolutePath());
if (origFile.Exists())
{
try
{
var backupFile = GetAbsolutePath() + ".defrag.backup";
IIdMapping mapping = new InMemoryIdMapping();
// new
// BTreeIDMapping(getAbsolutePath()+".defrag.mapping",4096,1,1000);
var defragConfig = new DefragmentConfig(GetAbsolutePath(), backupFile
, mapping);
defragConfig.ForceBackupDelete(true);
// FIXME Cloning is ugly - wrap original in Decorator within
// DefragContext instead?
var clonedConfig = (IConfiguration)((IDeepClone)config).DeepClone(null
);
defragConfig.Db4oConfig(clonedConfig);
Db4objects.Db4o.Defragment.Defragment.Defrag(defragConfig, new _IDefragmentListener_30
());
}
catch (IOException e)
{
Runtime.PrintStackTrace(e);
}
}
return(base.CreateDatabase(config));
}
private DefragmentConfig NewDefragmentConfig(string sourceFile, string backupFile
)
{
DefragmentConfig config = new DefragmentConfig(sourceFile, backupFile);
config.Db4oConfig(NewConfiguration());
return(config);
}
public void ConfigureFile()
{
// #example: Configure the file
DefragmentConfig config = new DefragmentConfig("database.db4o");
Defragment.Defrag(config);
// #end example
}
private void Defrag(string fileName, int blockSize)
{
DefragmentConfig config = new DefragmentConfig(fileName);
config.Db4oConfig(Config(blockSize));
config.ForceBackupDelete(true);
Db4objects.Db4o.Defragment.Defragment.Defrag(config);
}
public void ConfigureBackupFile()
{
// #example: Configure the file and backup file
DefragmentConfig config = new DefragmentConfig("database.db4o", "database.db4o.back");
Defragment.Defrag(config);
// #end example
}
/// <exception cref="System.Exception"></exception>
protected virtual void Defragment(string fileName)
{
string targetFile = fileName + ".defrag.backup";
DefragmentConfig defragConfig = new DefragmentConfig(fileName, targetFile);
defragConfig.ForceBackupDelete(true);
defragConfig.Db4oConfig(CloneConfiguration());
Db4objects.Db4o.Defragment.Defragment.Defrag(defragConfig);
}
// #end example
private static void DefragmentWithConfiguration()
{
CreateAndFillDatabase();
// #example: Defragment with configuration
DefragmentConfig config = new DefragmentConfig("database.db4o");
Defragment.Defrag(config);
// #end example
}
/// <exception cref="System.IO.IOException"></exception>
private void Defrag()
{
string backupPath = Path.GetTempFileName();
DefragmentConfig config = new DefragmentConfig(TempFile(), backupPath);
config.ForceBackupDelete(true);
Db4objects.Db4o.Defragment.Defragment.Defrag(config);
Delete(backupPath);
}
/// <exception cref="System.IO.IOException"></exception>
private void Defrag(string fname)
{
DefragmentConfig config = new DefragmentConfig(fname);
config.Db4oConfig(NewConfiguration());
config.StoredClassFilter(IgnoreClassFilter(typeof(StoredClassFilterTestCase.SimpleClass
)));
Db4objects.Db4o.Defragment.Defragment.Defrag(config);
}
public void SetMappingImplementation()
{
// #example: Choose a id mapping system
IIdMapping mapping = new InMemoryIdMapping();
DefragmentConfig config = new DefragmentConfig("database.db4o", "database.db4o.back", mapping);
Defragment.Defrag(config);
// #end example
}
private DefragmentConfig DefragmentConfig(MemoryStorage storage)
{
DefragmentConfig defragConfig = new DefragmentConfig(Uri, TempFile(), new InMemoryIdMapping
());
defragConfig.Db4oConfig(Config(storage));
defragConfig.BackupStorage(BackupStorage());
return(defragConfig);
}
/// <exception cref="System.IO.IOException"></exception>
private void Defrag()
{
var backupPath = Path.GetTempFileName();
var config = new DefragmentConfig(TempFile(), backupPath);
config.ForceBackupDelete(true);
Defragment.Defragment.Defrag(config);
Delete(backupPath);
}
public void ChangeBackupStorage()
{
// #example: Use a separate storage for the backup
DefragmentConfig config = new DefragmentConfig("database.db4o");
config.BackupStorage(new FileStorage());
Defragment.Defrag(config);
// #end example
}
public void SetCommitFrequency()
{
// #example: Set the commit frequency
DefragmentConfig config = new DefragmentConfig("database.db4o");
config.ObjectCommitFrequency(10000);
Defragment.Defrag(config);
// #end example
}
public void DisableReadOnlyForBackup()
{
// #example: Disable readonly on backup
DefragmentConfig config = new DefragmentConfig("database.db4o");
config.ReadOnly(false);
Defragment.Defrag(config);
// #end example
}
public void UpgradeDb4OFile()
{
// #example: Upgrade database version
DefragmentConfig config = new DefragmentConfig("database.db4o");
config.UpgradeFile(Environment.GetEnvironmentVariable("TEMP"));
Defragment.Defrag(config);
// #end example
}
public static DefragmentConfig DefragConfig(string sourceFile, IEmbeddedConfiguration
db4oConfig, bool forceBackupDelete)
{
var defragConfig = new DefragmentConfig(sourceFile, DefragmentTestCaseBase
.BackupFileNameFor(sourceFile));
defragConfig.ForceBackupDelete(forceBackupDelete);
defragConfig.Db4oConfig(Db4oConfig(db4oConfig));
return(defragConfig);
}
public void DeleteBackup()
{
// #example: Delete the backup after the defragmentation process
DefragmentConfig config = new DefragmentConfig("database.db4o");
config.ForceBackupDelete(true);
Defragment.Defrag(config);
// #end example
}
public void UseAClassFilter()
{
// #example: Use class filter
DefragmentConfig config = new DefragmentConfig("database.db4o");
config.StoredClassFilter(new AvailableTypeFilter());
Defragment.Defrag(config);
// #end example
}
private static void DefragmentationWithIdMissing()
{
CreateAndFillDatabase();
// #example: Use a defragmentation listener
DefragmentConfig config = new DefragmentConfig("database.db4o");
Defragment.Defrag(config, new DefragmentListener());
// #end example
}
private void DefragFileDataBase()
{
EnsureCloseDb4OContainer();
var defragConfig = new DefragmentConfig(Db4oDataBaseFilePath);
defragConfig.Db4oConfig(GetEmbeddedConfiguration());
defragConfig.ForceBackupDelete(true);
Defragment.Defrag(defragConfig);
}
public void Test()
{
GenerateDatabaseFile();
var config = new DefragmentConfig(TempFile());
config.ForceBackupDelete(true);
var e = Assert.Expect(typeof(InvalidOperationException), delegate { Defragment.Defragment.Defrag(config); });
Assert.IsTrue(e.Message.Contains("Thing"), "Message should contain the missing type name.");
}
/// <exception cref="System.Exception"></exception>
public virtual void TestCOR775()
{
Prepare();
VerifyDB();
DefragmentConfig config = new DefragmentConfig(TempFile(), Defgared);
config.ForceBackupDelete(true);
//config.storedClassFilter(new AvailableClassFilter());
config.Db4oConfig(GetConfiguration());
Db4objects.Db4o.Defragment.Defragment.Defrag(config);
VerifyDB();
}
public void SetDb4OConfiguration()
{
// #example: Use the database-configuration
DefragmentConfig config = new DefragmentConfig("database.db4o");
// It's best to use the very same configuration you use for the regular database
IEmbeddedConfiguration configuration = Db4oEmbedded.NewConfiguration();
config.Db4oConfig(configuration);
Defragment.Defrag(config);
// #end example
}
/// <exception cref="System.IO.IOException"></exception>
private void Defrag(TernaryBool generateCommitTimestamp)
{
DefragmentConfig config = new DefragmentConfig(SourceFile(), BackupFile());
config.Db4oConfig(NewConfiguration());
config.ForceBackupDelete(true);
if (!generateCommitTimestamp.IsUnspecified())
{
config.Db4oConfig().GenerateCommitTimestamps(generateCommitTimestamp.DefiniteYes(
));
}
Db4objects.Db4o.Defragment.Defragment.Defrag(config);
}