#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
+#include <string.h>
#include <sys/stat.h>
#include <sys/sysmacros.h>
#include <sys/types.h>
using std::ostream;
/* Version information. This will be filled in by the Makefile. */
-#ifndef LBS_VERSION
-#define LBS_VERSION Unknown
+#ifndef CUMULUS_VERSION
+#define CUMULUS_VERSION Unknown
#endif
-#define LBS_STRINGIFY(s) LBS_STRINGIFY2(s)
-#define LBS_STRINGIFY2(s) #s
-static const char lbs_version[] = LBS_STRINGIFY(LBS_VERSION);
+#define CUMULUS_STRINGIFY(s) CUMULUS_STRINGIFY2(s)
+#define CUMULUS_STRINGIFY2(s) #s
+static const char cumulus_version[] = CUMULUS_STRINGIFY(CUMULUS_VERSION);
static RemoteStore *remote = NULL;
static TarSegmentStore *tss = NULL;
/* Selection of files to include/exclude in the snapshot. */
std::list<string> includes; // Paths in which files should be saved
std::list<string> excludes; // Paths which will not be saved
+std::list<string> excluded_names; // Directories which will not be saved
std::list<string> searches; // Directories we don't want to save, but
// do want to descend searching for data
// in included paths
bool relative_paths = true;
+bool flag_rebuild_statcache = false;
+
+/* Whether verbose output is enabled. */
+bool verbose = false;
+
/* Ensure that the given segment is listed as a dependency of the current
* snapshot. */
void add_segment(const string& segment)
if (found)
old_blocks = metawriter->get_blocks();
- if (found && metawriter->is_unchanged(&stat_buf)) {
+ if (found
+ && !flag_rebuild_statcache
+ && metawriter->is_unchanged(&stat_buf)) {
cached = true;
/* If any of the blocks in the object have been expired, then we should
subfile.analyze_new_block(block_buf, bytes);
refs = subfile.create_incremental(tss, o, block_age);
} else {
+ if (flag_rebuild_statcache && ref.is_normal()) {
+ subfile.analyze_new_block(block_buf, bytes);
+ subfile.store_analyzed_signatures(ref);
+ }
refs.push_back(ref);
}
file_info["checksum"] = hash.checksum_str();
}
- if (status != NULL)
+ // Sanity check: if we are rebuilding the statcache, but the file looks
+ // like it hasn't changed, then the newly-computed checksum should match
+ // the checksum in the statcache. If not, we have possible disk corruption
+ // and report a warning.
+ if (flag_rebuild_statcache) {
+ if (found
+ && metawriter->is_unchanged(&stat_buf)
+ && file_info["checksum"] != metawriter->get_checksum()) {
+ fprintf(stderr,
+ "Warning: Checksum for %s does not match expected value\n"
+ " expected: %s\n"
+ " actual: %s\n",
+ path.c_str(),
+ metawriter->get_checksum().c_str(),
+ file_info["checksum"].c_str());
+ }
+ }
+
+ if (verbose && status != NULL)
printf(" [%s]\n", status);
string blocklist = "";
int64_t file_size;
ssize_t len;
- printf("%s\n", path.c_str());
+ if (verbose)
+ printf("%s\n", path.c_str());
metawriter->find(path);
file_info["name"] = uri_encode(path);
file_info["volatile"] = "1";
struct passwd *pwd = getpwuid(stat_buf.st_uid);
- if (pwd != NULL) {
+ if (pwd != NULL && pwd->pw_name != NULL) {
file_info["user"] += " (" + uri_encode(pwd->pw_name) + ")";
}
struct group *grp = getgrgid(stat_buf.st_gid);
- if (pwd != NULL) {
+ if (grp != NULL && grp->gr_name != NULL) {
file_info["group"] += " (" + uri_encode(grp->gr_name) + ")";
}
}
}
+ if (excluded_names.size() > 0) {
+ std::string name = path;
+ std::string::size_type last_slash = name.rfind('/');
+ if (last_slash != std::string::npos) {
+ name.replace(0, last_slash + 1, "");
+ }
+
+ for (list<string>::iterator i = excluded_names.begin();
+ i != excluded_names.end(); ++i) {
+ if (name == *i) {
+ include = false;
+ }
+ }
+ }
+
for (list<string>::iterator i = searches.begin();
i != searches.end(); ++i) {
if (path == *i) {
{
fprintf(
stderr,
- "LBS %s\n\n"
+ "Cumulus %s\n\n"
"Usage: %s [OPTION]... --dest=DEST PATHS...\n"
"Produce backup snapshot of files in SOURCE and store to DEST.\n"
"\n"
" --upload-script=COMMAND\n"
" program to invoke for each backup file generated\n"
" --exclude=PATH exclude files in PATH from snapshot\n"
+ " --exclude-name=NAME exclude files called NAME from snapshot\n"
" --localdb=PATH local backup metadata is stored in PATH\n"
" --tmpdir=PATH path for temporarily storing backup files\n"
" (defaults to TMPDIR environment variable or /tmp)\n"
" --intent=FLOAT intended backup type: 1=daily, 7=weekly, ...\n"
" (defaults to \"1\")\n"
" --full-metadata do not re-use metadata from previous backups\n"
+ " --rebuild-statcache re-read all file data to verify statcache\n"
+ " -v --verbose list files as they are backed up\n"
"\n"
"Exactly one of --dest or --upload-script must be specified.\n",
- lbs_version, program
+ cumulus_version, program
);
}
{"full-metadata", 0, 0, 0}, // 8
{"tmpdir", 1, 0, 0}, // 9
{"upload-script", 1, 0, 0}, // 10
+ {"rebuild-statcache", 0, 0, 0}, // 11
+ {"exclude-name", 1, 0, 0}, // 12
+ // Aliases for short options
+ {"verbose", 0, 0, 'v'},
{NULL, 0, 0, 0},
};
int long_index;
- int c = getopt_long(argc, argv, "", long_options, &long_index);
+ int c = getopt_long(argc, argv, "v", long_options, &long_index);
if (c == -1)
break;
case 10: // --upload-script
backup_script = optarg;
break;
+ case 11: // --rebuild-statcache
+ flag_rebuild_statcache = true;
+ break;
+ case 12: // --exclude-name
+ excluded_names.push_back(optarg);
+ break;
default:
fprintf(stderr, "Unhandled long option!\n");
return 1;
}
} else {
- usage(argv[0]);
- return 1;
+ switch (c) {
+ case 'v':
+ verbose = true;
+ break;
+ default:
+ usage(argv[0]);
+ return 1;
+ }
}
}
tmp_dir.c_str());
return 1;
}
- remote = new RemoteStore(tmp_dir);
- remote->set_script(backup_script);
+ remote = new RemoteStore(tmp_dir, backup_script=backup_script);
} else {
remote = new RemoteStore(backup_dest);
}
* snapshot. */
string database_path = localdb_dir + "/localdb.sqlite";
db = new LocalDb;
- db->Open(database_path.c_str(), desc_buf,
- backup_scheme.size() ? backup_scheme.c_str() : NULL,
+ db->Open(database_path.c_str(), desc_buf, backup_scheme.c_str(),
snapshot_intent);
tss = new TarSegmentStore(remote, db);
/* Initialize the stat cache, for skipping over unchanged files. */
metawriter = new MetadataWriter(tss, localdb_dir.c_str(), desc_buf,
- backup_scheme.size()
- ? backup_scheme.c_str()
- : NULL);
+ backup_scheme.c_str());
scanfile(".", false);
}
}
fclose(checksums);
+
+ SHA1Checksum checksum_csum;
+ string csum;
+ checksum_filename = checksum_file->get_local_path();
+ if (checksum_csum.process_file(checksum_filename.c_str())) {
+ csum = checksum_csum.checksum_str();
+ }
+
checksum_file->send();
db->Close();
}
FILE *descriptor = fdopen(descriptor_fd, "w");
- fprintf(descriptor, "Format: LBS Snapshot v0.6\n");
- fprintf(descriptor, "Producer: LBS %s\n", lbs_version);
+ fprintf(descriptor, "Format: LBS Snapshot v0.8\n");
+ fprintf(descriptor, "Producer: Cumulus %s\n", cumulus_version);
strftime(desc_buf, sizeof(desc_buf), "%Y-%m-%d %H:%M:%S %z", &time_buf);
fprintf(descriptor, "Date: %s\n", desc_buf);
if (backup_scheme.size() > 0)
fprintf(descriptor, "Backup-Intent: %g\n", snapshot_intent);
fprintf(descriptor, "Root: %s\n", backup_root.c_str());
- SHA1Checksum checksum_csum;
- if (checksum_csum.process_file(checksum_filename.c_str())) {
- string csum = checksum_csum.checksum_str();
+ if (csum.size() > 0) {
fprintf(descriptor, "Checksums: %s\n", csum.c_str());
}
waitpid(signature_pid, &status, 0);
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
- throw IOException("Signature filter process error");
+ fatal("Signature filter process error");
}
}