Drop dependence on libtar.

[cumulus.git] / store.cc

diff --git a/store.cc b/store.cc
index cf3eea9..9d4d1bd 100644 (file)
--- a/store.cc
+++ b/store.cc
@@ -3,10 +3,10 @@
  *
  * Backup data is stored in a collection of objects, which are grouped together
  * into segments for storage purposes.  This implementation of the object store
- * is built on top of libtar, and represents segments as TAR files and objects
- * as files within them. */
+ * represents segments as TAR files and objects as files within them. */
 
 #include <assert.h>
+#include <errno.h>
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -18,6 +18,7 @@
 
 #include <algorithm>
 #include <list>
+#include <map>
 #include <set>
 #include <string>
 #include <iostream>
@@ -27,6 +28,7 @@
 
 using std::max;
 using std::list;
+using std::map;
 using std::set;
 using std::string;
 
@@ -48,23 +50,25 @@ Tarfile::Tarfile(const string &path, const string &segment)
     : size(0),
       segment_name(segment)
 {
-    real_fd = open(path.c_str(), O_WRONLY | O_CREAT, 0600);
+    assert(sizeof(struct tar_header) == TAR_BLOCK_SIZE);
+
+    real_fd = open(path.c_str(), O_WRONLY | O_CREAT, 0666);
     if (real_fd < 0)
         throw IOException("Error opening output file");
 
     filter_fd = spawn_filter(real_fd);
-
-    if (tar_fdopen(&t, filter_fd, (char *)path.c_str(), NULL,
-                   O_WRONLY | O_CREAT, 0600, TAR_VERBOSE | TAR_GNU) == -1)
-        throw IOException("Error opening Tarfile");
 }
 
 Tarfile::~Tarfile()
 {
-    /* Close the tar file... */
-    tar_append_eof(t);
+    char buf[TAR_BLOCK_SIZE];
+
+    /* Append the EOF marker: two blocks filled with nulls. */
+    memset(buf, 0, sizeof(buf));
+    tar_write(buf, TAR_BLOCK_SIZE);
+    tar_write(buf, TAR_BLOCK_SIZE);
 
-    if (tar_close(t) != 0)
+    if (close(filter_fd) != 0)
         throw IOException("Error closing Tarfile");
 
     /* ...and wait for filter process to finish. */
@@ -124,6 +128,25 @@ int Tarfile::spawn_filter(int fd_out)
     return fds[1];
 }
 
+void Tarfile::tar_write(const char *data, size_t len)
+{
+    size += len;
+
+    while (len > 0) {
+        int res = write(filter_fd, data, len);
+
+        if (res < 0) {
+            if (errno == EINTR)
+                continue;
+            fprintf(stderr, "Write error: %m\n");
+            throw IOException("Write error");
+        }
+
+        len -= res;
+        data += res;
+    }
+}
+
 void Tarfile::write_object(int id, const char *data, size_t len)
 {
     char buf[64];
@@ -136,40 +159,40 @@ void Tarfile::write_object(int id, const char *data, size_t len)
 void Tarfile::internal_write_object(const string &path,
                                     const char *data, size_t len)
 {
-    memset(&t->th_buf, 0, sizeof(struct tar_header));
-
-    th_set_type(t, S_IFREG | 0600);
-    th_set_user(t, 0);
-    th_set_group(t, 0);
-    th_set_mode(t, 0600);
-    th_set_size(t, len);
-    th_set_mtime(t, time(NULL));
-    th_set_path(t, const_cast<char *>(path.c_str()));
-    th_finish(t);
-
-    if (th_write(t) != 0)
-        throw IOException("Error writing tar header");
+    struct tar_header header;
+    memset(&header, 0, sizeof(header));
+
+    assert(path.size() < 100);
+    memcpy(header.name, path.data(), path.size());
+    sprintf(header.mode, "%07o", 0600);
+    sprintf(header.uid, "%07o", 0);
+    sprintf(header.gid, "%07o", 0);
+    sprintf(header.size, "%011o", len);
+    sprintf(header.mtime, "%011o", (int)time(NULL));
+    header.typeflag = '0';
+    strcpy(header.magic, "ustar  ");
+    strcpy(header.uname, "root");
+    strcpy(header.gname, "root");
+
+    memset(header.chksum, ' ', sizeof(header.chksum));
+    int checksum = 0;
+    for (int i = 0; i < TAR_BLOCK_SIZE; i++) {
+        checksum += ((uint8_t *)&header)[i];
+    }
+    sprintf(header.chksum, "%06o", checksum);
 
-    size += T_BLOCKSIZE;
+    tar_write((const char *)&header, TAR_BLOCK_SIZE);
 
     if (len == 0)
         return;
 
-    size_t blocks = (len + T_BLOCKSIZE - 1) / T_BLOCKSIZE;
-    size_t padding = blocks * T_BLOCKSIZE - len;
-
-    for (size_t i = 0; i < blocks - 1; i++) {
-        if (tar_block_write(t, &data[i * T_BLOCKSIZE]) == -1)
-            throw IOException("Error writing tar block");
-    }
-
-    char block[T_BLOCKSIZE];
-    memset(block, 0, sizeof(block));
-    memcpy(block, &data[T_BLOCKSIZE * (blocks - 1)], T_BLOCKSIZE - padding);
-    if (tar_block_write(t, block) == -1)
-        throw IOException("Error writing final tar block");
+    tar_write(data, len);
 
-    size += blocks * T_BLOCKSIZE;
+    char padbuf[TAR_BLOCK_SIZE];
+    size_t blocks = (len + TAR_BLOCK_SIZE - 1) / TAR_BLOCK_SIZE;
+    size_t padding = blocks * TAR_BLOCK_SIZE - len;
+    memset(padbuf, 0, padding);
+    tar_write(padbuf, padding);
 }
 
 /* Estimate the size based on the size of the actual output file on disk.
@@ -194,6 +217,8 @@ size_t Tarfile::size_estimate()
 
 static const size_t SEGMENT_SIZE = 4 * 1024 * 1024;
 
+static map<string, int64_t> group_sizes;
+
 ObjectReference TarSegmentStore::write_object(const char *data, size_t len,
                                               const std::string &group)
 {
@@ -224,6 +249,8 @@ ObjectReference TarSegmentStore::write_object(const char *data, size_t len,
     segment->file->write_object(id, data, len);
     segment->count++;
 
+    group_sizes[group] += len;
+
     ObjectReference ref(segment->name, id_buf);
 
     // If this segment meets or exceeds the size target, close it so that
@@ -240,6 +267,15 @@ void TarSegmentStore::sync()
         close_segment(segments.begin()->first);
 }
 
+void TarSegmentStore::dump_stats()
+{
+    printf("Data written:\n");
+    for (map<string, int64_t>::iterator i = group_sizes.begin();
+         i != group_sizes.end(); ++i) {
+        printf("    %s: %lld\n", i->first.c_str(), i->second);
+    }
+}
+
 void TarSegmentStore::close_segment(const string &group)
 {
     struct segment_info *segment = segments[group];