X-Git-Url: http://git.vrable.net/?p=cumulus.git;a=blobdiff_plain;f=store.h;h=016e2756231e4d6b5150d5a4d4f02fae8d9f8a1c;hp=656659db62762e4639d5eee1d7b13a4806b1a6b3;hb=3d780590edec4583eb3ef0ca16120afd0f7451f9;hpb=0dfc70e01ddb7d2bce0db03d5364c0bd3a2bb308

diff --git a/store.h b/store.h
index 656659d..016e275 100644
--- a/store.h
+++ b/store.h
@@ -1,7 +1,6 @@
-/* Cumulus: Smart Filesystem Backup to Dumb Servers
- *
- * Copyright (C) 2006-2008  The Regents of the University of California
- * Written by Michael Vrable <mvrable@cs.ucsd.edu>
+/* Cumulus: Efficient Filesystem Backup to the Cloud
+ * Copyright (C) 2006-2008 The Cumulus Developers
+ * See the AUTHORS file for a list of contributors.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -36,8 +35,8 @@
 
 #include "localdb.h"
 #include "remote.h"
-#include "sha1.h"
 #include "ref.h"
+#include "third_party/sha1.h"
 
 class LbsObject;
 
@@ -45,19 +44,6 @@ class LbsObject;
  * metadata.  Currently implemented as map<string, string>. */
 typedef std::map<std::string, std::string> dictionary;
 
-/* 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
- * reading an individual file are less so. */
-class IOException : public std::exception {
-private:
-    std::string error;
-public:
-    explicit IOException(const std::string &err) { error = err; }
-    virtual ~IOException() throw () { }
-    std::string getError() const { return error; }
-};
-
 /* Simplified TAR header--we only need to store regular files, don't need to
  * handle long filenames, etc. */
 static const int TAR_BLOCK_SIZE = 512;
@@ -122,7 +108,9 @@ public:
     // used to control object placement; objects with different group
     // parameters are kept in separate segments.
     ObjectReference write_object(const char *data, size_t len,
-                                 const std::string &group = "");
+                                 const std::string &group = "",
+                                 const std::string &checksum = "",
+                                 double age = 0.0);
 
     // Ensure all segments have been fully written.
     void sync();
@@ -136,7 +124,7 @@ private:
         std::string group;
         std::string name;           // UUID
         int count;                  // Objects written to this segment
-        int size;                   // Combined size of objects written
+        int data_size;              // Combined size of objects written
         std::string basename;       // Name of segment without directory
         RemoteFile *rf;
     };
@@ -169,27 +157,32 @@ public:
     // Data in an object must be written all at once, and cannot be generated
     // incrementally.  Data can be an arbitrary block of binary data of any
     // size.  The pointer to the data need only remain valid until write() is
-    // called.
-    void set_data(const char *d, size_t len) { data = d; data_len = len; }
+    // called.  If checksum is non-NULL then it is assumed to contain a hash
+    // value for the data; this provides an optimization in case the caller has
+    // already checksummed the data.  Otherwise the set_data will compute a
+    // hash of the data itself.
+    void set_data(const char *d, size_t len, const char *checksum);
+
+    // Explicitly sets the age of the data, for later garbage-collection or
+    // repacking purposes.  If not set, the age defaults to the current time.
+    // The age is stored in the database as a floating point value, expressing
+    // the time in Julian days.
+    void set_age(double age) { this->age = age; }
 
     // Write an object to a segment, thus making it permanent.  This function
     // can be called at most once.
     void write(TarSegmentStore *store);
 
-    // Compute the checksum of an object, and include it in the object
-    // reference.  This should be called after write(), and the data specified
-    // by set_data() must remain valid through the call to checksum().
-    void checksum();
-
     // An object is assigned a permanent name once it has been written to a
     // segment.  Until that time, its name cannot be determined.
-    std::string get_name() const { return ref.to_string(); }
     ObjectReference get_ref() { return ref; }
 
 private:
     std::string group;
+    double age;
     const char *data;
     size_t data_len;
+    std::string checksum;
 
     bool written;
     ObjectReference ref;