tarstore.cc

   1 /* LBS: An LFS-inspired filesystem backup system
   2  * Copyright (C) 2006  Michael Vrable
   3  *
   4  * Backup data is stored in a collection of objects, which are grouped together
   5  * into segments for storage purposes.  This implementation of the object store
   6  * is built on top of libtar, and represents segments as TAR files and objects
   7  * as files within them. */
   8
   9 #include <stdio.h>
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <unistd.h>
  13 #include <fcntl.h>
  14 #include <time.h>
  15 #include <uuid/uuid.h>
  16
  17 #include <string>
  18 #include <iostream>
  19
  20 #include "tarstore.h"
  21
  22 using std::string;
  23
  24 Tarfile::Tarfile(const string &path, const string &segment)
  25     : segment_name(segment)
  26 {
  27     if (tar_open(&t, (char *)path.c_str(), NULL, O_WRONLY | O_CREAT, 0600,
  28                  TAR_VERBOSE | TAR_GNU) == -1)
  29         throw IOException("Error opening Tarfile");
  30 }
  31
  32 Tarfile::~Tarfile()
  33 {
  34     string checksum_list = checksums.str();
  35     internal_write_object(segment_name + "/checksums",
  36                           checksum_list.data(), checksum_list.size());
  37     tar_append_eof(t);
  38
  39     if (tar_close(t) != 0)
  40         throw IOException("Error closing Tarfile");
  41 }
  42
  43 void Tarfile::write_object(int id, const char *data, size_t len)
  44 {
  45     char buf[64];
  46     sprintf(buf, "%08x", id);
  47     string path = segment_name + "/" + buf;
  48     printf("path: %s\n", path.c_str());
  49
  50     internal_write_object(path, data, len);
  51
  52     // Compute a checksum for the data block, which will be stored at the end
  53     // of the TAR file.
  54     SHA1Checksum hash;
  55     hash.process(data, len);
  56     sprintf(buf, "%08x", id);
  57     checksums << buf << " " << hash.checksum_str() << "\n";
  58 }
  59
  60 void Tarfile::internal_write_object(const string &path,
  61                                     const char *data, size_t len)
  62 {
  63     memset(&t->th_buf, 0, sizeof(struct tar_header));
  64
  65     th_set_type(t, S_IFREG | 0600);
  66     th_set_user(t, 0);
  67     th_set_group(t, 0);
  68     th_set_mode(t, 0600);
  69     th_set_size(t, len);
  70     th_set_mtime(t, time(NULL));
  71     th_set_path(t, const_cast<char *>(path.c_str()));
  72     th_finish(t);
  73
  74     if (th_write(t) != 0)
  75         throw IOException("Error writing tar header");
  76
  77     th_print(t);
  78
  79     if (len == 0)
  80         return;
  81
  82     size_t blocks = (len + T_BLOCKSIZE - 1) / T_BLOCKSIZE;
  83     size_t padding = blocks * T_BLOCKSIZE - len;
  84
  85     for (size_t i = 0; i < blocks - 1; i++) {
  86         if (tar_block_write(t, &data[i * T_BLOCKSIZE]) == -1)
  87             throw IOException("Error writing tar block");
  88     }
  89
  90     char block[T_BLOCKSIZE];
  91     memset(block, 0, sizeof(block));
  92     memcpy(block, &data[T_BLOCKSIZE * (blocks - 1)], T_BLOCKSIZE - padding);
  93     if (tar_block_write(t, block) == -1)
  94         throw IOException("Error writing final tar block");
  95 }
  96
  97 string TarSegmentStore::write_object(const char *data, size_t len, const
  98                                      std::string &group)
  99 {
 100     struct segment_info *segment;
 101
 102     // Find the segment into which the object should be written, looking up by
 103     // group.  If no segment exists yet, create one.
 104     if (segments.find(group) == segments.end()) {
 105         segment = new segment_info;
 106
 107         uint8_t uuid[16];
 108         char uuid_buf[40];
 109         uuid_generate(uuid);
 110         uuid_unparse_lower(uuid, uuid_buf);
 111         segment->name = uuid_buf;
 112
 113         string filename = path + "/" + segment->name + ".tar";
 114         segment->file = new Tarfile(filename, segment->name);
 115
 116         segment->count = 0;
 117
 118         segments[group] = segment;
 119     } else {
 120         segment = segments[group];
 121     }
 122
 123     int id = segment->count;
 124     char id_buf[64];
 125     sprintf(id_buf, "%08x", id);
 126
 127     segment->file->write_object(id, data, len);
 128     segment->count++;
 129
 130     return segment->name + "/" + id_buf;
 131 }
 132
 133 void TarSegmentStore::sync()
 134 {
 135     while (!segments.empty()) {
 136         const string &name = segments.begin()->first;
 137         struct segment_info *segment = segments[name];
 138
 139         fprintf(stderr, "Closing segment group %s (%s)\n",
 140                 name.c_str(), segment->name.c_str());
 141
 142         delete segment->file;
 143         segments.erase(segments.begin());
 144         delete segment;
 145     }
 146 }