storage_manager.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2015, Hewlett-Packard Development Company, LP.
 * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * HP designates this particular file as subject to the "Classpath" exception
 * as provided by HP in the LICENSE.txt file that accompanied this code.
 */
#ifndef FOEDUS_STORAGE_STORAGE_MANAGER_HPP_
#define FOEDUS_STORAGE_STORAGE_MANAGER_HPP_
#include <string>

#include "foedus/cxx11.hpp"
#include "foedus/fwd.hpp"
#include "foedus/initializable.hpp"
#include "foedus/snapshot/fwd.hpp"
#include "foedus/storage/fwd.hpp"
#include "foedus/storage/storage_id.hpp"
#include "foedus/storage/array/array_storage.hpp"
#include "foedus/storage/array/fwd.hpp"
#include "foedus/storage/hash/fwd.hpp"
#include "foedus/storage/hash/hash_storage.hpp"
#include "foedus/storage/masstree/fwd.hpp"
#include "foedus/storage/masstree/masstree_storage.hpp"
#include "foedus/storage/sequential/fwd.hpp"
#include "foedus/storage/sequential/sequential_storage.hpp"
#include "foedus/thread/fwd.hpp"
#include "foedus/xct/fwd.hpp"
#include "foedus/xct/xct_id.hpp"

namespace foedus {
namespace storage {
class StorageManager CXX11_FINAL : public virtual Initializable {
 public:
  explicit StorageManager(Engine* engine);
  ~StorageManager();

  // Disable default constructors
  StorageManager() CXX11_FUNC_DELETE;
  StorageManager(const StorageManager&) CXX11_FUNC_DELETE;
  StorageManager& operator=(const StorageManager&) CXX11_FUNC_DELETE;

  Engine*     get_engine() const;
  ErrorStack  initialize() CXX11_OVERRIDE;
  bool        is_initialized() const CXX11_OVERRIDE;
  ErrorStack  uninitialize() CXX11_OVERRIDE;

  ErrorStack  reinitialize_for_recovered_snapshot();

  StorageId   issue_next_storage_id();
  StorageId   get_largest_storage_id();

  const StorageName& get_name(StorageId id);

  StorageControlBlock* get_storage(StorageId id);

  array::ArrayStorage get_array(StorageId id) {
    return array::ArrayStorage(get_engine(), get_storage(id));
  }

  hash::HashStorage get_hash(StorageId id) {
    return hash::HashStorage(get_engine(), get_storage(id));
  }

  sequential::SequentialStorage get_sequential(StorageId id) {
    return sequential::SequentialStorage(get_engine(), get_storage(id));
  }

  masstree::MasstreeStorage get_masstree(StorageId id) {
    return masstree::MasstreeStorage(get_engine(), get_storage(id));
  }

  StorageControlBlock* get_storage(const StorageName& name);

  array::ArrayStorage get_array(const StorageName& name) {
    return array::ArrayStorage(get_engine(), get_storage(name));
  }

  hash::HashStorage get_hash(const StorageName& name) {
    return hash::HashStorage(get_engine(), get_storage(name));
  }

  sequential::SequentialStorage get_sequential(const StorageName& name) {
    return sequential::SequentialStorage(get_engine(), get_storage(name));
  }

  masstree::MasstreeStorage get_masstree(const StorageName& name) {
    return masstree::MasstreeStorage(get_engine(), get_storage(name));
  }

  ErrorStack  drop_storage(StorageId id, Epoch *commit_epoch);
  void        drop_storage_apply(StorageId id);

  ErrorStack  create_storage(Metadata *metadata, Epoch *commit_epoch);
  void        create_storage_apply(const Metadata& metadata);

  ErrorStack  create_array(
    array::ArrayMetadata *metadata,
    array::ArrayStorage *storage,
    Epoch *commit_epoch);

  ErrorStack  create_hash(
    hash::HashMetadata *metadata,
    hash::HashStorage *storage,
    Epoch *commit_epoch);

  ErrorStack  create_sequential(
    sequential::SequentialMetadata *metadata,
    sequential::SequentialStorage *storage,
    Epoch *commit_epoch);

  ErrorStack  create_masstree(
    masstree::MasstreeMetadata *metadata,
    masstree::MasstreeStorage *storage,
    Epoch *commit_epoch);

  ErrorStack  clone_all_storage_metadata(snapshot::SnapshotMetadata *metadata);

  xct::TrackMovedRecordResult track_moved_record(
    StorageId storage_id,
    xct::RwLockableXctId* old_address,
    xct::WriteXctAccess* write_set);

  StorageManagerPimpl* get_pimpl() { return pimpl_; }

 private:
  StorageManagerPimpl *pimpl_;
};
}  // namespace storage
}  // namespace foedus
#endif  // FOEDUS_STORAGE_STORAGE_MANAGER_HPP_