Partial support for tracker inter-object references.

[cumulus.git] / store.h

diff --git a/store.h b/store.h
index 8344dda..5d877c6 100644 (file)
--- a/store.h
+++ b/store.h
@@ -16,10 +16,18 @@
 #include <sstream>
 #include <vector>
 
+#include "sha1.h"
+
 /* In memory datatype to represent key/value pairs of information, such as file
  * metadata.  Currently implemented as map<string, string>. */
 typedef std::map<std::string, std::string> dictionary;
 
+/* In-memory representation of a UUID (Universally-Unique Identifier), which is
+ * used to name a segment. */
+struct uuid {
+    uint8_t bytes[16];
+};
+
 /* IOException will be thrown if an error occurs while reading or writing in
  * one of the I/O wrappers.  Depending upon the context; this may be fatal or
  * not--typically, errors reading/writing the store will be serious, but errors
@@ -59,6 +67,7 @@ public:
 
     void write_varint(uint64_t val);
 
+    void write_uuid(const struct uuid &u);
     void write_string(const std::string &s);
     void write_dictionary(const dictionary &d);
 
@@ -112,41 +121,107 @@ private:
     OutputStream &real;
 };
 
+/* Like WrapperOutputStream, but additionally computes a checksum of data as it
+ * is written. */
+class ChecksumOutputStream : public OutputStream {
+public:
+    explicit ChecksumOutputStream(OutputStream &o);
+    virtual ~ChecksumOutputStream() { }
+
+    /* Once a checksum is computed, no further data should be written to the
+     * stream. */
+    const uint8_t *finish_and_checksum();
+    size_t checksum_size() const { return csum.checksum_size(); }
+
+protected:
+    virtual void write_internal(const void *data, size_t len);
+
+private:
+    OutputStream &real;
+    SHA1Checksum csum;
+};
+
 /* Simple wrappers that encode integers using a StringOutputStream and return
  * the encoded result. */
 std::string encode_u16(uint16_t val);
 std::string encode_u32(uint32_t val);
 std::string encode_u64(uint64_t val);
-
-struct uuid {
-    uint8_t bytes[16];
-};
-
+std::string encode_objref(const struct uuid &segment, uint32_t object);
+
+/* A class which is used to pack multiple objects into a single segment, with a
+ * lookup table to quickly locate each object.  Call new_object() to get an
+ * OutputStream to which a new object may be written, and optionally
+ * finish_object() when finished writing the current object.  Only one object
+ * may be written to a segment at a time; if multiple objects must be written
+ * concurrently, they must be to different segments. */
 class SegmentWriter {
 public:
-    SegmentWriter(OutputStream &output, struct uuid u);
+    SegmentWriter(OutputStream *output, struct uuid u);
     ~SegmentWriter();
 
     struct uuid get_uuid() const { return id; }
 
     // Start writing out a new object to this segment.
-    OutputStream *new_object();
+    OutputStream *new_object(int *id, const char *type);
     void finish_object();
 
+    // Determine size of segment data written out so far.
+    size_t get_size() const { return raw_out->get_pos(); }
+
     // Utility functions for generating and formatting UUIDs for display.
     static struct uuid generate_uuid();
     static std::string format_uuid(const struct uuid u);
 
 private:
-    typedef std::vector<std::pair<int64_t, int64_t> > object_table;
+    struct index_info {
+        int64_t offset;         // File offset at which object starts
+        int64_t size;           // Size of object in bytes
+        char type[4];           // Object type code
+    };
 
-    OutputStream &out;
+    typedef std::vector<struct index_info> object_table;
+
+    ChecksumOutputStream *out;  // Output stream with checksumming enabled
+    OutputStream *raw_out;      // Raw output stream, without checksumming
     struct uuid id;
 
-    int64_t object_start_offset;
     OutputStream *object_stream;
 
     object_table objects;
 };
 
+/* A SegmentStore, as the name suggests, is used to store the contents of many
+ * segments.  The SegmentStore internally tracks where data should be placed
+ * (such as a local directory or remote storage), and allows new segments to be
+ * easily created as needed. */
+class SegmentStore {
+public:
+    // New segments will be stored in the given directory.
+    SegmentStore(const std::string &path);
+
+    SegmentWriter *new_segment();
+
+private:
+    std::string directory;
+};
+
+/* A SegmentPartitioner helps to divide objects up among a collection of
+ * segments to meet a rough size limit per segment.  Like a SegmentWriter, only
+ * one object should be written at a time; however, multiple
+ * SegmentPartitioners can be created using the same base SegmentStore. */
+class SegmentPartitioner {
+public:
+    explicit SegmentPartitioner(SegmentStore *s);
+    ~SegmentPartitioner();
+
+    OutputStream *new_object(struct uuid *uuid, int *id, const char *type);
+
+private:
+    size_t target_size;
+
+    SegmentStore *store;
+    SegmentWriter *segment;
+    OutputStream *object;
+};
+
 #endif // _LBS_STORE_H