mirror of
https://github.com/zeek/zeek.git
synced 2025-10-15 04:58:21 +00:00
153 lines
3.4 KiB
C++
153 lines
3.4 KiB
C++
#ifndef BRO_COMM_STORE_H
|
|
#define BRO_COMM_STORE_H
|
|
|
|
#include "broker/store.bif.h"
|
|
#include "broker/data.bif.h"
|
|
#include "Reporter.h"
|
|
#include "Type.h"
|
|
#include "Val.h"
|
|
#include "Trigger.h"
|
|
|
|
#include <broker/store/frontend.hh>
|
|
|
|
namespace bro_broker {
|
|
|
|
extern OpaqueType* opaque_of_store_handle;
|
|
|
|
/**
|
|
* Enumerates the possible types of data stores.
|
|
*/
|
|
enum StoreType {
|
|
// Just a view in to a remote store, contains no data itself.
|
|
FRONTEND,
|
|
MASTER,
|
|
CLONE,
|
|
};
|
|
|
|
/**
|
|
* Create a BrokerStore::QueryStatus value.
|
|
* @param success whether the query status should be set to success or failure.
|
|
* @return a BrokerStore::QueryStatus value.
|
|
*/
|
|
inline EnumVal* query_status(bool success)
|
|
{
|
|
static EnumType* store_query_status = nullptr;
|
|
static int success_val;
|
|
static int failure_val;
|
|
|
|
if ( ! store_query_status )
|
|
{
|
|
store_query_status = internal_type("BrokerStore::QueryStatus")->AsEnumType();
|
|
success_val = store_query_status->Lookup("BrokerStore", "SUCCESS");
|
|
failure_val = store_query_status->Lookup("BrokerStore", "FAILURE");
|
|
}
|
|
|
|
return new EnumVal(success ? success_val : failure_val, store_query_status);
|
|
}
|
|
|
|
/**
|
|
* @return a BrokerStore::QueryResult value that has a BrokerStore::QueryStatus indicating
|
|
* a failure.
|
|
*/
|
|
inline RecordVal* query_result()
|
|
{
|
|
auto rval = new RecordVal(BifType::Record::BrokerStore::QueryResult);
|
|
rval->Assign(0, query_status(false));
|
|
rval->Assign(1, new RecordVal(BifType::Record::BrokerComm::Data));
|
|
return rval;
|
|
}
|
|
|
|
/**
|
|
* @param data the result of the query.
|
|
* @return a BrokerStore::QueryResult value that has a BrokerStore::QueryStatus indicating
|
|
* a success.
|
|
*/
|
|
inline RecordVal* query_result(RecordVal* data)
|
|
{
|
|
auto rval = new RecordVal(BifType::Record::BrokerStore::QueryResult);
|
|
rval->Assign(0, query_status(true));
|
|
rval->Assign(1, data);
|
|
return rval;
|
|
}
|
|
|
|
/**
|
|
* Used for asynchronous data store queries which use "when" statements.
|
|
*/
|
|
class StoreQueryCallback {
|
|
public:
|
|
|
|
StoreQueryCallback(Trigger* arg_trigger, const CallExpr* arg_call,
|
|
broker::store::identifier arg_store_id,
|
|
StoreType arg_store_type)
|
|
: trigger(arg_trigger), call(arg_call), store_id(move(arg_store_id)),
|
|
store_type(arg_store_type)
|
|
{
|
|
Ref(trigger);
|
|
}
|
|
|
|
~StoreQueryCallback()
|
|
{
|
|
Unref(trigger);
|
|
}
|
|
|
|
void Result(RecordVal* result)
|
|
{
|
|
trigger->Cache(call, result);
|
|
trigger->Release();
|
|
Unref(result);
|
|
}
|
|
|
|
void Abort()
|
|
{
|
|
auto result = query_result();
|
|
trigger->Cache(call, result);
|
|
trigger->Release();
|
|
Unref(result);
|
|
}
|
|
|
|
bool Disabled() const
|
|
{ return trigger->Disabled(); }
|
|
|
|
const broker::store::identifier& StoreID() const
|
|
{ return store_id; }
|
|
|
|
StoreType GetStoreType() const
|
|
{ return store_type; }
|
|
|
|
private:
|
|
|
|
Trigger* trigger;
|
|
const CallExpr* call;
|
|
broker::store::identifier store_id;
|
|
StoreType store_type;
|
|
};
|
|
|
|
/**
|
|
* An opaque handle which wraps a Broker data store.
|
|
*/
|
|
class StoreHandleVal : public OpaqueVal {
|
|
public:
|
|
|
|
StoreHandleVal(broker::store::identifier id,
|
|
bro_broker::StoreType arg_type,
|
|
broker::util::optional<BifEnum::BrokerStore::BackendType> arg_back,
|
|
RecordVal* backend_options,
|
|
std::chrono::duration<double> resync = std::chrono::seconds(1));
|
|
|
|
void ValDescribe(ODesc* d) const override;
|
|
|
|
DECLARE_SERIAL(StoreHandleVal);
|
|
|
|
broker::store::frontend* store;
|
|
bro_broker::StoreType store_type;
|
|
broker::util::optional<BifEnum::BrokerStore::BackendType> backend_type;
|
|
|
|
protected:
|
|
|
|
StoreHandleVal()
|
|
{}
|
|
};
|
|
|
|
} // namespace bro_broker
|
|
|
|
#endif // BRO_COMM_STORE_H
|