public void Stop()
{
// Check point before we stop
CheckPoint();
lock (lockObject) {
// We can't stop a database that hasn't started
if (databaseStarted == false || treeSystem == null)
{
return;
}
// Close the store
fileStore.Close();
// Stop the buffer manager
bufferManager.Stop();
// Offer up all the internal objects to the GC
bufferManager = null;
fileStore = null;
// Clear the internal state
treeSystem = null;
databaseStarted = false;
}
}
internal JournaledFileStore(string resourceName, LoggingBufferManager bufferManager, bool readOnly)
: base(readOnly)
{
this.bufferManager = bufferManager;
resource = bufferManager.CreateResource(resourceName);
}
private void Dispose(bool disposing)
{
if (disposing) {
if (bufferManager != null) {
try {
// Set a check point
SetCheckPoint();
// Stop the buffer manager
bufferManager.Stop();
bufferManager.Dispose();
} catch (IOException e) {
// TODO: log the issue
}
}
if (lockFile != null)
lockFile.Close();
}
bufferManager = null;
lockFile = null;
context = null;
}
public bool Start()
{
lock (lockObject) {
// We can't start a database that is already started,
if (databaseStarted || treeSystem != null)
{
return(false);
}
// Make a data.koi file with a single TreeSystem structure mapped into it
const string fileExt = "cdb";
const string dbFileName = "data";
bufferManager = new LoggingBufferManager(path, path, false, maxPageCount, pageSize, fileExt, fileRolloverSize,
logger, true);
bufferManager.Start();
// The backing store
fileStore = new JournalledFileStore(dbFileName, bufferManager, false);
fileStore.Open();
// The actual database
StoreTreeSystem treeStore;
// Get the header area
IArea headerArea = fileStore.GetArea(-1);
int magicValue = headerArea.ReadInt4();
// If header area magic value is zero, then we assume this is a brand
// new database and initialize it with the configuration information
// given.
if (magicValue == 0)
{
// Create a tree store inside the file store,
treeStore = new StoreTreeSystem(fileStore, branchNodeSize, leafNodeSize, heapNodeCacheSize,
branchNodeCacheSize);
// Create the tree and returns a pointer to the tree,
long treePointer = treeStore.Create();
// Create an area object with state information about the tree
IAreaWriter awriter = fileStore.CreateArea(128);
awriter.WriteInt4(0x0101); // The version value
awriter.WriteInt8(treePointer);
awriter.WriteInt4(branchNodeSize);
awriter.WriteInt4(leafNodeSize);
awriter.Finish();
long dummy = awriter.Id;
IMutableArea harea = fileStore.GetMutableArea(-1);
harea.WriteInt4(0x092BA001); // The magic value
harea.WriteInt8(awriter.Id);
harea.CheckOut();
}
else if (magicValue == 0x092BA001)
{
long apointer = headerArea.ReadInt8();
// The area that contains configuration details,
IArea initArea = fileStore.GetArea(apointer);
int version = initArea.ReadInt4();
if (version != 0x0101)
{
throw new IOException("Unknown version in tree initialization area");
}
// Read the pointer to the tree store
long treePointer = initArea.ReadInt8();
// Read the branch and leaf node sizes as set when the database was
// created.
int ibranchNodeSize = initArea.ReadInt4();
int ileafNodeSize = initArea.ReadInt4();
// Create the tree store
treeStore = new StoreTreeSystem(fileStore, ibranchNodeSize, ileafNodeSize, heapNodeCacheSize,
branchNodeCacheSize);
// Initialize the tree
treeStore.Init(treePointer);
}
else
{
throw new IOException("Data is corrupt, invalid magic value in store");
}
// Set the point of the tree store
treeStore.CheckPoint();
// Set up final internal state and return true
treeSystem = treeStore;
databaseStarted = true;
return(true);
}
}
private void Configure()
{
var configuration = context.ResolveService<IConfiguration>();
if (configuration == null)
throw new InvalidOperationException("Could not find any configuration in context");
var dataFactoryName = configuration.GetString("store.journaled.dataFactory", "scattering");
var dataFactory = context.ResolveService<IStoreDataFactory>(dataFactoryName);
if (dataFactory == null)
throw new ArgumentException(String.Format("The data factory '{0}' could not be resolved in this context.", dataFactoryName));
var maxPages = configuration.GetInt32("store.journaled.maxPages", DefaultMaxPages);
var pageSize = configuration.GetInt32("store.journaled.pageSize", DefaultPageSize);
var fsName = configuration.GetString("store.journaled.fileSystem");
if (String.IsNullOrEmpty(fsName))
fsName = configuration.GetString("store.fileSystem", "local");
FileSystem = context.ResolveService<IFileSystem>(fsName);
if (FileSystem == null)
throw new DatabaseConfigurationException(String.Format("The file-system '{0}' is not found in this context.", fsName));
var journalPath = configuration.GetString("store.journaled.journalPath");
if (String.IsNullOrEmpty(journalPath)) {
var dbName = configuration.GetString("database.name");
var dbPath = configuration.GetString("database.path");
if (String.IsNullOrEmpty(dbPath))
throw new DatabaseConfigurationException("Unable to determine the journal path");
journalPath = FileSystem.CombinePath(dbPath, "journals");
}
if (!FileSystem.DirectoryExists(journalPath))
FileSystem.CreateDirectory(journalPath);
ReadOnly = configuration.GetBoolean("database.readOnly", false);
bufferManager = new LoggingBufferManager(context, FileSystem, journalPath, dataFactory, pageSize, maxPages, ReadOnly);
bufferManager.Start();
}
