rippled
DatabaseCon.h
1 //------------------------------------------------------------------------------
2 /*
3  This file is part of rippled: https://github.com/ripple/rippled
4  Copyright (c) 2012, 2013 Ripple Labs Inc.
5 
6  Permission to use, copy, modify, and/or distribute this software for any
7  purpose with or without fee is hereby granted, provided that the above
8  copyright notice and this permission notice appear in all copies.
9 
10  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13  ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18 //==============================================================================
19 
20 #ifndef RIPPLE_APP_DATA_DATABASECON_H_INCLUDED
21 #define RIPPLE_APP_DATA_DATABASECON_H_INCLUDED
22 
23 #include <ripple/app/main/DBInit.h>
24 #include <ripple/core/Config.h>
25 #include <ripple/core/SociDB.h>
26 #include <boost/filesystem/path.hpp>
27 #include <mutex>
28 #include <optional>
29 #include <string>
30 
31 namespace soci {
32 class session;
33 }
34 
35 namespace ripple {
36 
38 {
39 public:
41 
42 private:
45 
46 public:
48  : session_(std::move(it)), lock_(m)
49  {
50  }
52  : session_(std::move(rhs.session_)), lock_(std::move(rhs.lock_))
53  {
54  }
55  LockedSociSession() = delete;
56  LockedSociSession(LockedSociSession const& rhs) = delete;
58  operator=(LockedSociSession const& rhs) = delete;
59 
60  soci::session*
61  get()
62  {
63  return session_.get();
64  }
65  soci::session&
67  {
68  return *session_;
69  }
70  soci::session*
72  {
73  return session_.get();
74  }
75  explicit operator bool() const
76  {
77  return bool(session_);
78  }
79 };
80 
82 {
83 public:
84  struct Setup
85  {
86  explicit Setup() = default;
87 
89  bool standAlone = false;
90  bool reporting = false;
91  boost::filesystem::path dataDir;
92  // Indicates whether or not to return the `globalPragma`
93  // from commonPragma()
94  bool useGlobalPragma = false;
95 
97  commonPragma() const
98  {
99  assert(!useGlobalPragma || globalPragma);
101  : nullptr;
102  }
103 
105  };
106 
108  {
111  };
112 
113  template <std::size_t N, std::size_t M>
115  Setup const& setup,
116  std::string const& dbName,
117  std::array<char const*, N> const& pragma,
118  std::array<char const*, M> const& initSQL)
119  // Use temporary files or regular DB files?
120  : DatabaseCon(
121  setup.standAlone && !setup.reporting &&
122  setup.startUp != Config::LOAD &&
123  setup.startUp != Config::LOAD_FILE &&
124  setup.startUp != Config::REPLAY
125  ? ""
126  : (setup.dataDir / dbName),
127  setup.commonPragma(),
128  pragma,
129  initSQL)
130  {
131  }
132 
133  // Use this constructor to setup checkpointing
134  template <std::size_t N, std::size_t M>
136  Setup const& setup,
137  std::string const& dbName,
138  std::array<char const*, N> const& pragma,
139  std::array<char const*, M> const& initSQL,
140  CheckpointerSetup const& checkpointerSetup)
141  : DatabaseCon(setup, dbName, pragma, initSQL)
142  {
143  setupCheckpointing(checkpointerSetup.jobQueue, *checkpointerSetup.logs);
144  }
145 
146  template <std::size_t N, std::size_t M>
148  boost::filesystem::path const& dataDir,
149  std::string const& dbName,
150  std::array<char const*, N> const& pragma,
151  std::array<char const*, M> const& initSQL)
152  : DatabaseCon(dataDir / dbName, nullptr, pragma, initSQL)
153  {
154  }
155 
156  // Use this constructor to setup checkpointing
157  template <std::size_t N, std::size_t M>
159  boost::filesystem::path const& dataDir,
160  std::string const& dbName,
161  std::array<char const*, N> const& pragma,
162  std::array<char const*, M> const& initSQL,
163  CheckpointerSetup const& checkpointerSetup)
164  : DatabaseCon(dataDir, dbName, pragma, initSQL)
165  {
166  setupCheckpointing(checkpointerSetup.jobQueue, *checkpointerSetup.logs);
167  }
168 
169  ~DatabaseCon();
170 
171  soci::session&
173  {
174  return *session_;
175  }
176 
179  {
181  }
182 
183 private:
184  void
186 
187  template <std::size_t N, std::size_t M>
189  boost::filesystem::path const& pPath,
190  std::vector<std::string> const* commonPragma,
191  std::array<char const*, N> const& pragma,
192  std::array<char const*, M> const& initSQL)
193  : session_(std::make_shared<soci::session>())
194  {
195  open(*session_, "sqlite", pPath.string());
196 
197  if (commonPragma)
198  {
199  for (auto const& p : *commonPragma)
200  {
201  soci::statement st = session_->prepare << p;
202  st.execute(true);
203  }
204  }
205  for (auto const& p : pragma)
206  {
207  soci::statement st = session_->prepare << p;
208  st.execute(true);
209  }
210  for (auto const& sql : initSQL)
211  {
212  soci::statement st = session_->prepare << sql;
213  st.execute(true);
214  }
215  }
216 
218 
219  // checkpointer may outlive the DatabaseCon when the checkpointer jobQueue
220  // callback locks a weak pointer and the DatabaseCon is then destroyed. In
221  // this case, the checkpointer needs to make sure it doesn't use an already
222  // destroyed session. Thus this class keeps a shared_ptr to the session (so
223  // the checkpointer can keep a weak_ptr) and the checkpointer is a
224  // shared_ptr in this class. session_ will never be null.
227 };
228 
229 // Return the checkpointer from its id. If the checkpointer no longer exists, an
230 // nullptr is returned
233 
236  Config const& c,
237  std::optional<beast::Journal> j = std::nullopt);
238 
239 } // namespace ripple
240 
241 #endif
ripple::DatabaseCon::CheckpointerSetup::logs
Logs * logs
Definition: DatabaseCon.h:110
ripple::Config::NORMAL
@ NORMAL
Definition: Config.h:153
ripple::DatabaseCon::CheckpointerSetup::jobQueue
JobQueue * jobQueue
Definition: DatabaseCon.h:109
ripple::DatabaseCon::Setup::globalPragma
static std::unique_ptr< std::vector< std::string > const > globalPragma
Definition: DatabaseCon.h:104
std::string
STL class.
ripple::DatabaseCon::DatabaseCon
DatabaseCon(boost::filesystem::path const &pPath, std::vector< std::string > const *commonPragma, std::array< char const *, N > const &pragma, std::array< char const *, M > const &initSQL)
Definition: DatabaseCon.h:188
std::shared_ptr< soci::session >
ripple::DatabaseCon::DatabaseCon
DatabaseCon(boost::filesystem::path const &dataDir, std::string const &dbName, std::array< char const *, N > const &pragma, std::array< char const *, M > const &initSQL, CheckpointerSetup const &checkpointerSetup)
Definition: DatabaseCon.h:158
ripple::Logs
Manages partitions for logging.
Definition: Log.h:48
ripple::DatabaseCon::Setup
Definition: DatabaseCon.h:84
ripple::setup_DatabaseCon
DatabaseCon::Setup setup_DatabaseCon(Config const &c, std::optional< beast::Journal > j=std::nullopt)
Definition: DatabaseCon.cpp:106
ripple::DatabaseCon::Setup::startUp
Config::StartUpType startUp
Definition: DatabaseCon.h:88
std::vector< std::string >
ripple::LockedSociSession::LockedSociSession
LockedSociSession()=delete
ripple::DatabaseCon::CheckpointerSetup
Definition: DatabaseCon.h:107
ripple::checkpointerFromId
std::shared_ptr< Checkpointer > checkpointerFromId(std::uintptr_t id)
Definition: DatabaseCon.cpp:79
std::recursive_mutex
STL class.
std::shared_ptr::get
T get(T... args)
ripple::DatabaseCon::Setup::dataDir
boost::filesystem::path dataDir
Definition: DatabaseCon.h:91
ripple::Config::StartUpType
StartUpType
Definition: Config.h:153
ripple::LockedSociSession::session_
std::shared_ptr< soci::session > session_
Definition: DatabaseCon.h:43
ripple::DatabaseCon::Setup::commonPragma
std::vector< std::string > const * commonPragma() const
Definition: DatabaseCon.h:97
ripple::DatabaseCon::setupCheckpointing
void setupCheckpointing(JobQueue *, Logs &)
Definition: DatabaseCon.cpp:248
soci
Definition: DatabaseCon.h:31
ripple::DatabaseCon::Setup::useGlobalPragma
bool useGlobalPragma
Definition: DatabaseCon.h:94
ripple::DatabaseCon::lock_
LockedSociSession::mutex lock_
Definition: DatabaseCon.h:217
ripple::DatabaseCon::Setup::standAlone
bool standAlone
Definition: DatabaseCon.h:89
ripple::DatabaseCon::checkoutDb
LockedSociSession checkoutDb()
Definition: DatabaseCon.h:178
ripple::DatabaseCon::Setup::reporting
bool reporting
Definition: DatabaseCon.h:90
ripple::Config
Definition: Config.h:89
ripple::DatabaseCon::session_
const std::shared_ptr< soci::session > session_
Definition: DatabaseCon.h:225
std::unique_lock
STL class.
ripple::LockedSociSession::operator->
soci::session * operator->()
Definition: DatabaseCon.h:71
std::array
STL class.
ripple::DatabaseCon::DatabaseCon
DatabaseCon(boost::filesystem::path const &dataDir, std::string const &dbName, std::array< char const *, N > const &pragma, std::array< char const *, M > const &initSQL)
Definition: DatabaseCon.h:147
std::uintptr_t
ripple::DatabaseCon::DatabaseCon
DatabaseCon(Setup const &setup, std::string const &dbName, std::array< char const *, N > const &pragma, std::array< char const *, M > const &initSQL, CheckpointerSetup const &checkpointerSetup)
Definition: DatabaseCon.h:135
ripple::LockedSociSession::operator*
soci::session & operator*()
Definition: DatabaseCon.h:66
ripple::JobQueue
A pool of threads to perform work.
Definition: JobQueue.h:55
ripple::DatabaseCon::getSession
soci::session & getSession()
Definition: DatabaseCon.h:172
ripple::DatabaseCon::~DatabaseCon
~DatabaseCon()
Definition: DatabaseCon.cpp:84
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
ripple::LockedSociSession
Definition: DatabaseCon.h:37
ripple::LockedSociSession::LockedSociSession
LockedSociSession(LockedSociSession &&rhs) noexcept
Definition: DatabaseCon.h:51
ripple::DatabaseCon::Setup::Setup
Setup()=default
std
STL namespace.
ripple::DatabaseCon::DatabaseCon
DatabaseCon(Setup const &setup, std::string const &dbName, std::array< char const *, N > const &pragma, std::array< char const *, M > const &initSQL)
Definition: DatabaseCon.h:114
ripple::DatabaseCon
Definition: DatabaseCon.h:81
ripple::LockedSociSession::operator=
LockedSociSession & operator=(LockedSociSession const &rhs)=delete
ripple::LockedSociSession::LockedSociSession
LockedSociSession(std::shared_ptr< soci::session > it, mutex &m)
Definition: DatabaseCon.h:47
optional
mutex
ripple::LockedSociSession::get
soci::session * get()
Definition: DatabaseCon.h:61
std::unique_ptr
STL class.
ripple::DatabaseCon::checkpointer_
std::shared_ptr< Checkpointer > checkpointer_
Definition: DatabaseCon.h:226
ripple::LockedSociSession::lock_
std::unique_lock< mutex > lock_
Definition: DatabaseCon.h:44
ripple::open
void open(soci::session &s, BasicConfig const &config, std::string const &dbName)
Open a soci session.
Definition: SociDB.cpp:98
string