X-Git-Url: http://git.vrable.net/?a=blobdiff_plain;f=localdb.cc;h=7d93bb174320270f53b60dc86295b7caddc9b603;hb=5f2e50c2ad75043142dc1812fe19dbd7ad86488c;hp=1c44fa4e8e1826aedbca35bc63b0a157d8c2f114;hpb=0546d239071daa82a8b85348a7f66fba10d85aff;p=cumulus.git diff --git a/localdb.cc b/localdb.cc index 1c44fa4..7d93bb1 100644 --- a/localdb.cc +++ b/localdb.cc @@ -1,7 +1,24 @@ -/* LBS: An LFS-inspired filesystem backup system - * Copyright (C) 2007 Michael Vrable +/* Cumulus: Smart Filesystem Backup to Dumb Servers * - * When creating backup snapshots, maintain a local database of data blocks and + * Copyright (C) 2007-2008 The Regents of the University of California + * Written by Michael Vrable + * + * 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. + */ + +/* When creating backup snapshots, maintain a local database of data blocks and * checksums, in addition to the data contents (which may be stored remotely). * This database is consulted when attempting to build incremental snapshots, * as it says which objects can be reused. @@ -15,11 +32,13 @@ #include #include +#include #include #include "localdb.h" #include "store.h" +using std::min; using std::string; /* Helper function to prepare a statement for execution in the current @@ -66,6 +85,9 @@ void LocalDb::Open(const char *path, const char *snapshot_name, sqlite3_extended_result_codes(db, 1); + if (snapshot_scheme == NULL) + snapshot_scheme = ""; + /* Insert this snapshot into the database, and determine the integer key * which will be used to identify it. */ sqlite3_stmt *stmt = Prepare("insert into " @@ -73,11 +95,8 @@ void LocalDb::Open(const char *path, const char *snapshot_name, "values (?, ?, julianday('now'), ?)"); sqlite3_bind_text(stmt, 1, snapshot_name, strlen(snapshot_name), SQLITE_TRANSIENT); - if (snapshot_scheme == NULL) - sqlite3_bind_null(stmt, 2); - else - sqlite3_bind_text(stmt, 2, snapshot_scheme, strlen(snapshot_scheme), - SQLITE_TRANSIENT); + sqlite3_bind_text(stmt, 2, snapshot_scheme, strlen(snapshot_scheme), + SQLITE_TRANSIENT); sqlite3_bind_double(stmt, 3, intent); rc = sqlite3_step(stmt); @@ -248,10 +267,12 @@ void LocalDb::StoreObject(const ObjectReference& ref, sqlite3_finalize(stmt); if (age != 0.0) { - stmt = Prepare("update segments set mtime = max(mtime, ?) " + stmt = Prepare("update segments " + "set mtime = coalesce(max(mtime, ?), ?) " "where segmentid = ?"); sqlite3_bind_double(stmt, 1, age); - sqlite3_bind_int64(stmt, 2, SegmentToId(ref.get_segment())); + sqlite3_bind_double(stmt, 2, age); + sqlite3_bind_int64(stmt, 3, SegmentToId(ref.get_segment())); rc = sqlite3_step(stmt); sqlite3_finalize(stmt); } @@ -274,7 +295,7 @@ ObjectReference LocalDb::FindObject(const string &checksum, int64_t size) } else if (rc == SQLITE_ROW) { ref = ObjectReference(IdToSegment(sqlite3_column_int64(stmt, 0)), (const char *)sqlite3_column_text(stmt, 1)); - ref.set_range(0, size); + ref.set_range(0, size, true); } else { fprintf(stderr, "Could not execute SELECT statement!\n"); ReportError(rc); @@ -357,20 +378,61 @@ void LocalDb::UseObject(const ObjectReference& ref) if (!ref.is_normal()) return; - stmt = Prepare("insert or ignore into snapshot_refs " - "select segmentid, object, size from block_index " + int64_t old_size = 0; + stmt = Prepare("select size from snapshot_refs " "where segmentid = ? and object = ?"); sqlite3_bind_int64(stmt, 1, SegmentToId(ref.get_segment())); string obj = ref.get_sequence(); sqlite3_bind_text(stmt, 2, obj.c_str(), obj.size(), SQLITE_TRANSIENT); - rc = sqlite3_step(stmt); - if (rc != SQLITE_DONE) { - fprintf(stderr, "Could not execute INSERT statement!\n"); - ReportError(rc); + if (rc == SQLITE_ROW) { + old_size = sqlite3_column_int64(stmt, 0); } + sqlite3_finalize(stmt); + int64_t block_size = 0; + stmt = Prepare("select size from block_index " + "where segmentid = ? and object = ?"); + sqlite3_bind_int64(stmt, 1, SegmentToId(ref.get_segment())); + obj = ref.get_sequence(); + sqlite3_bind_text(stmt, 2, obj.c_str(), obj.size(), SQLITE_TRANSIENT); + rc = sqlite3_step(stmt); + if (rc == SQLITE_ROW) { + block_size = sqlite3_column_int64(stmt, 0); + } else { + string refstr = ref.to_string(); + fprintf(stderr, "No block found in block_index for %s\n", + refstr.c_str()); + sqlite3_finalize(stmt); + return; + } sqlite3_finalize(stmt); + + int64_t new_size = old_size; + if (ref.has_range()) { + new_size += ref.get_range_length(); + new_size = min(new_size, block_size); + } else { + new_size = block_size; + } + + if (new_size != old_size) { + stmt = Prepare("insert or replace " + "into snapshot_refs(segmentid, object, size) " + "values (?, ?, ?)"); + sqlite3_bind_int64(stmt, 1, SegmentToId(ref.get_segment())); + obj = ref.get_sequence(); + sqlite3_bind_text(stmt, 2, obj.c_str(), obj.size(), SQLITE_TRANSIENT); + sqlite3_bind_int64(stmt, 3, new_size); + + rc = sqlite3_step(stmt); + if (rc != SQLITE_DONE) { + fprintf(stderr, "Could not execute INSERT statement!\n"); + ReportError(rc); + } + + sqlite3_finalize(stmt); + } } void LocalDb::UseSegment(const std::string &segment, double utilization) @@ -460,3 +522,88 @@ bool LocalDb::GetSegmentChecksum(const string &segment, return found; } + +/* Look up and return the packed representation of the subblock chunk + * signatures. Returns true if signatures were found for the specified object, + * and if so sets *buf to point at a buffer of memory (allocated with malloc; + * the caller should free it), and *len to the length of the buffer. */ +bool LocalDb::LoadChunkSignatures(ObjectReference ref, + void **buf, size_t *len, + string *algorithm) +{ + int rc; + sqlite3_stmt *stmt; + int found = false; + + stmt = Prepare("select signatures, algorithm from subblock_signatures " + "where blockid = (select blockid from block_index " + " where segmentid = ? and object = ?)"); + sqlite3_bind_int64(stmt, 1, SegmentToId(ref.get_segment())); + string obj = ref.get_sequence(); + sqlite3_bind_text(stmt, 2, obj.c_str(), obj.size(), SQLITE_TRANSIENT); + + rc = sqlite3_step(stmt); + if (rc == SQLITE_DONE) { + } else if (rc == SQLITE_ROW) { + const void *data = sqlite3_column_blob(stmt, 0); + *len = sqlite3_column_bytes(stmt, 0); + + if (*len > 0) { + *buf = malloc(*len); + if (*buf != NULL) { + memcpy(*buf, data, *len); + *algorithm = (const char *)sqlite3_column_text(stmt, 1); + found = true; + } + } + } else { + fprintf(stderr, "Could not execute SELECT statement!\n"); + ReportError(rc); + } + + sqlite3_finalize(stmt); + + return found; +} + +/* Store the subblock chunk signatures for a specified object. The object + * itself must have already been indexed in the database. */ +void LocalDb::StoreChunkSignatures(ObjectReference ref, + const void *buf, size_t len, + const string& algorithm) +{ + int rc; + sqlite3_stmt *stmt; + + stmt = Prepare("select blockid from block_index " + "where segmentid = ? and object = ?"); + sqlite3_bind_int64(stmt, 1, SegmentToId(ref.get_segment())); + string obj = ref.get_sequence(); + sqlite3_bind_text(stmt, 2, obj.c_str(), obj.size(), SQLITE_TRANSIENT); + + rc = sqlite3_step(stmt); + if (rc != SQLITE_ROW) { + fprintf(stderr, + "Could not determine blockid in StoreChunkSignatures!\n"); + ReportError(rc); + throw IOException("Error getting blockid"); + } + int64_t blockid = sqlite3_column_int64(stmt, 0); + sqlite3_finalize(stmt); + + stmt = Prepare("insert or replace " + "into subblock_signatures(blockid, algorithm, signatures) " + "values (?, ?, ?)"); + sqlite3_bind_int64(stmt, 1, blockid); + sqlite3_bind_text(stmt, 2, algorithm.c_str(), algorithm.size(), + SQLITE_TRANSIENT); + sqlite3_bind_blob(stmt, 3, buf, len, SQLITE_TRANSIENT); + + rc = sqlite3_step(stmt); + if (rc != SQLITE_DONE) { + fprintf(stderr, "Could not insert sub-block checksums!\n"); + ReportError(rc); + } + + sqlite3_finalize(stmt); +}