Mirror/zeek
1
0
Fork 0
mirror of https://github.com/zeek/zeek.git synced 2025-10-02 06:38:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Move threading classes to zeek namespaces

Browse source
This commit is contained in:
Tim Wojtulewicz 2020-08-01 10:48:46 -07:00
parent f310795d79
commit 1262109e5a
42 changed files with 299 additions and 210 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/Stats.cc
View file

@ -211,9 +211,9 @@ void ProfileLogger::Log()
current_timers[i]));
}
file->Write(fmt("%0.6f Threads: current=%d\n", network_time, thread_mgr->NumThreads()));
file->Write(fmt("%0.6f Threads: current=%d\n", network_time, zeek::thread_mgr->NumThreads()));
const threading::Manager::msg_stats_list& thread_stats = thread_mgr->GetMsgThreadStats();
const threading::Manager::msg_stats_list& thread_stats = zeek::thread_mgr->GetMsgThreadStats();
for ( threading::Manager::msg_stats_list::const_iterator i = thread_stats.begin();
i != thread_stats.end(); ++i )
{

7
src/Val.cc
View file

@ -489,7 +489,8 @@ TableValPtr Val::GetRecordFields()
}
// This is a static method in this file to avoid including rapidjson's headers in Val.h because they're huge.
static void BuildJSON(threading::formatter::JSON::NullDoubleWriter& writer, Val* val, bool only_loggable=false, RE_Matcher* re=nullptr, const string& key="")
static void BuildJSON(zeek::threading::formatter::JSON::NullDoubleWriter& writer, Val* val,
bool only_loggable=false, RE_Matcher* re=nullptr, const string& key="")
{
if ( !key.empty() )
writer.Key(key);
@ -585,7 +586,7 @@ static void BuildJSON(threading::formatter::JSON::NullDoubleWriter& writer, Val*
else
{
rapidjson::StringBuffer buffer;
threading::formatter::JSON::NullDoubleWriter key_writer(buffer);
zeek::threading::formatter::JSON::NullDoubleWriter key_writer(buffer);
BuildJSON(key_writer, entry_key, only_loggable, re);
string key_str = buffer.GetString();
@ -689,7 +690,7 @@ static void BuildJSON(threading::formatter::JSON::NullDoubleWriter& writer, Val*
StringValPtr Val::ToJSON(bool only_loggable, RE_Matcher* re)
{
rapidjson::StringBuffer buffer;
threading::formatter::JSON::NullDoubleWriter writer(buffer);
zeek::threading::formatter::JSON::NullDoubleWriter writer(buffer);
BuildJSON(writer, this, only_loggable, re, "");

6
src/broker/Data.cc
View file

@ -1264,7 +1264,7 @@ bool bro_broker::RecordIterator::DoUnserialize(const broker::data& data)
return true;
}
broker::data bro_broker::threading_field_to_data(const threading::Field* f)
broker::data bro_broker::threading_field_to_data(const zeek::threading::Field* f)
{
auto name = f->name;
auto type = static_cast<uint64_t>(f->type);
@ -1279,7 +1279,7 @@ broker::data bro_broker::threading_field_to_data(const threading::Field* f)
return broker::vector({name, secondary, type, subtype, optional});
}
threading::Field* bro_broker::data_to_threading_field(broker::data d)
zeek::threading::Field* bro_broker::data_to_threading_field(broker::data d)
{
if ( ! caf::holds_alternative<broker::vector>(d) )
return nullptr;
@ -1297,7 +1297,7 @@ threading::Field* bro_broker::data_to_threading_field(broker::data d)
if ( secondary != broker::nil && ! caf::holds_alternative<std::string>(secondary) )
return nullptr;
return new threading::Field(name->c_str(),
return new zeek::threading::Field(name->c_str(),
secondary != broker::nil ? caf::get<std::string>(secondary).c_str() : nullptr,
static_cast<zeek::TypeTag>(*type),
static_cast<zeek::TypeTag>(*subtype),

37
src/broker/Data.h
View file

@ -6,10 +6,13 @@
#include "Expr.h"
ZEEK_FORWARD_DECLARE_NAMESPACED(ODesc, zeek);
namespace zeek::threading {
struct Value;
struct Field;
}
namespace threading {
struct Value;
struct Field;
using Value [[deprecated("Remove in v4.1. Use zeek::threading::Value.")]] = zeek::threading::Value;
using Field [[deprecated("Remove in v4.1. Use zeek::threading::Field.")]] = zeek::threading::Field;
}
namespace bro_broker {
@ -65,34 +68,34 @@ broker::expected<broker::data> val_to_data(const zeek::Val* v);
zeek::ValPtr data_to_val(broker::data d, zeek::Type* type);
/**
* Convert a Bro threading::Value to a Broker data value.
* @param v a Bro threading::Value.
* @return a Broker data value if the Bro threading::Value could be converted to one.
* Convert a zeek::threading::Value to a Broker data value.
* @param v a zeek::threading::Value.
* @return a Broker data value if the zeek::threading::Value could be converted to one.
*/
broker::expected<broker::data> threading_val_to_data(const threading::Value* v);
broker::expected<broker::data> threading_val_to_data(const zeek::threading::Value* v);
/**
* Convert a Bro threading::Field to a Broker data value.
* @param f a Bro threading::Field.
* @return a Broker data value if the Bro threading::Field could be converted to one.
* Convert a zeek::threading::Field to a Broker data value.
* @param f a zeek::threading::Field.
* @return a Broker data value if the zeek::threading::Field could be converted to one.
*/
broker::data threading_field_to_data(const threading::Field* f);
broker::data threading_field_to_data(const zeek::threading::Field* f);
/**
* Convert a Broker data value to a Bro threading::Value.
* Convert a Broker data value to a zeek::threading::Value.
* @param d a Broker data value.
* @return a pointer to a new Bro threading::Value or a nullptr if the conversion was not
* @return a pointer to a new zeek::threading::Value or a nullptr if the conversion was not
* possible.
*/
threading::Value* data_to_threading_val(broker::data d);
zeek::threading::Value* data_to_threading_val(broker::data d);
/**
* Convert a Broker data value to a Bro threading::Value.
* Convert a Broker data value to a zeek::threading::Value.
* @param d a Broker data value.
* @return a pointer to a new Bro threading::Value or a nullptr if the conversion was not
* @return a pointer to a new zeek::threading::Value or a nullptr if the conversion was not
* possible.
*/
threading::Field* data_to_threading_field(broker::data d);
zeek::threading::Field* data_to_threading_field(broker::data d);
/**
* A Bro value which wraps a Broker data value.

10
src/broker/Manager.cc
View file

@ -494,7 +494,7 @@ bool Manager::PublishIdentifier(std::string topic, std::string id)
bool Manager::PublishLogCreate(zeek::EnumVal* stream, zeek::EnumVal* writer,
const zeek::logging::WriterBackend::WriterInfo& info,
int num_fields, const threading::Field* const * fields,
int num_fields, const zeek::threading::Field* const * fields,
const broker::endpoint_info& peer)
{
if ( bstate->endpoint.is_shutdown() )
@ -550,7 +550,7 @@ bool Manager::PublishLogCreate(zeek::EnumVal* stream, zeek::EnumVal* writer,
}
bool Manager::PublishLogWrite(zeek::EnumVal* stream, zeek::EnumVal* writer, string path,
int num_fields, const threading::Value* const * vals)
int num_fields, const zeek::threading::Value* const * vals)
{
if ( bstate->endpoint.is_shutdown() )
return true;
@ -1260,7 +1260,7 @@ bool bro_broker::Manager::ProcessLogCreate(broker::zeek::LogCreate lc)
}
auto num_fields = fields_data->size();
auto fields = new threading::Field* [num_fields];
auto fields = new zeek::threading::Field* [num_fields];
for ( size_t i = 0; i < num_fields; ++i )
{
@ -1344,11 +1344,11 @@ bool bro_broker::Manager::ProcessLogWrite(broker::zeek::LogWrite lw)
return false;
}
auto vals = new threading::Value* [num_fields];
auto vals = new zeek::threading::Value* [num_fields];
for ( int i = 0; i < num_fields; ++i )
{
vals[i] = new threading::Value;
vals[i] = new zeek::threading::Value;
if ( ! vals[i]->Read(&fmt) )
{

4
src/broker/Manager.h
View file

@ -189,7 +189,7 @@ public:
bool PublishLogCreate(zeek::EnumVal* stream, zeek::EnumVal* writer,
const zeek::logging::WriterBackend::WriterInfo& info,
int num_fields,
const threading::Field* const * fields,
const zeek::threading::Field* const * fields,
const broker::endpoint_info& peer = NoPeer);
/**
@ -205,7 +205,7 @@ public:
*/
bool PublishLogWrite(zeek::EnumVal* stream, zeek::EnumVal* writer,
std::string path, int num_vals,
const threading::Value* const * vals);
const zeek::threading::Value* const * vals);
/**
* Automatically send an event to any interested peers whenever it is

4
src/input/Manager.cc
View file

@ -23,8 +23,8 @@
#include "../threading/SerialTypes.h"
using namespace std;
using threading::Value;
using threading::Field;
using zeek::threading::Value;
using zeek::threading::Field;
namespace zeek::input {

4
src/input/ReaderBackend.cc
View file

@ -4,8 +4,8 @@
#include "ReaderFrontend.h"
#include "Manager.h"
using threading::Value;
using threading::Field;
using zeek::threading::Value;
using zeek::threading::Field;
namespace zeek::input {

9
src/input/readers/ascii/Ascii.cc
View file

@ -12,10 +12,9 @@
#include "threading/SerialTypes.h"
using namespace threading;
using namespace std;
using threading::Value;
using threading::Field;
using zeek::threading::Value;
using zeek::threading::Field;
namespace zeek::input::reader::detail {
@ -114,8 +113,8 @@ bool Ascii::DoInit(const ReaderInfo& info, int num_fields, const Field* const* f
if ( set_separator.size() != 1 )
Error("set_separator length has to be 1. Separator will be truncated.");
formatter::Ascii::SeparatorInfo sep_info(separator, set_separator, unset_field, empty_field);
formatter = unique_ptr<threading::formatter::Formatter>(new formatter::Ascii(this, sep_info));
zeek::threading::formatter::Ascii::SeparatorInfo sep_info(separator, set_separator, unset_field, empty_field);
formatter = unique_ptr<zeek::threading::Formatter>(new zeek::threading::formatter::Ascii(this, sep_info));
return DoUpdate();
}

2
src/input/readers/ascii/Ascii.h
View file

@ -82,7 +82,7 @@ private:
bool fail_on_file_problem;
std::string path_prefix;
std::unique_ptr<threading::formatter::Formatter> formatter;
std::unique_ptr<zeek::threading::Formatter> formatter;
};
} // namespace zeek::input::reader::detail

20
src/input/readers/benchmark/Benchmark.cc
View file

@ -29,7 +29,7 @@ Benchmark::Benchmark(zeek::input::ReaderFrontend *frontend) : zeek::input::Reade
heartbeatstarttime = 0;
heartbeat_interval = double(zeek::BifConst::Threading::heartbeat_interval);
ascii = new threading::formatter::Ascii(this, threading::formatter::Ascii::SeparatorInfo());
ascii = new zeek::threading::formatter::Ascii(this, zeek::threading::formatter::Ascii::SeparatorInfo());
}
Benchmark::~Benchmark()
@ -43,7 +43,7 @@ void Benchmark::DoClose()
{
}
bool Benchmark::DoInit(const ReaderInfo& info, int num_fields, const Field* const* fields)
bool Benchmark::DoInit(const ReaderInfo& info, int num_fields, const zeek::threading::Field* const* fields)
{
num_lines = atoi(info.source);
@ -88,7 +88,7 @@ bool Benchmark::DoUpdate()
int linestosend = num_lines * heartbeat_interval;
for ( int i = 0; i < linestosend; i++ )
{
Value** field = new Value*[NumFields()];
zeek::threading::Value** field = new zeek::threading::Value*[NumFields()];
for (int j = 0; j < NumFields(); j++ )
field[j] = EntryToVal(Fields()[j]->type, Fields()[j]->subtype);
@ -124,9 +124,9 @@ bool Benchmark::DoUpdate()
return true;
}
threading::Value* Benchmark::EntryToVal(zeek::TypeTag type, zeek::TypeTag subtype)
zeek::threading::Value* Benchmark::EntryToVal(zeek::TypeTag type, zeek::TypeTag subtype)
{
Value* val = new Value(type, subtype, true);
auto* val = new zeek::threading::Value(type, subtype, true);
// basically construct something random from the fields that we want.
@ -189,7 +189,7 @@ threading::Value* Benchmark::EntryToVal(zeek::TypeTag type, zeek::TypeTag subtyp
// how many entries do we have...
unsigned int length = random() / (RAND_MAX / 15);
Value** lvals = new Value* [length];
zeek::threading::Value** lvals = new zeek::threading::Value* [length];
if ( type == zeek::TYPE_TABLE )
{
@ -209,7 +209,7 @@ threading::Value* Benchmark::EntryToVal(zeek::TypeTag type, zeek::TypeTag subtyp
for ( unsigned int pos = 0; pos < length; pos++ )
{
Value* newval = EntryToVal(subtype, zeek::TYPE_ENUM);
zeek::threading::Value* newval = EntryToVal(subtype, zeek::TYPE_ENUM);
if ( newval == nullptr )
{
Error("Error while reading set");
@ -250,10 +250,10 @@ bool Benchmark::DoHeartbeat(double network_time, double current_time)
if ( multiplication_factor != 1 || add != 0 )
{
// we have to document at what time we changed the factor to what value.
Value** v = new Value*[2];
v[0] = new Value(zeek::TYPE_COUNT, true);
zeek::threading::Value** v = new zeek::threading::Value*[2];
v[0] = new zeek::threading::Value(zeek::TYPE_COUNT, true);
v[0]->val.uint_val = num_lines;
v[1] = new Value(zeek::TYPE_TIME, true);
v[1] = new zeek::threading::Value(zeek::TYPE_TIME, true);
v[1]->val.double_val = CurrTime();
SendEvent("lines_changed", 2, v);

2
src/input/readers/benchmark/Benchmark.h
View file

@ -39,7 +39,7 @@ private:
double timedspread;
double heartbeat_interval;
threading::formatter::Ascii* ascii;
zeek::threading::formatter::Ascii* ascii;
};
} // namespace zeek::input::reader

4
src/input/readers/binary/Binary.cc
View file

@ -8,8 +8,8 @@
#include "threading/SerialTypes.h"
using namespace std;
using threading::Value;
using threading::Field;
using zeek::threading::Value;
using zeek::threading::Field;
namespace zeek::input::reader::detail {

10
src/input/readers/config/Config.cc
View file

@ -15,9 +15,8 @@
#include "input/Manager.h"
#include "threading/SerialTypes.h"
using namespace threading;
using threading::Value;
using threading::Field;
using zeek::threading::Value;
using zeek::threading::Field;
namespace zeek::input::reader::detail {
@ -72,8 +71,9 @@ bool Config::DoInit(const ReaderInfo& info, int num_fields, const Field* const*
empty_field.assign( (const char*) zeek::BifConst::InputConfig::empty_field->Bytes(),
zeek::BifConst::InputConfig::empty_field->Len());
formatter::Ascii::SeparatorInfo sep_info("\t", set_separator, "", empty_field);
formatter = std::unique_ptr<threading::formatter::Formatter>(new formatter::Ascii(this, sep_info));
zeek::threading::formatter::Ascii::SeparatorInfo sep_info("\t", set_separator, "", empty_field);
formatter = std::unique_ptr<zeek::threading::Formatter>(
new zeek::threading::formatter::Ascii(this, sep_info));
return DoUpdate();
}

2
src/input/readers/config/Config.h
View file

@ -49,7 +49,7 @@ private:
std::string set_separator;
std::string empty_field;
std::unique_ptr<threading::formatter::Formatter> formatter;
std::unique_ptr<zeek::threading::Formatter> formatter;
std::unordered_map<std::string, std::tuple<zeek::TypeTag, zeek::TypeTag>> option_types;
std::unordered_map<std::string, std::string> option_values;
};

4
src/input/readers/raw/Raw.cc
View file

@ -20,8 +20,8 @@ extern "C" {
#include "setsignal.h"
}
using threading::Value;
using threading::Field;
using zeek::threading::Value;
using zeek::threading::Field;
namespace zeek::input::reader::detail {

8
src/input/readers/sqlite/SQLite.cc
View file

@ -15,8 +15,8 @@
#include "threading/SerialTypes.h"
using threading::Value;
using threading::Field;
using zeek::threading::Value;
using zeek::threading::Field;
namespace zeek::input::reader::detail {
@ -39,8 +39,8 @@ SQLite::SQLite(zeek::input::ReaderFrontend *frontend)
zeek::BifConst::InputSQLite::empty_field->Len()
);
io = new threading::formatter::Ascii(this, threading::formatter::Ascii::SeparatorInfo(std::string(),
set_separator, unset_field, empty_field));
io = new zeek::threading::formatter::Ascii(this, zeek::threading::formatter::Ascii::SeparatorInfo(
std::string(), set_separator, unset_field, empty_field));
}
SQLite::~SQLite()

6
src/input/readers/sqlite/SQLite.h
View file

@ -21,7 +21,7 @@ public:
static zeek::input::ReaderBackend* Instantiate(zeek::input::ReaderFrontend* frontend) { return new SQLite(frontend); }
protected:
bool DoInit(const ReaderInfo& info, int arg_num_fields, const threading::Field* const* arg_fields) override;
bool DoInit(const ReaderInfo& info, int arg_num_fields, const zeek::threading::Field* const* arg_fields) override;
void DoClose() override;
bool DoUpdate() override;
bool DoHeartbeat(double network_time, double current_time) override { return true; }
@ -29,7 +29,7 @@ protected:
private:
bool checkError(int code);
threading::Value* EntryToVal(sqlite3_stmt *st, const threading::Field *field, int pos, int subpos);
zeek::threading::Value* EntryToVal(sqlite3_stmt *st, const zeek::threading::Field *field, int pos, int subpos);
const threading::Field* const * fields; // raw mapping
unsigned int num_fields;
@ -38,7 +38,7 @@ private:
std::string query;
sqlite3 *db;
sqlite3_stmt *st;
threading::formatter::Ascii* io;
zeek::threading::formatter::Ascii* io;
std::string set_separator;
std::string unset_field;

4
src/logging/WriterBackend.cc
View file

@ -11,8 +11,8 @@
// Messages sent from backend to frontend (i.e., "OutputMessages").
using threading::Value;
using threading::Field;
using zeek::threading::Value;
using zeek::threading::Field;
namespace zeek::logging {

24
src/logging/WriterFrontend.cc
View file

@ -7,18 +7,18 @@
#include "WriterFrontend.h"
#include "WriterBackend.h"
using threading::Value;
using threading::Field;
using zeek::threading::Value;
using zeek::threading::Field;
namespace zeek::logging {
// Messages sent from frontend to backend (i.e., "InputMessages").
class InitMessage final : public threading::InputMessage<WriterBackend>
class InitMessage final : public zeek::threading::InputMessage<WriterBackend>
{
public:
InitMessage(WriterBackend* backend, const int num_fields, const Field* const* fields)
: threading::InputMessage<WriterBackend>("Init", backend),
: zeek::threading::InputMessage<WriterBackend>("Init", backend),
num_fields(num_fields), fields(fields)
{}
@ -29,12 +29,12 @@ private:
const Field * const* fields;
};
class RotateMessage final : public threading::InputMessage<WriterBackend>
class RotateMessage final : public zeek::threading::InputMessage<WriterBackend>
{
public:
RotateMessage(WriterBackend* backend, WriterFrontend* frontend, const char* rotated_path, const double open,
const double close, const bool terminating)
: threading::InputMessage<WriterBackend>("Rotate", backend),
: zeek::threading::InputMessage<WriterBackend>("Rotate", backend),
frontend(frontend),
rotated_path(copy_string(rotated_path)), open(open),
close(close), terminating(terminating) { }
@ -51,11 +51,11 @@ private:
const bool terminating;
};
class WriteMessage final : public threading::InputMessage<WriterBackend>
class WriteMessage final : public zeek::threading::InputMessage<WriterBackend>
{
public:
WriteMessage(WriterBackend* backend, int num_fields, int num_writes, Value*** vals)
: threading::InputMessage<WriterBackend>("Write", backend),
: zeek::threading::InputMessage<WriterBackend>("Write", backend),
num_fields(num_fields), num_writes(num_writes), vals(vals) {}
bool Process() override { return Object()->Write(num_fields, num_writes, vals); }
@ -66,11 +66,11 @@ private:
Value ***vals;
};
class SetBufMessage final : public threading::InputMessage<WriterBackend>
class SetBufMessage final : public zeek::threading::InputMessage<WriterBackend>
{
public:
SetBufMessage(WriterBackend* backend, const bool enabled)
: threading::InputMessage<WriterBackend>("SetBuf", backend),
: zeek::threading::InputMessage<WriterBackend>("SetBuf", backend),
enabled(enabled) { }
bool Process() override { return Object()->SetBuf(enabled); }
@ -79,11 +79,11 @@ private:
const bool enabled;
};
class FlushMessage final : public threading::InputMessage<WriterBackend>
class FlushMessage final : public zeek::threading::InputMessage<WriterBackend>
{
public:
FlushMessage(WriterBackend* backend, double network_time)
: threading::InputMessage<WriterBackend>("Flush", backend),
: zeek::threading::InputMessage<WriterBackend>("Flush", backend),
network_time(network_time) {}
bool Process() override { return Object()->Flush(network_time); }

25
src/logging/writers/ascii/Ascii.cc
View file

@ -23,9 +23,8 @@
#include "ascii.bif.h"
using namespace std;
using namespace threading;
using threading::Value;
using threading::Field;
using zeek::threading::Value;
using zeek::threading::Field;
static constexpr auto shadow_file_prefix = ".shadow.";
@ -359,22 +358,22 @@ bool Ascii::InitFormatter()
if ( use_json )
{
formatter::JSON::TimeFormat tf = formatter::JSON::TS_EPOCH;
zeek::threading::formatter::JSON::TimeFormat tf = zeek::threading::formatter::JSON::TS_EPOCH;
// Write out JSON formatted logs.
if ( strcmp(json_timestamps.c_str(), "JSON::TS_EPOCH") == 0 )
tf = formatter::JSON::TS_EPOCH;
tf = zeek::threading::formatter::JSON::TS_EPOCH;
else if ( strcmp(json_timestamps.c_str(), "JSON::TS_MILLIS") == 0 )
tf = formatter::JSON::TS_MILLIS;
tf = zeek::threading::formatter::JSON::TS_MILLIS;
else if ( strcmp(json_timestamps.c_str(), "JSON::TS_ISO8601") == 0 )
tf = formatter::JSON::TS_ISO8601;
tf = zeek::threading::formatter::JSON::TS_ISO8601;
else
{
Error(Fmt("Invalid JSON timestamp format: %s", json_timestamps.c_str()));
return false;
}
formatter = new formatter::JSON(this, tf);
formatter = new zeek::threading::formatter::JSON(this, tf);
// Using JSON implicitly turns off the header meta fields.
include_meta = false;
}
@ -387,8 +386,8 @@ bool Ascii::InitFormatter()
// Use the default "Bro logs" format.
desc.EnableEscaping();
desc.AddEscapeSequence(separator);
formatter::Ascii::SeparatorInfo sep_info(separator, set_separator, unset_field, empty_field);
formatter = new formatter::Ascii(this, sep_info);
zeek::threading::formatter::Ascii::SeparatorInfo sep_info(separator, set_separator, unset_field, empty_field);
formatter = new zeek::threading::formatter::Ascii(this, sep_info);
}
return true;
@ -424,7 +423,7 @@ void Ascii::CloseFile(double t)
gzfile = nullptr;
}
bool Ascii::DoInit(const WriterInfo& info, int num_fields, const Field* const * fields)
bool Ascii::DoInit(const WriterInfo& info, int num_fields, const zeek::threading::Field* const * fields)
{
assert(! fd);
@ -596,8 +595,8 @@ bool Ascii::DoFinish(double network_time)
return true;
}
bool Ascii::DoWrite(int num_fields, const Field* const * fields,
Value** vals)
bool Ascii::DoWrite(int num_fields, const zeek::threading::Field* const * fields,
zeek::threading::Value** vals)
{
if ( ! fd )
DoInit(Info(), NumFields(), Fields());

8
src/logging/writers/ascii/Ascii.h
View file

@ -26,9 +26,9 @@ public:
protected:
bool DoInit(const WriterInfo& info, int num_fields,
const threading::Field* const* fields) override;
bool DoWrite(int num_fields, const threading::Field* const* fields,
threading::Value** vals) override;
const zeek::threading::Field* const* fields) override;
bool DoWrite(int num_fields, const zeek::threading::Field* const* fields,
zeek::threading::Value** vals) override;
bool DoSetBuf(bool enabled) override;
bool DoRotate(const char* rotated_path, double open,
double close, bool terminating) override;
@ -75,7 +75,7 @@ private:
bool enable_utf_8;
std::string json_timestamps;
threading::formatter::Formatter* formatter;
zeek::threading::Formatter* formatter;
bool init_options;
};

8
src/logging/writers/sqlite/SQLite.cc
View file

@ -12,8 +12,8 @@
#include "sqlite.bif.h"
using namespace std;
using threading::Value;
using threading::Field;
using zeek::threading::Value;
using zeek::threading::Field;
namespace zeek::logging::writer::detail {
@ -36,8 +36,8 @@ SQLite::SQLite(zeek::logging::WriterFrontend* frontend)
zeek::BifConst::LogSQLite::empty_field->Len()
);
threading::formatter::Ascii::SeparatorInfo sep_info(string(), set_separator, unset_field, empty_field);
io = new threading::formatter::Ascii(this, sep_info);
zeek::threading::formatter::Ascii::SeparatorInfo sep_info(string(), set_separator, unset_field, empty_field);
io = new zeek::threading::formatter::Ascii(this, sep_info);
}
SQLite::~SQLite()

2
src/logging/writers/sqlite/SQLite.h
View file

@ -49,7 +49,7 @@ private:
std::string unset_field;
std::string empty_field;
threading::formatter::Ascii* io;
zeek::threading::formatter::Ascii* io;
};
} // namespace zeek::logging::writer::detail

11
src/plugin/Plugin.h
View file

@ -21,6 +21,13 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(Event, zeek);
ZEEK_FORWARD_DECLARE_NAMESPACED(Func, zeek);
ZEEK_FORWARD_DECLARE_NAMESPACED(Frame, zeek::detail);
namespace zeek::threading {
struct Field;
}
namespace threading {
using Field [[deprecated("Remove in v4.1. Use zeek::threading::Field.")]] = zeek::threading::Field;
}
namespace zeek {
template <class T> class IntrusivePtr;
using ValPtr = zeek::IntrusivePtr<Val>;
@ -29,10 +36,6 @@ class Obj;
using BroObj [[deprecated("Remove in v4.1. Use zeek::Obj instead.")]] = zeek::Obj;
namespace threading {
struct Field;
}
namespace zeek::plugin {
class Manager;

2
src/stats.bif
View file

@ -339,7 +339,7 @@ function get_thread_stats%(%): ThreadStats
auto r = zeek::make_intrusive<zeek::RecordVal>(ThreadStats);
int n = 0;
r->Assign(n++, zeek::val_mgr->Count(thread_mgr->NumThreads()));
r->Assign(n++, zeek::val_mgr->Count(zeek::thread_mgr->NumThreads()));
return r;
%}

4
src/threading/BasicThread.cc
View file

@ -7,7 +7,7 @@
#include "Manager.h"
#include "util.h"
using namespace threading;
namespace zeek::threading {
static const int STD_FMT_BUF_LEN = 2048;
@ -193,3 +193,5 @@ void* BasicThread::launcher(void *arg)
return nullptr;
}
} // namespace zeek::threading

10
src/threading/BasicThread.h
View file

@ -1,14 +1,16 @@
#pragma once
#include "zeek-config.h"
#include <stdint.h>
#include <iosfwd>
#include <thread>
namespace threading {
ZEEK_FORWARD_DECLARE_NAMESPACED(Manager, zeek, threading);
class Manager;
namespace zeek::threading {
/**
* Base class for all threads.
@ -211,4 +213,8 @@ private:
static uint64_t thread_counter;
};
} // namespace zeek::threading
namespace threading {
using BasicThread [[deprecated("Remove in v4.1. Use zeek::threading::BasicThread.")]] = zeek::threading::BasicThread;
}

10
src/threading/Formatter.cc
View file

@ -8,10 +8,10 @@
#include "MsgThread.h"
#include "bro_inet_ntop.h"
using namespace threading;
using namespace formatter;
using threading::Value;
using threading::Field;
using zeek::threading::Value;
using zeek::threading::Field;
namespace zeek::threading {
Formatter::Formatter(threading::MsgThread* t)
{
@ -125,3 +125,5 @@ std::string Formatter::Render(TransportProto proto)
else
return "unknown";
}
} // namespace zeek::threading::formatter

12
src/threading/Formatter.h
View file

@ -7,11 +7,9 @@
#include "Type.h"
#include "SerialTypes.h"
namespace threading {
ZEEK_FORWARD_DECLARE_NAMESPACED(MsgThread, zeek, threading);
class MsgThread;
namespace formatter {
namespace zeek::threading {
/**
* A thread-safe class for converting values into some textual format. This
@ -164,4 +162,8 @@ private:
threading::MsgThread* thread;
};
}}
} // zeek::threading
namespace threading::formatter {
using Formatter [[deprecated("Remove in v4.1. Use zeek::threading::Formatter.")]] = zeek::threading::Formatter;
}

9
src/threading/Manager.cc
View file

@ -8,7 +8,8 @@
#include "Event.h"
#include "IPAddr.h"
using namespace threading;
namespace zeek::threading {
namespace detail {
void HeartbeatTimer::Dispatch(double t, bool is_expire)
{
@ -19,6 +20,8 @@ void HeartbeatTimer::Dispatch(double t, bool is_expire)
thread_mgr->StartHeartbeatTimer();
}
} // namespace detail
Manager::Manager()
{
DBG_LOG(zeek::DBG_THREADING, "Creating thread manager ...");
@ -127,7 +130,7 @@ void Manager::SendHeartbeats()
void Manager::StartHeartbeatTimer()
{
heartbeat_timer_running = true;
zeek::detail::timer_mgr->Add(new HeartbeatTimer(network_time + zeek::BifConst::Threading::heartbeat_interval));
zeek::detail::timer_mgr->Add(new detail::HeartbeatTimer(network_time + zeek::BifConst::Threading::heartbeat_interval));
}
// Raise everything in here as warnings so it is passed to scriptland without
@ -269,3 +272,5 @@ const threading::Manager::msg_stats_list& threading::Manager::GetMsgThreadStats(
return stats;
}
} // namespace zeek::threading

21
src/threading/Manager.h
View file

@ -7,7 +7,9 @@
#include <list>
#include <utility>
namespace zeek {
namespace threading {
namespace detail {
class HeartbeatTimer final : public zeek::detail::Timer {
public:
@ -21,6 +23,8 @@ protected:
void Init();
};
} // namespace detail
/**
* The thread manager coordinates all child threads. Once a BasicThread is
* instantitated, it gets addedd to the manager, which will delete it later
@ -103,7 +107,7 @@ public:
protected:
friend class BasicThread;
friend class MsgThread;
friend class HeartbeatTimer;
friend class detail::HeartbeatTimer;
/**
* Registers a new basic thread with the manager. This is
@ -151,10 +155,21 @@ private:
bool heartbeat_timer_running = false;
};
}
} // namespace threading
/**
* A singleton instance of the thread manager. All methods must only be
* called from Bro's main thread.
* called from Zeek's main thread.
*/
extern threading::Manager* thread_mgr;
} // namespace zeek
extern zeek::threading::Manager*& thread_mgr [[deprecated("Remove in v4.1. Use zeek::thread_mgr.")]];
namespace threading::detail {
using HeartbeatTimer [[deprecated("Remove in v4.1. Use zeek::threading::detail::HeartbeatTimer.")]] = zeek::threading::detail::HeartbeatTimer;
}
namespace threading {
using Manager [[deprecated("Remove in v4.1. Use zeek::threading::Manager.")]] = zeek::threading::Manager;
}

53
src/threading/MsgThread.cc
View file

@ -8,9 +8,11 @@
#include "Manager.h"
#include "iosource/Manager.h"
using namespace threading;
// Set by Zeek's main signal handler.
extern int signal_val;
namespace threading {
namespace zeek::threading {
namespace detail {
////// Messages.
@ -124,8 +126,6 @@ private:
};
#endif
}
// An event that the child wants to pass into the main event queue
class SendEventMessage final : public OutputMessage<MsgThread> {
public:
@ -151,13 +151,6 @@ private:
Value* *val;
};
////// Methods.
Message::~Message()
{
delete [] name;
}
bool ReporterMessage::Process()
{
switch ( type ) {
@ -197,6 +190,15 @@ bool ReporterMessage::Process()
return true;
}
} // namespace detail
////// Methods.
Message::~Message()
{
delete [] name;
}
MsgThread::MsgThread() : BasicThread(), queue_in(this, nullptr), queue_out(nullptr, this)
{
cnt_sent_in = cnt_sent_out = 0;
@ -219,9 +221,6 @@ MsgThread::~MsgThread()
zeek::iosource_mgr->UnregisterFd(flare.FD(), this);
}
// Set by Bro's main signal handler.
extern int signal_val;
void MsgThread::OnSignalStop()
{
if ( main_finished || Killed() || child_sent_finish )
@ -229,7 +228,7 @@ void MsgThread::OnSignalStop()
child_sent_finish = true;
// Signal thread to terminate.
SendIn(new FinishMessage(this, network_time), true);
SendIn(new detail::FinishMessage(this, network_time), true);
}
void MsgThread::OnWaitForStop()
@ -303,43 +302,43 @@ void MsgThread::Heartbeat()
if ( child_sent_finish )
return;
SendIn(new HeartbeatMessage(this, network_time, current_time()));
SendIn(new detail::HeartbeatMessage(this, network_time, current_time()));
}
void MsgThread::Finished()
{
child_finished = true;
SendOut(new FinishedMessage(this));
SendOut(new detail::FinishedMessage(this));
}
void MsgThread::Info(const char* msg)
{
SendOut(new ReporterMessage(ReporterMessage::INFO, this, msg));
SendOut(new detail::ReporterMessage(detail::ReporterMessage::INFO, this, msg));
}
void MsgThread::Warning(const char* msg)
{
SendOut(new ReporterMessage(ReporterMessage::WARNING, this, msg));
SendOut(new detail::ReporterMessage(detail::ReporterMessage::WARNING, this, msg));
}
void MsgThread::Error(const char* msg)
{
SendOut(new ReporterMessage(ReporterMessage::ERROR, this, msg));
SendOut(new detail::ReporterMessage(detail::ReporterMessage::ERROR, this, msg));
}
void MsgThread::FatalError(const char* msg)
{
SendOut(new ReporterMessage(ReporterMessage::FATAL_ERROR, this, msg));
SendOut(new detail::ReporterMessage(detail::ReporterMessage::FATAL_ERROR, this, msg));
}
void MsgThread::FatalErrorWithCore(const char* msg)
{
SendOut(new ReporterMessage(ReporterMessage::FATAL_ERROR_WITH_CORE, this, msg));
SendOut(new detail::ReporterMessage(detail::ReporterMessage::FATAL_ERROR_WITH_CORE, this, msg));
}
void MsgThread::InternalWarning(const char* msg)
{
SendOut(new ReporterMessage(ReporterMessage::INTERNAL_WARNING, this, msg));
SendOut(new detail::ReporterMessage(detail::ReporterMessage::INTERNAL_WARNING, this, msg));
}
void MsgThread::InternalError(const char* msg)
@ -353,7 +352,7 @@ void MsgThread::InternalError(const char* msg)
void MsgThread::Debug(zeek::DebugStream stream, const char* msg)
{
SendOut(new DebugMessage(stream, this, msg));
SendOut(new detail::DebugMessage(stream, this, msg));
}
#endif
@ -390,7 +389,7 @@ void MsgThread::SendOut(BasicOutputMessage* msg, bool force)
void MsgThread::SendEvent(const char* name, const int num_vals, Value* *vals)
{
SendOut(new SendEventMessage(this, name, num_vals, vals));
SendOut(new detail::SendEventMessage(this, name, num_vals, vals));
}
BasicOutputMessage* MsgThread::RetrieveOut()
@ -440,7 +439,7 @@ void MsgThread::Run()
// after all other outgoing messages (in particular
// error messages have been processed by then main
// thread).
SendOut(new KillMeMessage(this));
SendOut(new detail::KillMeMessage(this));
failed = true;
}
}
@ -483,3 +482,5 @@ void MsgThread::Process()
delete msg;
}
}
} // namespace zeek::threading

39
src/threading/MsgThread.h
View file

@ -8,13 +8,29 @@
#include "iosource/IOSource.h"
#include "Flare.h"
namespace zeek::threading {
struct Value;
struct Field;
}
namespace threading {
using Value [[deprecated("Remove in v4.1. Use zeek::threading::Value.")]] = zeek::threading::Value;
using Field [[deprecated("Remove in v4.1. Use zeek::threading::Field.")]] = zeek::threading::Field;
}
namespace zeek::threading {
class BasicInputMessage;
class BasicOutputMessage;
namespace detail {
// These classes are marked as friends later so they need to be forward declared.
class HeartbeatMessage;
struct Value;
struct Field;
class FinishMessage;
class FinishedMessage;
class KillMeMessage;
}
/**
* A specialized thread that provides bi-directional message passing between
@ -205,10 +221,10 @@ public:
protected:
friend class Manager;
friend class HeartbeatMessage;
friend class FinishMessage;
friend class FinishedMessage;
friend class KillMeMessage;
friend class detail::HeartbeatMessage;
friend class detail::FinishMessage;
friend class detail::FinishedMessage;
friend class detail::KillMeMessage;
/**
* Pops a message sent by the child from the child-to-main queue.
@ -464,4 +480,13 @@ private:
O* object;
};
}
} // namespace zeek::threading
namespace threading {
using MsgThread [[deprecated("Remove in v4.1. Use zeek::threading::MsgThread.")]] = zeek::threading::MsgThread;
using Message [[deprecated("Remove in v4.1. Use zeek::threading::Message.")]] = zeek::threading::Message;
using BasicInputMessage [[deprecated("Remove in v4.1. Use zeek::threading::BasicInputMessage.")]] = zeek::threading::BasicInputMessage;
using BasicOutputMessage [[deprecated("Remove in v4.1. Use zeek::threading::BasicOutputMessage.")]] = zeek::threading::BasicOutputMessage;
template<typename O> using InputMessage [[deprecated("Remove in v4.1. Use zeek::threading::InputMessage.")]] = zeek::threading::InputMessage<O>;
template<typename O> using OutputMessage [[deprecated("Remove in v4.1. Use zeek::threading::OutputMessage.")]] = zeek::threading::OutputMessage<O>;
} // namespace threading

6
src/threading/Queue.h
View file

@ -12,7 +12,7 @@
#undef Queue // Defined elsewhere unfortunately.
namespace threading {
namespace zeek::threading {
/**
* A thread-safe single-reader single-writer queue.
@ -261,4 +261,8 @@ inline void Queue<T>::WakeUp()
}
}
} // namespace zeek::threading
namespace threading {
template<typename T> using Queue [[deprecated("Remove in v4.1. Use zeek::threading::Queue.")]] = zeek::threading::Queue<T>;
}

4
src/threading/SerialTypes.cc
View file

@ -14,7 +14,7 @@
#include "Scope.h"
#include "IPAddr.h"
using namespace threading;
namespace zeek::threading {
bool Field::Read(zeek::detail::SerializationFormat* fmt)
{
@ -636,3 +636,5 @@ zeek::Val* Value::ValueToVal(const std::string& source, const Value* val, bool&
assert(false);
return nullptr;
}
} // namespace zeek::threading

7
src/threading/SerialTypes.h
View file

@ -11,7 +11,7 @@
ZEEK_FORWARD_DECLARE_NAMESPACED(SerializationFormat, zeek::detail);
namespace threading {
namespace zeek::threading {
/**
* Definition of a log file, i.e., one column of a log stream.
@ -214,4 +214,9 @@ private:
Value(const Value& other) = delete;
};
} // namespace zeek::threading
namespace threading {
using Field [[deprecated("Remove in v4.1. Use zeek::threading::Field.")]] = zeek::threading::Field;
using Value [[deprecated("Remove in v4.1. Use zeek::threading::Value.")]] = zeek::threading::Value;
}

25
src/threading/formatters/Ascii.cc
View file

@ -10,7 +10,8 @@
#include <errno.h>
using namespace std;
using namespace threading::formatter;
namespace zeek::threading::formatter {
// If the value we'd write out would match exactly the a reserved string, we
// escape the first character so that the output won't be ambigious. If this
@ -47,7 +48,7 @@ Ascii::SeparatorInfo::SeparatorInfo(const string& arg_separator,
empty_field = arg_empty_field;
}
Ascii::Ascii(threading::MsgThread* t, const SeparatorInfo& info) : Formatter(t)
Ascii::Ascii(zeek::threading::MsgThread* t, const SeparatorInfo& info) : zeek::threading::Formatter(t)
{
separators = info;
}
@ -56,8 +57,8 @@ Ascii::~Ascii()
{
}
bool Ascii::Describe(zeek::ODesc* desc, int num_fields, const threading::Field* const * fields,
threading::Value** vals) const
bool Ascii::Describe(zeek::ODesc* desc, int num_fields, const zeek::threading::Field* const * fields,
zeek::threading::Value** vals) const
{
for ( int i = 0; i < num_fields; i++ )
{
@ -71,7 +72,7 @@ bool Ascii::Describe(zeek::ODesc* desc, int num_fields, const threading::Field*
return true;
}
bool Ascii::Describe(zeek::ODesc* desc, threading::Value* val, const string& name) const
bool Ascii::Describe(zeek::ODesc* desc, zeek::threading::Value* val, const string& name) const
{
if ( ! val->present )
{
@ -207,12 +208,12 @@ bool Ascii::Describe(zeek::ODesc* desc, threading::Value* val, const string& nam
}
threading::Value* Ascii::ParseValue(const string& s, const string& name, zeek::TypeTag type, zeek::TypeTag subtype) const
zeek::threading::Value* Ascii::ParseValue(const string& s, const string& name, zeek::TypeTag type, zeek::TypeTag subtype) const
{
if ( ! separators.unset_field.empty() && s.compare(separators.unset_field) == 0 ) // field is not set...
return new threading::Value(type, false);
return new zeek::threading::Value(type, false);
threading::Value* val = new threading::Value(type, subtype, true);
zeek::threading::Value* val = new zeek::threading::Value(type, subtype, true);
const char* start = s.c_str();
char* end = nullptr;
errno = 0;
@ -373,7 +374,7 @@ threading::Value* Ascii::ParseValue(const string& s, const string& name, zeek::T
if ( separators.empty_field.empty() && s.empty() )
length = 0;
threading::Value** lvals = new threading::Value* [length];
zeek::threading::Value** lvals = new zeek::threading::Value* [length];
if ( type == zeek::TYPE_TABLE )
{
@ -409,7 +410,7 @@ threading::Value* Ascii::ParseValue(const string& s, const string& name, zeek::T
break;
}
threading::Value* newval = ParseValue(element, name, subtype);
zeek::threading::Value* newval = ParseValue(element, name, subtype);
if ( newval == nullptr )
{
GetThread()->Warning("Error while reading set or vector");
@ -474,7 +475,7 @@ parse_error:
bool Ascii::CheckNumberError(const char* start, const char* end) const
{
threading::MsgThread* thread = GetThread();
zeek::threading::MsgThread* thread = GetThread();
if ( end == start && *end != '\0' ) {
thread->Warning(thread->Fmt("String '%s' contained no parseable number", start));
@ -504,3 +505,5 @@ bool Ascii::CheckNumberError(const char* start, const char* end) const
return false;
}
} // namespace zeek::threading::formatter

20
src/threading/formatters/Ascii.h
View file

@ -4,9 +4,9 @@
#include "../Formatter.h"
namespace threading { namespace formatter {
namespace zeek::threading::formatter {
class Ascii final : public Formatter {
class Ascii final : public zeek::threading::Formatter {
public:
/**
* A struct to pass the necessary configuration values to the
@ -44,13 +44,13 @@ public:
* @param info SeparatorInfo structure defining the necessary
* separators.
*/
Ascii(threading::MsgThread* t, const SeparatorInfo& info);
Ascii(zeek::threading::MsgThread* t, const SeparatorInfo& info);
virtual ~Ascii();
virtual bool Describe(zeek::ODesc* desc, threading::Value* val, const std::string& name = "") const;
virtual bool Describe(zeek::ODesc* desc, int num_fields, const threading::Field* const * fields,
threading::Value** vals) const;
virtual threading::Value* ParseValue(const std::string& s, const std::string& name,
virtual bool Describe(zeek::ODesc* desc, zeek::threading::Value* val, const std::string& name = "") const;
virtual bool Describe(zeek::ODesc* desc, int num_fields, const zeek::threading::Field* const * fields,
zeek::threading::Value** vals) const;
virtual zeek::threading::Value* ParseValue(const std::string& s, const std::string& name,
zeek::TypeTag type, zeek::TypeTag subtype = zeek::TYPE_ERROR) const;
private:
@ -59,4 +59,8 @@ private:
SeparatorInfo separators;
};
}}
} // namespace zeek::threading::formatter
namespace threading::formatter {
using Ascii [[deprecated("Remove in v4.1. Use zeek::threading::formatter::Ascii.")]] = zeek::threading::formatter::Ascii;
}

17
src/threading/formatters/JSON.cc
View file

@ -16,7 +16,7 @@
#include <math.h>
#include <stdint.h>
using namespace threading::formatter;
namespace zeek::threading::formatter {
bool JSON::NullDoubleWriter::Double(double d)
{
@ -26,7 +26,7 @@ bool JSON::NullDoubleWriter::Double(double d)
return rapidjson::Writer<rapidjson::StringBuffer>::Double(d);
}
JSON::JSON(MsgThread* t, TimeFormat tf) : Formatter(t), surrounding_braces(true)
JSON::JSON(zeek::threading::MsgThread* t, TimeFormat tf) : zeek::threading::Formatter(t), surrounding_braces(true)
{
timestamps = tf;
}
@ -35,8 +35,8 @@ JSON::~JSON()
{
}
bool JSON::Describe(zeek::ODesc* desc, int num_fields, const Field* const * fields,
Value** vals) const
bool JSON::Describe(zeek::ODesc* desc, int num_fields, const zeek::threading::Field* const * fields,
zeek::threading::Value** vals) const
{
rapidjson::StringBuffer buffer;
NullDoubleWriter writer(buffer);
@ -55,7 +55,7 @@ bool JSON::Describe(zeek::ODesc* desc, int num_fields, const Field* const * fiel
return true;
}
bool JSON::Describe(zeek::ODesc* desc, Value* val, const std::string& name) const
bool JSON::Describe(zeek::ODesc* desc, zeek::threading::Value* val, const std::string& name) const
{
if ( desc->IsBinary() )
{
@ -78,13 +78,14 @@ bool JSON::Describe(zeek::ODesc* desc, Value* val, const std::string& name) cons
return true;
}
threading::Value* JSON::ParseValue(const std::string& s, const std::string& name, zeek::TypeTag type, zeek::TypeTag subtype) const
zeek::threading::Value* JSON::ParseValue(const std::string& s, const std::string& name,
zeek::TypeTag type, zeek::TypeTag subtype) const
{
GetThread()->Error("JSON formatter does not support parsing yet.");
return nullptr;
}
void JSON::BuildJSON(NullDoubleWriter& writer, Value* val, const std::string& name) const
void JSON::BuildJSON(NullDoubleWriter& writer, zeek::threading::Value* val, const std::string& name) const
{
if ( ! val->present )
{
@ -204,3 +205,5 @@ void JSON::BuildJSON(NullDoubleWriter& writer, Value* val, const std::string& na
break;
}
}
} // namespace zeek::threading::formatter

22
src/threading/formatters/JSON.h
View file

@ -8,13 +8,13 @@
#include "../Formatter.h"
namespace threading { namespace formatter {
namespace zeek::threading::formatter {
/**
* A thread-safe class for converting values into a JSON representation
* and vice versa.
*/
class JSON : public Formatter {
class JSON : public zeek::threading::Formatter {
public:
enum TimeFormat {
TS_EPOCH, // Doubles that represents seconds from the UNIX epoch.
@ -22,13 +22,13 @@ public:
TS_MILLIS // Milliseconds from the UNIX epoch. Some consumers need this (e.g., elasticsearch).
};
JSON(threading::MsgThread* t, TimeFormat tf);
JSON(zeek::threading::MsgThread* t, TimeFormat tf);
~JSON() override;
bool Describe(zeek::ODesc* desc, threading::Value* val, const std::string& name = "") const override;
bool Describe(zeek::ODesc* desc, int num_fields, const threading::Field* const * fields,
threading::Value** vals) const override;
threading::Value* ParseValue(const std::string& s, const std::string& name, zeek::TypeTag type,
bool Describe(zeek::ODesc* desc, zeek::threading::Value* val, const std::string& name = "") const override;
bool Describe(zeek::ODesc* desc, int num_fields, const zeek::threading::Field* const * fields,
zeek::threading::Value** vals) const override;
zeek::threading::Value* ParseValue(const std::string& s, const std::string& name, zeek::TypeTag type,
zeek::TypeTag subtype = zeek::TYPE_ERROR) const override;
class NullDoubleWriter : public rapidjson::Writer<rapidjson::StringBuffer> {
@ -38,10 +38,14 @@ public:
};
private:
void BuildJSON(NullDoubleWriter& writer, Value* val, const std::string& name = "") const;
void BuildJSON(NullDoubleWriter& writer, zeek::threading::Value* val, const std::string& name = "") const;
TimeFormat timestamps;
bool surrounding_braces;
};
}}
} // namespace zeek::threading::formatter
namespace threading::formatter {
using JSON [[deprecated("Remove in v4.1. Use zeek::threading::formatter::JSON.")]] = zeek::threading::formatter::JSON;
}

7
src/zeek-setup.cc
View file

@ -104,7 +104,8 @@ zeek::detail::TimerMgr*& timer_mgr = zeek::detail::timer_mgr;
zeek::logging::Manager* zeek::log_mgr = nullptr;
zeek::logging::Manager*& log_mgr = zeek::log_mgr;
threading::Manager* thread_mgr = nullptr;
zeek::threading::Manager* zeek::thread_mgr = nullptr;
zeek::threading::Manager*& thread_mgr = zeek::thread_mgr;
zeek::input::Manager* zeek::input_mgr = nullptr;
zeek::input::Manager*& input_mgr = zeek::input_mgr;
zeek::file_analysis::Manager* zeek::file_mgr = nullptr;
@ -309,7 +310,7 @@ void terminate_bro()
notifier::registry.Terminate();
zeek::log_mgr->Terminate();
zeek::input_mgr->Terminate();
thread_mgr->Terminate();
zeek::thread_mgr->Terminate();
broker_mgr->Terminate();
zeek::detail::dns_mgr->Terminate();
@ -485,7 +486,7 @@ zeek::detail::SetupResult zeek::detail::setup(int argc, char** argv,
zeek::val_mgr = new ValManager();
reporter = new Reporter(options.abort_on_scripting_errors);
thread_mgr = new threading::Manager();
zeek::thread_mgr = new threading::Manager();
zeek::plugin_mgr = new zeek::plugin::Manager();
#ifdef DEBUG