ceph/src/rocksdb/utilities/transactions/transaction_db_impl.h

   1 //  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
   2 //  This source code is licensed under the BSD-style license found in the
   3 //  LICENSE file in the root directory of this source tree. An additional grant
   4 //  of patent rights can be found in the PATENTS file in the same directory.
   5
   6 #pragma once
   7 #ifndef ROCKSDB_LITE
   8
   9 #include <mutex>
  10 #include <queue>
  11 #include <string>
  12 #include <unordered_map>
  13 #include <vector>
  14
  15 #include "rocksdb/db.h"
  16 #include "rocksdb/options.h"
  17 #include "rocksdb/utilities/transaction_db.h"
  18 #include "utilities/transactions/transaction_impl.h"
  19 #include "utilities/transactions/transaction_lock_mgr.h"
  20
  21 namespace rocksdb {
  22
  23 class TransactionDBImpl : public TransactionDB {
  24  public:
  25   explicit TransactionDBImpl(DB* db,
  26                              const TransactionDBOptions& txn_db_options);
  27
  28   explicit TransactionDBImpl(StackableDB* db,
  29                              const TransactionDBOptions& txn_db_options);
  30
  31   ~TransactionDBImpl();
  32
  33   Status Initialize(const std::vector<size_t>& compaction_enabled_cf_indices,
  34                     const std::vector<ColumnFamilyHandle*>& handles);
  35
  36   Transaction* BeginTransaction(const WriteOptions& write_options,
  37                                 const TransactionOptions& txn_options,
  38                                 Transaction* old_txn) override;
  39
  40   using StackableDB::Put;
  41   virtual Status Put(const WriteOptions& options,
  42                      ColumnFamilyHandle* column_family, const Slice& key,
  43                      const Slice& val) override;
  44
  45   using StackableDB::Delete;
  46   virtual Status Delete(const WriteOptions& wopts,
  47                         ColumnFamilyHandle* column_family,
  48                         const Slice& key) override;
  49
  50   using StackableDB::Merge;
  51   virtual Status Merge(const WriteOptions& options,
  52                        ColumnFamilyHandle* column_family, const Slice& key,
  53                        const Slice& value) override;
  54
  55   using StackableDB::Write;
  56   virtual Status Write(const WriteOptions& opts, WriteBatch* updates) override;
  57
  58   using StackableDB::CreateColumnFamily;
  59   virtual Status CreateColumnFamily(const ColumnFamilyOptions& options,
  60                                     const std::string& column_family_name,
  61                                     ColumnFamilyHandle** handle) override;
  62
  63   using StackableDB::DropColumnFamily;
  64   virtual Status DropColumnFamily(ColumnFamilyHandle* column_family) override;
  65
  66   Status TryLock(TransactionImpl* txn, uint32_t cfh_id, const std::string& key,
  67                  bool exclusive);
  68
  69   void UnLock(TransactionImpl* txn, const TransactionKeyMap* keys);
  70   void UnLock(TransactionImpl* txn, uint32_t cfh_id, const std::string& key);
  71
  72   void AddColumnFamily(const ColumnFamilyHandle* handle);
  73
  74   static TransactionDBOptions ValidateTxnDBOptions(
  75       const TransactionDBOptions& txn_db_options);
  76
  77   const TransactionDBOptions& GetTxnDBOptions() const {
  78     return txn_db_options_;
  79   }
  80
  81   void InsertExpirableTransaction(TransactionID tx_id, TransactionImpl* tx);
  82   void RemoveExpirableTransaction(TransactionID tx_id);
  83
  84   // If transaction is no longer available, locks can be stolen
  85   // If transaction is available, try stealing locks directly from transaction
  86   // It is the caller's responsibility to ensure that the referred transaction
  87   // is expirable (GetExpirationTime() > 0) and that it is expired.
  88   bool TryStealingExpiredTransactionLocks(TransactionID tx_id);
  89
  90   Transaction* GetTransactionByName(const TransactionName& name) override;
  91
  92   void RegisterTransaction(Transaction* txn);
  93   void UnregisterTransaction(Transaction* txn);
  94
  95   // not thread safe. current use case is during recovery (single thread)
  96   void GetAllPreparedTransactions(std::vector<Transaction*>* trans) override;
  97
  98   TransactionLockMgr::LockStatusData GetLockStatusData() override;
  99
 100  private:
 101   void ReinitializeTransaction(
 102       Transaction* txn, const WriteOptions& write_options,
 103       const TransactionOptions& txn_options = TransactionOptions());
 104
 105   DBImpl* db_impl_;
 106   const TransactionDBOptions txn_db_options_;
 107   TransactionLockMgr lock_mgr_;
 108
 109   // Must be held when adding/dropping column families.
 110   InstrumentedMutex column_family_mutex_;
 111   Transaction* BeginInternalTransaction(const WriteOptions& options);
 112   Status WriteHelper(WriteBatch* updates, TransactionImpl* txn_impl);
 113
 114   // Used to ensure that no locks are stolen from an expirable transaction
 115   // that has started a commit. Only transactions with an expiration time
 116   // should be in this map.
 117   std::mutex map_mutex_;
 118   std::unordered_map<TransactionID, TransactionImpl*>
 119       expirable_transactions_map_;
 120
 121   // map from name to two phase transaction instance
 122   std::mutex name_map_mutex_;
 123   std::unordered_map<TransactionName, Transaction*> transactions_;
 124 };
 125
 126 }  //  namespace rocksdb
 127 #endif  // ROCKSDB_LITE