Skip to content
Fetching contributors…
Cannot retrieve contributors at this time
138 lines (119 sloc) 4.58 KB
/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
* Copyright 2011 Couchbase, Inc.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* See the License for the specific language governing permissions and
* limitations under the License.
#ifndef RESTORE_HH
#define RESTORE_HH 1
#include <string>
#include <sstream>
#include <memcached/engine.h>
class EventuallyPersistentEngine;
* The restore manager is responsible for running the restore of a set of
* incremental backup files.
class RestoreManager {
* Initialize a new instance of the Restore Manager.
* @param theEngine the engine to restore the data into
RestoreManager(EventuallyPersistentEngine &theEngine) : engine(theEngine) {}
* Parse the configuration and intialize the instance.
* An exception is thrown if there is something wrong with the configuration
* @param config what to initialize the restore manager with (this could be
* a pointer to a file or whatever.. it's up to the implementation
* to define)
* @throws a string describing the error if it failed to intitalize itself
virtual void initialize(const std::string &config) throw(std::string) = 0;
* Start the restore. The restore may use its own threads or utilize the
* scheduler. that's up to the implementation to decide. This method
* should start the restore and return immediately (not wait for the
* restore to complete).
* @throws a string describing why we failed to start the restore
virtual void start() throw (std::string) = 0;
* Terminate the restore process as soon as possible. This method should
* <b>not</b> wait for the abortion to complete, but return to the caller
* immediately.
* @throws a string describing why we failed to abort the restore
virtual void abort() throw (std::string) = 0;
* Wait for the restore process to stop (after a successfull completion or
* an abort).
* @throws a string describing why we aren't waiting for the restore to
* shut down
virtual void wait() throw (std::string) = 0;
* Get statistics from the restore
* @param cookie provided by the core
* @param add_stat callback to the core
virtual void stats(const void* /* cookie */, ADD_STAT /* add_stat */) {}
virtual bool isRunning() = 0;
virtual void enableRestoreFileChecks(bool restore_file_checks) = 0;
* Release all allocated resources.
virtual ~RestoreManager() {}
template <typename T>
void addStat(const void *cookie, const char *nm, T val, ADD_STAT add_stat) {
std::stringstream name;
name << "ep_restore:" << nm;
std::stringstream value;
value << val;
std::string n = name.str();
add_stat(, static_cast<uint16_t>(n.length()),
value.str().data(), static_cast<uint32_t>(value.str().length()),
void addStat(const char *nm, bool val, ADD_STAT add_stat, const void *c) {
addStat(nm, val ? "true" : "false", add_stat, c);
EventuallyPersistentEngine &engine;
extern "C" {
* Create a new restore manager to restore data into the specified
* engine. The restore manager should be returned in an uninitialized
* state, so the only thing that may make the method call is an out
* of memory error. The user should call initialize() on the returning
* object.
* The primary reason for creating this the hard way with an extern "C"
* linkage and not throw an exception, is that I want to be able to
* put it into a separate loadable module.
* @param engine the engine to restore the data into
* @return a pointer to the restore manager
RestoreManager* create_restore_manager(EventuallyPersistentEngine &engine);
* Destroy the instance of the restore manager.
* @param restoreManager the manager to destroy.
void destroy_restore_manager(RestoreManager *restoreManager);
Something went wrong with that request. Please try again.