Skip to content

Commit

Permalink
Replaced all FooEventConsoleColumns by their respective FooLambdaColu…
Browse files Browse the repository at this point in the history 
…mns.

Change-Id: I625d7684991406745cc179387b3e38f4dcf41d77
  • Loading branch information
@spt29
spt29 committed Sep 18, 2020
1 parent 185f334 commit 6c9c582
Show file tree
Hide file tree
Showing 6 changed files with 216 additions and 207 deletions.
70 changes: 65 additions & 5 deletions livestatus/src/TableEventConsole.cc
View file
Expand Up @@ -6,7 +6,9 @@
#include "TableEventConsole.h"

#include <algorithm> // IWYU pragma: keep
#include <chrono>
#include <cstdlib>
#include <ctime>
#include <filesystem>
#include <functional> // IWYU pragma: keep
#include <iosfwd>
Expand All @@ -19,9 +21,13 @@

#include "Column.h"
#include "EventConsoleConnection.h"
#include "ListColumn.h"
#include "Logger.h"
#include "MonitoringCore.h"
#include "Query.h"
#include "Row.h"
#include "StringColumn.h"
#include "StringUtils.h"
#include "auth.h"

using namespace std::chrono_literals;
Expand Down Expand Up @@ -158,6 +164,57 @@ ECRow::ECRow(MonitoringCore *mc, const std::vector<std::string> &headers,
host_ = it == map_.end() ? nullptr : mc->getHostByDesignation(it->second);
}

// static
std::unique_ptr<StringLambdaColumn<ECRow>> ECRow::makeStringColumn(
const std::string &name, const std::string &description,
const ColumnOffsets &offsets) {
return std::make_unique<StringLambdaColumn<ECRow>>(
name, description, offsets,
[name](const ECRow &r) { return r.getString(name); });
}

// static
std::unique_ptr<IntLambdaColumn<ECRow>> ECRow::makeIntColumn(
const std::string &name, const std::string &description,
const ColumnOffsets &offsets) {
return std::make_unique<IntLambdaColumn<ECRow>>(
name, description, offsets,
[name](const ECRow &r) { return r.getInt(name); });
}

// static
std::unique_ptr<DoubleLambdaColumn<ECRow>> ECRow::makeDoubleColumn(
const std::string &name, const std::string &description,
const ColumnOffsets &offsets) {
return std::make_unique<DoubleLambdaColumn<ECRow>>(
name, description, offsets,
[name](const ECRow &r) { return r.getDouble(name); });
}

// static
std::unique_ptr<TimeLambdaColumn<ECRow>> ECRow::makeTimeColumn(
const std::string &name, const std::string &description,
const ColumnOffsets &offsets) {
return std::make_unique<TimeLambdaColumn<ECRow>>(
name, description, offsets, [name](const ECRow &r) {
return std::chrono::system_clock::from_time_t(
static_cast<std::time_t>(r.getDouble(name)));
});
}

// static
std::unique_ptr<ListLambdaColumn<ECRow>> ECRow::makeListColumn(
const std::string &name, const std::string &description,
const ColumnOffsets &offsets) {
return std::make_unique<ListLambdaColumn<ECRow>>(
name, description, offsets, [name](const ECRow &r) {
auto result = r.getString(name);
return result.empty() || result == "\002"
? std::vector<std::string>()
: mk::split(result.substr(1), '\001');
});
}

std::string ECRow::getString(const std::string &column_name) const {
return get(column_name, "");
}
Expand Down Expand Up @@ -196,7 +253,7 @@ bool TableEventConsole::isAuthorizedForEvent(Row row,
const auto *c = reinterpret_cast<const MonitoringCore::Contact *>(ctc);
// NOTE: Further filtering in the GUI for mkeventd.seeunrelated permission
bool result = true;
auto precedence = std::static_pointer_cast<StringEventConsoleColumn>(
auto precedence = std::static_pointer_cast<StringColumn>(
column("event_contact_groups_precedence"))
->getValue(row);
if (precedence == "rule") {
Expand All @@ -215,10 +272,13 @@ bool TableEventConsole::isAuthorizedForEvent(Row row,

bool TableEventConsole::isAuthorizedForEventViaContactGroups(
const MonitoringCore::Contact *ctc, Row row, bool &result) const {
auto col = std::static_pointer_cast<ListEventConsoleColumn>(
column("event_contact_groups"));
if (col->isNone(row)) {
return false;
auto col =
std::static_pointer_cast<ListColumn>(column("event_contact_groups"));
if (const auto *r = col->columnData<ECRow>(row)) {
// TODO(sp) This check for None is a hack...
if (r->getString(col->name()) == "\002") {
return false;
}
}
for (const auto &name : col->getValue(row, unknown_auth_user(), 0s)) {
if (core()->is_contact_member_of_contactgroup(
Expand Down
124 changes: 29 additions & 95 deletions livestatus/src/TableEventConsole.h
View file
Expand Up @@ -8,33 +8,53 @@

#include "config.h" // IWYU pragma: keep

#include <chrono>
#include <cstdint>
#include <ctime>
#include <map>
#include <memory>
#include <string>
#include <vector>

#include "DoubleColumn.h"
#include "IntColumn.h"
#include "ListColumn.h"
#include "DoubleLambdaColumn.h" // IWYU pragma: keep
#include "IntLambdaColumn.h" // IWYU pragma: keep
#include "ListLambdaColumn.h" // IWYU pragma: keep
#include "MonitoringCore.h"
#include "Row.h"
#include "StringColumn.h"
#include "StringUtils.h"
#include "StringLambdaColumn.h" // IWYU pragma: keep
#include "Table.h"
#include "TimeColumn.h"
#include "TimeLambdaColumn.h" // IWYU pragma: keep
#include "nagios.h"
class ColumnOffsets;
class Query;
class Row;

// NOTE: We have a few "keep" pragmas above to avoid the insane handling of
// template foward declarations, when the templates have parameters with
// defaults. Yet another example "simple things gone wrong"... :-/

class ECRow {
public:
ECRow(MonitoringCore *mc, const std::vector<std::string> &headers,
const std::vector<std::string> &columns);

static std::unique_ptr<StringLambdaColumn<ECRow>> makeStringColumn(
const std::string &name, const std::string &description,
const ColumnOffsets &offsets);
static std::unique_ptr<IntLambdaColumn<ECRow>> makeIntColumn(
const std::string &name, const std::string &description,
const ColumnOffsets &offsets);
static std::unique_ptr<DoubleLambdaColumn<ECRow>> makeDoubleColumn(
const std::string &name, const std::string &description,
const ColumnOffsets &offsets);
static std::unique_ptr<TimeLambdaColumn<ECRow>> makeTimeColumn(
const std::string &name, const std::string &description,
const ColumnOffsets &offsets);
static std::unique_ptr<ListLambdaColumn<ECRow>> makeListColumn(
const std::string &name, const std::string &description,
const ColumnOffsets &offsets);

[[nodiscard]] std::string getString(const std::string &column_name) const;
[[nodiscard]] int32_t getInt(const std::string &column_name) const;
[[nodiscard]] double getDouble(const std::string &column_name) const;

[[nodiscard]] const MonitoringCore::Host *host() const;

private:
Expand All @@ -52,92 +72,6 @@ class TableEventConsole : public Table {
void answerQuery(Query *query) override;

protected:
struct StringEventConsoleColumn : public StringColumn {
StringEventConsoleColumn(const std::string &name,
const std::string &description,
const ColumnOffsets &offsets)
: StringColumn(name, description, offsets) {}

[[nodiscard]] std::string getValue(Row row) const override {
if (const auto *r = columnData<ECRow>(row)) {
return r->getString(name());
}
return "";
}
};

struct IntEventConsoleColumn : public IntColumn {
IntEventConsoleColumn(const std::string &name,
const std::string &description,
const ColumnOffsets &offsets)
: IntColumn(name, description, offsets) {}

int32_t getValue(Row row,
const contact * /* auth_user */) const override {
if (const auto *r = columnData<ECRow>(row)) {
return r->getInt(name());
}
return 0;
}
};

struct DoubleEventConsoleColumn : public DoubleColumn {
DoubleEventConsoleColumn(const std::string &name,
const std::string &description,
const ColumnOffsets &offsets)
: DoubleColumn(name, description, offsets) {}

[[nodiscard]] double getValue(Row row) const override {
if (const auto *r = columnData<ECRow>(row)) {
return r->getDouble(name());
}
return 0.0;
}
};

struct TimeEventConsoleColumn : public TimeColumn {
TimeEventConsoleColumn(const std::string &name,
const std::string &description,
const ColumnOffsets &offsets)
: TimeColumn(name, description, offsets) {}

private:
[[nodiscard]] std::chrono::system_clock::time_point getRawValue(
Row row) const override {
if (const auto *r = columnData<ECRow>(row)) {
return std::chrono::system_clock::from_time_t(
static_cast<std::time_t>(r->getDouble(name())));
}
return {};
}
};

struct ListEventConsoleColumn : public ListColumn {
ListEventConsoleColumn(const std::string &name,
const std::string &description,
const ColumnOffsets &offsets)
: ListColumn(name, description, offsets) {}

std::vector<std::string> getValue(
Row row, const contact * /*auth_user*/,
std::chrono::seconds /*timezone_offset*/) const override {
if (const auto *r = columnData<ECRow>(row)) {
auto result = r->getString(name());
return result.empty() || result == "\002"
? std::vector<std::string>()
: mk::split(result.substr(1), '\001');
}
return {};
}

[[nodiscard]] bool isNone(Row row) const {
if (const auto *r = columnData<ECRow>(row)) {
return r->getString(name()) == "\002";
}
return false;
}
};

bool isAuthorizedForEvent(Row row, const contact *ctc) const;

private:
Expand Down
63 changes: 34 additions & 29 deletions livestatus/src/TableEventConsoleEvents.cc
View file
Expand Up @@ -5,12 +5,17 @@

#include "TableEventConsoleEvents.h"

#include <memory>
#include <cstdint>
#include <vector>

#include "Column.h"
#include "IntLambdaColumn.h"
#include "ListLambdaColumn.h"
#include "Row.h"
#include "StringLambdaColumn.h"
#include "Table.h"
#include "TableHosts.h"
#include "TimeLambdaColumn.h"

TableEventConsoleEvents::TableEventConsoleEvents(MonitoringCore *mc)
: TableEventConsole(mc) {
Expand All @@ -20,57 +25,57 @@ TableEventConsoleEvents::TableEventConsoleEvents(MonitoringCore *mc)
// static
void TableEventConsoleEvents::addColumns(Table *table) {
ColumnOffsets offsets{};
table->addColumn(std::make_unique<IntEventConsoleColumn>(
table->addColumn(ECRow::makeIntColumn(
"event_id", "The unique ID for this event", offsets));
table->addColumn(std::make_unique<IntEventConsoleColumn>(
table->addColumn(ECRow::makeIntColumn(
"event_count", "The number of occurrences of this event within period",
offsets));
table->addColumn(std::make_unique<StringEventConsoleColumn>(
table->addColumn(ECRow::makeStringColumn(
"event_text", "The textual description of the event", offsets));
table->addColumn(std::make_unique<TimeEventConsoleColumn>(
table->addColumn(ECRow::makeTimeColumn(
"event_first",
"Time of the first occurrence of the event (Unix timestamp)", offsets));
table->addColumn(std::make_unique<TimeEventConsoleColumn>(
table->addColumn(ECRow::makeTimeColumn(
"event_last",
"Time of the last occurrence of this event (Unix timestamp)", offsets));
table->addColumn(std::make_unique<StringEventConsoleColumn>(
"event_comment", "Event comment", offsets));
table->addColumn(std::make_unique<IntEventConsoleColumn>(
table->addColumn(
ECRow::makeStringColumn("event_comment", "Event comment", offsets));
table->addColumn(ECRow::makeIntColumn(
"event_sl", "The service level for this event", offsets));
table->addColumn(std::make_unique<StringEventConsoleColumn>(
table->addColumn(ECRow::makeStringColumn(
"event_host", "Host name for this event", offsets));
table->addColumn(std::make_unique<StringEventConsoleColumn>(
"event_contact", "Contact information", offsets));
table->addColumn(std::make_unique<StringEventConsoleColumn>(
table->addColumn(ECRow::makeStringColumn("event_contact",
"Contact information", offsets));
table->addColumn(ECRow::makeStringColumn(
"event_application", "Syslog tag/application", offsets));
table->addColumn(std::make_unique<IntEventConsoleColumn>(
table->addColumn(ECRow::makeIntColumn(
"event_pid", "The process ID of the originating process", offsets));
table->addColumn(std::make_unique<IntEventConsoleColumn>(
"event_priority", "Syslog priority", offsets));
table->addColumn(std::make_unique<IntEventConsoleColumn>(
"event_facility", "Syslog facility", offsets));
table->addColumn(std::make_unique<StringEventConsoleColumn>(
"event_rule_id", "The ID of the rule", offsets));
table->addColumn(std::make_unique<IntEventConsoleColumn>(
table->addColumn(
ECRow::makeIntColumn("event_priority", "Syslog priority", offsets));
table->addColumn(
ECRow::makeIntColumn("event_facility", "Syslog facility", offsets));
table->addColumn(ECRow::makeStringColumn("event_rule_id",
"The ID of the rule", offsets));
table->addColumn(ECRow::makeIntColumn(
"event_state", "The state of the event (0/1/2/3)", offsets));
table->addColumn(std::make_unique<StringEventConsoleColumn>(
table->addColumn(ECRow::makeStringColumn(
"event_phase",
"The phase the event is currently in (one of open/closed/delayed/counting/ack)",
offsets));
table->addColumn(std::make_unique<StringEventConsoleColumn>(
table->addColumn(ECRow::makeStringColumn(
"event_owner", "The owner of the event", offsets));
table->addColumn(std::make_unique<ListEventConsoleColumn>(
table->addColumn(ECRow::makeListColumn(
"event_match_groups", "Text groups from regular expression match",
offsets));
table->addColumn(std::make_unique<ListEventConsoleColumn>(
"event_contact_groups", "Contact groups", offsets));
table->addColumn(std::make_unique<StringEventConsoleColumn>(
table->addColumn(ECRow::makeListColumn("event_contact_groups",
"Contact groups", offsets));
table->addColumn(ECRow::makeStringColumn(
"event_contact_groups_precedence",
"Whether or not the host- or rule groups have precedence", offsets));
table->addColumn(std::make_unique<StringEventConsoleColumn>(
table->addColumn(ECRow::makeStringColumn(
"event_ipaddress", "The IP address where the event originated",
offsets));
table->addColumn(std::make_unique<IntEventConsoleColumn>(
table->addColumn(ECRow::makeIntColumn(
"event_host_in_downtime",
"Whether or not the host (if found in core) was in downtime during event creation (0/1)",
offsets));
Expand Down

0 comments on commit 6c9c582

Please sign in to comment.