Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
arangodb/arangod/IResearch/IResearchFeature.cpp

785 lines
27 KiB
C++
Raw Blame History

//////////////////////////////////////////////////////////////////////////////
/// 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 Vasily Nabatchikov
////////////////////////////////////////////////////////////////////////////////
// otherwise define conflict between 3rdParty\date\include\date\date.h and 3rdParty\iresearch\core\shared.hpp
#if defined(_MSC_VER)
#include "date/date.h"
#undef NOEXCEPT
#endif
#include "search/scorers.hpp"
#include "utils/log.hpp"
#include "ApplicationServerHelper.h"
#include "Aql/AqlFunctionFeature.h"
#include "Aql/AqlValue.h"
#include "Aql/Function.h"
#include "Basics/ConditionLocker.h"
#include "Basics/SmallVector.h"
#include "Cluster/ServerState.h"
#include "Containers.h"
#include "IResearchCommon.h"
#include "IResearchFeature.h"
#include "IResearchLinkCoordinator.h"
#include "IResearchLinkHelper.h"
#include "IResearchMMFilesLink.h"
#include "IResearchRocksDBLink.h"
#include "IResearchRocksDBRecoveryHelper.h"
#include "IResearchView.h"
#include "IResearchViewCoordinator.h"
#include "IResearchViewDBServer.h"
#include "Logger/LogMacros.h"
#include "MMFiles/MMFilesEngine.h"
#include "RestServer/ViewTypesFeature.h"
#include "RocksDBEngine/RocksDBEngine.h"
#include "StorageEngine/EngineSelectorFeature.h"
#include "StorageEngine/StorageEngine.h"
#include "StorageEngine/TransactionState.h"
#include "Transaction/Methods.h"
#include "VocBase/LogicalView.h"
NS_BEGIN(arangodb)
NS_BEGIN(basics)
class VPackStringBufferAdapter;
NS_END // basics
NS_BEGIN(aql) class Query;
NS_END // aql
NS_END // arangodb
NS_LOCAL
class IResearchLogTopic final : public arangodb::LogTopic {
public:
IResearchLogTopic(std::string const& name)
: arangodb::LogTopic(name, DEFAULT_LEVEL) {
setIResearchLogLevel(DEFAULT_LEVEL);
}
virtual void setLogLevel(arangodb::LogLevel level) override {
arangodb::LogTopic::setLogLevel(level);
setIResearchLogLevel(level);
}
private:
static arangodb::LogLevel const DEFAULT_LEVEL = arangodb::LogLevel::INFO;
typedef std::underlying_type<irs::logger::level_t>::type irsLogLevelType;
typedef std::underlying_type<arangodb::LogLevel>::type arangoLogLevelType;
static_assert(static_cast<irsLogLevelType>(irs::logger::IRL_FATAL) ==
static_cast<arangoLogLevelType>(arangodb::LogLevel::FATAL) - 1 &&
static_cast<irsLogLevelType>(irs::logger::IRL_ERROR) ==
static_cast<arangoLogLevelType>(arangodb::LogLevel::ERR) - 1 &&
static_cast<irsLogLevelType>(irs::logger::IRL_WARN) ==
static_cast<arangoLogLevelType>(arangodb::LogLevel::WARN) - 1 &&
static_cast<irsLogLevelType>(irs::logger::IRL_INFO) ==
static_cast<arangoLogLevelType>(arangodb::LogLevel::INFO) - 1 &&
static_cast<irsLogLevelType>(irs::logger::IRL_DEBUG) ==
static_cast<arangoLogLevelType>(arangodb::LogLevel::DEBUG) - 1 &&
static_cast<irsLogLevelType>(irs::logger::IRL_TRACE) ==
static_cast<arangoLogLevelType>(arangodb::LogLevel::TRACE) - 1,
"inconsistent log level mapping");
static void setIResearchLogLevel(arangodb::LogLevel level) {
if (level == arangodb::LogLevel::DEFAULT) {
level = DEFAULT_LEVEL;
}
auto irsLevel = static_cast<irs::logger::level_t>(
static_cast<arangoLogLevelType>(level) - 1); // -1 for DEFAULT
irsLevel = std::max(irsLevel, irs::logger::IRL_FATAL);
irsLevel = std::min(irsLevel, irs::logger::IRL_TRACE);
irs::logger::output_le(irsLevel, stderr);
}
}; // IResearchLogTopic
// template <char const *name>
arangodb::aql::AqlValue dummyFilterFunc(arangodb::aql::Query*,
arangodb::transaction::Methods*,
arangodb::SmallVector<arangodb::aql::AqlValue> const&) {
THROW_ARANGO_EXCEPTION_MESSAGE(
TRI_ERROR_NOT_IMPLEMENTED,
"ArangoSearch filter functions EXISTS, STARTS_WITH, IN_RANGE, PHRASE, MIN_MATCH, "
"BOOST and ANALYZER "
" are designed to be used only within a corresponding SEARCH statement "
"of ArangoSearch view."
" Please ensure function signature is correct.");
}
arangodb::aql::AqlValue dummyScorerFunc(arangodb::aql::Query*,
arangodb::transaction::Methods*,
arangodb::SmallVector<arangodb::aql::AqlValue> const&) {
THROW_ARANGO_EXCEPTION_MESSAGE(
TRI_ERROR_NOT_IMPLEMENTED,
"ArangoSearch scorer functions BM25() and TFIDF() are designed to "
"be used only outside SEARCH statement within a context of ArangoSearch "
"view."
" Please ensure function signature is correct.");
}
size_t computeThreadPoolSize(size_t threads, size_t threadsLimit) {
static const size_t MAX_THREADS = 8; // arbitrary limit on the upper bound of threads in pool
static const size_t MIN_THREADS = 1; // at least one thread is required
auto maxThreads = threadsLimit ? threadsLimit : MAX_THREADS;
return threads ? threads
: std::max(MIN_THREADS,
std::min(maxThreads,
size_t(std::thread::hardware_concurrency()) / 4));
}
void registerFunctions(arangodb::aql::AqlFunctionFeature& /*functions*/) {
#if 0
arangodb::iresearch::addFunction(functions, {
"__ARANGOSEARCH_SCORE_DEBUG", // name
".", // value to convert
arangodb::aql::Function::makeFlags(
arangodb::aql::Function::Flags::Deterministic,
arangodb::aql::Function::Flags::Cacheable,
arangodb::aql::Function::Flags::CanRunOnDBServer
),
[](arangodb::aql::Query*,
arangodb::transaction::Methods*,
arangodb::SmallVector<arangodb::aql::AqlValue> const& args) {
if (args.empty()) {
// no such input parameter. return NaN
return arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble(double_t(std::nan(""))));
} else {
// unsafe
VPackValueLength length;
auto const floatValue = *reinterpret_cast<float_t const*>(args[0].slice().getString(length));
return arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble(double_t(floatValue)));
}
}
});
#endif
}
void registerFilters(arangodb::aql::AqlFunctionFeature& functions) {
using arangodb::iresearch::addFunction;
auto flags =
arangodb::aql::Function::makeFlags(arangodb::aql::Function::Flags::Deterministic,
arangodb::aql::Function::Flags::Cacheable,
arangodb::aql::Function::Flags::CanRunOnDBServer);
addFunction(functions, {"EXISTS", ".|.,.", flags, &dummyFilterFunc}); // (attribute, [ "analyzer"|"type"|"string"|"numeric"|"bool"|"null" ])
addFunction(functions, {"STARTS_WITH", ".,.|.", flags, &dummyFilterFunc}); // (attribute, prefix, scoring-limit)
addFunction(functions, {"PHRASE", ".,.|.+", flags, &dummyFilterFunc}); // (attribute, input [, offset, input... ] [, analyzer])
addFunction(functions, {"IN_RANGE", ".,.,.,.,.", flags, &dummyFilterFunc}); // (attribute, lower, upper, include lower, include upper)
addFunction(functions, {"MIN_MATCH", ".,.|.+", flags, &dummyFilterFunc}); // (filter expression [, filter expression, ... ], min match count)
addFunction(functions, {"BOOST", ".,.", flags, &dummyFilterFunc}); // (filter expression, boost)
addFunction(functions, {"ANALYZER", ".,.", flags, &dummyFilterFunc}); // (filter expression, analyzer)
}
void registerIndexFactory() {
static const std::map<std::string, arangodb::IndexFactory::IndexTypeFactory> factories = {
{"ClusterEngine", arangodb::iresearch::IResearchLinkCoordinator::make},
{"MMFilesEngine", arangodb::iresearch::IResearchMMFilesLink::make},
{"RocksDBEngine", arangodb::iresearch::IResearchRocksDBLink::make}};
auto const& indexType = arangodb::iresearch::DATA_SOURCE_TYPE.name();
// register 'arangosearch' link
for (auto& entry : factories) {
auto* engine =
arangodb::application_features::ApplicationServer::lookupFeature<arangodb::StorageEngine>(
entry.first);
// valid situation if not running with the specified storage engine
if (!engine) {
LOG_TOPIC(WARN, arangodb::iresearch::TOPIC)
<< "failed to find feature '" << entry.first
<< "' while registering index type '" << indexType << "', skipping";
continue;
}
// ok to const-cast since this should only be called on startup
auto& indexFactory = const_cast<arangodb::IndexFactory&>(engine->indexFactory());
auto res = indexFactory.emplaceFactory(indexType, entry.second);
if (!res.ok()) {
THROW_ARANGO_EXCEPTION_MESSAGE(
res.errorNumber(),
std::string("failure registering IResearch link factory with index "
"factory from feature '") +
entry.first + "': " + res.errorMessage());
}
res = indexFactory.emplaceNormalizer(indexType, arangodb::iresearch::IResearchLinkHelper::normalize);
if (!res.ok()) {
THROW_ARANGO_EXCEPTION_MESSAGE(
res.errorNumber(),
std::string("failure registering IResearch link normalizer with "
"index factory from feature '") +
entry.first + "': " + res.errorMessage());
}
}
}
void registerScorers(arangodb::aql::AqlFunctionFeature& functions) {
irs::string_ref const args(".|+"); // positional arguments (attribute [, <scorer-specific properties>...]);
irs::scorers::visit([&functions, &args](irs::string_ref const& name,
irs::text_format::type_id const& args_format) -> bool {
// ArangoDB, for API consistency, only supports scorers configurable via jSON
if (irs::text_format::json != args_format) {
return true;
}
std::string upperName = name;
// AQL function external names are always in upper case
std::transform(upperName.begin(), upperName.end(), upperName.begin(), ::toupper);
arangodb::iresearch::addFunction(
functions,
{
std::move(upperName), args.c_str(),
arangodb::aql::Function::makeFlags(arangodb::aql::Function::Flags::Deterministic,
arangodb::aql::Function::Flags::Cacheable,
arangodb::aql::Function::Flags::CanRunOnDBServer),
&dummyScorerFunc // function implementation
});
return true;
});
}
void registerRecoveryHelper() {
auto helper = std::make_shared<arangodb::iresearch::IResearchRocksDBRecoveryHelper>();
auto res = arangodb::RocksDBEngine::registerRecoveryHelper(helper);
if (res.fail()) {
THROW_ARANGO_EXCEPTION_MESSAGE(
res.errorNumber(), "failed to register RocksDB recovery helper");
}
}
void registerViewFactory() {
auto& viewType = arangodb::iresearch::DATA_SOURCE_TYPE;
auto* viewTypes =
arangodb::application_features::ApplicationServer::lookupFeature<arangodb::ViewTypesFeature>();
if (!viewTypes) {
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_INTERNAL,
std::string("failed to find feature '") +
arangodb::ViewTypesFeature::name() +
"' while registering view type '" +
viewType.name() + "'");
}
arangodb::Result res;
// DB server in custer or single-server
if (arangodb::ServerState::instance()->isCoordinator()) {
res = viewTypes->emplace(viewType,
arangodb::iresearch::IResearchViewCoordinator::factory());
} else if (arangodb::ServerState::instance()->isDBServer()) {
res = viewTypes->emplace(viewType, arangodb::iresearch::IResearchViewDBServer::factory());
} else if (arangodb::ServerState::instance()->isSingleServer()) {
res = viewTypes->emplace(viewType, arangodb::iresearch::IResearchView::factory());
} else {
THROW_ARANGO_EXCEPTION_MESSAGE(
TRI_ERROR_FAILED,
std::string("Invalid role for arangosearch view creation."));
}
if (!res.ok()) {
THROW_ARANGO_EXCEPTION_MESSAGE(
res.errorNumber(),
std::string("failure registering arangosearch view factory: ") + res.errorMessage());
}
}
arangodb::Result transactionDataSourceRegistrationCallback(
arangodb::LogicalDataSource& dataSource, arangodb::transaction::Methods& trx) {
if (arangodb::iresearch::DATA_SOURCE_TYPE != dataSource.type()) {
return {}; // not an IResearchView (noop)
}
// TODO FIXME find a better way to look up a LogicalView
#ifdef ARANGODB_ENABLE_MAINTAINER_MODE
auto* view = dynamic_cast<arangodb::LogicalView*>(&dataSource);
#else
auto* view = static_cast<arangodb::LogicalView*>(&dataSource);
#endif
if (!view) {
LOG_TOPIC(WARN, arangodb::iresearch::TOPIC)
<< "failure to get LogicalView while processing a TransactionState by "
"IResearchFeature for name '"
<< dataSource.name() << "'";
return {TRI_ERROR_INTERNAL};
}
// TODO FIXME find a better way to look up an IResearch View
auto& impl = arangodb::LogicalView::cast<arangodb::iresearch::IResearchView>(*view);
return arangodb::Result(impl.apply(trx) ? TRI_ERROR_NO_ERROR : TRI_ERROR_INTERNAL);
}
void registerTransactionDataSourceRegistrationCallback() {
if (arangodb::ServerState::instance()->isSingleServer()) {
arangodb::transaction::Methods::addDataSourceRegistrationCallback(
&transactionDataSourceRegistrationCallback);
}
}
std::string const FEATURE_NAME("ArangoSearch");
IResearchLogTopic LIBIRESEARCH("libiresearch");
NS_END
NS_BEGIN(arangodb)
NS_BEGIN(iresearch)
bool isFilter(arangodb::aql::Function const& func) noexcept {
return func.implementation == &dummyFilterFunc;
}
bool isScorer(arangodb::aql::Function const& func) noexcept {
return func.implementation == &dummyScorerFunc;
}
class IResearchFeature::Async {
public:
typedef std::function<bool(size_t& timeoutMsec, bool timeout)> Fn;
explicit Async(size_t poolSize = 0);
Async(size_t poolSize, Async&& other);
~Async();
void emplace(std::shared_ptr<ResourceMutex> const& mutex, Fn&& fn); // add an asynchronous task
void notify() const; // notify all tasks
size_t poolSize() { return _pool.size(); }
void start();
private:
struct Pending {
Fn _fn; // the function to execute
std::shared_ptr<ResourceMutex> _mutex; // mutex for the task resources
std::chrono::system_clock::time_point _timeout; // when the task should be notified (std::chrono::milliseconds::max() == disabled)
Pending(std::shared_ptr<ResourceMutex> const& mutex, Fn&& fn)
: _fn(std::move(fn)),
_mutex(mutex),
_timeout(std::chrono::system_clock::time_point::max()) {}
};
struct Task : public Pending {
std::unique_lock<ReadMutex> _lock; // prevent resource deallocation
Task(Pending&& pending) : Pending(std::move(pending)) {}
};
struct Thread : public arangodb::Thread {
mutable std::condition_variable _cond; // trigger task run
mutable std::mutex _mutex; // mutex used with '_cond' and '_pending'
Thread* _next; // next thread in circular-list (never null!!!) (need to store pointer for move-assignment)
std::vector<Pending> _pending; // pending tasks
std::atomic<size_t> _size; // approximate size of the active+pending task list
std::vector<Task> _tasks; // the tasks to perform
std::atomic<bool>* _terminate; // trigger termination of this thread (need to store pointer for move-assignment)
mutable bool _wasNotified; // a notification was raised from another thread
Thread(std::string const& name)
: arangodb::Thread(name), _next(nullptr), _terminate(nullptr), _wasNotified(false) {}
Thread(Thread&& other) // used in constructor before tasks are started
: arangodb::Thread(other.name()),
_next(nullptr),
_terminate(nullptr),
_wasNotified(false) {}
virtual bool isSystem() override {
return true;
} // or start(...) will fail
virtual void run() override;
};
arangodb::basics::ConditionVariable _join; // mutex to join on
std::vector<Thread> _pool; // thread pool (size fixed for the entire life of object)
std::atomic<bool> _terminate; // unconditionaly terminate async tasks
void stop(Thread* redelegate = nullptr);
};
void IResearchFeature::Async::Thread::run() {
std::vector<Pending> pendingRedelegate;
std::chrono::system_clock::time_point timeout;
bool timeoutSet = false;
for (;;) {
bool onlyPending;
auto pendingStart = _tasks.size();
{
SCOPED_LOCK_NAMED(_mutex, lock); // aquire before '_terminate' check so that don't miss notify()
if (_terminate->load()) {
break; // termination requested
}
// transfer any new pending tasks into active tasks
for (auto& pending : _pending) {
_tasks.emplace_back(std::move(pending)); // will aquire resource lock
auto& task = _tasks.back();
if (task._mutex) {
task._lock = std::unique_lock<ReadMutex>(task._mutex->mutex(), std::try_to_lock);
if (!task._lock.owns_lock()) {
// if can't lock 'task._mutex' then reasign the task to the next worker
pendingRedelegate.emplace_back(std::move(task));
} else if (*(task._mutex)) {
continue; // resourceMutex acquisition successful
}
_tasks.pop_back(); // resource no longer valid
}
}
_pending.clear();
_size.store(_tasks.size());
// do not sleep if a notification was raised or pending tasks were added
if (_wasNotified || pendingStart < _tasks.size() || !pendingRedelegate.empty()) {
timeout = std::chrono::system_clock::now();
timeoutSet = true;
}
// sleep until timeout
if (!timeoutSet) {
_cond.wait(lock); // wait forever
} else {
_cond.wait_until(lock, timeout); // wait for timeout or notify
}
onlyPending = !_wasNotified && pendingStart < _tasks.size(); // process all tasks if a notification was raised
_wasNotified = false; // ignore notification since woke up
if (_terminate->load()) { // check again after sleep
break; // termination requested
}
}
timeoutSet = false;
// transfer some tasks to '_next' if have too many
if (!pendingRedelegate.empty() ||
(_size.load() > _next->_size.load() * 2 && _tasks.size() > 1)) {
SCOPED_LOCK(_next->_mutex);
// reasign to '_next' tasks that failed resourceMutex aquisition
while (!pendingRedelegate.empty()) {
_next->_pending.emplace_back(std::move(pendingRedelegate.back()));
pendingRedelegate.pop_back();
++_next->_size;
}
// transfer some tasks to '_next' if have too many
while (_size.load() > _next->_size.load() * 2 && _tasks.size() > 1) {
_next->_pending.emplace_back(std::move(_tasks.back()));
_tasks.pop_back();
++_next->_size;
--_size;
}
_next->_cond.notify_all(); // notify thread about a new task (thread may be sleeping indefinitely)
}
for (size_t i = onlyPending ? pendingStart : 0, count = _tasks.size(); // optimization to skip previously run tasks if a notificationw as not raised
i < count;) {
auto& task = _tasks[i];
auto exec = std::chrono::system_clock::now() >= task._timeout;
size_t timeoutMsec = 0; // by default reschedule for the same time span
try {
if (!task._fn(timeoutMsec, exec)) {
if (i + 1 < count) {
std::swap(task, _tasks[count - 1]); // swap 'i' with tail
}
_tasks.pop_back(); // remove stale tail
--count;
continue;
}
} catch (...) {
LOG_TOPIC(WARN, arangodb::iresearch::TOPIC)
<< "caught error while executing asynchronous task";
IR_LOG_EXCEPTION();
timeoutMsec = 0; // sleep until previously set timeout
}
// task reschedule time modification requested
if (timeoutMsec) {
task._timeout = std::chrono::system_clock::now() +
std::chrono::milliseconds(timeoutMsec);
}
timeout = timeoutSet ? std::min(timeout, task._timeout) : task._timeout;
timeoutSet = true;
++i;
}
}
// ...........................................................................
// move all tasks back into _pending in case the may neeed to be reasigned
// ...........................................................................
SCOPED_LOCK_NAMED(_mutex, lock); // '_pending' may be modified asynchronously
for (auto& task : pendingRedelegate) {
_pending.emplace_back(std::move(task));
}
for (auto& task : _tasks) {
_pending.emplace_back(std::move(task));
}
_tasks.clear();
}
IResearchFeature::Async::Async(size_t poolSize) : _terminate(false) {
poolSize = std::max(size_t(1), poolSize); // need at least one thread
for (size_t i = 0; i < poolSize; ++i) {
_pool.emplace_back(std::string("ArangoSearch #") + std::to_string(i));
}
auto* last = &(_pool.back());
// build circular list
for (auto& thread : _pool) {
last->_next = &thread;
last = &thread;
thread._terminate = &_terminate;
}
}
IResearchFeature::Async::Async(size_t poolSize, Async&& other)
: Async(poolSize) {
other.stop(&_pool[0]);
}
IResearchFeature::Async::~Async() { stop(); }
void IResearchFeature::Async::emplace(std::shared_ptr<ResourceMutex> const& mutex, Fn&& fn) {
if (!fn) {
return; // skip empty functers
}
auto& thread = _pool[0];
SCOPED_LOCK(thread._mutex);
thread._pending.emplace_back(mutex, std::move(fn));
++thread._size;
thread._cond.notify_all(); // notify thread about a new task (thread may be sleeping indefinitely)
}
void IResearchFeature::Async::notify() const {
// notify all threads
for (auto& thread : _pool) {
SCOPED_LOCK(thread._mutex);
thread._cond.notify_all();
thread._wasNotified = true;
}
}
void IResearchFeature::Async::start() {
// start threads
for (auto& thread : _pool) {
thread.start(&_join);
}
LOG_TOPIC(DEBUG, arangodb::iresearch::TOPIC)
<< "started " << _pool.size() << " ArangoSearch maintenance thread(s)";
}
void IResearchFeature::Async::stop(Thread* redelegate /*= nullptr*/) {
_terminate.store(true); // request stop asynchronous tasks
notify(); // notify all threads
CONDITION_LOCKER(lock, _join);
// join with all threads in pool
for (auto& thread : _pool) {
if (thread.hasStarted()) {
while (thread.isRunning()) {
_join.wait();
}
}
// redelegate all thread tasks if requested
if (redelegate) {
SCOPED_LOCK(redelegate->_mutex);
for (auto& task : thread._pending) {
redelegate->_pending.emplace_back(std::move(task));
++redelegate->_size;
}
thread._pending.clear();
redelegate->_cond.notify_all(); // notify thread about a new task (thread may be sleeping indefinitely)
}
}
}
IResearchFeature::IResearchFeature(arangodb::application_features::ApplicationServer& server)
: ApplicationFeature(server, IResearchFeature::name()),
_async(std::make_unique<Async>()),
_running(false),
_threads(0),
_threadsLimit(0) {
setOptional(true);
startsAfter("V8Phase");
startsAfter("IResearchAnalyzer"); // used for retrieving IResearch analyzers for functions
startsAfter("AQLFunctions");
}
void IResearchFeature::async(std::shared_ptr<ResourceMutex> const& mutex, Async::Fn&& fn) {
_async->emplace(mutex, std::move(fn));
}
void IResearchFeature::asyncNotify() const { _async->notify(); }
void IResearchFeature::beginShutdown() {
_running.store(false);
ApplicationFeature::beginShutdown();
}
void IResearchFeature::collectOptions(std::shared_ptr<arangodb::options::ProgramOptions> options) {
auto section = FEATURE_NAME;
_running.store(false);
std::transform(section.begin(), section.end(), section.begin(), ::tolower);
ApplicationFeature::collectOptions(options);
options->addSection(section,
std::string("Configure the ") + FEATURE_NAME + " feature");
options->addOption(std::string("--") + section + ".threads",
"the exact number of threads to use for asynchronous "
"tasks (0 == autodetect)",
new arangodb::options::UInt64Parameter(&_threads));
options->addOption(std::string("--") + section + ".threads-limit",
"upper limit to the autodetected number of threads to use "
"for asynchronous tasks (0 == use default)",
new arangodb::options::UInt64Parameter(&_threadsLimit));
}
/*static*/ std::string const& IResearchFeature::name() { return FEATURE_NAME; }
void IResearchFeature::prepare() {
if (!isEnabled()) {
return;
}
_running.store(false);
ApplicationFeature::prepare();
// load all known codecs
::iresearch::formats::init();
// load all known scorers
::iresearch::scorers::init();
// register 'arangosearch' index
registerIndexFactory();
// register 'arangosearch' view
registerViewFactory();
// register 'arangosearch' Transaction DataSource registration callback
registerTransactionDataSourceRegistrationCallback();
registerRecoveryHelper();
// start the async task thread pool
if (!ServerState::instance()->isCoordinator() && !ServerState::instance()->isAgent()) {
auto poolSize = computeThreadPoolSize(_threads, _threadsLimit);
if (_async->poolSize() != poolSize) {
_async = std::make_unique<Async>(poolSize, std::move(*_async));
}
_async->start();
}
}
void IResearchFeature::start() {
if (!isEnabled()) {
return;
}
ApplicationFeature::start();
// register IResearchView filters
{
auto* functions =
arangodb::application_features::ApplicationServer::lookupFeature<arangodb::aql::AqlFunctionFeature>(
"AQLFunctions");
if (functions) {
registerFilters(*functions);
registerScorers(*functions);
registerFunctions(*functions);
} else {
LOG_TOPIC(WARN, arangodb::iresearch::TOPIC)
<< "failure to find feature 'AQLFunctions' while registering "
"arangosearch filters";
}
}
_running.store(true);
}
void IResearchFeature::stop() {
if (!isEnabled()) {
return;
}
_running.store(false);
ApplicationFeature::stop();
}
void IResearchFeature::unprepare() {
if (!isEnabled()) {
return;
}
_running.store(false);
ApplicationFeature::unprepare();
}
void IResearchFeature::validateOptions(std::shared_ptr<arangodb::options::ProgramOptions> options) {
_running.store(false);
ApplicationFeature::validateOptions(options);
}
NS_END // iresearch
NS_END // arangodb
// -----------------------------------------------------------------------------
// --SECTION-- END-OF-FILE
// -----------------------------------------------------------------------------
Reference in New Issue View Git Blame Copy Permalink