diff -r 000000000000 -r 31a43d94cc26 src/Ottoman.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/Ottoman.cpp	Sun Sep 20 15:14:12 2009 -0700
@@ -0,0 +1,261 @@
+/*
+ *  Ottoman.cpp
+ *  Ottoman
+ *
+ *  Created by Jens Alfke on 8/31/09.
+ *  Copyright 2009 Jens Alfke. All rights reserved.
+ *  BSD-Licensed: See the file "LICENSE.txt" for details.
+ */
+
+#include "Ottoman.h"
+#include "VersionDictionary.h"
+#include "Chunk.h"
+#include "Index.h"
+#include "File.h"
+#include <fcntl.h>
+#include <stdio.h>
+#include <unistd.h>
+
+namespace Mooseyard {
+    
+    class DictionaryFileHeader :public Chunk {
+    public:
+        DictionaryFileHeader()                      
+            :Chunk(sizeof(DictionaryFileHeader),kChunkType) 
+        {
+            memcpy(&magicNumber, &kMagicNumber, sizeof(magicNumber));
+        }
+        
+        bool valid() const {
+            return type()==kChunkType && memcmp(&magicNumber,&kMagicNumber,sizeof(magicNumber))==0;
+        }
+        
+        uint8_t magicNumber[8];
+        
+        static const uint16_t kChunkType = 4;
+        static const uint8_t kMagicNumber[8];
+    };
+
+    const uint8_t DictionaryFileHeader::kMagicNumber[8] = {0x4A, 0x54, 0xF1, 0x1E, 'h', 'A', 's', 'H'};
+
+    
+    
+    Ottoman::Ottoman()
+    :_writeable(true),
+     _filename(NULL),
+     _lastVersion(NULL),
+     _current( new OverlayDictionary(&Dictionary::kEmpty) )
+    {
+    }
+    
+    Ottoman::Ottoman (const char *filename, bool writeable)
+    :_writeable(writeable),
+     _filename(strdup(filename)),
+     _lastVersion(),
+     _current()
+    {
+        _file = new File(_filename, writeable ?O_RDWR :O_RDONLY);
+        _lastVersion = new VersionDictionary(_file);
+        if (writeable)
+            _current = new OverlayDictionary(_lastVersion);
+    }
+    
+    Ottoman::~Ottoman() {
+        delete _current;
+        delete _lastVersion;
+        delete _file;
+        free(_filename);
+    }
+    
+    
+    bool Ottoman::needsSync() const {
+        return _file && (!_lastVersion->isLatestVersion() || !_file->hasPath(_filename));
+    }
+    
+    bool Ottoman::sync() {
+        if (!needsSync())
+            return false;
+        File *curFile = _file;
+        if (!curFile->hasPath(_filename))
+            curFile = new File(_filename, _writeable ?O_RDWR :O_RDONLY);
+        
+        VersionDictionary *newest = new VersionDictionary(curFile);
+        bool changed = (newest->generation() != _lastVersion->generation());
+        if (changed) {
+            if (newest->generation() < _lastVersion->generation())
+                throw File::Error("Versions got lost in file update");
+            
+            if (_current)
+                _current->rebase(newest);
+            
+            delete _lastVersion;
+            _lastVersion = newest;
+        }
+        
+        if (_file != curFile) {
+            delete _file;
+            _file = curFile;
+        }
+        return changed;
+    }
+    
+    
+    ChunkIterator* Ottoman::chunkIterator() const {
+        return _file ?new ChunkIterator(_file, sizeof(DictionaryFileHeader)) :NULL;
+    }
+    
+    bool Ottoman::scavenge (bool repair) {
+        if (!_file)
+            return true;
+        
+        const off_t actualEOF = _file->length();
+        fprintf(stderr, "Ottoman::scavenge: Scanning %s (%llu / 0x%llX bytes) ...\n", 
+                _filename, actualEOF, actualEOF);
+        _file->setPosition(0);
+        ChunkIterator it(_file, 0);
+        const DictionaryFileHeader *header = (const DictionaryFileHeader *) it.chunk();
+        if (!header || !header->valid()) {
+            fprintf(stderr, "Ottoman::scavenge: No valid file header at all!\n");
+            return false;
+        }
+        
+        // Scan through all the chunks:
+        FilePosition lastValidTrailer = 0;
+        FilePosition validEOF = 0;
+        int lastType = -1;
+        int count = 0;
+        try{
+            for (; it; ++it) {
+                const Chunk *chunk = it.chunk();
+
+                uint16_t type = it.chunk()->type();
+                if (type != lastType) {
+                    if (count > 0)
+                        printf("%6d\n", count);
+                    fprintf(stderr, "Ottoman::scavenge:    at 0x%08X: type %u ... ", 
+                            it.position(), type);
+                    lastType = type;
+                    count = 0;
+                }
+                count++;
+                
+                switch (type) {
+                    case KeyValueChunk::kChunkType:
+                        ((const KeyValueChunk*)chunk)->validate();
+                        break;
+                    case Index::kChunkType:
+                        ((const Index*)chunk)->validateEntries(_file);
+                        break;
+                    case VersionDictionary::kChunkType: {
+                        fprintf(stderr, "Found dictionary trailer at %u!\n", it.position());
+                        count = 0;
+                        // Validate by instantiating the VersionDictionary:
+                        VersionDictionary tempDict(_file, it.position());
+                        // If constructor succeeded, it's valid, so remember it:
+                        lastValidTrailer = it.position();
+                        validEOF = lastValidTrailer + chunk->size();
+                        fprintf(stderr, "Ottoman::scavenge:    Valid dictionary trailer at %X--%X\n",
+                                lastValidTrailer, validEOF);
+                        break;
+                    }
+                }
+            }
+            if (count > 0)
+                fprintf(stderr, "%6d\n", count);
+        } catch (File::Error &err) {
+            fprintf(stderr, "Ottoman::scavenge caught File::Error(%i,\"%s\") at pos %llX\n",
+                    err.code, err.message, _file->position());
+            // Keep going; we can recover the dictionary(ies) before the bad one.
+        }
+        
+        if (lastValidTrailer == 0) {
+            fprintf(stderr, "Ottoman::scavenge: No valid dictionaries found!\n");
+            return false;
+        } else if (validEOF < actualEOF) {
+            fprintf(stderr, "Ottoman::scavenge: Need to truncate to 0x%X (0x%llX bytes)\n",
+                    lastValidTrailer, actualEOF-lastValidTrailer);
+            if (repair) {
+                _file->setLength(validEOF);
+                _file->flushDisk();
+            }
+            return false;
+        }
+        
+        fprintf(stderr, "Ottoman::scavenge: File is OK!\n");
+        return true;
+    }
+    
+    
+#pragma mark -
+#pragma mark SAVING:
+    
+    
+    // low-level write. Does not lock or check for conflicts!
+    void Ottoman::_append (File *dstFile) {
+        VersionDictionary *lastVersion = _lastVersion;
+        if (!lastVersion)
+            lastVersion = new VersionDictionary(dstFile);
+        VersionDictionary *saved = lastVersion->_appendAndOpen(_current->overlay(), 
+                                                            dstFile,
+                                                            _current->baseReplaced());
+        // (don't delete _lastVersion: saved->_previousVersion now points to it.)
+        _lastVersion = saved;
+        _current->revertTo(_lastVersion);
+    }
+    
+    bool Ottoman::save() {
+        if (!_file)
+            return false;
+        if (_current && _current->isChanged()) {
+            File::Lock lock(_file);
+            if (needsSync())
+                return false;       // conflict!
+            _append(_file);
+        }
+        return true;
+    }
+    
+    File* Ottoman::_writeTo (const char *dstFileName, bool overwriteAllowed) {
+        int mode = O_RDWR | O_CREAT | O_TRUNC | O_EXLOCK;
+        if (!overwriteAllowed)
+            mode |= O_EXCL;
+        File *dstFile = new File(dstFileName, mode);
+        try {
+            dstFile->write(DictionaryFileHeader());
+            _append(dstFile);
+        } catch (...) {
+            delete dstFile;
+            File::unlink(dstFileName);
+            throw;
+        }
+        return dstFile;
+    }
+    
+    void Ottoman::saveAs (const char *dstFileName, bool overwriteAllowed) {
+        File *dstFile = _writeTo(dstFileName, overwriteAllowed);
+        free(_filename);
+        _filename = strdup(dstFileName);
+        _file = dstFile;
+    }
+
+    bool Ottoman::saveAndCompact() {
+        if (!_file)
+            return false;
+        char tempFileName[1024];
+        strlcpy(tempFileName, _filename, sizeof(tempFileName)-1);
+        strlcat(tempFileName, "~", sizeof(tempFileName));
+        File *tempFile;
+        {
+            // Check for conflict in existing file:
+            File::Lock lock(_file);
+            if (needsSync())
+                return false;
+            tempFile = _writeTo(tempFileName, false);
+            File::rename(tempFileName, _filename);
+        }
+        delete _file;
+        _file = tempFile;
+        return true;
+    }
+
+}