-/* LBS: An LFS-inspired filesystem backup system
- * Copyright (C) 2007-2008 Michael Vrable
+/* Cumulus: Efficient Filesystem Backup to the Cloud
+ * Copyright (C) 2007-2008 The Cumulus Developers
+ * See the AUTHORS file for a list of contributors.
*
- * Handling of metadata written to backup snapshots. This manages the writing
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/* Handling of metadata written to backup snapshots. This manages the writing
* of file metadata into new backup snapshots, including breaking the metadata
* log apart across separate objects. Eventually this should include unified
* handling of the statcache, and re-use of metadata between snapshots.
*/
+#include <stdlib.h>
+#include <string.h>
#include <string>
#include <iostream>
#include <map>
/* TODO: Move to header file */
extern LocalDb *db;
-void add_segment(const string& segment);
/* Like strcmp, but sorts in the order that files will be visited in the
* filesystem. That is, we break paths apart at slashes, and compare path
string result;
if (dict.find("name") != dict.end()) {
- result += "name: " + dict.at("name") + "\n";
+ result += "name: " + dict.find("name")->second + "\n";
}
for (map<string, string>::const_iterator i = dict.begin();
{
statcache_path = path;
statcache_path += "/statcache2";
- if (snapshot_scheme != NULL)
+ if (snapshot_scheme != NULL && strlen(snapshot_scheme) > 0)
statcache_path = statcache_path + "-" + snapshot_scheme;
statcache_tmp_path = statcache_path + "." + snapshot_name;
if (statcache_out == NULL) {
fprintf(stderr, "Error opening statcache %s: %m\n",
statcache_tmp_path.c_str());
- throw IOException("Error opening statcache");
+ fatal("Error opening statcache");
}
old_metadata_eof = false;
// If indirectly referencing any other metadata logs, be sure those
// segments are properly referenced.
if (i->reused) {
- add_segment(i->ref.get_segment());
- db->UseSegment(i->ref.get_segment(), 1.0);
+ db->UseObject(i->ref);
}
// Write out an indirect reference to any previous objects which could
/* Write current metadata information to a new object. */
LbsObject *meta = new LbsObject;
meta->set_group("metadata");
- meta->set_data(m.data(), m.size());
+ meta->set_data(m.data(), m.size(), NULL);
meta->write(store);
- meta->checksum();
/* Write a reference to this block in the root. */
ObjectReference ref = meta->get_ref();
metadata_root << "@" << ref.to_string() << "\n";
- add_segment(ref.get_segment());
- db->UseSegment(ref.get_segment(), 1.0);
+ db->UseObject(ref);
delete meta;
if (info == old_metadata && !flag_full_metadata) {
ObjectReference ref = ObjectReference::parse(old_metadata_loc);
- if (!ref.is_null()) {
+ if (!ref.is_null() && db->IsAvailable(ref)) {
item.reused = true;
item.ref = ref;
}
LbsObject *root = new LbsObject;
root->set_group("metadata");
- root->set_data(root_data.data(), root_data.size());
+ root->set_data(root_data.data(), root_data.size(), NULL);
root->write(store);
- root->checksum();
- add_segment(root->get_ref().get_segment());
- db->UseSegment(root->get_ref().get_segment(), 1.0);
+ db->UseObject(root->get_ref());
ObjectReference ref = root->get_ref();
delete root;