1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
/* Icinga 2 | (c) 2012 Icinga GmbH | GPLv2+ */
#include "icinga/user.hpp"
#include "icinga/user-ti.cpp"
#include "icinga/usergroup.hpp"
#include "icinga/notification.hpp"
#include "icinga/usergroup.hpp"
#include "base/objectlock.hpp"
#include "base/exception.hpp"
using namespace icinga;
REGISTER_TYPE(User);
User::User()
{
// If a User is created without specifying the "types/states" attribute, the Set* methods won't be called,
// consequently the filter bitset will also be 0. Thus, we need to ensure that the type/state filter are
// initialized to the default values, which are all types and states enabled.
SetTypes(nullptr, false, Empty);
SetStates(nullptr, false, Empty);
}
void User::OnAllConfigLoaded()
{
ObjectImpl<User>::OnAllConfigLoaded();
UserGroup::EvaluateObjectRules(this);
Array::Ptr groups = GetGroups();
if (groups) {
groups = groups->ShallowClone();
ObjectLock olock(groups);
for (String name : groups) {
UserGroup::Ptr ug = UserGroup::GetByName(name);
if (ug)
ug->ResolveGroupMembership(this, true);
}
}
}
void User::Stop(bool runtimeRemoved)
{
ObjectImpl<User>::Stop(runtimeRemoved);
Array::Ptr groups = GetGroups();
if (groups) {
ObjectLock olock(groups);
for (String name : groups) {
UserGroup::Ptr ug = UserGroup::GetByName(name);
if (ug)
ug->ResolveGroupMembership(this, false);
}
}
}
void User::AddGroup(const String& name)
{
std::unique_lock<std::mutex> lock(m_UserMutex);
Array::Ptr groups = GetGroups();
if (groups && groups->Contains(name))
return;
if (!groups)
groups = new Array();
groups->Add(name);
}
TimePeriod::Ptr User::GetPeriod() const
{
return TimePeriod::GetByName(GetPeriodRaw());
}
Array::Ptr User::GetTypes() const
{
return m_Types.load();
}
void User::SetTypes(const Array::Ptr& value, bool suppress_events, const Value& cookie)
{
m_Types.store(value);
// Ensure that the type filter is updated when the types attribute changes.
SetTypeFilter(FilterArrayToInt(value, Notification::GetTypeFilterMap(), ~0));
if (!suppress_events) {
NotifyTypes(cookie);
}
}
Array::Ptr User::GetStates() const
{
return m_States.load();
}
void User::SetStates(const Array::Ptr& value, bool suppress_events, const Value& cookie)
{
m_States.store(value);
// Ensure that the state filter is updated when the states attribute changes.
SetStateFilter(FilterArrayToInt(value, Notification::GetStateFilterMap(), ~0));
if (!suppress_events) {
NotifyStates(cookie);
}
}
void User::ValidateStates(const Lazy<Array::Ptr>& lvalue, const ValidationUtils& utils)
{
ObjectImpl<User>::ValidateStates(lvalue, utils);
int filter = FilterArrayToInt(lvalue(), Notification::GetStateFilterMap(), 0);
if (filter == -1 || (filter & ~(StateFilterUp | StateFilterDown | StateFilterOK | StateFilterWarning | StateFilterCritical | StateFilterUnknown)) != 0)
BOOST_THROW_EXCEPTION(ValidationError(this, { "states" }, "State filter is invalid."));
}
void User::ValidateTypes(const Lazy<Array::Ptr>& lvalue, const ValidationUtils& utils)
{
ObjectImpl<User>::ValidateTypes(lvalue, utils);
int filter = FilterArrayToInt(lvalue(), Notification::GetTypeFilterMap(), 0);
if (filter == -1 || (filter & ~(NotificationDowntimeStart | NotificationDowntimeEnd | NotificationDowntimeRemoved |
NotificationCustom | NotificationAcknowledgement | NotificationProblem | NotificationRecovery |
NotificationFlappingStart | NotificationFlappingEnd)) != 0)
BOOST_THROW_EXCEPTION(ValidationError(this, { "types" }, "Type filter is invalid."));
}
|
