mirror of https://gitee.com/bigwinds/arangodb
301 lines
17 KiB
C++
301 lines
17 KiB
C++
//////////////////////////////////////////////////////////////////////////////
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2017 EMC Corporation
|
|
///
|
|
/// 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
|
|
///
|
|
/// http://www.apache.org/licenses/LICENSE-2.0
|
|
///
|
|
/// Unless required by applicable law or agreed to in writing, software
|
|
/// distributed under the License is distributed on an "AS IS" BASIS,
|
|
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
/// See the License for the specific language governing permissions and
|
|
/// limitations under the License.
|
|
///
|
|
/// Copyright holder is EMC Corporation
|
|
///
|
|
/// @author Andrey Abramov
|
|
/// @author Vasiliy Nabatchikov
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef ARANGODB_TESTS_MOCKS_STORAGE_ENGINE_MOCK_H
|
|
#define ARANGODB_TESTS_MOCKS_STORAGE_ENGINE_MOCK_H 1
|
|
|
|
#include <deque>
|
|
|
|
#include "Basics/Result.h"
|
|
#include "Indexes/IndexIterator.h"
|
|
#include "StorageEngine/PhysicalCollection.h"
|
|
#include "StorageEngine/StorageEngine.h"
|
|
#include "StorageEngine/TransactionCollection.h"
|
|
#include "StorageEngine/TransactionState.h"
|
|
#include "Transaction/ContextData.h"
|
|
#include "VocBase/LocalDocumentId.h"
|
|
|
|
#include <velocypack/StringRef.h>
|
|
|
|
namespace arangodb {
|
|
|
|
struct KeyLockInfo;
|
|
class TransactionManager;
|
|
class WalAccess;
|
|
|
|
namespace aql {
|
|
class OptimizerRulesFeature;
|
|
}
|
|
|
|
} // namespace arangodb
|
|
|
|
class PhysicalCollectionMock : public arangodb::PhysicalCollection {
|
|
public:
|
|
struct DocElement {
|
|
DocElement(std::shared_ptr<arangodb::velocypack::Buffer<uint8_t>> data, uint64_t docId);
|
|
|
|
arangodb::velocypack::Slice data() const;
|
|
std::shared_ptr<arangodb::velocypack::Buffer<uint8_t>> rawData() const;
|
|
arangodb::LocalDocumentId docId() const;
|
|
uint8_t const* vptr() const;
|
|
void swapBuffer(std::shared_ptr<arangodb::velocypack::Buffer<uint8_t>>& newData);
|
|
|
|
private:
|
|
std::shared_ptr<arangodb::velocypack::Buffer<uint8_t>> _data;
|
|
uint64_t const _docId;
|
|
};
|
|
|
|
static std::function<void()> before;
|
|
std::string physicalPath;
|
|
|
|
PhysicalCollectionMock(arangodb::LogicalCollection& collection,
|
|
arangodb::velocypack::Slice const& info);
|
|
virtual PhysicalCollection* clone(arangodb::LogicalCollection& collection) const override;
|
|
virtual int close() override;
|
|
virtual std::shared_ptr<arangodb::Index> createIndex(arangodb::velocypack::Slice const& info,
|
|
bool restore, bool& created) override;
|
|
virtual void deferDropCollection(std::function<bool(arangodb::LogicalCollection&)> const& callback) override;
|
|
virtual bool dropIndex(TRI_idx_iid_t iid) override;
|
|
virtual void figuresSpecific(arangodb::velocypack::Builder&) override;
|
|
virtual std::unique_ptr<arangodb::IndexIterator> getAllIterator(
|
|
arangodb::transaction::Methods* trx) const override;
|
|
virtual std::unique_ptr<arangodb::IndexIterator> getAnyIterator(
|
|
arangodb::transaction::Methods* trx) const override;
|
|
virtual void getPropertiesVPack(arangodb::velocypack::Builder&) const override;
|
|
virtual arangodb::Result insert(arangodb::transaction::Methods* trx,
|
|
arangodb::velocypack::Slice const newSlice,
|
|
arangodb::ManagedDocumentResult& result,
|
|
arangodb::OperationOptions& options, bool lock,
|
|
arangodb::KeyLockInfo* /*keyLockInfo*/,
|
|
std::function<void()> const& callbackDuringLock) override;
|
|
|
|
virtual arangodb::LocalDocumentId lookupKey(arangodb::transaction::Methods*,
|
|
arangodb::velocypack::Slice const&) const override;
|
|
virtual size_t memory() const override;
|
|
virtual uint64_t numberDocuments(arangodb::transaction::Methods* trx) const override;
|
|
virtual void open(bool ignoreErrors) override;
|
|
virtual std::string const& path() const override;
|
|
virtual arangodb::Result persistProperties() override;
|
|
virtual void prepareIndexes(arangodb::velocypack::Slice indexesSlice) override;
|
|
virtual arangodb::Result read(arangodb::transaction::Methods*,
|
|
arangodb::velocypack::StringRef const& key,
|
|
arangodb::ManagedDocumentResult& result, bool) override;
|
|
virtual arangodb::Result read(arangodb::transaction::Methods*,
|
|
arangodb::velocypack::Slice const& key,
|
|
arangodb::ManagedDocumentResult& result, bool) override;
|
|
virtual bool readDocument(arangodb::transaction::Methods* trx,
|
|
arangodb::LocalDocumentId const& token,
|
|
arangodb::ManagedDocumentResult& result) const override;
|
|
virtual bool readDocumentWithCallback(arangodb::transaction::Methods* trx,
|
|
arangodb::LocalDocumentId const& token,
|
|
arangodb::IndexIterator::DocumentCallback const& cb) const override;
|
|
virtual arangodb::Result remove(arangodb::transaction::Methods& trx,
|
|
arangodb::velocypack::Slice slice,
|
|
arangodb::ManagedDocumentResult& previous,
|
|
arangodb::OperationOptions& options, bool lock,
|
|
arangodb::KeyLockInfo* /*keyLockInfo*/,
|
|
std::function<void()> const& callbackDuringLock) override;
|
|
virtual arangodb::Result replace(arangodb::transaction::Methods* trx,
|
|
arangodb::velocypack::Slice const newSlice,
|
|
arangodb::ManagedDocumentResult& result,
|
|
arangodb::OperationOptions& options, bool lock,
|
|
arangodb::ManagedDocumentResult& previous) override;
|
|
virtual TRI_voc_rid_t revision(arangodb::transaction::Methods* trx) const override;
|
|
virtual void setPath(std::string const&) override;
|
|
virtual arangodb::Result truncate(arangodb::transaction::Methods& trx,
|
|
arangodb::OperationOptions& options) override;
|
|
virtual arangodb::Result compact() override;
|
|
virtual arangodb::Result update(arangodb::transaction::Methods* trx,
|
|
arangodb::velocypack::Slice const newSlice,
|
|
arangodb::ManagedDocumentResult& result,
|
|
arangodb::OperationOptions& options, bool lock,
|
|
arangodb::ManagedDocumentResult& previous) override;
|
|
virtual void load() override {}
|
|
virtual void unload() override {}
|
|
virtual arangodb::Result updateProperties(arangodb::velocypack::Slice const& slice,
|
|
bool doSync) override;
|
|
|
|
private:
|
|
bool addIndex(std::shared_ptr<arangodb::Index> idx);
|
|
|
|
arangodb::Result updateInternal(arangodb::transaction::Methods* trx,
|
|
arangodb::velocypack::Slice const newSlice,
|
|
arangodb::ManagedDocumentResult& result,
|
|
arangodb::OperationOptions& options, bool lock,
|
|
arangodb::ManagedDocumentResult& previous, bool isUpdate);
|
|
|
|
uint64_t _lastDocumentId;
|
|
// keep old documents memory, unclear if needed.
|
|
std::vector<std::shared_ptr<arangodb::velocypack::Buffer<uint8_t>>> _graveyard;
|
|
// map _key => data. Keyslice references memory in the value
|
|
std::unordered_map<arangodb::velocypack::StringRef, DocElement> _documents;
|
|
};
|
|
|
|
class TransactionCollectionMock : public arangodb::TransactionCollection {
|
|
public:
|
|
TransactionCollectionMock(arangodb::TransactionState* state, TRI_voc_cid_t cid,
|
|
arangodb::AccessMode::Type accessType);
|
|
virtual bool canAccess(arangodb::AccessMode::Type accessType) const override;
|
|
virtual void freeOperations(arangodb::transaction::Methods* activeTrx,
|
|
bool mustRollback) override;
|
|
virtual bool hasOperations() const override;
|
|
virtual void release() override;
|
|
virtual void unuse(int nestingLevel) override;
|
|
virtual int use(int nestingLevel) override;
|
|
|
|
private:
|
|
int doLock(arangodb::AccessMode::Type type, int nestingLevel) override;
|
|
int doUnlock(arangodb::AccessMode::Type type, int nestingLevel) override;
|
|
};
|
|
|
|
class TransactionStateMock : public arangodb::TransactionState {
|
|
public:
|
|
static size_t abortTransactionCount;
|
|
static size_t beginTransactionCount;
|
|
static size_t commitTransactionCount;
|
|
|
|
TransactionStateMock(TRI_vocbase_t& vocbase, TRI_voc_tid_t tid,
|
|
arangodb::transaction::Options const& options);
|
|
virtual arangodb::Result abortTransaction(arangodb::transaction::Methods* trx) override;
|
|
virtual arangodb::Result beginTransaction(arangodb::transaction::Hints hints) override;
|
|
virtual arangodb::Result commitTransaction(arangodb::transaction::Methods* trx) override;
|
|
virtual bool hasFailedOperations() const override;
|
|
};
|
|
|
|
class StorageEngineMock : public arangodb::StorageEngine {
|
|
public:
|
|
static std::function<void()> before;
|
|
static arangodb::Result flushSubscriptionResult;
|
|
static arangodb::RecoveryState recoveryStateResult;
|
|
static TRI_voc_tick_t recoveryTickResult;
|
|
static std::string versionFilenameResult;
|
|
static std::function<void()> recoveryTickCallback;
|
|
std::map<std::pair<TRI_voc_tick_t, TRI_voc_cid_t>, arangodb::velocypack::Builder> views;
|
|
std::atomic<size_t> vocbaseCount;
|
|
|
|
explicit StorageEngineMock(arangodb::application_features::ApplicationServer& server);
|
|
virtual void addOptimizerRules(arangodb::aql::OptimizerRulesFeature& feature) override;
|
|
virtual void addRestHandlers(arangodb::rest::RestHandlerFactory& handlerFactory) override;
|
|
virtual void addV8Functions() override;
|
|
virtual void changeCollection(TRI_vocbase_t& vocbase,
|
|
arangodb::LogicalCollection const& collection,
|
|
bool doSync) override;
|
|
virtual arangodb::Result changeView(TRI_vocbase_t& vocbase,
|
|
arangodb::LogicalView const& view, bool doSync) override;
|
|
virtual std::string collectionPath(TRI_vocbase_t const& vocbase, TRI_voc_cid_t id) const override;
|
|
virtual std::string createCollection(TRI_vocbase_t& vocbase,
|
|
arangodb::LogicalCollection const& collection) override;
|
|
virtual std::unique_ptr<TRI_vocbase_t> createDatabase(arangodb::CreateDatabaseInfo&&,
|
|
int& status) override;
|
|
virtual arangodb::Result createLoggerState(TRI_vocbase_t*, VPackBuilder&) override;
|
|
virtual std::unique_ptr<arangodb::PhysicalCollection> createPhysicalCollection(
|
|
arangodb::LogicalCollection& collection, arangodb::velocypack::Slice const& info) override;
|
|
virtual arangodb::Result createTickRanges(VPackBuilder&) override;
|
|
virtual std::unique_ptr<arangodb::TransactionCollection> createTransactionCollection(
|
|
arangodb::TransactionState& state, TRI_voc_cid_t cid,
|
|
arangodb::AccessMode::Type, int nestingLevel) override;
|
|
virtual std::unique_ptr<arangodb::transaction::ContextData> createTransactionContextData() override;
|
|
virtual std::unique_ptr<arangodb::transaction::Manager> createTransactionManager(
|
|
arangodb::transaction::ManagerFeature&) override;
|
|
virtual std::unique_ptr<arangodb::TransactionState> createTransactionState(
|
|
TRI_vocbase_t& vocbase, TRI_voc_tid_t tid,
|
|
arangodb::transaction::Options const& options) override;
|
|
virtual arangodb::Result createView(TRI_vocbase_t& vocbase, TRI_voc_cid_t id,
|
|
arangodb::LogicalView const& view) override;
|
|
virtual void getViewProperties(TRI_vocbase_t& vocbase, arangodb::LogicalView const& view,
|
|
VPackBuilder& builder) override;
|
|
virtual TRI_voc_tick_t currentTick() const override;
|
|
virtual std::string dataPath() const override;
|
|
virtual std::string databasePath(TRI_vocbase_t const* vocbase) const override;
|
|
virtual void destroyCollection(TRI_vocbase_t& vocbase,
|
|
arangodb::LogicalCollection& collection) override;
|
|
virtual void destroyView(TRI_vocbase_t const& vocbase,
|
|
arangodb::LogicalView const& view) noexcept override;
|
|
virtual arangodb::Result dropCollection(TRI_vocbase_t& vocbase,
|
|
arangodb::LogicalCollection& collection) override;
|
|
virtual arangodb::Result dropDatabase(TRI_vocbase_t& vocbase) override;
|
|
virtual arangodb::Result dropView(TRI_vocbase_t const& vocbase,
|
|
arangodb::LogicalView const& view) override;
|
|
virtual arangodb::Result firstTick(uint64_t&) override;
|
|
virtual std::vector<std::string> currentWalFiles() const override;
|
|
virtual arangodb::Result flushWal(bool waitForSync, bool waitForCollector,
|
|
bool writeShutdownFile) override;
|
|
virtual void getCollectionInfo(TRI_vocbase_t& vocbase, TRI_voc_cid_t cid,
|
|
arangodb::velocypack::Builder& result,
|
|
bool includeIndexes, TRI_voc_tick_t maxTick) override;
|
|
virtual int getCollectionsAndIndexes(TRI_vocbase_t& vocbase,
|
|
arangodb::velocypack::Builder& result,
|
|
bool wasCleanShutdown, bool isUpgrade) override;
|
|
virtual void getDatabases(arangodb::velocypack::Builder& result) override;
|
|
virtual void cleanupReplicationContexts() override;
|
|
virtual arangodb::velocypack::Builder getReplicationApplierConfiguration(TRI_vocbase_t& vocbase,
|
|
int& result) override;
|
|
virtual arangodb::velocypack::Builder getReplicationApplierConfiguration(int& result) override;
|
|
virtual int getViews(TRI_vocbase_t& vocbase, arangodb::velocypack::Builder& result) override;
|
|
virtual arangodb::Result handleSyncKeys(arangodb::DatabaseInitialSyncer& syncer,
|
|
arangodb::LogicalCollection& col,
|
|
std::string const& keysId) override;
|
|
virtual arangodb::RecoveryState recoveryState() override;
|
|
virtual TRI_voc_tick_t recoveryTick() override;
|
|
virtual arangodb::Result lastLogger(TRI_vocbase_t& vocbase,
|
|
std::shared_ptr<arangodb::transaction::Context> transactionContext,
|
|
uint64_t tickStart, uint64_t tickEnd,
|
|
std::shared_ptr<VPackBuilder>& builderSPtr) override;
|
|
virtual std::unique_ptr<TRI_vocbase_t> openDatabase(arangodb::CreateDatabaseInfo&&,
|
|
bool isUpgrade) override;
|
|
virtual arangodb::Result persistCollection(TRI_vocbase_t& vocbase,
|
|
arangodb::LogicalCollection const& collection) override;
|
|
virtual void prepareDropDatabase(TRI_vocbase_t& vocbase, bool useWriteMarker,
|
|
int& status) override;
|
|
using StorageEngine::registerCollection;
|
|
using StorageEngine::registerView;
|
|
virtual TRI_voc_tick_t releasedTick() const override;
|
|
virtual void releaseTick(TRI_voc_tick_t) override;
|
|
virtual int removeReplicationApplierConfiguration(TRI_vocbase_t& vocbase) override;
|
|
virtual int removeReplicationApplierConfiguration() override;
|
|
virtual arangodb::Result renameCollection(TRI_vocbase_t& vocbase,
|
|
arangodb::LogicalCollection const& collection,
|
|
std::string const& oldName) override;
|
|
virtual int saveReplicationApplierConfiguration(TRI_vocbase_t& vocbase,
|
|
arangodb::velocypack::Slice slice,
|
|
bool doSync) override;
|
|
virtual int saveReplicationApplierConfiguration(arangodb::velocypack::Slice, bool) override;
|
|
virtual int shutdownDatabase(TRI_vocbase_t& vocbase) override;
|
|
virtual void signalCleanup(TRI_vocbase_t& vocbase) override;
|
|
virtual bool supportsDfdb() const override;
|
|
virtual void unloadCollection(TRI_vocbase_t& vocbase,
|
|
arangodb::LogicalCollection& collection) override;
|
|
virtual bool useRawDocumentPointers() override { return false; }
|
|
virtual std::string versionFilename(TRI_voc_tick_t) const override;
|
|
virtual void waitForEstimatorSync(std::chrono::milliseconds maxWaitTime) override;
|
|
virtual void waitForSyncTick(TRI_voc_tick_t tick) override;
|
|
virtual void waitUntilDeletion(TRI_voc_tick_t id, bool force, int& status) override;
|
|
virtual arangodb::WalAccess const* walAccess() const override;
|
|
virtual int writeCreateDatabaseMarker(TRI_voc_tick_t id, VPackSlice const& slice) override;
|
|
|
|
private:
|
|
TRI_voc_tick_t _releasedTick;
|
|
};
|
|
|
|
#endif
|