Persist() private method

private Persist ( long start, long end ) : void
start long
end long
return void
            private void Execute()
            {
                bool localFinished = false;

                while (!localFinished)
                {
                    List <JournalFile> toProcess = null;
                    lock (system.topJournalLock) {
                        if (system.journalArchives.Count > 0)
                        {
                            toProcess = new List <JournalFile>();
                            toProcess.AddRange(system.journalArchives);
                        }
                    }

                    if (toProcess == null)
                    {
                        // Nothing to process so wait
                        lock (this) {
                            if (!finished)
                            {
#if PCL
                                try {
                                    Monitor.Wait(this);
                                } catch (OperationCanceledException) {
                                }
#else
                                try {
                                    Monitor.Wait(this);
                                } catch (ThreadInterruptedException) { /* ignore */ }
#endif
                            }
                        }
                    }
                    else if (toProcess.Count > 0)
                    {
                        // Something to process, so go ahead and process the journals,
                        int sz = toProcess.Count;
                        // For all journals
                        for (int i = 0; i < sz; ++i)
                        {
                            // Pick the lowest journal to persist
                            JournalFile jf = toProcess[i];
                            try {
                                // Persist the journal
                                jf.Persist(8, jf.Length);
                                // Close and then delete the journal file
                                jf.CloseAndDelete();
                            } catch (IOException e) {
                                system.Context.OnError(String.Format("Error persisting journal '{0}", jf), e);

                                // If there is an error persisting the best thing to do is
                                // finish
                                lock (this) {
                                    finished = true;
                                }
                            }
                        }
                    }

                    lock (this) {
                        localFinished = finished;
                        // Remove the journals that we have just persisted.
                        if (toProcess != null)
                        {
                            lock (system.topJournalLock) {
                                int sz = toProcess.Count;
                                for (int i = 0; i < sz; ++i)
                                {
                                    system.journalArchives.RemoveAt(0);
                                }
                            }
                        }

                        // Notify any threads waiting
                        Monitor.PulseAll(this);
                    }
                }

                lock (this) {
                    actually_finished = true;
                    Monitor.PulseAll(this);
                }
            }
        private void RollForwardRecover()
        {
            // The list of all journal files,
            var journalFilesList = new List <JournalSummary>();

            // Scan the journal path for any journal files.
            for (int i = 10; i < 74; ++i)
            {
                string journalFn = GetJournalFileName(i);
                string f         = FileSystem.CombinePath(JournalPath, journalFn);
                // If the journal exists, create a summary of the journal
                if (FileSystem.FileExists(f))
                {
                    if (ReadOnly)
                    {
                        throw new IOException(
                                  "Journal file " + f + " exists for a read-only session.  " +
                                  "There may not be any pending journals for a Read-only session.");
                    }

                    var jf = new JournalFile(this, FileSystem, f, ReadOnly);

                    // Open the journal file for recovery.  This will set various
                    // information about the journal such as the last check point and the
                    // id of the journal file.
                    JournalSummary summary = jf.OpenForRecovery();
                    // If the journal can be recovered from.
                    if (summary.CanBeRecovered)
                    {
                        Context.OnInformation(String.Format("Journal '{0}' found: can be recovered", jf));

                        journalFilesList.Add(summary);
                    }
                    else
                    {
                        Context.OnInformation(String.Format("Deleting journal '{0}': nothing to recover", jf));

                        // Otherwise close and delete it
                        jf.CloseAndDelete();
                    }
                }
            }

            // Sort the journal file list from oldest to newest.  The oldest journals
            // are recovered first.
            journalFilesList.Sort(new JournalSummaryComparer());

            long lastJournalNumber = -1;

            // Persist the journals
            for (int i = 0; i < journalFilesList.Count; ++i)
            {
                var summary = journalFilesList[i];

                // Check the resources for this summary
                var resList = summary.Resources;
                foreach (string resourceName in resList)
                {
                    // This puts the resource into the hash map.
                    CreateResource(resourceName);
                }

                // Assert that we are recovering the journals input the correct order
                JournalFile jf = summary.JournalFile;
                if (jf.JournalNumber < lastJournalNumber)
                {
                    throw new InvalidOperationException("Assertion failed, sort failed.");
                }

                lastJournalNumber = jf.JournalNumber;

                Context.OnInformation(String.Format("Recovering '{0}' (8 .. {1})", jf, summary.LastCheckPoint));

                jf.Persist(8, summary.LastCheckPoint);
                // Then close and delete.
                jf.CloseAndDelete();

                // Check the resources for this summary and close them
                foreach (var resourceName in resList)
                {
                    var resource = (ResourceBase)CreateResource(resourceName);
                    // When we finished, make sure the resource is closed again
                    // Close the resource
                    resource.PersistClose();
                    // Post recover notification
                    resource.OnPostRecover();
                }
            }
        }