protected ResourceBase(JournaledSystem journaledSystem, long id, string name, IStoreData data)
{
JournaledSystem = journaledSystem;
this.id = id;
Name = name;
Data = data;
}
public override void SetSize(long value)
{
lock (journalMap) {
size = value;
}
JournaledSystem.LogResourceSizeChange(Name, size);
}
public override void Delete()
{
// Log that this resource was deleted.
JournaledSystem.LogResourceDelete(Name);
lock (journalMap) {
dataExists = false;
dataDeleted = true;
size = 0;
}
}
private void PersistDelete(BinaryReader reader, Dictionary <long, string> idNameMap)
{
// Resource delete
long id = reader.ReadInt64();
var resourceName = idNameMap[id];
var resource = JournaledSystem.GetResource(resourceName);
JournaledSystem.Context.OnDebug(String.Format("Jounral Command: Delete {0}", resourceName));
resource.PersistDelete();
}
private void Dispose(bool disposing)
{
if (disposing)
{
if (JournaledSystem != null)
{
JournaledSystem.Dispose();
}
}
JournaledSystem = null;
}
public JournalingThread(JournaledSystem system)
{
this.system = system;
#if PCL
task = new Task(Execute);
#else
thread = new Thread(Execute);
thread.Name = "JournalingThread";
thread.IsBackground = true;
#endif
}
private void PersistSizeChange(BinaryReader reader, Dictionary <long, string> idNameMap)
{
// Resource size change
long id = reader.ReadInt64();
long newSize = reader.ReadInt64();
var resourceName = idNameMap[id];
var resource = JournaledSystem.GetResource(resourceName);
JournaledSystem.Context.OnInformation(String.Format("Jounral Command: Set Size {0} = {1}", resourceName, newSize));
resource.PersistSetSize(newSize);
}
public JournalFile(JournaledSystem journaledSystem, IFileSystem fileSystem, string path, bool readOnly)
{
JournaledSystem = journaledSystem;
FileSystem = fileSystem;
FilePath = path;
ReadOnly = readOnly;
buffer = new byte[36];
resourceIdMap = new Dictionary <string, long>();
cur_seq_id = 0;
reference_count = 1;
}
internal LoggingBufferManager(IContext context, IFileSystem fileSystem, string journalPath, IStoreDataFactory dataFactory, int pageSize, int maxPages, bool readOnly)
{
Context = context;
pageComparer = new PageComparer(this);
JournalPath = journalPath;
FileSystem = fileSystem;
PageSize = pageSize;
MaxPages = maxPages;
ReadOnly = readOnly;
JournaledSystem = new JournaledSystem(context, FileSystem, JournalPath, ReadOnly, true, PageSize, dataFactory);
}
private void PersistPageModification(BinaryReader reader, Dictionary <long, string> idNameMap)
{
// Page modification
long id = reader.ReadInt64();
long page = reader.ReadInt64();
int off = reader.ReadInt32();
int len = reader.ReadInt32();
var resourceName = idNameMap[id];
var resource = JournaledSystem.GetResource(resourceName);
JournaledSystem.Context.OnDebug(String.Format(
"Jounral Command: Page Change {0} page= {1} offset = {2} length = {3}", resourceName, page, off, len));
resource.PersistPageChange(page, off, len, reader.BaseStream);
}
public LoggingResource(JournaledSystem journaledSystem, long id, string name, IStoreData data)
: base(journaledSystem, id, name, data)
{
journalMap = new JournalEntry[257];
dataOpen = false;
dataExists = data.Exists;
dataDeleted = false;
if (dataExists)
{
try {
size = data.Length;
} catch (IOException e) {
throw new Exception("Error getting size of resource: " + e.Message);
}
}
reallyOpen = false;
pageBuffer = new byte[journaledSystem.PageSize];
}
private void PersistTag(BinaryReader reader, Dictionary <long, string> idNameMap, List <ResourceBase> resourcesUpdated)
{
// Resource id tag
long id = reader.ReadInt64();
int len = reader.ReadInt32();
StringBuilder buf = new StringBuilder(len);
for (int i = 0; i < len; ++i)
{
buf.Append(reader.ReadChar());
}
string resourceName = buf.ToString();
// Put this input the map
idNameMap[id] = resourceName;
JournaledSystem.Context.OnDebug(String.Format("Jounral Command: Tag {0} = {1}", id, resourceName));
// Add this to the list of resources we updated.
resourcesUpdated.Add(JournaledSystem.GetResource(resourceName));
}
public void Stop()
{
JournaledSystem.Stop();
}
public NonLoggingResource(JournaledSystem journaledSystem, long id, string name, IStoreData data)
: base(journaledSystem, id, name, data)
{
}
public void Start()
{
JournaledSystem.Start();
}
public override void Write(long pageNumber, byte[] buffer, int offset, int count)
{
lock (journalMap) {
if (!dataOpen)
{
throw new IOException("Assertion failed: Data file is not open.");
}
// Make this modification input the log
var journal = JournaledSystem.LogPageModification(Name, pageNumber, buffer, offset, count);
// This adds the modification to the END of the hash list. This means
// when we reconstruct the page the journals will always be input the
// correct order - from oldest to newest.
// The map index.
int i = ((int)(pageNumber & 0x0FFFFFFF) % journalMap.Length);
var entry = journalMap[i];
// Make sure this entry is added to the END
if (entry == null)
{
// Add at the head if no first entry
journalMap[i] = journal;
journal.Next = null;
}
else
{
// Otherwise search to the end
// The number of journal entries input the linked list
int journalEntryCount = 0;
while (entry.Next != null)
{
entry = entry.Next;
++journalEntryCount;
}
// and add to the end
entry.Next = journal;
journal.Next = null;
// If there are over 35 journal entries, scan and remove all entries
// on journals that have persisted
if (journalEntryCount > 35)
{
entry = journalMap[i];
JournalEntry prev = null;
while (entry != null)
{
bool deletedHash = false;
JournalFile file = entry.File;
// Note that once we have a reference the journal file can not be
// deleted.
file.Reference();
// If the file is closed (or deleted)
if (file.IsDeleted)
{
deletedHash = true;
// Deleted so remove the reference to the journal
file.Dereference();
// Remove the journal entry from the chain.
if (prev == null)
{
journalMap[i] = entry.Next;
}
else
{
prev.Next = entry.Next;
}
}
// Remove the reference
file.Dereference();
// Only move prev is we have NOT deleted a hash entry
if (!deletedHash)
{
prev = entry;
}
entry = entry.Next;
}
}
}
}
}
public IJournaledResource CreateResource(string resourceName)
{
return(JournaledSystem.CreateResource(resourceName));
}
public void SetCheckPoint(bool flushJournals)
{
// Wait until the writes have finished
lock (writeLock) {
while (writeLockCount > 0)
{
Monitor.Wait(writeLock);
}
checkpointInProgress = true;
}
try {
Context.OnDebug("Checkpoint requested");
lock (pageMap) {
// Flush all the pages out to the log.
for (int i = 0; i < pageMap.Length; ++i)
{
var page = pageMap[i];
Page prev = null;
while (page != null)
{
bool deletedHash = false;
lock (page) {
// Flush the page (will only actually flush if there are changes)
page.Flush();
// Remove this page if it is no longer in use
if (!page.IsUsed)
{
deletedHash = true;
if (prev == null)
{
pageMap[i] = page.Next;
}
else
{
prev.Next = page.Next;
}
}
}
// Go to next page in hash chain
if (!deletedHash)
{
prev = page;
}
page = page.Next;
}
}
}
JournaledSystem.SetCheckPoint(flushJournals);
} finally {
// Make sure we unset the check point in progress flag and notify
// any blockers.
lock (writeLock) {
checkpointInProgress = false;
Monitor.PulseAll(writeLock);
}
}
}