granicus.if.org Git - icinga2/blob - lib/base/configuration.cpp

   1 /* Icinga 2 | (c) 2012 Icinga GmbH | GPLv2+ */
   2
   3 #include "base/configuration.hpp"
   4 #include "base/configuration-ti.cpp"
   5 #include "base/exception.hpp"
   6
   7 using namespace icinga;
   8
   9 REGISTER_TYPE(Configuration);
  10
  11 String Configuration::ApiBindHost;
  12 String Configuration::ApiBindPort{"5665"};
  13 bool Configuration::AttachDebugger{false};
  14 String Configuration::CacheDir;
  15 int Configuration::Concurrency{static_cast<int>(std::thread::hardware_concurrency())};
  16 String Configuration::ConfigDir;
  17 String Configuration::DataDir;
  18 String Configuration::EventEngine;
  19 String Configuration::IncludeConfDir;
  20 String Configuration::InitRunDir;
  21 String Configuration::LogDir;
  22 String Configuration::ModAttrPath;
  23 String Configuration::ObjectsPath;
  24 String Configuration::PidPath;
  25 String Configuration::PkgDataDir;
  26 String Configuration::PrefixDir;
  27 String Configuration::ProgramData;
  28 int Configuration::RLimitFiles;
  29 int Configuration::RLimitProcesses;
  30 int Configuration::RLimitStack;
  31 String Configuration::RunAsGroup;
  32 String Configuration::RunAsUser;
  33 String Configuration::SpoolDir;
  34 String Configuration::StatePath;
  35 double Configuration::TlsHandshakeTimeout{10};
  36 String Configuration::VarsPath;
  37 String Configuration::ZonesDir;
  38
  39 /* deprecated */
  40 String Configuration::LocalStateDir;
  41 String Configuration::RunDir;
  42 String Configuration::SysconfDir;
  43
  44 /* internal */
  45 bool Configuration::m_ReadOnly{false};
  46
  47 template<typename T>
  48 void HandleUserWrite(const String& name, T *target, const T& value, bool readOnly)
  49 {
  50         if (readOnly)
  51                 BOOST_THROW_EXCEPTION(ScriptError("Configuration attribute '" + name + "' is read-only."));
  52
  53         *target = value;
  54 }
  55
  56 String Configuration::GetApiBindHost() const
  57 {
  58         return Configuration::ApiBindHost;
  59 }
  60
  61 void Configuration::SetApiBindHost(const String& val, bool suppress_events, const Value& cookie)
  62 {
  63         HandleUserWrite("ApiBindHost", &Configuration::ApiBindHost, val, m_ReadOnly);
  64 }
  65
  66 String Configuration::GetApiBindPort() const
  67 {
  68         return Configuration::ApiBindPort;
  69 }
  70
  71 void Configuration::SetApiBindPort(const String& val, bool suppress_events, const Value& cookie)
  72 {
  73         HandleUserWrite("ApiBindPort", &Configuration::ApiBindPort, val, m_ReadOnly);
  74 }
  75
  76 bool Configuration::GetAttachDebugger() const
  77 {
  78         return Configuration::AttachDebugger;
  79 }
  80
  81 void Configuration::SetAttachDebugger(bool val, bool suppress_events, const Value& cookie)
  82 {
  83         HandleUserWrite("AttachDebugger", &Configuration::AttachDebugger, val, m_ReadOnly);
  84 }
  85
  86 String Configuration::GetCacheDir() const
  87 {
  88         return Configuration::CacheDir;
  89 }
  90
  91 void Configuration::SetCacheDir(const String& val, bool suppress_events, const Value& cookie)
  92 {
  93         HandleUserWrite("CacheDir", &Configuration::CacheDir, val, m_ReadOnly);
  94 }
  95
  96 int Configuration::GetConcurrency() const
  97 {
  98         return Configuration::Concurrency;
  99 }
 100
 101 void Configuration::SetConcurrency(int val, bool suppress_events, const Value& cookie)
 102 {
 103         HandleUserWrite("Concurrency", &Configuration::Concurrency, val, m_ReadOnly);
 104 }
 105
 106 String Configuration::GetConfigDir() const
 107 {
 108         return Configuration::ConfigDir;
 109 }
 110
 111 void Configuration::SetConfigDir(const String& val, bool suppress_events, const Value& cookie)
 112 {
 113         HandleUserWrite("ConfigDir", &Configuration::ConfigDir, val, m_ReadOnly);
 114 }
 115
 116 String Configuration::GetDataDir() const
 117 {
 118         return Configuration::DataDir;
 119 }
 120
 121 void Configuration::SetDataDir(const String& val, bool suppress_events, const Value& cookie)
 122 {
 123         HandleUserWrite("DataDir", &Configuration::DataDir, val, m_ReadOnly);
 124 }
 125
 126 String Configuration::GetEventEngine() const
 127 {
 128         return Configuration::EventEngine;
 129 }
 130
 131 void Configuration::SetEventEngine(const String& val, bool suppress_events, const Value& cookie)
 132 {
 133         HandleUserWrite("EventEngine", &Configuration::EventEngine, val, m_ReadOnly);
 134 }
 135
 136 String Configuration::GetIncludeConfDir() const
 137 {
 138         return Configuration::IncludeConfDir;
 139 }
 140
 141 void Configuration::SetIncludeConfDir(const String& val, bool suppress_events, const Value& cookie)
 142 {
 143         HandleUserWrite("IncludeConfDir", &Configuration::IncludeConfDir, val, m_ReadOnly);
 144 }
 145
 146 String Configuration::GetInitRunDir() const
 147 {
 148         return Configuration::InitRunDir;
 149 }
 150
 151 void Configuration::SetInitRunDir(const String& val, bool suppress_events, const Value& cookie)
 152 {
 153         HandleUserWrite("InitRunDir", &Configuration::InitRunDir, val, m_ReadOnly);
 154 }
 155
 156 String Configuration::GetLogDir() const
 157 {
 158         return Configuration::LogDir;
 159 }
 160
 161 void Configuration::SetLogDir(const String& val, bool suppress_events, const Value& cookie)
 162 {
 163         HandleUserWrite("LogDir", &Configuration::LogDir, val, m_ReadOnly);
 164 }
 165
 166 String Configuration::GetModAttrPath() const
 167 {
 168         return Configuration::ModAttrPath;
 169 }
 170
 171 void Configuration::SetModAttrPath(const String& val, bool suppress_events, const Value& cookie)
 172 {
 173         HandleUserWrite("ModAttrPath", &Configuration::ModAttrPath, val, m_ReadOnly);
 174 }
 175
 176 String Configuration::GetObjectsPath() const
 177 {
 178         return Configuration::ObjectsPath;
 179 }
 180
 181 void Configuration::SetObjectsPath(const String& val, bool suppress_events, const Value& cookie)
 182 {
 183         HandleUserWrite("ObjectsPath", &Configuration::ObjectsPath, val, m_ReadOnly);
 184 }
 185
 186 String Configuration::GetPidPath() const
 187 {
 188         return Configuration::PidPath;
 189 }
 190
 191 void Configuration::SetPidPath(const String& val, bool suppress_events, const Value& cookie)
 192 {
 193         HandleUserWrite("PidPath", &Configuration::PidPath, val, m_ReadOnly);
 194 }
 195
 196 String Configuration::GetPkgDataDir() const
 197 {
 198         return Configuration::PkgDataDir;
 199 }
 200
 201 void Configuration::SetPkgDataDir(const String& val, bool suppress_events, const Value& cookie)
 202 {
 203         HandleUserWrite("PkgDataDir", &Configuration::PkgDataDir, val, m_ReadOnly);
 204 }
 205
 206 String Configuration::GetPrefixDir() const
 207 {
 208         return Configuration::PrefixDir;
 209 }
 210
 211 void Configuration::SetPrefixDir(const String& val, bool suppress_events, const Value& cookie)
 212 {
 213         HandleUserWrite("PrefixDir", &Configuration::PrefixDir, val, m_ReadOnly);
 214 }
 215
 216 String Configuration::GetProgramData() const
 217 {
 218         return Configuration::ProgramData;
 219 }
 220
 221 void Configuration::SetProgramData(const String& val, bool suppress_events, const Value& cookie)
 222 {
 223         HandleUserWrite("ProgramData", &Configuration::ProgramData, val, m_ReadOnly);
 224 }
 225
 226 int Configuration::GetRLimitFiles() const
 227 {
 228         return Configuration::RLimitFiles;
 229 }
 230
 231 void Configuration::SetRLimitFiles(int val, bool suppress_events, const Value& cookie)
 232 {
 233         HandleUserWrite("RLimitFiles", &Configuration::RLimitFiles, val, m_ReadOnly);
 234 }
 235
 236 int Configuration::GetRLimitProcesses() const
 237 {
 238         return RLimitProcesses;
 239 }
 240
 241 void Configuration::SetRLimitProcesses(int val, bool suppress_events, const Value& cookie)
 242 {
 243         HandleUserWrite("RLimitProcesses", &Configuration::RLimitProcesses, val, m_ReadOnly);
 244 }
 245
 246 int Configuration::GetRLimitStack() const
 247 {
 248         return Configuration::RLimitStack;
 249 }
 250
 251 void Configuration::SetRLimitStack(int val, bool suppress_events, const Value& cookie)
 252 {
 253         HandleUserWrite("RLimitStack", &Configuration::RLimitStack, val, m_ReadOnly);
 254 }
 255
 256 String Configuration::GetRunAsGroup() const
 257 {
 258         return Configuration::RunAsGroup;
 259 }
 260
 261 void Configuration::SetRunAsGroup(const String& val, bool suppress_events, const Value& cookie)
 262 {
 263         HandleUserWrite("RunAsGroup", &Configuration::RunAsGroup, val, m_ReadOnly);
 264 }
 265
 266 String Configuration::GetRunAsUser() const
 267 {
 268         return Configuration::RunAsUser;
 269 }
 270
 271 void Configuration::SetRunAsUser(const String& val, bool suppress_events, const Value& cookie)
 272 {
 273         HandleUserWrite("RunAsUser", &Configuration::RunAsUser, val, m_ReadOnly);
 274 }
 275
 276 String Configuration::GetSpoolDir() const
 277 {
 278         return Configuration::SpoolDir;
 279 }
 280
 281 void Configuration::SetSpoolDir(const String& val, bool suppress_events, const Value& cookie)
 282 {
 283         HandleUserWrite("SpoolDir", &Configuration::SpoolDir, val, m_ReadOnly);
 284 }
 285
 286 String Configuration::GetStatePath() const
 287 {
 288         return Configuration::StatePath;
 289 }
 290
 291 void Configuration::SetStatePath(const String& val, bool suppress_events, const Value& cookie)
 292 {
 293         HandleUserWrite("StatePath", &Configuration::StatePath, val, m_ReadOnly);
 294 }
 295
 296 double Configuration::GetTlsHandshakeTimeout() const
 297 {
 298         return Configuration::TlsHandshakeTimeout;
 299 }
 300
 301 void Configuration::SetTlsHandshakeTimeout(double val, bool suppress_events, const Value& cookie)
 302 {
 303         HandleUserWrite("TlsHandshakeTimeout", &Configuration::TlsHandshakeTimeout, val, m_ReadOnly);
 304 }
 305
 306 String Configuration::GetVarsPath() const
 307 {
 308         return Configuration::VarsPath;
 309 }
 310
 311 void Configuration::SetVarsPath(const String& val, bool suppress_events, const Value& cookie)
 312 {
 313         HandleUserWrite("VarsPath", &Configuration::VarsPath, val, m_ReadOnly);
 314 }
 315
 316 String Configuration::GetZonesDir() const
 317 {
 318         return Configuration::ZonesDir;
 319 }
 320
 321 void Configuration::SetZonesDir(const String& val, bool suppress_events, const Value& cookie)
 322 {
 323         HandleUserWrite("ZonesDir", &Configuration::ZonesDir, val, m_ReadOnly);
 324 }
 325
 326 String Configuration::GetLocalStateDir() const
 327 {
 328         return Configuration::LocalStateDir;
 329 }
 330
 331 void Configuration::SetLocalStateDir(const String& val, bool suppress_events, const Value& cookie)
 332 {
 333         HandleUserWrite("LocalStateDir", &Configuration::LocalStateDir, val, m_ReadOnly);
 334 }
 335
 336 String Configuration::GetSysconfDir() const
 337 {
 338         return Configuration::SysconfDir;
 339 }
 340
 341 void Configuration::SetSysconfDir(const String& val, bool suppress_events, const Value& cookie)
 342 {
 343         HandleUserWrite("SysconfDir", &Configuration::SysconfDir, val, m_ReadOnly);
 344 }
 345
 346 String Configuration::GetRunDir() const
 347 {
 348         return Configuration::RunDir;
 349 }
 350
 351 void Configuration::SetRunDir(const String& val, bool suppress_events, const Value& cookie)
 352 {
 353         HandleUserWrite("RunDir", &Configuration::RunDir, val, m_ReadOnly);
 354 }
 355
 356 bool Configuration::GetReadOnly()
 357 {
 358         return m_ReadOnly;
 359 }
 360
 361 void Configuration::SetReadOnly(bool readOnly)
 362 {
 363         m_ReadOnly = readOnly;
 364 }