return std::vector<String>();
}
-static int Main(void)
+static int Main()
{
int argc = Application::GetArgC();
char **argv = Application::GetArgV();
SetDefaultItem(m_ButtonsOK);
}
-Url::Ptr ConnectForm::GetUrl(void) const
+Url::Ptr ConnectForm::GetUrl() const
{
wxString url = "https://" + m_UserText->GetValue() + ":" + m_PasswordText->GetValue()
+ "@" + m_HostText->GetValue() + ":" + m_PortText->GetValue() + "/";
public:
ConnectForm(wxWindow *parent, const Url::Ptr& url);
- Url::Ptr GetUrl(void) const;
+ Url::Ptr GetUrl() const;
};
}
class IcingaStudio final : public wxApp
{
public:
- virtual bool OnInit(void) override
+ virtual bool OnInit() override
{
Application::InitializeBase();
using namespace icinga;
-String Application::GetAppVersion(void)
+String Application::GetAppVersion()
{
return VERSION;
}
-String Application::GetAppSpecVersion(void)
+String Application::GetAppSpecVersion()
{
return SPEC_VERSION;
}
REGISTER_TYPE(Application);
-boost::signals2::signal<void (void)> Application::OnReopenLogs;
+boost::signals2::signal<void ()> Application::OnReopenLogs;
Application::Ptr Application::m_Instance = nullptr;
bool Application::m_ShuttingDown = false;
bool Application::m_RequestRestart = false;
/**
* Constructor for the Application class.
*/
-void Application::OnConfigLoaded(void)
+void Application::OnConfigLoaded()
{
m_PidFile = nullptr;
ObjectImpl<Application>::Stop(runtimeRemoved);
}
-Application::~Application(void)
+Application::~Application()
{
m_Instance = nullptr;
}
#endif /* I2_DEBUG */
}
-void Application::InitializeBase(void)
+void Application::InitializeBase()
{
#ifdef _WIN32
/* disable GUI-based error messages for LoadLibrary() */
GetTP().Start();
}
-void Application::UninitializeBase(void)
+void Application::UninitializeBase()
{
Timer::Uninitialize();
*
* @returns The application object.
*/
-Application::Ptr Application::GetInstance(void)
+Application::Ptr Application::GetInstance()
{
return m_Instance;
}
-void Application::SetResourceLimits(void)
+void Application::SetResourceLimits()
{
#ifdef __linux__
rlimit rl;
#endif /* __linux__ */
}
-int Application::GetArgC(void)
+int Application::GetArgC()
{
return m_ArgC;
}
m_ArgC = argc;
}
-char **Application::GetArgV(void)
+char **Application::GetArgV()
{
return m_ArgV;
}
* Processes events for registered sockets and timers and calls whatever
* handlers have been set up for these events.
*/
-void Application::RunEventLoop(void)
+void Application::RunEventLoop()
{
double lastLoop = Utility::GetTime();
UninitializeBase();
}
-bool Application::IsShuttingDown(void)
+bool Application::IsShuttingDown()
{
return m_ShuttingDown;
}
-void Application::OnShutdown(void)
+void Application::OnShutdown()
{
/* Nothing to do here. */
}
t.detach();
}
-pid_t Application::StartReloadProcess(void)
+pid_t Application::StartReloadProcess()
{
Log(LogInformation, "Application", "Got reload command: Starting new instance.");
* Signals the application to shut down during the next
* execution of the event loop.
*/
-void Application::RequestShutdown(void)
+void Application::RequestShutdown()
{
Log(LogInformation, "Application", "Received request to shut down.");
* Signals the application to restart during the next
* execution of the event loop.
*/
-void Application::RequestRestart(void)
+void Application::RequestRestart()
{
m_RequestRestart = true;
}
* Signals the application to reopen log files during the
* next execution of the event loop.
*/
-void Application::RequestReopenLogs(void)
+void Application::RequestReopenLogs()
{
m_RequestReopenLogs = true;
}
<< "***" << "\n";
}
-String Application::GetCrashReportFilename(void)
+String Application::GetCrashReportFilename()
{
return GetLocalStateDir() + "/log/icinga2/crash/report." + Convert::ToString(Utility::GetTime());
}
return TRUE;
}
-bool Application::IsProcessElevated(void) {
+bool Application::IsProcessElevated() {
BOOL fIsElevated = FALSE;
DWORD dwError = ERROR_SUCCESS;
HANDLE hToken = nullptr;
/**
* Handler for unhandled exceptions.
*/
-void Application::ExceptionHandler(void)
+void Application::ExceptionHandler()
{
if (l_InExceptionHandler)
for (;;)
/**
* Installs the exception handlers.
*/
-void Application::InstallExceptionHandlers(void)
+void Application::InstallExceptionHandlers()
{
std::set_terminate(&Application::ExceptionHandler);
*
* @returns The application's exit code.
*/
-int Application::Run(void)
+int Application::Run()
{
#ifndef _WIN32
struct sigaction sa;
*
* @returns The path.
*/
-String Application::GetPrefixDir(void)
+String Application::GetPrefixDir()
{
return ScriptGlobal::Get("PrefixDir");
}
*
* @returns The path.
*/
-String Application::GetSysconfDir(void)
+String Application::GetSysconfDir()
{
return ScriptGlobal::Get("SysconfDir");
}
*
* @returns The path.
*/
-String Application::GetRunDir(void)
+String Application::GetRunDir()
{
return ScriptGlobal::Get("RunDir");
}
*
* @returns The path.
*/
-String Application::GetLocalStateDir(void)
+String Application::GetLocalStateDir()
{
return ScriptGlobal::Get("LocalStateDir");
}
*
* @returns The path.
*/
-String Application::GetZonesDir(void)
+String Application::GetZonesDir()
{
return ScriptGlobal::Get("ZonesDir", &Empty);
}
*
* @returns The path.
*/
-String Application::GetPkgDataDir(void)
+String Application::GetPkgDataDir()
{
String defaultValue = "";
return ScriptGlobal::Get("PkgDataDir", &Empty);
*
* @returns The path.
*/
-String Application::GetIncludeConfDir(void)
+String Application::GetIncludeConfDir()
{
return ScriptGlobal::Get("IncludeConfDir", &Empty);
}
*
* @returns The path.
*/
-String Application::GetStatePath(void)
+String Application::GetStatePath()
{
return ScriptGlobal::Get("StatePath", &Empty);
}
*
* @returns The path.
*/
-String Application::GetModAttrPath(void)
+String Application::GetModAttrPath()
{
return ScriptGlobal::Get("ModAttrPath", &Empty);
}
*
* @returns The path.
*/
-String Application::GetObjectsPath(void)
+String Application::GetObjectsPath()
{
return ScriptGlobal::Get("ObjectsPath", &Empty);
}
*
* @returns The path.
*/
-String Application::GetVarsPath(void)
+String Application::GetVarsPath()
{
return ScriptGlobal::Get("VarsPath", &Empty);
}
*
* @returns The path.
*/
-String Application::GetPidPath(void)
+String Application::GetPidPath()
{
return ScriptGlobal::Get("PidPath", &Empty);
}
*
* @returns The name.
*/
-String Application::GetRunAsUser(void)
+String Application::GetRunAsUser()
{
return ScriptGlobal::Get("RunAsUser");
}
*
* @returns The name.
*/
-String Application::GetRunAsGroup(void)
+String Application::GetRunAsGroup()
{
return ScriptGlobal::Get("RunAsGroup");
}
*
* @returns The limit.
*/
-int Application::GetRLimitFiles(void)
+int Application::GetRLimitFiles()
{
return ScriptGlobal::Get("RLimitFiles");
}
-int Application::GetDefaultRLimitFiles(void)
+int Application::GetDefaultRLimitFiles()
{
return 16 * 1024;
}
*
* @returns The limit.
*/
-int Application::GetRLimitProcesses(void)
+int Application::GetRLimitProcesses()
{
return ScriptGlobal::Get("RLimitProcesses");
}
-int Application::GetDefaultRLimitProcesses(void)
+int Application::GetDefaultRLimitProcesses()
{
return 16 * 1024;
}
*
* @returns The limit.
*/
-int Application::GetRLimitStack(void)
+int Application::GetRLimitStack()
{
return ScriptGlobal::Get("RLimitStack");
}
-int Application::GetDefaultRLimitStack(void)
+int Application::GetDefaultRLimitStack()
{
return 256 * 1024;
}
*
* @returns The concurrency level.
*/
-int Application::GetConcurrency(void)
+int Application::GetConcurrency()
{
Value defaultConcurrency = std::thread::hardware_concurrency();
return ScriptGlobal::Get("Concurrency", &defaultConcurrency);
*
* @returns The global thread pool.
*/
-ThreadPool& Application::GetTP(void)
+ThreadPool& Application::GetTP()
{
static ThreadPool tp;
return tp;
}
-double Application::GetStartTime(void)
+double Application::GetStartTime()
{
return m_StartTime;
}
m_StartTime = ts;
}
-double Application::GetMainTime(void)
+double Application::GetMainTime()
{
return m_MainTime;
}
m_MainTime = ts;
}
-bool Application::GetScriptDebuggerEnabled(void)
+bool Application::GetScriptDebuggerEnabled()
{
return m_ScriptDebuggerEnabled;
}
m_ScriptDebuggerEnabled = enabled;
}
-double Application::GetLastReloadFailed(void)
+double Application::GetLastReloadFailed()
{
return m_LastReloadFailed;
}
public:
DECLARE_OBJECT(Application);
- static boost::signals2::signal<void (void)> OnReopenLogs;
+ static boost::signals2::signal<void ()> OnReopenLogs;
- ~Application(void);
+ ~Application();
- static void InitializeBase(void);
- static void UninitializeBase(void);
+ static void InitializeBase();
+ static void UninitializeBase();
- static Application::Ptr GetInstance(void);
+ static Application::Ptr GetInstance();
static void Exit(int rc);
- int Run(void);
+ int Run();
/**
* Starts the application.
*
* @returns The exit code of the application.
*/
- virtual int Main(void) = 0;
+ virtual int Main() = 0;
- static void SetResourceLimits(void);
+ static void SetResourceLimits();
- static int GetArgC(void);
+ static int GetArgC();
static void SetArgC(int argc);
- static char **GetArgV(void);
+ static char **GetArgV();
static void SetArgV(char **argv);
- static void InstallExceptionHandlers(void);
+ static void InstallExceptionHandlers();
- static void RequestShutdown(void);
- static void RequestRestart(void);
- static void RequestReopenLogs(void);
+ static void RequestShutdown();
+ static void RequestRestart();
+ static void RequestReopenLogs();
- static bool IsShuttingDown(void);
+ static bool IsShuttingDown();
static void SetDebuggingSeverity(LogSeverity severity);
- static LogSeverity GetDebuggingSeverity(void);
+ static LogSeverity GetDebuggingSeverity();
void UpdatePidFile(const String& filename, pid_t pid = Utility::GetPid());
void ClosePidFile(bool unlink);
static String GetExePath(const String& argv0);
- static String GetPrefixDir(void);
+ static String GetPrefixDir();
static void DeclarePrefixDir(const String& path);
- static String GetSysconfDir(void);
+ static String GetSysconfDir();
static void DeclareSysconfDir(const String& path);
- static String GetZonesDir(void);
+ static String GetZonesDir();
static void DeclareZonesDir(const String& path);
- static String GetRunDir(void);
+ static String GetRunDir();
static void DeclareRunDir(const String& path);
- static String GetLocalStateDir(void);
+ static String GetLocalStateDir();
static void DeclareLocalStateDir(const String& path);
- static String GetPkgDataDir(void);
+ static String GetPkgDataDir();
static void DeclarePkgDataDir(const String& path);
- static String GetIncludeConfDir(void);
+ static String GetIncludeConfDir();
static void DeclareIncludeConfDir(const String& path);
- static String GetStatePath(void);
+ static String GetStatePath();
static void DeclareStatePath(const String& path);
- static String GetModAttrPath(void);
+ static String GetModAttrPath();
static void DeclareModAttrPath(const String& path);
- static String GetObjectsPath(void);
+ static String GetObjectsPath();
static void DeclareObjectsPath(const String& path);
- static String GetVarsPath(void);
+ static String GetVarsPath();
static void DeclareVarsPath(const String& path);
- static String GetPidPath(void);
+ static String GetPidPath();
static void DeclarePidPath(const String& path);
- static String GetRunAsUser(void);
+ static String GetRunAsUser();
static void DeclareRunAsUser(const String& user);
- static String GetRunAsGroup(void);
+ static String GetRunAsGroup();
static void DeclareRunAsGroup(const String& group);
#ifdef _WIN32
- static bool IsProcessElevated(void);
+ static bool IsProcessElevated();
#endif /* _WIN32 */
- static int GetRLimitFiles(void);
- static int GetDefaultRLimitFiles(void);
+ static int GetRLimitFiles();
+ static int GetDefaultRLimitFiles();
static void DeclareRLimitFiles(int limit);
- static int GetRLimitProcesses(void);
- static int GetDefaultRLimitProcesses(void);
+ static int GetRLimitProcesses();
+ static int GetDefaultRLimitProcesses();
static void DeclareRLimitProcesses(int limit);
- static int GetRLimitStack(void);
- static int GetDefaultRLimitStack(void);
+ static int GetRLimitStack();
+ static int GetDefaultRLimitStack();
static void DeclareRLimitStack(int limit);
- static int GetConcurrency(void);
+ static int GetConcurrency();
static void DeclareConcurrency(int ncpus);
- static ThreadPool& GetTP(void);
+ static ThreadPool& GetTP();
- static String GetAppVersion(void);
- static String GetAppSpecVersion(void);
+ static String GetAppVersion();
+ static String GetAppSpecVersion();
- static double GetStartTime(void);
+ static double GetStartTime();
static void SetStartTime(double ts);
- static double GetMainTime(void);
+ static double GetMainTime();
static void SetMainTime(double ts);
- static bool GetScriptDebuggerEnabled(void);
+ static bool GetScriptDebuggerEnabled();
static void SetScriptDebuggerEnabled(bool enabled);
- static double GetLastReloadFailed(void);
+ static double GetLastReloadFailed();
static void SetLastReloadFailed(double ts);
static void DisplayInfoMessage(std::ostream& os, bool skipVersion = false);
protected:
- virtual void OnConfigLoaded(void) override;
+ virtual void OnConfigLoaded() override;
virtual void Stop(bool runtimeRemoved) override;
- void RunEventLoop(void);
+ void RunEventLoop();
- pid_t StartReloadProcess(void);
+ pid_t StartReloadProcess();
- virtual void OnShutdown(void);
+ virtual void OnShutdown();
virtual void ValidateName(const String& value, const ValidationUtils& utils) override final;
static void SigAbrtHandler(int signum);
static void SigUsr1Handler(int signum);
- static void ExceptionHandler(void);
+ static void ExceptionHandler();
- static String GetCrashReportFilename(void);
+ static String GetCrashReportFilename();
static void AttachDebugger(const String& filename, bool interactive);
};
using namespace icinga;
-static double ArrayLen(void)
+static double ArrayLen()
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
Array::Ptr self = static_cast<Array::Ptr>(vframe->Self);
return self->Contains(value);
}
-static void ArrayClear(void)
+static void ArrayClear()
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
Array::Ptr self = static_cast<Array::Ptr>(vframe->Self);
return arr;
}
-static Array::Ptr ArrayShallowClone(void)
+static Array::Ptr ArrayShallowClone()
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
Array::Ptr self = static_cast<Array::Ptr>(vframe->Self);
return result;
}
-static Array::Ptr ArrayReverse(void)
+static Array::Ptr ArrayReverse()
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
Array::Ptr self = static_cast<Array::Ptr>(vframe->Self);
return true;
}
-static Array::Ptr ArrayUnique(void)
+static Array::Ptr ArrayUnique()
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
Array::Ptr self = static_cast<Array::Ptr>(vframe->Self);
return Array::FromSet(result);
}
-Object::Ptr Array::GetPrototype(void)
+Object::Ptr Array::GetPrototype()
{
static Dictionary::Ptr prototype;
REGISTER_PRIMITIVE_TYPE(Array, Object, Array::GetPrototype());
-Array::Array(void)
+Array::Array()
{ }
Array::Array(std::initializer_list<Value> init)
: m_Data(init)
{ }
-Array::~Array(void)
+Array::~Array()
{ }
/**
*
* @returns An iterator.
*/
-Array::Iterator Array::Begin(void)
+Array::Iterator Array::Begin()
{
ASSERT(OwnsLock());
*
* @returns An iterator.
*/
-Array::Iterator Array::End(void)
+Array::Iterator Array::End()
{
ASSERT(OwnsLock());
*
* @returns Number of elements.
*/
-size_t Array::GetLength(void) const
+size_t Array::GetLength() const
{
ObjectLock olock(this);
m_Data.resize(newSize);
}
-void Array::Clear(void)
+void Array::Clear()
{
ObjectLock olock(this);
*
* @returns a copy of the array.
*/
-Array::Ptr Array::ShallowClone(void) const
+Array::Ptr Array::ShallowClone() const
{
Array::Ptr clone = new Array();
CopyTo(clone);
*
* @returns a copy of the array.
*/
-Object::Ptr Array::Clone(void) const
+Object::Ptr Array::Clone() const
{
Array::Ptr arr = new Array();
return arr;
}
-Array::Ptr Array::Reverse(void) const
+Array::Ptr Array::Reverse() const
{
Array::Ptr result = new Array();
return result;
}
-void Array::Sort(void)
+void Array::Sort()
{
ObjectLock olock(this);
std::sort(m_Data.begin(), m_Data.end());
}
-String Array::ToString(void) const
+String Array::ToString() const
{
std::ostringstream msgbuf;
ConfigWriter::EmitArray(msgbuf, 1, const_cast<Array *>(this));
typedef std::vector<Value>::size_type SizeType;
- Array(void);
+ Array();
Array(std::initializer_list<Value> init);
- ~Array(void);
+ ~Array();
Value Get(SizeType index) const;
void Set(SizeType index, const Value& value);
void Add(const Value& value);
void Add(Value&& value);
- Iterator Begin(void);
- Iterator End(void);
+ Iterator Begin();
+ Iterator End();
- size_t GetLength(void) const;
+ size_t GetLength() const;
bool Contains(const Value& value) const;
void Insert(SizeType index, const Value& value);
void Remove(Iterator it);
void Resize(SizeType newSize);
- void Clear(void);
+ void Clear();
void Reserve(SizeType newSize);
void CopyTo(const Array::Ptr& dest) const;
- Array::Ptr ShallowClone(void) const;
+ Array::Ptr ShallowClone() const;
- static Object::Ptr GetPrototype(void);
+ static Object::Ptr GetPrototype();
template<typename T>
static Array::Ptr FromVector(const std::vector<T>& v)
}
template<typename T>
- std::set<T> ToSet(void)
+ std::set<T> ToSet()
{
ObjectLock olock(this);
return std::set<T>(Begin(), End());
return result;
}
- virtual Object::Ptr Clone(void) const override;
+ virtual Object::Ptr Clone() const override;
- Array::Ptr Reverse(void) const;
+ Array::Ptr Reverse() const;
- void Sort(void);
+ void Sort();
- virtual String ToString(void) const override;
+ virtual String ToString() const override;
virtual Value GetFieldByName(const String& field, bool sandboxed, const DebugInfo& debugInfo) const override;
virtual void SetFieldByName(const String& field, const Value& value, const DebugInfo& debugInfo) override;
using namespace icinga;
-static String BooleanToString(void)
+static String BooleanToString()
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
bool self = vframe->Self;
return self ? "true" : "false";
}
-Object::Ptr Boolean::GetPrototype(void)
+Object::Ptr Boolean::GetPrototype()
{
static Dictionary::Ptr prototype;
class Boolean
{
public:
- static Object::Ptr GetPrototype(void);
+ static Object::Ptr GetPrototype();
private:
- Boolean(void);
+ Boolean();
};
}
return self->RestoreAttribute(attr);
}
-Object::Ptr ConfigObject::GetPrototype(void)
+Object::Ptr ConfigObject::GetPrototype()
{
static Dictionary::Ptr prototype;
boost::signals2::signal<void (const ConfigObject::Ptr&)> ConfigObject::OnStateChanged;
-ConfigObject::ConfigObject(void)
+ConfigObject::ConfigObject()
{ }
-bool ConfigObject::IsActive(void) const
+bool ConfigObject::IsActive() const
{
return GetActive();
}
-bool ConfigObject::IsPaused(void) const
+bool ConfigObject::IsPaused() const
{
return GetPaused();
}
return original_attributes->Contains(attr);
}
-void ConfigObject::Register(void)
+void ConfigObject::Register()
{
ASSERT(!OwnsLock());
type->RegisterObject(this);
}
-void ConfigObject::Unregister(void)
+void ConfigObject::Unregister()
{
ASSERT(!OwnsLock());
SetStartCalled(true);
}
-void ConfigObject::PreActivate(void)
+void ConfigObject::PreActivate()
{
CONTEXT("Setting 'active' to true for object '" + GetName() + "' of type '" + GetReflectionType()->GetName() + "'");
NotifyActive();
}
-void ConfigObject::OnConfigLoaded(void)
+void ConfigObject::OnConfigLoaded()
{
/* Nothing to do here. */
}
-void ConfigObject::OnAllConfigLoaded(void)
+void ConfigObject::OnAllConfigLoaded()
{
static ConfigType *ctype;
/* Nothing to do here. */
}
-void ConfigObject::OnStateLoaded(void)
+void ConfigObject::OnStateLoaded()
{
/* Nothing to do here. */
}
-void ConfigObject::Pause(void)
+void ConfigObject::Pause()
{
SetPauseCalled(true);
}
-void ConfigObject::Resume(void)
+void ConfigObject::Resume()
{
SetResumeCalled(true);
}
<< "Restored " << restored << " objects. Loaded " << no_state << " new objects without state.";
}
-void ConfigObject::StopObjects(void)
+void ConfigObject::StopObjects()
{
for (const Type::Ptr& type : Type::GetAllTypes()) {
ConfigType *dtype = dynamic_cast<ConfigType *>(type.get());
return ctype->GetObject(name);
}
-ConfigObject::Ptr ConfigObject::GetZone(void) const
+ConfigObject::Ptr ConfigObject::GetZone() const
{
return m_Zone;
}
-Dictionary::Ptr ConfigObject::GetSourceLocation(void) const
+Dictionary::Ptr ConfigObject::GetSourceLocation() const
{
DebugInfo di = GetDebugInfo();
return result;
}
-NameComposer::~NameComposer(void)
+NameComposer::~NameComposer()
{ }
static boost::signals2::signal<void (const ConfigObject::Ptr&)> OnStateChanged;
- bool IsActive(void) const;
- bool IsPaused(void) const;
+ bool IsActive() const;
+ bool IsPaused() const;
void SetExtension(const String& key, const Value& value);
Value GetExtension(const String& key);
void ClearExtension(const String& key);
- ConfigObject::Ptr GetZone(void) const;
+ ConfigObject::Ptr GetZone() const;
void ModifyAttribute(const String& attr, const Value& value, bool updateVersion = true);
void RestoreAttribute(const String& attr, bool updateVersion = true);
bool IsAttributeModified(const String& attr) const;
- void Register(void);
- void Unregister(void);
+ void Register();
+ void Unregister();
- void PreActivate(void);
+ void PreActivate();
void Activate(bool runtimeCreated = false);
void Deactivate(bool runtimeRemoved = false);
void SetAuthority(bool authority);
virtual void Start(bool runtimeCreated = false) override;
virtual void Stop(bool runtimeRemoved = false) override;
- virtual void Pause(void);
- virtual void Resume(void);
+ virtual void Pause();
+ virtual void Resume();
- virtual void OnConfigLoaded(void);
+ virtual void OnConfigLoaded();
virtual void CreateChildObjects(const Type::Ptr& childType);
- virtual void OnAllConfigLoaded(void);
- virtual void OnStateLoaded(void);
+ virtual void OnAllConfigLoaded();
+ virtual void OnStateLoaded();
- virtual Dictionary::Ptr GetSourceLocation(void) const override;
+ virtual Dictionary::Ptr GetSourceLocation() const override;
template<typename T>
static intrusive_ptr<T> GetObject(const String& name)
static void DumpObjects(const String& filename, int attributeTypes = FAState);
static void RestoreObjects(const String& filename, int attributeTypes = FAState);
- static void StopObjects(void);
+ static void StopObjects();
static void DumpModifiedAttributes(const std::function<void(const ConfigObject::Ptr&, const String&, const Value&)>& callback);
- static Object::Ptr GetPrototype(void);
+ static Object::Ptr GetPrototype();
protected:
- explicit ConfigObject(void);
+ explicit ConfigObject();
private:
ConfigObject::Ptr m_Zone;
};
#define DECLARE_OBJECTNAME(klass) \
- inline static String GetTypeName(void) \
+ inline static String GetTypeName() \
{ \
return #klass; \
} \
class NameComposer
{
public:
- virtual ~NameComposer(void);
+ virtual ~NameComposer();
virtual String MakeName(const String& shortName, const Object::Ptr& context) const = 0;
virtual Dictionary::Ptr ParseName(const String& name) const = 0;
class ConfigObjectBase : public ObjectImpl<ConfigObjectBase>
{
public:
- inline DebugInfo GetDebugInfo(void) const
+ inline DebugInfo GetDebugInfo() const
{
return m_DebugInfo;
}
using namespace icinga;
-ConfigType::~ConfigType(void)
+ConfigType::~ConfigType()
{ }
ConfigObject::Ptr ConfigType::GetObject(const String& name) const
}
}
-std::vector<ConfigObject::Ptr> ConfigType::GetObjects(void) const
+std::vector<ConfigObject::Ptr> ConfigType::GetObjects() const
{
boost::mutex::scoped_lock lock(m_Mutex);
return m_ObjectVector;
return static_cast<TypeImpl<ConfigObject> *>(type)->GetObjects();
}
-int ConfigType::GetObjectCount(void) const
+int ConfigType::GetObjectCount() const
{
boost::mutex::scoped_lock lock(m_Mutex);
return m_ObjectVector.size();
class ConfigType
{
public:
- virtual ~ConfigType(void);
+ virtual ~ConfigType();
intrusive_ptr<ConfigObject> GetObject(const String& name) const;
void RegisterObject(const intrusive_ptr<ConfigObject>& object);
void UnregisterObject(const intrusive_ptr<ConfigObject>& object);
- std::vector<intrusive_ptr<ConfigObject> > GetObjects(void) const;
+ std::vector<intrusive_ptr<ConfigObject> > GetObjects() const;
template<typename T>
- static TypeImpl<T> *Get(void)
+ static TypeImpl<T> *Get()
{
typedef TypeImpl<T> ObjType;
return static_cast<ObjType *>(T::TypeInstance.get());
}
template<typename T>
- static std::vector<intrusive_ptr<T> > GetObjectsByType(void)
+ static std::vector<intrusive_ptr<T> > GetObjectsByType()
{
std::vector<intrusive_ptr<ConfigObject> > objects = GetObjectsHelper(T::TypeInstance.get());
std::vector<intrusive_ptr<T> > result;
return result;
}
- int GetObjectCount(void) const;
+ int GetObjectCount() const;
private:
typedef std::map<String, intrusive_ptr<ConfigObject> > ObjectMap;
return result;
}
-const std::vector<String>& ConfigWriter::GetKeywords(void)
+const std::vector<String>& ConfigWriter::GetKeywords()
{
static std::vector<String> keywords;
static boost::mutex mutex;
: m_Name(identifier)
{ }
-String ConfigIdentifier::GetName(void) const
+String ConfigIdentifier::GetName() const
{
return m_Name;
}
ConfigIdentifier(const String& name);
- String GetName(void) const;
+ String GetName() const;
private:
String m_Name;
static void EmitComment(std::ostream& fp, const String& text);
static void EmitFunctionCall(std::ostream& fp, const String& name, const Array::Ptr& arguments);
- static const std::vector<String>& GetKeywords(void);
+ static const std::vector<String>& GetKeywords();
private:
static String EscapeIcingaString(const String& str);
- ConfigWriter(void);
+ ConfigWriter();
};
}
static ConsoleType l_ConsoleType = Console_Dumb;
-static void InitializeConsole(void)
+static void InitializeConsole()
{
l_ConsoleType = Console_Dumb;
class Console
{
public:
- static void DetectType(void);
+ static void DetectType();
static void SetType(std::ostream& fp, ConsoleType type);
static ConsoleType GetType(std::ostream& fp);
#endif /* _WIN32 */
private:
- Console(void);
+ Console();
};
}
GetFrames().push_front(message);
}
-ContextFrame::~ContextFrame(void)
+ContextFrame::~ContextFrame()
{
GetFrames().pop_front();
}
-std::list<String>& ContextFrame::GetFrames(void)
+std::list<String>& ContextFrame::GetFrames()
{
if (!l_Frames.get())
l_Frames.reset(new std::list<String>());
return *l_Frames;
}
-ContextTrace::ContextTrace(void)
+ContextTrace::ContextTrace()
: m_Frames(ContextFrame::GetFrames())
{ }
}
}
-size_t ContextTrace::GetLength(void) const
+size_t ContextTrace::GetLength() const
{
return m_Frames.size();
}
class ContextTrace
{
public:
- ContextTrace(void);
+ ContextTrace();
void Print(std::ostream& fp) const;
- size_t GetLength(void) const;
+ size_t GetLength() const;
private:
std::list<String> m_Frames;
{
public:
ContextFrame(const String& message);
- ~ContextFrame(void);
+ ~ContextFrame();
private:
- static std::list<String>& GetFrames(void);
+ static std::list<String>& GetFrames();
friend class ContextTrace;
};
static double ToDateTimeValue(const Value& val);
private:
- Convert(void);
+ Convert();
};
}
return self->Format(format);
}
-Object::Ptr DateTime::GetPrototype(void)
+Object::Ptr DateTime::GetPrototype()
{
static Dictionary::Ptr prototype;
BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid number of arguments for the DateTime constructor."));
}
-double DateTime::GetValue(void) const
+double DateTime::GetValue() const
{
return m_Value;
}
return Utility::FormatDateTime(format.CStr(), m_Value);
}
-String DateTime::ToString(void) const
+String DateTime::ToString() const
{
return Format("%Y-%m-%d %H:%M:%S %z");
}
String Format(const String& format) const;
- virtual double GetValue(void) const override;
- virtual String ToString(void) const override;
+ virtual double GetValue() const override;
+ virtual String ToString() const override;
- static Object::Ptr GetPrototype(void);
+ static Object::Ptr GetPrototype();
private:
double m_Value;
using namespace icinga;
-DebugInfo::DebugInfo(void)
+DebugInfo::DebugInfo()
: FirstLine(0), FirstColumn(0), LastLine(0), LastColumn(0)
{ }
int LastLine;
int LastColumn;
- DebugInfo(void);
+ DebugInfo();
};
std::ostream& operator<<(std::ostream& out, const DebugInfo& val);
static std::vector<Object::Ptr> GetParents(const Object::Ptr& child);
private:
- DependencyGraph(void);
+ DependencyGraph();
static boost::mutex m_Mutex;
static std::map<Object *, std::map<Object *, int> > m_Dependencies;
using namespace icinga;
-static double DictionaryLen(void)
+static double DictionaryLen()
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
Dictionary::Ptr self = static_cast<Dictionary::Ptr>(vframe->Self);
return self->Contains(key);
}
-static Dictionary::Ptr DictionaryShallowClone(void)
+static Dictionary::Ptr DictionaryShallowClone()
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
Dictionary::Ptr self = static_cast<Dictionary::Ptr>(vframe->Self);
return self->ShallowClone();
}
-static Array::Ptr DictionaryKeys(void)
+static Array::Ptr DictionaryKeys()
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
Dictionary::Ptr self = static_cast<Dictionary::Ptr>(vframe->Self);
return keys;
}
-static Array::Ptr DictionaryValues(void)
+static Array::Ptr DictionaryValues()
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
Dictionary::Ptr self = static_cast<Dictionary::Ptr>(vframe->Self);
return keys;
}
-Object::Ptr Dictionary::GetPrototype(void)
+Object::Ptr Dictionary::GetPrototype()
{
static Dictionary::Ptr prototype;
REGISTER_PRIMITIVE_TYPE(Dictionary, Object, Dictionary::GetPrototype());
-Dictionary::Dictionary(void)
+Dictionary::Dictionary()
{ }
-Dictionary::~Dictionary(void)
+Dictionary::~Dictionary()
{ }
/**
*
* @returns Number of elements.
*/
-size_t Dictionary::GetLength(void) const
+size_t Dictionary::GetLength() const
{
ObjectLock olock(this);
*
* @returns An iterator.
*/
-Dictionary::Iterator Dictionary::Begin(void)
+Dictionary::Iterator Dictionary::Begin()
{
ASSERT(OwnsLock());
*
* @returns An iterator.
*/
-Dictionary::Iterator Dictionary::End(void)
+Dictionary::Iterator Dictionary::End()
{
ASSERT(OwnsLock());
/**
* Removes all dictionary items.
*/
-void Dictionary::Clear(void)
+void Dictionary::Clear()
{
ObjectLock olock(this);
*
* @returns a copy of the dictionary.
*/
-Dictionary::Ptr Dictionary::ShallowClone(void) const
+Dictionary::Ptr Dictionary::ShallowClone() const
{
Dictionary::Ptr clone = new Dictionary();
CopyTo(clone);
*
* @returns a copy of the dictionary.
*/
-Object::Ptr Dictionary::Clone(void) const
+Object::Ptr Dictionary::Clone() const
{
Dictionary::Ptr dict = new Dictionary();
*
* @returns an array of key names
*/
-std::vector<String> Dictionary::GetKeys(void) const
+std::vector<String> Dictionary::GetKeys() const
{
ObjectLock olock(this);
return keys;
}
-String Dictionary::ToString(void) const
+String Dictionary::ToString() const
{
std::ostringstream msgbuf;
ConfigWriter::EmitScope(msgbuf, 1, const_cast<Dictionary *>(this));
typedef std::map<String, Value>::value_type Pair;
- Dictionary(void);
+ Dictionary();
- ~Dictionary(void);
+ ~Dictionary();
Value Get(const String& key) const;
bool Get(const String& key, Value *result) const;
void Set(const String& key, Value&& value);
bool Contains(const String& key) const;
- Iterator Begin(void);
- Iterator End(void);
+ Iterator Begin();
+ Iterator End();
- size_t GetLength(void) const;
+ size_t GetLength() const;
void Remove(const String& key);
void Remove(Iterator it);
- void Clear(void);
+ void Clear();
void CopyTo(const Dictionary::Ptr& dest) const;
- Dictionary::Ptr ShallowClone(void) const;
+ Dictionary::Ptr ShallowClone() const;
- std::vector<String> GetKeys(void) const;
+ std::vector<String> GetKeys() const;
- static Object::Ptr GetPrototype(void);
+ static Object::Ptr GetPrototype();
- virtual Object::Ptr Clone(void) const override;
+ virtual Object::Ptr Clone() const override;
- virtual String ToString(void) const override;
+ virtual String ToString() const override;
virtual Value GetFieldByName(const String& field, bool sandboxed, const DebugInfo& debugInfo) const override;
virtual void SetFieldByName(const String& field, const Value& value, const DebugInfo& debugInfo) override;
extern "C" void __cxa_throw(void *obj, TYPEINFO_TYPE *pvtinfo, void (*dest)(void *));
#endif /* HAVE_CXXABI_H */
-void icinga::RethrowUncaughtException(void)
+void icinga::RethrowUncaughtException()
{
#if defined(__GLIBCXX__) || !defined(HAVE_CXXABI_H)
throw;
}
#endif /* HAVE_CXXABI_H */
-StackTrace *icinga::GetLastExceptionStack(void)
+StackTrace *icinga::GetLastExceptionStack()
{
return l_LastExceptionStack.get();
}
l_LastExceptionStack.reset(new StackTrace(trace));
}
-ContextTrace *icinga::GetLastExceptionContext(void)
+ContextTrace *icinga::GetLastExceptionContext()
{
return l_LastExceptionContext.get();
}
: m_Message(message), m_DebugInfo(di), m_IncompleteExpr(incompleteExpr), m_HandledByDebugger(false)
{ }
-ScriptError::~ScriptError(void) throw()
+ScriptError::~ScriptError() throw()
{ }
-const char *ScriptError::what(void) const throw()
+const char *ScriptError::what() const throw()
{
return m_Message.CStr();
}
-DebugInfo ScriptError::GetDebugInfo(void) const
+DebugInfo ScriptError::GetDebugInfo() const
{
return m_DebugInfo;
}
-bool ScriptError::IsIncompleteExpression(void) const
+bool ScriptError::IsIncompleteExpression() const
{
return m_IncompleteExpr;;
}
-bool ScriptError::IsHandledByDebugger(void) const
+bool ScriptError::IsHandledByDebugger() const
{
return m_HandledByDebugger;
}
m_HandledByDebugger = handled;
}
-posix_error::posix_error(void)
+posix_error::posix_error()
: m_Message(nullptr)
{ }
-posix_error::~posix_error(void) throw()
+posix_error::~posix_error() throw()
{
free(m_Message);
}
-const char *posix_error::what(void) const throw()
+const char *posix_error::what() const throw()
{
if (!m_Message) {
std::ostringstream msgbuf;
m_What += ": " + message;
}
-ValidationError::~ValidationError(void) throw()
+ValidationError::~ValidationError() throw()
{ }
-const char *ValidationError::what(void) const throw()
+const char *ValidationError::what() const throw()
{
return m_What.CStr();
}
-ConfigObject::Ptr ValidationError::GetObject(void) const
+ConfigObject::Ptr ValidationError::GetObject() const
{
return m_Object;
}
-std::vector<String> ValidationError::GetAttributePath(void) const
+std::vector<String> ValidationError::GetAttributePath() const
{
return m_AttributePath;
}
-String ValidationError::GetMessage(void) const
+String ValidationError::GetMessage() const
{
return m_Message;
}
m_DebugHint = dhint;
}
-Dictionary::Ptr ValidationError::GetDebugHint(void) const
+Dictionary::Ptr ValidationError::GetDebugHint() const
{
return m_DebugHint;
}
public:
ScriptError(const String& message);
ScriptError(const String& message, const DebugInfo& di, bool incompleteExpr = false);
- ~ScriptError(void) throw();
+ ~ScriptError() throw();
virtual const char *what(void) const throw() override final;
- DebugInfo GetDebugInfo(void) const;
- bool IsIncompleteExpression(void) const;
+ DebugInfo GetDebugInfo() const;
+ bool IsIncompleteExpression() const;
- bool IsHandledByDebugger(void) const;
+ bool IsHandledByDebugger() const;
void SetHandledByDebugger(bool handled);
private:
{
public:
ValidationError(const ConfigObject::Ptr& object, const std::vector<String>& attributePath, const String& message);
- ~ValidationError(void) throw();
+ ~ValidationError() throw();
virtual const char *what(void) const throw() override final;
- ConfigObject::Ptr GetObject(void) const;
- std::vector<String> GetAttributePath(void) const;
- String GetMessage(void) const;
+ ConfigObject::Ptr GetObject() const;
+ std::vector<String> GetAttributePath() const;
+ String GetMessage() const;
void SetDebugHint(const Dictionary::Ptr& dhint);
- Dictionary::Ptr GetDebugHint(void) const;
+ Dictionary::Ptr GetDebugHint() const;
private:
ConfigObject::Ptr m_Object;
Dictionary::Ptr m_DebugHint;
};
-StackTrace *GetLastExceptionStack(void);
+StackTrace *GetLastExceptionStack();
void SetLastExceptionStack(const StackTrace& trace);
-ContextTrace *GetLastExceptionContext(void);
+ContextTrace *GetLastExceptionContext();
void SetLastExceptionContext(const ContextTrace& context);
-void RethrowUncaughtException(void);
+void RethrowUncaughtException();
typedef boost::error_info<StackTrace, StackTrace> StackTraceErrorInfo;
class posix_error : virtual public std::exception, virtual public boost::exception {
public:
- posix_error(void);
- virtual ~posix_error(void) throw();
+ posix_error();
+ virtual ~posix_error() throw();
virtual const char *what(void) const throw() override final;
/**
* Constructor for the FIFO class.
*/
-FIFO::FIFO(void)
+FIFO::FIFO()
: m_Buffer(nullptr), m_DataSize(0), m_AllocSize(0), m_Offset(0)
{ }
/**
* Destructor for the FIFO class.
*/
-FIFO::~FIFO(void)
+FIFO::~FIFO()
{
free(m_Buffer);
}
* Optimizes memory usage of the FIFO buffer by reallocating
* and moving the buffer.
*/
-void FIFO::Optimize(void)
+void FIFO::Optimize()
{
if (m_Offset > m_DataSize / 10 && m_Offset - m_DataSize > 1024) {
std::memmove(m_Buffer, m_Buffer + m_Offset, m_DataSize);
SignalDataAvailable();
}
-void FIFO::Close(void)
+void FIFO::Close()
{ }
-bool FIFO::IsEof(void) const
+bool FIFO::IsEof() const
{
return false;
}
-size_t FIFO::GetAvailableBytes(void) const
+size_t FIFO::GetAvailableBytes() const
{
return m_DataSize;
}
-bool FIFO::SupportsWaiting(void) const
+bool FIFO::SupportsWaiting() const
{
return true;
}
-bool FIFO::IsDataAvailable(void) const
+bool FIFO::IsDataAvailable() const
{
return m_DataSize > 0;
}
static const size_t BlockSize = 512;
- FIFO(void);
- ~FIFO(void);
+ FIFO();
+ ~FIFO();
virtual size_t Peek(void *buffer, size_t count, bool allow_partial = false) override;
virtual size_t Read(void *buffer, size_t count, bool allow_partial = false) override;
virtual void Write(const void *buffer, size_t count) override;
- virtual void Close(void) override;
- virtual bool IsEof(void) const override;
- virtual bool SupportsWaiting(void) const override;
- virtual bool IsDataAvailable(void) const override;
+ virtual void Close() override;
+ virtual bool IsEof() const override;
+ virtual bool SupportsWaiting() const override;
+ virtual bool IsDataAvailable() const override;
- size_t GetAvailableBytes(void) const;
+ size_t GetAvailableBytes() const;
private:
char *m_Buffer;
size_t m_Offset;
void ResizeBuffer(size_t newSize, bool decrease);
- void Optimize(void);
+ void Optimize();
};
}
ObjectImpl<FileLogger>::Start(runtimeCreated);
}
-void FileLogger::ReopenLogFile(void)
+void FileLogger::ReopenLogFile()
{
std::ofstream *stream = new std::ofstream();
virtual void Start(bool runtimeCreated) override;
private:
- void ReopenLogFile(void);
+ void ReopenLogFile();
};
}
}
-Object::Ptr Function::GetPrototype(void)
+Object::Ptr Function::GetPrototype()
{
static Dictionary::Ptr prototype;
return m_Callback(arguments);
}
-Object::Ptr Function::Clone(void) const
+Object::Ptr Function::Clone() const
{
return const_cast<Function *>(this);
}
Value Invoke(const std::vector<Value>& arguments = std::vector<Value>());
Value InvokeThis(const Value& otherThis, const std::vector<Value>& arguments = std::vector<Value>());
- bool IsSideEffectFree(void) const
+ bool IsSideEffectFree() const
{
return GetSideEffectFree();
}
- bool IsDeprecated(void) const
+ bool IsDeprecated() const
{
return GetDeprecated();
}
- static Object::Ptr GetPrototype(void);
+ static Object::Ptr GetPrototype();
- virtual Object::Ptr Clone(void) const override;
+ virtual Object::Ptr Clone() const override;
private:
Callback m_Callback;
using namespace icinga;
-bool icinga::InitializeOnceHelper(void (*func)(void), int priority)
+bool icinga::InitializeOnceHelper(void (*func)(), int priority)
{
Loader::AddDeferredInitializer(func, priority);
return true;
#define I2_UNIQUE_NAME(prefix) I2_TOKENPASTE2(prefix, __COUNTER__)
-bool InitializeOnceHelper(void (*func)(void), int priority = 0);
+bool InitializeOnceHelper(void (*func)(), int priority = 0);
#define INITIALIZE_ONCE(func) \
namespace { namespace I2_UNIQUE_NAME(io) { \
bool KeySet;
Value EValue;
- JsonElement(void)
+ JsonElement()
: KeySet(false)
{ }
};
m_Stack.push(element);
}
- JsonElement Pop(void)
+ JsonElement Pop()
{
JsonElement value = m_Stack.top();
m_Stack.pop();
}
}
- Value GetValue(void) const
+ Value GetValue() const
{
ASSERT(m_Stack.size() == 1);
return m_Stack.top().EValue;
}
- void SaveException(void)
+ void SaveException()
{
m_Exception = boost::current_exception();
}
- void ThrowException(void) const
+ void ThrowException() const
{
if (m_Exception)
boost::rethrow_exception(m_Exception);
class Library
{
public:
- Library(void) = default;
+ Library() = default;
Library(const String& name);
void *GetSymbolAddress(const String& name) const;
using namespace icinga;
-boost::thread_specific_ptr<std::priority_queue<DeferredInitializer> >& Loader::GetDeferredInitializers(void)
+boost::thread_specific_ptr<std::priority_queue<DeferredInitializer> >& Loader::GetDeferredInitializers()
{
static boost::thread_specific_ptr<std::priority_queue<DeferredInitializer> > initializers;
return initializers;
}
-void Loader::ExecuteDeferredInitializers(void)
+void Loader::ExecuteDeferredInitializers()
{
if (!GetDeferredInitializers().get())
return;
}
}
-void Loader::AddDeferredInitializer(const std::function<void(void)>& callback, int priority)
+void Loader::AddDeferredInitializer(const std::function<void()>& callback, int priority)
{
if (!GetDeferredInitializers().get())
GetDeferredInitializers().reset(new std::priority_queue<DeferredInitializer>());
struct DeferredInitializer
{
public:
- DeferredInitializer(const std::function<void (void)>& callback, int priority)
+ DeferredInitializer(const std::function<void ()>& callback, int priority)
: m_Callback(callback), m_Priority(priority)
{ }
return m_Priority < other.m_Priority;
}
- void operator()(void)
+ void operator()()
{
m_Callback();
}
private:
- std::function<void (void)> m_Callback;
+ std::function<void ()> m_Callback;
int m_Priority;
};
class Loader
{
public:
- static void AddDeferredInitializer(const std::function<void(void)>& callback, int priority = 0);
- static void ExecuteDeferredInitializers(void);
+ static void AddDeferredInitializer(const std::function<void ()>& callback, int priority = 0);
+ static void ExecuteDeferredInitializers();
private:
- Loader(void);
+ Loader();
- static boost::thread_specific_ptr<std::priority_queue<DeferredInitializer> >& GetDeferredInitializers(void);
+ static boost::thread_specific_ptr<std::priority_queue<DeferredInitializer> >& GetDeferredInitializers();
};
}
ObjectImpl<Logger>::Stop(runtimeRemoved);
}
-std::set<Logger::Ptr> Logger::GetLoggers(void)
+std::set<Logger::Ptr> Logger::GetLoggers()
{
boost::mutex::scoped_lock lock(m_Mutex);
return m_Loggers;
*
* @returns The minimum severity.
*/
-LogSeverity Logger::GetMinSeverity(void) const
+LogSeverity Logger::GetMinSeverity() const
{
String severity = GetSeverity();
if (severity.IsEmpty())
BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid severity: " + severity));
}
-void Logger::DisableConsoleLog(void)
+void Logger::DisableConsoleLog()
{
m_ConsoleLogEnabled = false;
}
-void Logger::EnableConsoleLog(void)
+void Logger::EnableConsoleLog()
{
m_ConsoleLogEnabled = true;
}
-bool Logger::IsConsoleLogEnabled(void)
+bool Logger::IsConsoleLogEnabled()
{
return m_ConsoleLogEnabled;
}
m_ConsoleLogSeverity = logSeverity;
}
-LogSeverity Logger::GetConsoleLogSeverity(void)
+LogSeverity Logger::GetConsoleLogSeverity()
{
return m_ConsoleLogSeverity;
}
m_TimestampEnabled = !disable;
}
-bool Logger::IsTimestampEnabled(void)
+bool Logger::IsTimestampEnabled()
{
return m_TimestampEnabled;
}
/**
* Writes the message to the application's log.
*/
-Log::~Log(void)
+Log::~Log()
{
LogEntry entry;
entry.Timestamp = Utility::GetTime();
static String SeverityToString(LogSeverity severity);
static LogSeverity StringToSeverity(const String& severity);
- LogSeverity GetMinSeverity(void) const;
+ LogSeverity GetMinSeverity() const;
/**
* Processes the log entry and writes it to the log that is
*/
virtual void ProcessLogEntry(const LogEntry& entry) = 0;
- virtual void Flush(void) = 0;
+ virtual void Flush() = 0;
- static std::set<Logger::Ptr> GetLoggers(void);
+ static std::set<Logger::Ptr> GetLoggers();
- static void DisableConsoleLog(void);
- static void EnableConsoleLog(void);
- static bool IsConsoleLogEnabled(void);
+ static void DisableConsoleLog();
+ static void EnableConsoleLog();
+ static bool IsConsoleLogEnabled();
static void DisableTimestamp(bool);
- static bool IsTimestampEnabled(void);
+ static bool IsTimestampEnabled();
static void SetConsoleLogSeverity(LogSeverity logSeverity);
- static LogSeverity GetConsoleLogSeverity(void);
+ static LogSeverity GetConsoleLogSeverity();
virtual void ValidateSeverity(const String& value, const ValidationUtils& utils) override final;
class Log
{
public:
- Log(void) = delete;
+ Log() = delete;
Log(const Log& other) = delete;
Log& operator=(const Log& rhs) = delete;
Log(LogSeverity severity, const String& facility, const String& message);
Log(LogSeverity severity, const String& facility);
- ~Log(void);
+ ~Log();
template<typename T>
Log& operator<<(const T& val)
return std::pow(x, y);
}
-static double MathRandom(void)
+static double MathRandom()
{
return (double)std::rand() / RAND_MAX;
}
static void WriteStringToStream(std::ostream& stream, const String& message);
private:
- NetString(void);
+ NetString();
};
}
: m_Socket(socket), m_Eof(false)
{ }
-void NetworkStream::Close(void)
+void NetworkStream::Close()
{
Stream::Close();
}
}
-bool NetworkStream::IsEof(void) const
+bool NetworkStream::IsEof() const
{
return m_Eof;
}
virtual size_t Read(void *buffer, size_t count, bool allow_partial = false) override;
virtual void Write(const void *buffer, size_t count) override;
- virtual void Close(void) override;
+ virtual void Close() override;
- virtual bool IsEof(void) const override;
+ virtual bool IsEof() const override;
private:
Socket::Ptr m_Socket;
using namespace icinga;
-static String NumberToString(void)
+static String NumberToString()
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
return vframe->Self;
}
-Object::Ptr Number::GetPrototype(void)
+Object::Ptr Number::GetPrototype()
{
static Dictionary::Ptr prototype;
class Number
{
public:
- static Object::Ptr GetPrototype(void);
+ static Object::Ptr GetPrototype();
private:
- Number(void);
+ Number();
};
}
using namespace icinga;
-static String ObjectToString(void)
+static String ObjectToString()
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
Object::Ptr self = static_cast<Object::Ptr>(vframe->Self);
self->NotifyField(self->GetReflectionType()->GetFieldId(attribute));
}
-static Object::Ptr ObjectClone(void)
+static Object::Ptr ObjectClone()
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
Object::Ptr self = static_cast<Object::Ptr>(vframe->Self);
return self->Clone();
}
-Object::Ptr Object::GetPrototype(void)
+Object::Ptr Object::GetPrototype()
{
static Dictionary::Ptr prototype;
/**
* Default constructor for the Object class.
*/
-Object::Object(void)
+Object::Object()
: m_References(0), m_Mutex(0)
#ifdef I2_DEBUG
, m_LockOwner(0)
/**
* Destructor for the Object class.
*/
-Object::~Object(void)
+Object::~Object()
{
delete reinterpret_cast<boost::recursive_mutex *>(m_Mutex);
}
/**
* Returns a string representation for the object.
*/
-String Object::ToString(void) const
+String Object::ToString() const
{
return "Object of type '" + GetReflectionType()->GetName() + "'";
}
*
* @returns True if the calling thread owns the lock, false otherwise.
*/
-bool Object::OwnsLock(void) const
+bool Object::OwnsLock() const
{
#ifdef _WIN32
DWORD tid = InterlockedExchangeAdd(&m_LockOwner, 0);
BOOST_THROW_EXCEPTION(std::runtime_error("Invalid field ID."));
}
-Object::Ptr Object::Clone(void) const
+Object::Ptr Object::Clone() const
{
BOOST_THROW_EXCEPTION(std::runtime_error("Object cannot be cloned."));
}
-Type::Ptr Object::GetReflectionType(void) const
+Type::Ptr Object::GetReflectionType() const
{
return Object::TypeInstance;
}
l_ObjectCounts[typeName]--;
}
-static void TypeInfoTimerHandler(void)
+static void TypeInfoTimerHandler()
{
boost::mutex::scoped_lock lock(l_ObjectCountLock);
#define IMPL_TYPE_LOOKUP() \
static intrusive_ptr<Type> TypeInstance; \
- virtual intrusive_ptr<Type> GetReflectionType(void) const override \
+ virtual intrusive_ptr<Type> GetReflectionType() const override \
{ \
return TypeInstance; \
}
template<typename T>
struct TypeHelper<T, false>
{
- static ObjectFactory GetFactory(void)
+ static ObjectFactory GetFactory()
{
return DefaultObjectFactory<T>;
}
template<typename T>
struct TypeHelper<T, true>
{
- static ObjectFactory GetFactory(void)
+ static ObjectFactory GetFactory()
{
return DefaultObjectFactoryVA<T>;
}
public:
DECLARE_PTR_TYPEDEFS(Object);
- Object(void);
- virtual ~Object(void);
+ Object();
+ virtual ~Object();
- virtual String ToString(void) const;
+ virtual String ToString() const;
- virtual intrusive_ptr<Type> GetReflectionType(void) const;
+ virtual intrusive_ptr<Type> GetReflectionType() const;
virtual void Validate(int types, const ValidationUtils& utils);
virtual Object::Ptr NavigateField(int id) const;
#ifdef I2_DEBUG
- bool OwnsLock(void) const;
+ bool OwnsLock() const;
#endif /* I2_DEBUG */
- static Object::Ptr GetPrototype(void);
+ static Object::Ptr GetPrototype();
- virtual Object::Ptr Clone(void) const;
+ virtual Object::Ptr Clone() const;
static intrusive_ptr<Type> TypeInstance;
#define I2MUTEX_UNLOCKED 0
#define I2MUTEX_LOCKED 1
-ObjectLock::ObjectLock(void)
+ObjectLock::ObjectLock()
: m_Object(nullptr), m_Locked(false)
{ }
-ObjectLock::~ObjectLock(void)
+ObjectLock::~ObjectLock()
{
Unlock();
}
#endif /* _WIN32 */
}
-void ObjectLock::Lock(void)
+void ObjectLock::Lock()
{
ASSERT(!m_Locked && m_Object);
}
}
-void ObjectLock::Unlock(void)
+void ObjectLock::Unlock()
{
#ifdef I2_DEBUG
if (m_Locked) {
struct ObjectLock
{
public:
- ObjectLock(void);
+ ObjectLock();
ObjectLock(const Object::Ptr& object);
ObjectLock(const Object *object);
- ~ObjectLock(void);
+ ~ObjectLock();
static void LockMutex(const Object *object);
- void Lock(void);
+ void Lock();
static void Spin(unsigned int it);
- void Unlock(void);
+ void Unlock();
private:
const Object *m_Object;
Object::TypeInstance = type;
}, 20);
-ObjectType::ObjectType(void)
+ObjectType::ObjectType()
{ }
-String ObjectType::GetName(void) const
+String ObjectType::GetName() const
{
return "Object";
}
-Type::Ptr ObjectType::GetBaseType(void) const
+Type::Ptr ObjectType::GetBaseType() const
{
return nullptr;
}
-int ObjectType::GetAttributes(void) const
+int ObjectType::GetAttributes() const
{
return 0;
}
BOOST_THROW_EXCEPTION(std::runtime_error("Invalid field ID."));
}
-int ObjectType::GetFieldCount(void) const
+int ObjectType::GetFieldCount() const
{
return 1;
}
-ObjectFactory ObjectType::GetFactory(void) const
+ObjectFactory ObjectType::GetFactory() const
{
return DefaultObjectFactory<Object>;
}
class ObjectType final : public Type
{
public:
- ObjectType(void);
+ ObjectType();
- virtual String GetName(void) const override;
- virtual Type::Ptr GetBaseType(void) const override;
- virtual int GetAttributes(void) const override;
+ virtual String GetName() const override;
+ virtual Type::Ptr GetBaseType() const override;
+ virtual int GetAttributes() const override;
virtual int GetFieldId(const String& name) const override;
virtual Field GetFieldInfo(int id) const override;
- virtual int GetFieldCount(void) const override;
+ virtual int GetFieldCount() const override;
protected:
- virtual ObjectFactory GetFactory(void) const override;
+ virtual ObjectFactory GetFactory() const override;
};
}
REGISTER_TYPE(PerfdataValue);
REGISTER_SCRIPTFUNCTION_NS(System, parse_performance_data, PerfdataValue::Parse, "perfdata");
-PerfdataValue::PerfdataValue(void)
+PerfdataValue::PerfdataValue()
{ }
PerfdataValue::PerfdataValue(String label, double value, bool counter,
return new PerfdataValue(label, value, counter, unit, warn, crit, min, max);
}
-String PerfdataValue::Format(void) const
+String PerfdataValue::Format() const
{
std::ostringstream result;
public:
DECLARE_OBJECT(PerfdataValue);
- PerfdataValue(void);
+ PerfdataValue();
PerfdataValue(String label, double value, bool counter = false, const String& unit = "",
const Value& warn = Empty, const Value& crit = Empty,
const Value& min = Empty, const Value& max = Empty);
static PerfdataValue::Ptr Parse(const String& perfdata);
- String Format(void) const;
+ String Format() const;
private:
static Value ParseWarnCritMinMaxToken(const std::vector<String>& tokens,
: m_Name(name), m_Base(base), m_Factory(factory)
{ }
-String PrimitiveType::GetName(void) const
+String PrimitiveType::GetName() const
{
return m_Name;
}
-Type::Ptr PrimitiveType::GetBaseType(void) const
+Type::Ptr PrimitiveType::GetBaseType() const
{
if (m_Base == "None")
return nullptr;
return Type::GetByName(m_Base);
}
-int PrimitiveType::GetAttributes(void) const
+int PrimitiveType::GetAttributes() const
{
return 0;
}
throw std::runtime_error("Invalid field ID.");
}
-int PrimitiveType::GetFieldCount(void) const
+int PrimitiveType::GetFieldCount() const
{
Type::Ptr base = GetBaseType();
return 0;
}
-ObjectFactory PrimitiveType::GetFactory(void) const
+ObjectFactory PrimitiveType::GetFactory() const
{
return m_Factory;
}
public:
PrimitiveType(const String& name, const String& base, const ObjectFactory& factory = ObjectFactory());
- virtual String GetName(void) const override;
- virtual Type::Ptr GetBaseType(void) const override;
- virtual int GetAttributes(void) const override;
+ virtual String GetName() const override;
+ virtual Type::Ptr GetBaseType() const override;
+ virtual int GetAttributes() const override;
virtual int GetFieldId(const String& name) const override;
virtual Field GetFieldInfo(int id) const override;
- virtual int GetFieldCount(void) const override;
+ virtual int GetFieldCount() const override;
protected:
- virtual ObjectFactory GetFactory(void) const override;
+ virtual ObjectFactory GetFactory() const override;
private:
String m_Name;
#endif /* _WIN32 */
}
-Process::~Process(void)
+Process::~Process()
{
#ifdef _WIN32
CloseHandle(m_Overlapped.hEvent);
return response;
}
-static void ProcessHandler(void)
+static void ProcessHandler()
{
sigset_t mask;
sigfillset(&mask);
_exit(0);
}
-static void StartSpawnProcessHelper(void)
+static void StartSpawnProcessHelper()
{
if (l_ProcessControlFD != -1) {
(void)close(l_ProcessControlFD);
return response->Get("rc");
}
-void Process::InitializeSpawnHelper(void)
+void Process::InitializeSpawnHelper()
{
if (l_ProcessControlFD == -1)
StartSpawnProcessHelper();
}
#endif /* _WIN32 */
-static void InitializeProcess(void)
+static void InitializeProcess()
{
for (int tid = 0; tid < IOTHREADS; tid++) {
#ifdef _WIN32
INITIALIZE_ONCE(InitializeProcess);
-void Process::ThreadInitialize(void)
+void Process::ThreadInitialize()
{
/* Note to self: Make sure this runs _after_ we've daemonized. */
for (int tid = 0; tid < IOTHREADS; tid++) {
m_Timeout = timeout;
}
-double Process::GetTimeout(void) const
+double Process::GetTimeout() const
{
return m_Timeout;
}
m_AdjustPriority = adjust;
}
-bool Process::GetAdjustPriority(void) const
+bool Process::GetAdjustPriority() const
{
return m_AdjustPriority;
}
#endif /* _WIN32 */
}
-bool Process::DoEvents(void)
+bool Process::DoEvents()
{
bool is_timeout = false;
#ifndef _WIN32
return false;
}
-pid_t Process::GetPID(void) const
+pid_t Process::GetPID() const
{
return m_PID;
}
-int Process::GetTID(void) const
+int Process::GetTID() const
{
return (reinterpret_cast<uintptr_t>(this) / sizeof(void *)) % IOTHREADS;
}
static const std::deque<Process::Ptr>::size_type MaxTasksPerThread = 512;
Process(const Arguments& arguments, const Dictionary::Ptr& extraEnvironment = nullptr);
- ~Process(void);
+ ~Process();
void SetTimeout(double timeout);
- double GetTimeout(void) const;
+ double GetTimeout() const;
void SetAdjustPriority(bool adjust);
- bool GetAdjustPriority(void) const;
+ bool GetAdjustPriority() const;
void Run(const std::function<void (const ProcessResult&)>& callback = std::function<void (const ProcessResult&)>());
- pid_t GetPID(void) const;
+ pid_t GetPID() const;
static Arguments PrepareCommand(const Value& command);
- static void ThreadInitialize(void);
+ static void ThreadInitialize();
static String PrettyPrintArguments(const Arguments& arguments);
#ifndef _WIN32
- static void InitializeSpawnHelper(void);
+ static void InitializeSpawnHelper();
#endif /* _WIN32 */
private:
ProcessResult m_Result;
static void IOThreadProc(int tid);
- bool DoEvents(void);
- int GetTID(void) const;
+ bool DoEvents();
+ int GetTID() const;
};
}
OnUnregistered(name);
}
- void Clear(void)
+ void Clear()
{
typename Registry<U, T>::ItemMap items;
return it->second;
}
- ItemMap GetItems(void) const
+ ItemMap GetItems() const
{
boost::mutex::scoped_lock lock(m_Mutex);
: Object(), m_Slots(slots, 0), m_TimeValue(0), m_InsertedValues(0)
{ }
-RingBuffer::SizeType RingBuffer::GetLength(void) const
+RingBuffer::SizeType RingBuffer::GetLength() const
{
ObjectLock olock(this);
RingBuffer(SizeType slots);
- SizeType GetLength(void) const;
+ SizeType GetLength() const;
void InsertValue(SizeType tv, int num);
int UpdateAndGetValues(SizeType tv, SizeType span);
double CalculateRate(SizeType tv, SizeType span);
InitializeFrame();
}
-void ScriptFrame::InitializeFrame(void)
+void ScriptFrame::InitializeFrame()
{
std::stack<ScriptFrame *> *frames = m_ScriptFrames.get();
PushFrame(this);
}
-ScriptFrame::~ScriptFrame(void)
+ScriptFrame::~ScriptFrame()
{
ScriptFrame *frame = PopFrame();
ASSERT(frame == this);
}
-void ScriptFrame::IncreaseStackDepth(void)
+void ScriptFrame::IncreaseStackDepth()
{
if (Depth + 1 > 300)
BOOST_THROW_EXCEPTION(ScriptError("Stack overflow while evaluating expression: Recursion level too deep."));
Depth++;
}
-void ScriptFrame::DecreaseStackDepth(void)
+void ScriptFrame::DecreaseStackDepth()
{
Depth--;
}
-ScriptFrame *ScriptFrame::GetCurrentFrame(void)
+ScriptFrame *ScriptFrame::GetCurrentFrame()
{
std::stack<ScriptFrame *> *frames = m_ScriptFrames.get();
return frames->top();
}
-ScriptFrame *ScriptFrame::PopFrame(void)
+ScriptFrame *ScriptFrame::PopFrame()
{
std::stack<ScriptFrame *> *frames = m_ScriptFrames.get();
frames->push(frame);
}
-Array::Ptr ScriptFrame::GetImports(void)
+Array::Ptr ScriptFrame::GetImports()
{
return m_Imports;
}
ScriptFrame(bool allocLocals);
ScriptFrame(bool allocLocals, const Value& self);
- ~ScriptFrame(void);
+ ~ScriptFrame();
- void IncreaseStackDepth(void);
- void DecreaseStackDepth(void);
+ void IncreaseStackDepth();
+ void DecreaseStackDepth();
- static ScriptFrame *GetCurrentFrame(void);
+ static ScriptFrame *GetCurrentFrame();
- static Array::Ptr GetImports(void);
+ static Array::Ptr GetImports();
static void AddImport(const Object::Ptr& import);
private:
static Array::Ptr m_Imports;
static void PushFrame(ScriptFrame *frame);
- static ScriptFrame *PopFrame(void);
+ static ScriptFrame *PopFrame();
- void InitializeFrame(void);
+ void InitializeFrame();
};
}
return m_Globals->Contains(name);
}
-Dictionary::Ptr ScriptGlobal::GetGlobals(void)
+Dictionary::Ptr ScriptGlobal::GetGlobals()
{
return m_Globals;
}
static void WriteToFile(const String& filename);
- static Dictionary::Ptr GetGlobals(void);
+ static Dictionary::Ptr GetGlobals();
private:
static Dictionary::Ptr m_Globals;
MatchAny
};
-void ScriptUtils::StaticInitialize(void)
+void ScriptUtils::StaticInitialize()
{
ScriptGlobal::Set("MatchAll", MatchAll);
ScriptGlobal::Set("MatchAny", MatchAny);
class ScriptUtils
{
public:
- static void StaticInitialize(void);
+ static void StaticInitialize();
static String CastString(const Value& value);
static double CastNumber(const Value& value);
static bool CastBool(const Value& value);
static Value GlobRecursive(const std::vector<Value>& args);
private:
- ScriptUtils(void);
+ ScriptUtils();
};
}
class Singleton
{
public:
- static T *GetInstance(void)
+ static T *GetInstance()
{
/* FIXME: This relies on static initializers being atomic. */
static boost::mutex mutex;
/**
* Constructor for the Socket class.
*/
-Socket::Socket(void)
+Socket::Socket()
: m_FD(INVALID_SOCKET)
{ }
/**
* Destructor for the Socket class.
*/
-Socket::~Socket(void)
+Socket::~Socket()
{
Close();
}
*
* @returns The file descriptor.
*/
-SOCKET Socket::GetFD(void) const
+SOCKET Socket::GetFD() const
{
ObjectLock olock(this);
/**
* Closes the socket.
*/
-void Socket::Close(void)
+void Socket::Close()
{
ObjectLock olock(this);
*
* @returns An error code.
*/
-int Socket::GetError(void) const
+int Socket::GetError() const
{
int opt;
socklen_t optlen = sizeof(opt);
*
* @returns A String describing the local address.
*/
-String Socket::GetClientAddress(void)
+String Socket::GetClientAddress()
{
boost::mutex::scoped_lock lock(m_SocketMutex);
*
* @returns A String describing the peer address.
*/
-String Socket::GetPeerAddress(void)
+String Socket::GetPeerAddress()
{
boost::mutex::scoped_lock lock(m_SocketMutex);
/**
* Starts listening for incoming client connections.
*/
-void Socket::Listen(void)
+void Socket::Listen()
{
if (listen(GetFD(), SOMAXCONN) < 0) {
#ifndef _WIN32
/**
* Accepts a new client and creates a new client object for it.
*/
-Socket::Ptr Socket::Accept(void)
+Socket::Ptr Socket::Accept()
{
sockaddr_storage addr;
socklen_t addrlen = sizeof(addr);
return (rc != 0);
}
-void Socket::MakeNonBlocking(void)
+void Socket::MakeNonBlocking()
{
#ifdef _WIN32
Utility::SetNonBlockingSocket(GetFD());
public:
DECLARE_PTR_TYPEDEFS(Socket);
- Socket(void);
+ Socket();
Socket(SOCKET fd);
- ~Socket(void);
+ ~Socket();
- SOCKET GetFD(void) const;
+ SOCKET GetFD() const;
- void Close(void);
+ void Close();
- String GetClientAddress(void);
- String GetPeerAddress(void);
+ String GetClientAddress();
+ String GetPeerAddress();
size_t Read(void *buffer, size_t size);
size_t Write(const void *buffer, size_t size);
- void Listen(void);
- Socket::Ptr Accept(void);
+ void Listen();
+ Socket::Ptr Accept();
bool Poll(bool read, bool write, struct timeval *timeout = nullptr);
- void MakeNonBlocking(void);
+ void MakeNonBlocking();
static void SocketPair(SOCKET s[2]);
protected:
void SetFD(SOCKET fd);
- int GetError(void) const;
+ int GetError() const;
mutable boost::mutex m_SocketMutex;
int SocketEvents::m_NextID = 0;
-void SocketEventEngine::Start(void)
+void SocketEventEngine::Start()
{
for (int tid = 0; tid < SOCKET_IOTHREADS; tid++) {
Socket::SocketPair(m_EventFDs[tid]);
}
}
-void SocketEvents::InitializeEngine(void)
+void SocketEvents::InitializeEngine()
{
String eventEngine = ScriptGlobal::Get("EventEngine", &Empty);
Register(lifesupportObject);
}
-SocketEvents::~SocketEvents(void)
+SocketEvents::~SocketEvents()
{
VERIFY(m_FD == INVALID_SOCKET);
}
l_SocketIOEngine->Register(this, lifesupportObject);
}
-void SocketEvents::Unregister(void)
+void SocketEvents::Unregister()
{
l_SocketIOEngine->Unregister(this);
}
return m_EventMutex[tid];
}
-bool SocketEvents::IsHandlingEvents(void) const
+bool SocketEvents::IsHandlingEvents() const
{
int tid = m_ID % SOCKET_IOTHREADS;
boost::mutex::scoped_lock lock(l_SocketIOEngine->GetMutex(tid));
class SocketEvents
{
public:
- ~SocketEvents(void);
+ ~SocketEvents();
virtual void OnEvent(int revents);
- void Unregister(void);
+ void Unregister();
void ChangeEvents(int events);
- bool IsHandlingEvents(void) const;
+ bool IsHandlingEvents() const;
- void *GetEnginePrivate(void) const;
+ void *GetEnginePrivate() const;
void SetEnginePrivate(void *priv);
protected:
static int m_NextID;
- static void InitializeEngine(void);
+ static void InitializeEngine();
void WakeUpThread(bool wait = false);
SocketEvents *EventInterface;
Object *LifesupportObject;
- SocketEventDescriptor(void)
+ SocketEventDescriptor()
: Events(POLLIN), EventInterface(nullptr), LifesupportObject(nullptr)
{ }
};
class SocketEventEngine
{
public:
- void Start(void);
+ void Start();
void WakeUpThread(int sid, bool wait);
# pragma optimize("", off)
#endif /* _MSC_VER */
-StackTrace::StackTrace(void)
+StackTrace::StackTrace()
{
#ifdef HAVE_BACKTRACE_SYMBOLS
m_Count = backtrace(m_Frames, sizeof(m_Frames) / sizeof(m_Frames[0]));
class StackTrace
{
public:
- StackTrace(void);
+ StackTrace();
#ifdef _WIN32
explicit StackTrace(PEXCEPTION_POINTERS exi);
#endif /* _WIN32 */
void Print(std::ostream& fp, int ignoreFrames = 0) const;
- static void StaticInitialize(void);
+ static void StaticInitialize();
private:
void *m_Frames[64];
: m_InnerStream(innerStream), m_OwnsStream(ownsStream)
{ }
-StdioStream::~StdioStream(void)
+StdioStream::~StdioStream()
{
Close();
}
m_InnerStream->write(static_cast<const char *>(buffer), size);
}
-void StdioStream::Close(void)
+void StdioStream::Close()
{
Stream::Close();
}
}
-bool StdioStream::IsDataAvailable(void) const
+bool StdioStream::IsDataAvailable() const
{
return !IsEof();
}
-bool StdioStream::IsEof(void) const
+bool StdioStream::IsEof() const
{
return !m_InnerStream->good();
}
DECLARE_PTR_TYPEDEFS(StdioStream);
StdioStream(std::iostream *innerStream, bool ownsStream);
- ~StdioStream(void);
+ ~StdioStream();
virtual size_t Read(void *buffer, size_t size, bool allow_partial = false) override;
virtual void Write(const void *buffer, size_t size) override;
- virtual void Close(void) override;
+ virtual void Close() override;
- virtual bool IsDataAvailable(void) const override;
- virtual bool IsEof(void) const override;
+ virtual bool IsDataAvailable() const override;
+ virtual bool IsEof() const override;
private:
std::iostream *m_InnerStream;
BOOST_THROW_EXCEPTION(std::runtime_error("Stream does not support waiting."));
}
-bool Stream::SupportsWaiting(void) const
+bool Stream::SupportsWaiting() const
{
return false;
}
-bool Stream::IsDataAvailable(void) const
+bool Stream::IsDataAvailable() const
{
return false;
}
-void Stream::Shutdown(void)
+void Stream::Shutdown()
{
BOOST_THROW_EXCEPTION(std::runtime_error("Stream does not support Shutdown()."));
}
BOOST_THROW_EXCEPTION(std::runtime_error("Stream does not support Peek()."));
}
-void Stream::SignalDataAvailable(void)
+void Stream::SignalDataAvailable()
{
OnDataAvailable(this);
return IsDataAvailable() || IsEof();
}
-static void StreamDummyCallback(void)
+static void StreamDummyCallback()
{ }
-void Stream::Close(void)
+void Stream::Close()
{
OnDataAvailable.disconnect_all_slots();
struct StreamReadContext
{
- StreamReadContext(void)
+ StreamReadContext()
: Buffer(nullptr), Size(0), MustRead(true), Eof(false)
{ }
- ~StreamReadContext(void)
+ ~StreamReadContext()
{
free(Buffer);
}
* Causes the stream to be closed (via Close()) once all pending data has been
* written.
*/
- virtual void Shutdown(void);
+ virtual void Shutdown();
/**
* Closes the stream and releases resources.
*/
- virtual void Close(void);
+ virtual void Close();
/**
* Checks whether we've reached the end-of-file condition.
*
* @returns true if EOF.
*/
- virtual bool IsEof(void) const = 0;
+ virtual bool IsEof() const = 0;
/**
* Waits until data can be read from the stream.
*/
bool WaitForData(int timeout = -1);
- virtual bool SupportsWaiting(void) const;
+ virtual bool SupportsWaiting() const;
- virtual bool IsDataAvailable(void) const;
+ virtual bool IsDataAvailable() const;
void RegisterDataHandler(const std::function<void(const Stream::Ptr&)>& handler);
StreamReadStatus ReadLine(String *line, StreamReadContext& context, bool may_wait = false);
protected:
- void SignalDataAvailable(void);
+ void SignalDataAvailable();
private:
boost::signals2::signal<void(const Stream::Ptr&)> OnDataAvailable;
/**
* Constructor for the StreamLogger class.
*/
-StreamLogger::StreamLogger(void)
+StreamLogger::StreamLogger()
: m_Stream(nullptr), m_OwnsStream(false)
{ }
/**
* Destructor for the StreamLogger class.
*/
-StreamLogger::~StreamLogger(void)
+StreamLogger::~StreamLogger()
{
if (m_FlushLogTimer)
m_FlushLogTimer->Stop();
delete m_Stream;
}
-void StreamLogger::FlushLogTimerHandler(void)
+void StreamLogger::FlushLogTimerHandler()
{
Flush();
}
-void StreamLogger::Flush(void)
+void StreamLogger::Flush()
{
if (m_Stream)
m_Stream->flush();
public:
DECLARE_OBJECT(StreamLogger);
- StreamLogger(void);
+ StreamLogger();
virtual void Stop(bool runtimeRemoved) override;
- ~StreamLogger(void);
+ ~StreamLogger();
void BindStream(std::ostream *stream, bool ownsStream);
static void ProcessLogEntry(std::ostream& stream, const LogEntry& entry);
protected:
- virtual void ProcessLogEntry(const LogEntry& entry) override final;
- virtual void Flush(void) override final;
+ void ProcessLogEntry(const LogEntry& entry) final;
+ void Flush(void) final;
private:
static boost::mutex m_Mutex;
Timer::Ptr m_FlushLogTimer;
- void FlushLogTimerHandler(void);
+ void FlushLogTimerHandler();
};
}
using namespace icinga;
-static int StringLen(void)
+static int StringLen()
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
String self = vframe->Self;
return self.GetLength();
}
-static String StringToString(void)
+static String StringToString()
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
return vframe->Self;
return self.SubStr(args[0]);
}
-static String StringUpper(void)
+static String StringUpper()
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
String self = vframe->Self;
return boost::to_upper_copy(self);
}
-static String StringLower(void)
+static String StringLower()
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
String self = vframe->Self;
return self;
}
-static String StringReverse(void)
+static String StringReverse()
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
String self = vframe->Self;
return self.Reverse();
}
-static String StringTrim(void)
+static String StringTrim()
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
String self = vframe->Self;
return self.Trim();
}
-Object::Ptr String::GetPrototype(void)
+Object::Ptr String::GetPrototype()
{
static Dictionary::Ptr prototype;
const String::SizeType String::NPos = std::string::npos;
-String::String(void)
+String::String()
: m_Data()
{ }
}
#endif /* _MSC_VER */
-String::~String(void)
+String::~String()
{ }
String& String::operator=(Value&& other)
return *this;
}
-bool String::IsEmpty(void) const
+bool String::IsEmpty() const
{
return m_Data.empty();
}
return m_Data < rhs.m_Data;
}
-String::operator const std::string&(void) const
+String::operator const std::string&() const
{
return m_Data;
}
-const char *String::CStr(void) const
+const char *String::CStr() const
{
return m_Data.c_str();
}
-void String::Clear(void)
+void String::Clear()
{
m_Data.clear();
}
-String::SizeType String::GetLength(void) const
+String::SizeType String::GetLength() const
{
return m_Data.size();
}
-std::string& String::GetData(void)
+std::string& String::GetData()
{
return m_Data;
}
-const std::string& String::GetData(void) const
+const std::string& String::GetData() const
{
return m_Data;
}
m_Data.replace(first, second, str);
}
-String String::Trim(void) const
+String String::Trim() const
{
String t = m_Data;
boost::algorithm::trim(t);
return t;
}
-String String::ToLower(void) const
+String String::ToLower() const
{
String t = m_Data;
boost::algorithm::to_lower(t);
return t;
}
-String String::ToUpper(void) const
+String String::ToUpper() const
{
String t = m_Data;
boost::algorithm::to_upper(t);
return t;
}
-String String::Reverse(void) const
+String String::Reverse() const
{
String t = m_Data;
std::reverse(t.m_Data.begin(), t.m_Data.end());
return m_Data.erase(first, last);
}
-String::Iterator String::Begin(void)
+String::Iterator String::Begin()
{
return m_Data.begin();
}
-String::ConstIterator String::Begin(void) const
+String::ConstIterator String::Begin() const
{
return m_Data.begin();
}
-String::Iterator String::End(void)
+String::Iterator String::End()
{
return m_Data.end();
}
-String::ConstIterator String::End(void) const
+String::ConstIterator String::End() const
{
return m_Data.end();
}
-String::ReverseIterator String::RBegin(void)
+String::ReverseIterator String::RBegin()
{
return m_Data.rbegin();
}
-String::ConstReverseIterator String::RBegin(void) const
+String::ConstReverseIterator String::RBegin() const
{
return m_Data.rbegin();
}
-String::ReverseIterator String::REnd(void)
+String::ReverseIterator String::REnd()
{
return m_Data.rend();
}
-String::ConstReverseIterator String::REnd(void) const
+String::ConstReverseIterator String::REnd() const
{
return m_Data.rend();
}
typedef std::string::size_type SizeType;
- String(void);
+ String();
String(const char *data);
String(const std::string& data);
String(std::string&& data);
String(Value&& other);
#endif /* _MSC_VER */
- ~String(void);
+ ~String();
template<typename InputIterator>
String(InputIterator begin, InputIterator end)
String& operator+=(const Value& rhs);
String& operator+=(char rhs);
- bool IsEmpty(void) const;
+ bool IsEmpty() const;
bool operator<(const String& rhs) const;
- operator const std::string&(void) const;
+ operator const std::string&() const;
- const char *CStr(void) const;
+ const char *CStr() const;
- void Clear(void);
+ void Clear();
- SizeType GetLength(void) const;
+ SizeType GetLength() const;
- std::string& GetData(void);
- const std::string& GetData(void) const;
+ std::string& GetData();
+ const std::string& GetData() const;
SizeType Find(const String& str, SizeType pos = 0) const;
SizeType RFind(const String& str, SizeType pos = NPos) const;
void Replace(SizeType first, SizeType second, const String& str);
- String Trim(void) const;
+ String Trim() const;
- String ToLower(void) const;
+ String ToLower() const;
- String ToUpper(void) const;
+ String ToUpper() const;
- String Reverse(void) const;
+ String Reverse() const;
void Append(int count, char ch);
m_Data.insert(p, first, last);
}
- Iterator Begin(void);
- ConstIterator Begin(void) const;
- Iterator End(void);
- ConstIterator End(void) const;
- ReverseIterator RBegin(void);
- ConstReverseIterator RBegin(void) const;
- ReverseIterator REnd(void);
- ConstReverseIterator REnd(void) const;
+ Iterator Begin();
+ ConstIterator Begin() const;
+ Iterator End();
+ ConstIterator End() const;
+ ReverseIterator RBegin();
+ ConstReverseIterator RBegin() const;
+ ReverseIterator REnd();
+ ConstReverseIterator REnd() const;
static const SizeType NPos;
- static Object::Ptr GetPrototype(void);
+ static Object::Ptr GetPrototype();
private:
std::string m_Data;
std::map<String, int> SyslogLogger::m_FacilityMap;
-void SyslogLogger::StaticInitialize(void)
+void SyslogLogger::StaticInitialize()
{
ScriptGlobal::Set("FacilityAuth", "LOG_AUTH");
ScriptGlobal::Set("FacilityAuthPriv", "LOG_AUTHPRIV");
status->Set("sysloglogger", nodes);
}
-void SyslogLogger::OnConfigLoaded(void)
+void SyslogLogger::OnConfigLoaded()
{
ObjectImpl<SyslogLogger>::OnConfigLoaded();
syslog(severity | m_Facility, "%s", entry.Message.CStr());
}
-void SyslogLogger::Flush(void)
+void SyslogLogger::Flush()
{
/* Nothing to do here. */
}
DECLARE_OBJECT(SyslogLogger);
DECLARE_OBJECTNAME(SyslogLogger);
- static void StaticInitialize(void);
+ static void StaticInitialize();
static void StatsFunc(const Dictionary::Ptr& status, const Array::Ptr& perfdata);
- virtual void OnConfigLoaded(void) override;
+ virtual void OnConfigLoaded() override;
virtual void ValidateFacility(const String& value, const ValidationUtils& utils) override;
protected:
int m_Facility;
virtual void ProcessLogEntry(const LogEntry& entry) override;
- virtual void Flush(void) override;
+ virtual void Flush() override;
};
}
Start();
}
-ThreadPool::~ThreadPool(void)
+ThreadPool::~ThreadPool()
{
Stop();
}
-void ThreadPool::Start(void)
+void ThreadPool::Start()
{
if (!m_Stopped)
return;
m_MgmtThread = std::thread(std::bind(&ThreadPool::ManagerThreadProc, this));
}
-void ThreadPool::Stop(void)
+void ThreadPool::Stop()
{
if (m_Stopped)
return;
return true;
}
-void ThreadPool::ManagerThreadProc(void)
+void ThreadPool::ManagerThreadProc()
{
std::ostringstream idbuf;
idbuf << "TP #" << m_ID << " Manager";
typedef std::function<void ()> WorkFunction;
ThreadPool(size_t max_threads = UINT_MAX);
- ~ThreadPool(void);
+ ~ThreadPool();
- void Start(void);
- void Stop(void);
+ void Start();
+ void Stop();
bool Post(const WorkFunction& callback, SchedulerPolicy policy = DefaultScheduler);
WorkerThread Threads[16];
- Queue(void)
+ Queue()
: WaitTime(0), ServiceTime(0), TaskCount(0), Stopped(false)
{ }
Queue m_Queues[QUEUECOUNT];
- void ManagerThreadProc(void);
+ void ManagerThreadProc();
};
}
: m_Timer(timer)
{ }
- inline Timer *GetObject(void) const
+ inline Timer *GetObject() const
{
return m_Timer;
}
- inline double GetNextUnlocked(void) const
+ inline double GetNextUnlocked() const
{
return m_Timer->m_Next;
}
- operator Timer *(void) const
+ operator Timer *() const
{
return m_Timer;
}
/**
* Constructor for the Timer class.
*/
-Timer::Timer(void)
+Timer::Timer()
: m_Interval(0), m_Next(0), m_Started(false), m_Running(false)
{ }
/**
* Destructor for the Timer class.
*/
-Timer::~Timer(void)
+Timer::~Timer()
{
Stop(true);
}
-void Timer::Uninitialize(void)
+void Timer::Uninitialize()
{
{
boost::mutex::scoped_lock lock(l_TimerMutex);
/**
* Calls this timer.
*/
-void Timer::Call(void)
+void Timer::Call()
{
try {
OnTimerExpired(Timer::Ptr(this));
*
* @returns The interval.
*/
-double Timer::GetInterval(void) const
+double Timer::GetInterval() const
{
boost::mutex::scoped_lock lock(l_TimerMutex);
return m_Interval;
/**
* Registers the timer and starts processing events for it.
*/
-void Timer::Start(void)
+void Timer::Start()
{
{
boost::mutex::scoped_lock lock(l_TimerMutex);
*
* @returns The timestamp.
*/
-double Timer::GetNext(void) const
+double Timer::GetNext() const
{
boost::mutex::scoped_lock lock(l_TimerMutex);
return m_Next;
/**
* Worker thread proc for Timer objects.
*/
-void Timer::TimerThreadProc(void)
+void Timer::TimerThreadProc()
{
Utility::SetThreadName("Timer Thread");
public:
DECLARE_PTR_TYPEDEFS(Timer);
- Timer(void);
- ~Timer(void);
+ Timer();
+ ~Timer();
- static void Uninitialize(void);
+ static void Uninitialize();
void SetInterval(double interval);
- double GetInterval(void) const;
+ double GetInterval() const;
static void AdjustTimers(double adjustment);
- void Start(void);
+ void Start();
void Stop(bool wait = false);
void Reschedule(double next = -1);
- double GetNext(void) const;
+ double GetNext() const;
boost::signals2::signal<void(const Timer::Ptr&)> OnTimerExpired;
void Call();
void InternalReschedule(bool completed, double next = -1);
- static void TimerThreadProc(void);
+ static void TimerThreadProc();
friend class TimerHolder;
};
}
}
-TlsStream::~TlsStream(void)
+TlsStream::~TlsStream()
{
CloseInternal(true);
}
return 1;
}
-bool TlsStream::IsVerifyOK(void) const
+bool TlsStream::IsVerifyOK() const
{
return m_VerifyOK;
}
-String TlsStream::GetVerifyError(void) const
+String TlsStream::GetVerifyError() const
{
return m_VerifyError;
}
*
* @returns The X509 certificate.
*/
-std::shared_ptr<X509> TlsStream::GetClientCertificate(void) const
+std::shared_ptr<X509> TlsStream::GetClientCertificate() const
{
boost::mutex::scoped_lock lock(m_Mutex);
return std::shared_ptr<X509>(SSL_get_certificate(m_SSL.get()), &Utility::NullDeleter);
*
* @returns The X509 certificate.
*/
-std::shared_ptr<X509> TlsStream::GetPeerCertificate(void) const
+std::shared_ptr<X509> TlsStream::GetPeerCertificate() const
{
boost::mutex::scoped_lock lock(m_Mutex);
return std::shared_ptr<X509>(SSL_get_peer_certificate(m_SSL.get()), X509_free);
}
}
-void TlsStream::HandleError(void) const
+void TlsStream::HandleError() const
{
if (m_ErrorOccurred) {
BOOST_THROW_EXCEPTION(openssl_error()
}
}
-void TlsStream::Handshake(void)
+void TlsStream::Handshake()
{
boost::mutex::scoped_lock lock(m_Mutex);
ChangeEvents(POLLIN|POLLOUT);
}
-void TlsStream::Shutdown(void)
+void TlsStream::Shutdown()
{
m_Shutdown = true;
ChangeEvents(POLLOUT);
/**
* Closes the stream.
*/
-void TlsStream::Close(void)
+void TlsStream::Close()
{
CloseInternal(false);
}
m_CV.notify_all();
}
-bool TlsStream::IsEof(void) const
+bool TlsStream::IsEof() const
{
return m_Eof;
}
-bool TlsStream::SupportsWaiting(void) const
+bool TlsStream::SupportsWaiting() const
{
return true;
}
-bool TlsStream::IsDataAvailable(void) const
+bool TlsStream::IsDataAvailable() const
{
boost::mutex::scoped_lock lock(m_Mutex);
return m_RecvQ->GetAvailableBytes() > 0;
}
-Socket::Ptr TlsStream::GetSocket(void) const
+Socket::Ptr TlsStream::GetSocket() const
{
return m_Socket;
}
DECLARE_PTR_TYPEDEFS(TlsStream);
TlsStream(const Socket::Ptr& socket, const String& hostname, ConnectionRole role, const std::shared_ptr<SSL_CTX>& sslContext = MakeSSLContext());
- ~TlsStream(void);
+ ~TlsStream();
- Socket::Ptr GetSocket(void) const;
+ Socket::Ptr GetSocket() const;
- std::shared_ptr<X509> GetClientCertificate(void) const;
- std::shared_ptr<X509> GetPeerCertificate(void) const;
+ std::shared_ptr<X509> GetClientCertificate() const;
+ std::shared_ptr<X509> GetPeerCertificate() const;
- void Handshake(void);
+ void Handshake();
- virtual void Close(void) override;
- virtual void Shutdown(void) override;
+ virtual void Close() override;
+ virtual void Shutdown() override;
virtual size_t Peek(void *buffer, size_t count, bool allow_partial = false) override;
virtual size_t Read(void *buffer, size_t count, bool allow_partial = false) override;
virtual void Write(const void *buffer, size_t count) override;
- virtual bool IsEof(void) const override;
+ virtual bool IsEof() const override;
- virtual bool SupportsWaiting(void) const override;
- virtual bool IsDataAvailable(void) const override;
+ virtual bool SupportsWaiting() const override;
+ virtual bool IsDataAvailable() const override;
- bool IsVerifyOK(void) const;
- String GetVerifyError(void) const;
+ bool IsVerifyOK() const;
+ String GetVerifyError() const;
private:
std::shared_ptr<SSL> m_SSL;
virtual void OnEvent(int revents) override;
- void HandleError(void) const;
+ void HandleError() const;
static int ValidateCertificate(int preverify_ok, X509_STORE_CTX *ctx);
static void NullCertificateDeleter(X509 *certificate);
l_Mutexes[type].unlock();
}
-static unsigned long OpenSSLIDCallback(void)
+static unsigned long OpenSSLIDCallback()
{
#ifdef _WIN32
return (unsigned long)GetCurrentThreadId();
/**
* Initializes the OpenSSL library.
*/
-void InitializeOpenSSL(void)
+void InitializeOpenSSL()
{
if (l_SSLInitialized)
return;
return std::shared_ptr<X509>(cert, X509_free);
}
-String GetIcingaCADir(void)
+String GetIcingaCADir()
{
return Application::GetLocalStateDir() + "/lib/icinga2/ca";
}
namespace icinga
{
-void InitializeOpenSSL(void);
+void InitializeOpenSSL();
std::shared_ptr<SSL_CTX> MakeSSLContext(const String& pubkey = String(), const String& privkey = String(), const String& cakey = String());
void AddCRLToSSLContext(const std::shared_ptr<SSL_CTX>& context, const String& crlPath);
void SetCipherListToSSLContext(const std::shared_ptr<SSL_CTX>& context, const String& cipherList);
std::shared_ptr<X509> GetX509Certificate(const String& pemfile);
int MakeX509CSR(const String& cn, const String& keyfile, const String& csrfile = String(), const String& certfile = String(), bool ca = false);
std::shared_ptr<X509> CreateCert(EVP_PKEY *pubkey, X509_NAME *subject, X509_NAME *issuer, EVP_PKEY *cakey, bool ca);
-String GetIcingaCADir(void);
+String GetIcingaCADir();
String CertificateToString(const std::shared_ptr<X509>& cert);
std::shared_ptr<X509> StringToCertificate(const String& cert);
std::shared_ptr<X509> CreateCertIcingaCA(EVP_PKEY *pubkey, X509_NAME *subject);
Type::Register(type);
}, 20);
-Type::Type(void)
+Type::Type()
{ }
-Type::~Type(void)
+Type::~Type()
{ }
-String Type::ToString(void) const
+String Type::ToString() const
{
return "type '" + GetName() + "'";
}
return ptype;
}
-std::vector<Type::Ptr> Type::GetAllTypes(void)
+std::vector<Type::Ptr> Type::GetAllTypes()
{
std::vector<Type::Ptr> types;
return types;
}
-String Type::GetPluralName(void) const
+String Type::GetPluralName() const
{
String name = GetName();
return factory(args);
}
-bool Type::IsAbstract(void) const
+bool Type::IsAbstract() const
{
return ((GetAttributes() & TAAbstract) != 0);
}
return false;
}
-Object::Ptr Type::GetPrototype(void) const
+Object::Ptr Type::GetPrototype() const
{
return m_Prototype;
}
BOOST_THROW_EXCEPTION(std::runtime_error("Invalid field ID."));
}
-std::vector<String> Type::GetLoadDependencies(void) const
+std::vector<String> Type::GetLoadDependencies() const
{
return std::vector<String>();
}
throw std::runtime_error("Invalid field ID.");
}
-String TypeType::GetName(void) const
+String TypeType::GetName() const
{
return "Type";
}
-Type::Ptr TypeType::GetBaseType(void) const
+Type::Ptr TypeType::GetBaseType() const
{
return Object::TypeInstance;
}
-int TypeType::GetAttributes(void) const
+int TypeType::GetAttributes() const
{
return 0;
}
throw std::runtime_error("Invalid field ID.");
}
-int TypeType::GetFieldCount(void) const
+int TypeType::GetFieldCount() const
{
return GetBaseType()->GetFieldCount() + 3;
}
-ObjectFactory TypeType::GetFactory(void) const
+ObjectFactory TypeType::GetFactory() const
{
return nullptr;
}
public:
DECLARE_OBJECT(Type);
- Type(void);
- ~Type(void);
+ Type();
+ ~Type();
- virtual String ToString(void) const override;
+ virtual String ToString() const override;
- virtual String GetName(void) const = 0;
- virtual Type::Ptr GetBaseType(void) const = 0;
- virtual int GetAttributes(void) const = 0;
+ virtual String GetName() const = 0;
+ virtual Type::Ptr GetBaseType() const = 0;
+ virtual int GetAttributes() const = 0;
virtual int GetFieldId(const String& name) const = 0;
virtual Field GetFieldInfo(int id) const = 0;
- virtual int GetFieldCount(void) const = 0;
+ virtual int GetFieldCount() const = 0;
- String GetPluralName(void) const;
+ String GetPluralName() const;
Object::Ptr Instantiate(const std::vector<Value>& args) const;
bool IsAssignableFrom(const Type::Ptr& other) const;
- bool IsAbstract(void) const;
+ bool IsAbstract() const;
- Object::Ptr GetPrototype(void) const;
+ Object::Ptr GetPrototype() const;
void SetPrototype(const Object::Ptr& object);
static void Register(const Type::Ptr& type);
static Type::Ptr GetByName(const String& name);
- static std::vector<Type::Ptr> GetAllTypes(void);
+ static std::vector<Type::Ptr> GetAllTypes();
virtual void SetField(int id, const Value& value, bool suppress_events = false, const Value& cookie = Empty) override;
virtual Value GetField(int id) const override;
- virtual std::vector<String> GetLoadDependencies(void) const;
+ virtual std::vector<String> GetLoadDependencies() const;
typedef std::function<void (const Object::Ptr&, const Value&)> AttributeHandler;
virtual void RegisterAttributeHandler(int fieldId, const AttributeHandler& callback);
protected:
- virtual ObjectFactory GetFactory(void) const = 0;
+ virtual ObjectFactory GetFactory() const = 0;
private:
Object::Ptr m_Prototype;
public:
DECLARE_PTR_TYPEDEFS(Type);
- virtual String GetName(void) const override;
- virtual Type::Ptr GetBaseType(void) const override;
- virtual int GetAttributes(void) const override;
+ virtual String GetName() const override;
+ virtual Type::Ptr GetBaseType() const override;
+ virtual int GetAttributes() const override;
virtual int GetFieldId(const String& name) const override;
virtual Field GetFieldInfo(int id) const override;
- virtual int GetFieldCount(void) const override;
+ virtual int GetFieldCount() const override;
- static Object::Ptr GetPrototype(void);
+ static Object::Ptr GetPrototype();
protected:
- virtual ObjectFactory GetFactory(void) const override;
+ virtual ObjectFactory GetFactory() const override;
};
template<typename T>
self->RegisterAttributeHandler(fid, std::bind(&InvokeAttributeHandlerHelper, callback, _1, _2));
}
-Object::Ptr TypeType::GetPrototype(void)
+Object::Ptr TypeType::GetPrototype()
{
static Dictionary::Ptr prototype;
#ifndef _WIN32
using namespace icinga;
-UnixSocket::UnixSocket(void)
+UnixSocket::UnixSocket()
{
int fd = socket(AF_UNIX, SOCK_STREAM, 0);
public:
DECLARE_PTR_TYPEDEFS(UnixSocket);
- UnixSocket(void);
+ UnixSocket();
void Bind(const String& path);
*
* @returns The current time.
*/
-double Utility::GetTime(void)
+double Utility::GetTime()
{
#ifdef I2_DEBUG
if (m_DebugTime >= 0) {
*
* @returns The PID.
*/
-pid_t Utility::GetPid(void)
+pid_t Utility::GetPid()
{
#ifndef _WIN32
return getpid();
*
* @returns The new unique ID.
*/
-String Utility::NewUniqueID(void)
+String Utility::NewUniqueID()
{
return boost::lexical_cast<std::string>(boost::uuids::random_generator()());
}
#endif /* _WIN32 */
}
-void Utility::QueueAsyncCallback(const std::function<void (void)>& callback, SchedulerPolicy policy)
+void Utility::QueueAsyncCallback(const std::function<void ()>& callback, SchedulerPolicy policy)
{
Application::GetTP().Post(callback, policy);
}
#endif /* HAVE_PTHREAD_SETNAME_NP */
}
-String Utility::GetThreadName(void)
+String Utility::GetThreadName()
{
String *name = m_ThreadName.get();
return 0;
}
-String Utility::GetHostName(void)
+String Utility::GetHostName()
{
char name[255];
*
* @returns The FQDN.
*/
-String Utility::GetFQDN(void)
+String Utility::GetFQDN()
{
String hostname = GetHostName();
return hostname;
}
-int Utility::Random(void)
+int Utility::Random()
{
#ifdef _WIN32
return rand();
#endif /* _WIN32 */
}
-String Utility::GetPlatformKernel(void)
+String Utility::GetPlatformKernel()
{
#ifdef _WIN32
return "Windows";
#endif /* _WIN32 */
}
-String Utility::GetPlatformKernelVersion(void)
+String Utility::GetPlatformKernelVersion()
{
#ifdef _WIN32
OSVERSIONINFO info;
#endif /* _WIN32 */
}
-String Utility::GetPlatformName(void)
+String Utility::GetPlatformName()
{
String platformName;
if (!ReleaseHelper(&platformName, nullptr))
return platformName;
}
-String Utility::GetPlatformVersion(void)
+String Utility::GetPlatformVersion()
{
String platformVersion;
if (!ReleaseHelper(nullptr, &platformVersion))
return platformVersion;
}
-String Utility::GetPlatformArchitecture(void)
+String Utility::GetPlatformArchitecture()
{
#ifdef _WIN32
SYSTEM_INFO info;
return -1;
}
-String Utility::GetIcingaInstallPath(void)
+String Utility::GetIcingaInstallPath()
{
char szProduct[39];
return "";
}
-String Utility::GetIcingaDataPath(void)
+String Utility::GetIcingaDataPath()
{
char path[MAX_PATH];
if (!SUCCEEDED(SHGetFolderPath(nullptr, CSIDL_COMMON_APPDATA, nullptr, 0, path)))
static void NullDeleter(void *);
- static double GetTime(void);
+ static double GetTime();
- static pid_t GetPid(void);
+ static pid_t GetPid();
static void Sleep(double timeout);
- static String NewUniqueID(void);
+ static String NewUniqueID();
static bool Glob(const String& pathSpec, const std::function<void (const String&)>& callback, int type = GlobFile | GlobDirectory);
static bool GlobRecursive(const String& path, const String& pattern, const std::function<void (const String&)>& callback, int type = GlobFile | GlobDirectory);
static void MkDirP(const String& path, int mode);
static bool SetFileOwnership(const String& file, const String& user, const String& group);
- static void QueueAsyncCallback(const std::function<void (void)>& callback, SchedulerPolicy policy = DefaultScheduler);
+ static void QueueAsyncCallback(const std::function<void ()>& callback, SchedulerPolicy policy = DefaultScheduler);
static String NaturalJoin(const std::vector<String>& tokens);
static String Join(const Array::Ptr& tokens, char separator, bool escapeSeparator = true);
static String UnescapeString(const String& s);
static void SetThreadName(const String& name, bool os = true);
- static String GetThreadName(void);
+ static String GetThreadName();
static unsigned long SDBM(const String& str, size_t len = String::NPos);
static int CompareVersion(const String& v1, const String& v2);
- static int Random(void);
+ static int Random();
- static String GetHostName(void);
- static String GetFQDN(void);
+ static String GetHostName();
+ static String GetFQDN();
static tm LocalTime(time_t ts);
static Value LoadJsonFile(const String& path);
static void SaveJsonFile(const String& path, int mode, const Value& value);
- static String GetPlatformKernel(void);
- static String GetPlatformKernelVersion(void);
- static String GetPlatformName(void);
- static String GetPlatformVersion(void);
- static String GetPlatformArchitecture(void);
+ static String GetPlatformKernel();
+ static String GetPlatformKernelVersion();
+ static String GetPlatformName();
+ static String GetPlatformVersion();
+ static String GetPlatformArchitecture();
static String ValidateUTF8(const String& input);
static String CreateTempFile(const String& path, int mode, std::fstream& fp);
#ifdef _WIN32
- static String GetIcingaInstallPath(void);
- static String GetIcingaDataPath(void);
+ static String GetIcingaInstallPath();
+ static String GetIcingaDataPath();
#endif /* _WIN32 */
#ifdef I2_DEBUG
#endif /* I2_DEBUG */
private:
- Utility(void);
+ Utility();
static void CollectPaths(const String& path, std::vector<String>& paths);
#ifdef _WIN32
using namespace icinga;
-Value::operator double(void) const
+Value::operator double() const
{
const double *value = boost::get<double>(&m_Value);
}
}
-Value::operator String(void) const
+Value::operator String() const
{
Object *object;
using namespace icinga;
template class boost::variant<boost::blank, double, bool, String, Object::Ptr>;
-template const double& Value::Get<double>(void) const;
-template const bool& Value::Get<bool>(void) const;
-template const String& Value::Get<String>(void) const;
-template const Object::Ptr& Value::Get<Object::Ptr>(void) const;
+template const double& Value::Get<double>() const;
+template const bool& Value::Get<bool>() const;
+template const String& Value::Get<String>() const;
+template const Object::Ptr& Value::Get<Object::Ptr>() const;
Value icinga::Empty;
-Value::Value(void)
+Value::Value()
{ }
Value::Value(std::nullptr_t)
m_Value = value;
}
-Value::~Value(void)
+Value::~Value()
{ }
Value& Value::operator=(const Value& other)
*
* @returns true if the variant is empty, false otherwise.
*/
-bool Value::IsEmpty(void) const
+bool Value::IsEmpty() const
{
return (GetType() == ValueEmpty || (IsString() && boost::get<String>(m_Value).IsEmpty()));
}
*
* @returns true if the variant is scalar, false otherwise.
*/
-bool Value::IsScalar(void) const
+bool Value::IsScalar() const
{
return !IsEmpty() && !IsObject();
}
*
* @returns true if the variant is a number.
*/
-bool Value::IsNumber(void) const
+bool Value::IsNumber() const
{
return (GetType() == ValueNumber);
}
*
* @returns true if the variant is a boolean.
*/
-bool Value::IsBoolean(void) const
+bool Value::IsBoolean() const
{
return (GetType() == ValueBoolean);
}
*
* @returns true if the variant is a string.
*/
-bool Value::IsString(void) const
+bool Value::IsString() const
{
return (GetType() == ValueString);
}
*
* @returns true if the variant is a non-null object, false otherwise.
*/
-bool Value::IsObject(void) const
+bool Value::IsObject() const
{
return (GetType() == ValueObject);
}
*
* @returns The type.
*/
-ValueType Value::GetType(void) const
+ValueType Value::GetType() const
{
return static_cast<ValueType>(m_Value.which());
}
m_Value.swap(other.m_Value);
}
-bool Value::ToBool(void) const
+bool Value::ToBool() const
{
switch (GetType()) {
case ValueNumber:
}
}
-String Value::GetTypeName(void) const
+String Value::GetTypeName() const
{
Type::Ptr t;
}
}
-Type::Ptr Value::GetReflectionType(void) const
+Type::Ptr Value::GetReflectionType() const
{
switch (GetType()) {
case ValueEmpty:
}
}
-Value Value::Clone(void) const
+Value Value::Clone() const
{
if (IsObject())
return static_cast<Object::Ptr>(*this)->Clone();
class Value
{
public:
- Value(void);
+ Value();
Value(std::nullptr_t);
Value(int value);
Value(unsigned int value);
static_assert(!std::is_same<T, Object>::value, "T must not be Object");
}
- ~Value(void);
+ ~Value();
- bool ToBool(void) const;
+ bool ToBool() const;
- operator double(void) const;
- operator String(void) const;
+ operator double() const;
+ operator String() const;
Value& operator=(const Value& other);
Value& operator=(Value&& other);
bool operator!=(const Value& rhs) const;
template<typename T>
- operator intrusive_ptr<T>(void) const
+ operator intrusive_ptr<T>() const
{
if (IsEmpty() && !IsString())
return intrusive_ptr<T>();
return tobject;
}
- bool IsEmpty(void) const;
- bool IsScalar(void) const;
- bool IsNumber(void) const;
- bool IsBoolean(void) const;
- bool IsString(void) const;
- bool IsObject(void) const;
+ bool IsEmpty() const;
+ bool IsScalar() const;
+ bool IsNumber() const;
+ bool IsBoolean() const;
+ bool IsString() const;
+ bool IsObject() const;
template<typename T>
- bool IsObjectType(void) const
+ bool IsObjectType() const
{
if (!IsObject())
return false;
return dynamic_cast<T *>(Get<Object::Ptr>().get());
}
- ValueType GetType(void) const;
+ ValueType GetType() const;
void Swap(Value& other);
- String GetTypeName(void) const;
+ String GetTypeName() const;
- Type::Ptr GetReflectionType(void) const;
+ Type::Ptr GetReflectionType() const;
- Value Clone(void) const;
+ Value Clone() const;
template<typename T>
- const T& Get(void) const
+ const T& Get() const
{
return boost::get<T>(m_Value);
}
boost::variant<boost::blank, double, bool, String, Object::Ptr> m_Value;
};
-extern template const double& Value::Get<double>(void) const;
-extern template const bool& Value::Get<bool>(void) const;
-extern template const String& Value::Get<String>(void) const;
-extern template const Object::Ptr& Value::Get<Object::Ptr>(void) const;
+extern template const double& Value::Get<double>() const;
+extern template const bool& Value::Get<bool>() const;
+extern template const String& Value::Get<String>() const;
+extern template const Object::Ptr& Value::Get<Object::Ptr>() const;
extern Value Empty;
m_StatusTimer->Start();
}
-WorkQueue::~WorkQueue(void)
+WorkQueue::~WorkQueue()
{
m_StatusTimer->Stop(true);
m_Name = name;
}
-String WorkQueue::GetName(void) const
+String WorkQueue::GetName() const
{
return m_Name;
}
* allowInterleaved is true in which case the new task might be run
* immediately if it's being enqueued from within the WorkQueue thread.
*/
-void WorkQueue::Enqueue(std::function<void (void)>&& function, WorkQueuePriority priority,
+void WorkQueue::Enqueue(std::function<void ()>&& function, WorkQueuePriority priority,
bool allowInterleaved)
{
bool wq_thread = IsWorkerThread();
*
* @returns true if called from one of the worker threads, false otherwise
*/
-bool WorkQueue::IsWorkerThread(void) const
+bool WorkQueue::IsWorkerThread() const
{
WorkQueue **pwq = l_ThreadWorkQueue.get();
* work queue. When a custom exception callback is set this method will always
* return false.
*/
-bool WorkQueue::HasExceptions(void) const
+bool WorkQueue::HasExceptions() const
{
boost::mutex::scoped_lock lock(m_Mutex);
* Returns all exceptions which have occurred for tasks in this work queue. When a
* custom exception callback is set this method will always return an empty list.
*/
-std::vector<boost::exception_ptr> WorkQueue::GetExceptions(void) const
+std::vector<boost::exception_ptr> WorkQueue::GetExceptions() const
{
boost::mutex::scoped_lock lock(m_Mutex);
<< exceptions.size() << " error" << (exceptions.size() != 1 ? "s" : "");
}
-size_t WorkQueue::GetLength(void) const
+size_t WorkQueue::GetLength() const
{
boost::mutex::scoped_lock lock(m_Mutex);
return m_Tasks.size();
}
-void WorkQueue::StatusTimerHandler(void)
+void WorkQueue::StatusTimerHandler()
{
boost::mutex::scoped_lock lock(m_Mutex);
}
}
-void WorkQueue::WorkerThreadProc(void)
+void WorkQueue::WorkerThreadProc()
{
std::ostringstream idbuf;
idbuf << "WQ #" << m_ID;
}
}
-void WorkQueue::IncreaseTaskCount(void)
+void WorkQueue::IncreaseTaskCount()
{
double now = Utility::GetTime();
struct Task
{
- Task(void)
+ Task()
: Priority(PriorityNormal), ID(-1)
{ }
typedef std::function<void (boost::exception_ptr)> ExceptionCallback;
WorkQueue(size_t maxItems = 0, int threadCount = 1);
- ~WorkQueue(void);
+ ~WorkQueue();
void SetName(const String& name);
- String GetName(void) const;
+ String GetName() const;
void Enqueue(std::function<void (void)>&& function, WorkQueuePriority priority = PriorityNormal,
bool allowInterleaved = false);
void Join(bool stop = false);
- bool IsWorkerThread(void) const;
+ bool IsWorkerThread() const;
- size_t GetLength(void) const;
+ size_t GetLength() const;
size_t GetTaskCount(RingBuffer::SizeType span);
void SetExceptionCallback(const ExceptionCallback& callback);
- bool HasExceptions(void) const;
- std::vector<boost::exception_ptr> GetExceptions(void) const;
+ bool HasExceptions() const;
+ std::vector<boost::exception_ptr> GetExceptions() const;
void ReportExceptions(const String& facility) const;
protected:
- void IncreaseTaskCount(void);
+ void IncreaseTaskCount();
private:
int m_ID;
size_t m_PendingTasks;
double m_PendingTasksTimestamp;
- void WorkerThreadProc(void);
- void StatusTimerHandler(void);
+ void WorkerThreadProc();
+ void StatusTimerHandler();
};
}
status->Set("checkercomponent", nodes);
}
-CheckerComponent::CheckerComponent(void)
+CheckerComponent::CheckerComponent()
: m_Stopped(false)
{ }
-void CheckerComponent::OnConfigLoaded(void)
+void CheckerComponent::OnConfigLoaded()
{
ConfigObject::OnActiveChanged.connect(std::bind(&CheckerComponent::ObjectHandler, this, _1));
ConfigObject::OnPausedChanged.connect(std::bind(&CheckerComponent::ObjectHandler, this, _1));
ObjectImpl<CheckerComponent>::Stop(runtimeRemoved);
}
-void CheckerComponent::CheckThreadProc(void)
+void CheckerComponent::CheckThreadProc()
{
Utility::SetThreadName("Check Scheduler");
<< "Check finished for object '" << checkable->GetName() << "'";
}
-void CheckerComponent::ResultTimerHandler(void)
+void CheckerComponent::ResultTimerHandler()
{
std::ostringstream msgbuf;
m_CV.notify_all();
}
-unsigned long CheckerComponent::GetIdleCheckables(void)
+unsigned long CheckerComponent::GetIdleCheckables()
{
boost::mutex::scoped_lock lock(m_Mutex);
return m_IdleCheckables.size();
}
-unsigned long CheckerComponent::GetPendingCheckables(void)
+unsigned long CheckerComponent::GetPendingCheckables()
{
boost::mutex::scoped_lock lock(m_Mutex);
>
> CheckableSet;
- CheckerComponent(void);
+ CheckerComponent();
- virtual void OnConfigLoaded(void) override;
+ virtual void OnConfigLoaded() override;
virtual void Start(bool runtimeCreated) override;
virtual void Stop(bool runtimeRemoved) override;
static void StatsFunc(const Dictionary::Ptr& status, const Array::Ptr& perfdata);
- unsigned long GetIdleCheckables(void);
- unsigned long GetPendingCheckables(void);
+ unsigned long GetIdleCheckables();
+ unsigned long GetPendingCheckables();
private:
boost::mutex m_Mutex;
Timer::Ptr m_ResultTimer;
- void CheckThreadProc(void);
- void ResultTimerHandler(void);
+ void CheckThreadProc();
+ void ResultTimerHandler();
void ExecuteCheckHelper(const Checkable::Ptr& checkable);
- void AdjustCheckTimer(void);
+ void AdjustCheckTimer();
void ObjectHandler(const ConfigObject::Ptr& object);
void NextCheckChangedHandler(const Checkable::Ptr& checkable);
- void RescheduleCheckTimer(void);
+ void RescheduleCheckTimer();
static CheckableScheduleInfo GetCheckableScheduleInfo(const Checkable::Ptr& checkable);
};
REGISTER_CLICOMMAND("api/setup", ApiSetupCommand);
-String ApiSetupCommand::GetDescription(void) const
+String ApiSetupCommand::GetDescription() const
{
return "Setup for Icinga 2 API.";
}
-String ApiSetupCommand::GetShortDescription(void) const
+String ApiSetupCommand::GetShortDescription() const
{
return "setup for api";
}
-ImpersonationLevel ApiSetupCommand::GetImpersonationLevel(void) const
+ImpersonationLevel ApiSetupCommand::GetImpersonationLevel() const
{
return ImpersonateRoot;
}
-int ApiSetupCommand::GetMaxArguments(void) const
+int ApiSetupCommand::GetMaxArguments() const
{
return -1;
}
public:
DECLARE_PTR_TYPEDEFS(ApiSetupCommand);
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
- virtual int GetMaxArguments(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
+ virtual int GetMaxArguments() const override;
virtual int Run(const boost::program_options::variables_map& vm, const std::vector<std::string>& ap) const override;
- virtual ImpersonationLevel GetImpersonationLevel(void) const override;
+ virtual ImpersonationLevel GetImpersonationLevel() const override;
};
}
using namespace icinga;
-String ApiSetupUtility::GetConfdPath(void)
+String ApiSetupUtility::GetConfdPath()
{
return Application::GetSysconfDir() + "/icinga2/conf.d";
}
return true;
}
-bool ApiSetupUtility::SetupMasterApiUser(void)
+bool ApiSetupUtility::SetupMasterApiUser()
{
String api_username = "root"; // TODO make this available as cli parameter?
String api_password = RandomString(8);
return true;
}
-bool ApiSetupUtility::SetupMasterEnableApi(void)
+bool ApiSetupUtility::SetupMasterEnableApi()
{
Log(LogInformation, "cli", "Enabling the 'api' feature.");
static bool SetupMaster(const String& cn, bool prompt_restart = false);
static bool SetupMasterCertificates(const String& cn);
- static bool SetupMasterApiUser(void);
- static bool SetupMasterEnableApi(void);
+ static bool SetupMasterApiUser();
+ static bool SetupMasterEnableApi();
static bool SetupMasterUpdateConstants(const String& cn);
- static String GetConfdPath(void);
+ static String GetConfdPath();
private:
- ApiSetupUtility(void);
+ ApiSetupUtility();
};
}
REGISTER_CLICOMMAND("ca/list", CAListCommand);
-String CAListCommand::GetDescription(void) const
+String CAListCommand::GetDescription() const
{
return "Lists all certificate signing requests.";
}
-String CAListCommand::GetShortDescription(void) const
+String CAListCommand::GetShortDescription() const
{
return "lists all certificate signing requests";
}
public:
DECLARE_PTR_TYPEDEFS(CAListCommand);
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
virtual void InitParameters(boost::program_options::options_description& visibleDesc,
boost::program_options::options_description& hiddenDesc) const override;
virtual int Run(const boost::program_options::variables_map& vm, const std::vector<std::string>& ap) const override;
REGISTER_CLICOMMAND("ca/sign", CASignCommand);
-String CASignCommand::GetDescription(void) const
+String CASignCommand::GetDescription() const
{
return "Signs an outstanding certificate request.";
}
-String CASignCommand::GetShortDescription(void) const
+String CASignCommand::GetShortDescription() const
{
return "signs an outstanding certificate request";
}
-int CASignCommand::GetMinArguments(void) const
+int CASignCommand::GetMinArguments() const
{
return 1;
}
-ImpersonationLevel CASignCommand::GetImpersonationLevel(void) const
+ImpersonationLevel CASignCommand::GetImpersonationLevel() const
{
return ImpersonateIcinga;
}
public:
DECLARE_PTR_TYPEDEFS(CASignCommand);
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
- virtual int GetMinArguments(void) const override;
- virtual ImpersonationLevel GetImpersonationLevel(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
+ virtual int GetMinArguments() const override;
+ virtual ImpersonationLevel GetImpersonationLevel() const override;
virtual int Run(const boost::program_options::variables_map& vm, const std::vector<std::string>& ap) const override;
};
return result;
}
-int CLICommand::GetMinArguments(void) const
+int CLICommand::GetMinArguments() const
{
return 0;
}
-int CLICommand::GetMaxArguments(void) const
+int CLICommand::GetMaxArguments() const
{
return GetMinArguments();
}
-bool CLICommand::IsHidden(void) const
+bool CLICommand::IsHidden() const
{
return false;
}
-bool CLICommand::IsDeprecated(void) const
+bool CLICommand::IsDeprecated() const
{
return false;
}
-boost::mutex& CLICommand::GetRegistryMutex(void)
+boost::mutex& CLICommand::GetRegistryMutex()
{
static boost::mutex mtx;
return mtx;
}
-std::map<std::vector<String>, CLICommand::Ptr>& CLICommand::GetRegistry(void)
+std::map<std::vector<String>, CLICommand::Ptr>& CLICommand::GetRegistry()
{
static std::map<std::vector<String>, CLICommand::Ptr> registry;
return registry;
boost::program_options::options_description& hiddenDesc) const
{ }
-ImpersonationLevel CLICommand::GetImpersonationLevel(void) const
+ImpersonationLevel CLICommand::GetImpersonationLevel() const
{
return ImpersonateIcinga;
}
typedef std::vector<String>(*ArgumentCompletionCallback)(const String&, const String&);
- virtual String GetDescription(void) const = 0;
- virtual String GetShortDescription(void) const = 0;
- virtual int GetMinArguments(void) const;
- virtual int GetMaxArguments(void) const;
- virtual bool IsHidden(void) const;
- virtual bool IsDeprecated(void) const;
+ virtual String GetDescription() const = 0;
+ virtual String GetShortDescription() const = 0;
+ virtual int GetMinArguments() const;
+ virtual int GetMaxArguments() const;
+ virtual bool IsHidden() const;
+ virtual bool IsDeprecated() const;
virtual void InitParameters(boost::program_options::options_description& visibleDesc,
boost::program_options::options_description& hiddenDesc) const;
- virtual ImpersonationLevel GetImpersonationLevel(void) const;
+ virtual ImpersonationLevel GetImpersonationLevel() const;
virtual int Run(const boost::program_options::variables_map& vm, const std::vector<std::string>& ap) const = 0;
virtual std::vector<String> GetArgumentSuggestions(const String& argument, const String& word) const;
virtual std::vector<String> GetPositionalSuggestions(const String& word) const;
bool autocomplete = false, int autoindex = -1);
private:
- static boost::mutex& GetRegistryMutex(void);
- static std::map<std::vector<String>, CLICommand::Ptr>& GetRegistry(void);
+ static boost::mutex& GetRegistryMutex();
+ static std::map<std::vector<String>, CLICommand::Ptr>& GetRegistry();
};
#define REGISTER_CLICOMMAND(name, klass) \
INITIALIZE_ONCE(&ConsoleCommand::StaticInitialize);
-extern "C" void dbg_spawn_console(void)
+extern "C" void dbg_spawn_console()
{
ScriptFrame frame(true);
ConsoleCommand::RunScriptConsole(frame);
ConsoleCommand::RunScriptConsole(frame);
}
-void ConsoleCommand::StaticInitialize(void)
+void ConsoleCommand::StaticInitialize()
{
Expression::OnBreakpoint.connect(&ConsoleCommand::BreakpointHandler);
}
-String ConsoleCommand::GetDescription(void) const
+String ConsoleCommand::GetDescription() const
{
return "Interprets Icinga script expressions.";
}
-String ConsoleCommand::GetShortDescription(void) const
+String ConsoleCommand::GetShortDescription() const
{
return "Icinga console";
}
-ImpersonationLevel ConsoleCommand::GetImpersonationLevel(void) const
+ImpersonationLevel ConsoleCommand::GetImpersonationLevel() const
{
return ImpersonateNone;
}
public:
DECLARE_PTR_TYPEDEFS(ConsoleCommand);
- static void StaticInitialize(void);
+ static void StaticInitialize();
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
- virtual ImpersonationLevel GetImpersonationLevel(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
+ virtual ImpersonationLevel GetImpersonationLevel() const override;
virtual void InitParameters(boost::program_options::options_description& visibleDesc,
boost::program_options::options_description& hiddenDesc) const override;
virtual int Run(const boost::program_options::variables_map& vm, const std::vector<std::string>& ap) const override;
}
#endif /* _WIN32 */
-static bool Daemonize(void)
+static bool Daemonize()
{
#ifndef _WIN32
Application::UninitializeBase();
#endif /* _WIN32 */
}
-String DaemonCommand::GetDescription(void) const
+String DaemonCommand::GetDescription() const
{
return "Starts Icinga 2.";
}
-String DaemonCommand::GetShortDescription(void) const
+String DaemonCommand::GetShortDescription() const
{
return "starts Icinga 2";
}
public:
DECLARE_PTR_TYPEDEFS(DaemonCommand);
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
virtual void InitParameters(boost::program_options::options_description& visibleDesc,
boost::program_options::options_description& hiddenDesc) const override;
virtual std::vector<String> GetArgumentSuggestions(const String& argument, const String& word) const override;
REGISTER_CLICOMMAND("feature/disable", FeatureDisableCommand);
-String FeatureDisableCommand::GetDescription(void) const
+String FeatureDisableCommand::GetDescription() const
{
return "Disables specified Icinga 2 feature.";
}
-String FeatureDisableCommand::GetShortDescription(void) const
+String FeatureDisableCommand::GetShortDescription() const
{
return "disables specified feature";
}
return FeatureUtility::GetFieldCompletionSuggestions(word, false);
}
-int FeatureDisableCommand::GetMinArguments(void) const
+int FeatureDisableCommand::GetMinArguments() const
{
return 1;
}
-int FeatureDisableCommand::GetMaxArguments(void) const
+int FeatureDisableCommand::GetMaxArguments() const
{
return -1;
}
-ImpersonationLevel FeatureDisableCommand::GetImpersonationLevel(void) const
+ImpersonationLevel FeatureDisableCommand::GetImpersonationLevel() const
{
return ImpersonateRoot;
}
public:
DECLARE_PTR_TYPEDEFS(FeatureDisableCommand);
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
- virtual int GetMinArguments(void) const override;
- virtual int GetMaxArguments(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
+ virtual int GetMinArguments() const override;
+ virtual int GetMaxArguments() const override;
virtual std::vector<String> GetPositionalSuggestions(const String& word) const override;
- virtual ImpersonationLevel GetImpersonationLevel(void) const override;
+ virtual ImpersonationLevel GetImpersonationLevel() const override;
virtual int Run(const boost::program_options::variables_map& vm, const std::vector<std::string>& ap) const override;
};
REGISTER_CLICOMMAND("feature/enable", FeatureEnableCommand);
-String FeatureEnableCommand::GetDescription(void) const
+String FeatureEnableCommand::GetDescription() const
{
return "Enables specified Icinga 2 feature.";
}
-String FeatureEnableCommand::GetShortDescription(void) const
+String FeatureEnableCommand::GetShortDescription() const
{
return "enables specified feature";
}
return FeatureUtility::GetFieldCompletionSuggestions(word, true);
}
-int FeatureEnableCommand::GetMinArguments(void) const
+int FeatureEnableCommand::GetMinArguments() const
{
return 1;
}
-int FeatureEnableCommand::GetMaxArguments(void) const
+int FeatureEnableCommand::GetMaxArguments() const
{
return -1;
}
-ImpersonationLevel FeatureEnableCommand::GetImpersonationLevel(void) const
+ImpersonationLevel FeatureEnableCommand::GetImpersonationLevel() const
{
return ImpersonateRoot;
}
public:
DECLARE_PTR_TYPEDEFS(FeatureEnableCommand);
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
- virtual int GetMinArguments(void) const override;
- virtual int GetMaxArguments(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
+ virtual int GetMinArguments() const override;
+ virtual int GetMaxArguments() const override;
virtual std::vector<String> GetPositionalSuggestions(const String& word) const override;
- virtual ImpersonationLevel GetImpersonationLevel(void) const override;
+ virtual ImpersonationLevel GetImpersonationLevel() const override;
virtual int Run(const boost::program_options::variables_map& vm, const std::vector<std::string>& ap) const override;
};
REGISTER_CLICOMMAND("feature/list", FeatureListCommand);
-String FeatureListCommand::GetDescription(void) const
+String FeatureListCommand::GetDescription() const
{
return "Lists all available Icinga 2 features.";
}
-String FeatureListCommand::GetShortDescription(void) const
+String FeatureListCommand::GetShortDescription() const
{
return "lists all available features";
}
public:
DECLARE_PTR_TYPEDEFS(FeatureListCommand);
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
virtual int Run(const boost::program_options::variables_map& vm, const std::vector<std::string>& ap) const override;
};
using namespace icinga;
-String FeatureUtility::GetFeaturesAvailablePath(void)
+String FeatureUtility::GetFeaturesAvailablePath()
{
return Application::GetSysconfDir() + "/icinga2/features-available";
}
-String FeatureUtility::GetFeaturesEnabledPath(void)
+String FeatureUtility::GetFeaturesEnabledPath()
{
return Application::GetSysconfDir() + "/icinga2/features-enabled";
}
class FeatureUtility
{
public:
- static String GetFeaturesAvailablePath(void);
- static String GetFeaturesEnabledPath(void);
+ static String GetFeaturesAvailablePath();
+ static String GetFeaturesEnabledPath();
static std::vector<String> GetFieldCompletionSuggestions(const String& word, bool enable);
static bool CheckFeatureDisabled(const String& feature);
private:
- FeatureUtility(void);
+ FeatureUtility();
static void CollectFeatures(const String& feature_file, std::vector<String>& features);
static bool CheckFeatureInternal(const String& feature, bool check_disabled);
};
REGISTER_CLICOMMAND("node/setup", NodeSetupCommand);
-String NodeSetupCommand::GetDescription(void) const
+String NodeSetupCommand::GetDescription() const
{
return "Sets up an Icinga 2 node.";
}
-String NodeSetupCommand::GetShortDescription(void) const
+String NodeSetupCommand::GetShortDescription() const
{
return "set up node";
}
return CLICommand::GetArgumentSuggestions(argument, word);
}
-ImpersonationLevel NodeSetupCommand::GetImpersonationLevel(void) const
+ImpersonationLevel NodeSetupCommand::GetImpersonationLevel() const
{
return ImpersonateRoot;
}
public:
DECLARE_PTR_TYPEDEFS(NodeSetupCommand);
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
virtual void InitParameters(boost::program_options::options_description& visibleDesc,
boost::program_options::options_description& hiddenDesc) const override;
virtual std::vector<String> GetArgumentSuggestions(const String& argument, const String& word) const override;
- virtual ImpersonationLevel GetImpersonationLevel(void) const override;
+ virtual ImpersonationLevel GetImpersonationLevel() const override;
virtual int Run(const boost::program_options::variables_map& vm, const std::vector<std::string>& ap) const override;
private:
using namespace icinga;
-String NodeUtility::GetConstantsConfPath(void)
+String NodeUtility::GetConstantsConfPath()
{
return Application::GetSysconfDir() + "/icinga2/constants.conf";
}
class NodeUtility
{
public:
- static String GetConstantsConfPath(void);
+ static String GetConstantsConfPath();
static bool CreateBackupFile(const String& target, bool is_private = false);
static int GenerateNodeMasterIcingaConfig(const std::vector<String>& globalZones);
private:
- NodeUtility(void);
+ NodeUtility();
static void SerializeObject(std::ostream& fp, const Dictionary::Ptr& object);
};
REGISTER_CLICOMMAND("node/wizard", NodeWizardCommand);
-String NodeWizardCommand::GetDescription(void) const
+String NodeWizardCommand::GetDescription() const
{
return "Wizard for Icinga 2 node setup.";
}
-String NodeWizardCommand::GetShortDescription(void) const
+String NodeWizardCommand::GetShortDescription() const
{
return "wizard for node setup";
}
-ImpersonationLevel NodeWizardCommand::GetImpersonationLevel(void) const
+ImpersonationLevel NodeWizardCommand::GetImpersonationLevel() const
{
return ImpersonateRoot;
}
-int NodeWizardCommand::GetMaxArguments(void) const
+int NodeWizardCommand::GetMaxArguments() const
{
return -1;
}
return 0;
}
-int NodeWizardCommand::ClientSetup(void) const
+int NodeWizardCommand::ClientSetup() const
{
std::string answer;
String choice;
return 0;
}
-int NodeWizardCommand::MasterSetup(void) const
+int NodeWizardCommand::MasterSetup() const
{
std::string answer;
String choice;
public:
DECLARE_PTR_TYPEDEFS(NodeWizardCommand);
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
- virtual int GetMaxArguments(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
+ virtual int GetMaxArguments() const override;
virtual int Run(const boost::program_options::variables_map& vm, const std::vector<std::string>& ap) const override;
- virtual ImpersonationLevel GetImpersonationLevel(void) const override;
+ virtual ImpersonationLevel GetImpersonationLevel() const override;
virtual void InitParameters(boost::program_options::options_description& visibleDesc,
boost::program_options::options_description& hiddenDesc) const override;
private:
- int ClientSetup(void) const;
- int MasterSetup(void) const;
+ int ClientSetup() const;
+ int MasterSetup() const;
};
}
REGISTER_CLICOMMAND("object/list", ObjectListCommand);
-String ObjectListCommand::GetDescription(void) const
+String ObjectListCommand::GetDescription() const
{
return "Lists all Icinga 2 objects.";
}
-String ObjectListCommand::GetShortDescription(void) const
+String ObjectListCommand::GetShortDescription() const
{
return "lists all objects";
}
public:
DECLARE_PTR_TYPEDEFS(ObjectListCommand);
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
virtual void InitParameters(boost::program_options::options_description& visibleDesc,
boost::program_options::options_description& hiddenDesc) const override;
virtual int Run(const boost::program_options::variables_map& vm, const std::vector<std::string>& ap) const override;
REGISTER_CLICOMMAND("pki/new-ca", PKINewCACommand);
-String PKINewCACommand::GetDescription(void) const
+String PKINewCACommand::GetDescription() const
{
return "Sets up a new Certificate Authority.";
}
-String PKINewCACommand::GetShortDescription(void) const
+String PKINewCACommand::GetShortDescription() const
{
return "sets up a new CA";
}
public:
DECLARE_PTR_TYPEDEFS(PKINewCACommand);
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
virtual int Run(const boost::program_options::variables_map& vm, const std::vector<std::string>& ap) const override;
};
REGISTER_CLICOMMAND("pki/new-cert", PKINewCertCommand);
-String PKINewCertCommand::GetDescription(void) const
+String PKINewCertCommand::GetDescription() const
{
return "Creates a new Certificate Signing Request, a self-signed X509 certificate or both.";
}
-String PKINewCertCommand::GetShortDescription(void) const
+String PKINewCertCommand::GetShortDescription() const
{
return "creates a new CSR";
}
public:
DECLARE_PTR_TYPEDEFS(PKINewCertCommand);
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
virtual void InitParameters(boost::program_options::options_description& visibleDesc,
boost::program_options::options_description& hiddenDesc) const override;
virtual std::vector<String> GetArgumentSuggestions(const String& argument, const String& word) const override;
REGISTER_CLICOMMAND("pki/request", PKIRequestCommand);
-String PKIRequestCommand::GetDescription(void) const
+String PKIRequestCommand::GetDescription() const
{
return "Sends a PKI request to Icinga 2.";
}
-String PKIRequestCommand::GetShortDescription(void) const
+String PKIRequestCommand::GetShortDescription() const
{
return "requests a certificate";
}
public:
DECLARE_PTR_TYPEDEFS(PKIRequestCommand);
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
virtual void InitParameters(boost::program_options::options_description& visibleDesc,
boost::program_options::options_description& hiddenDesc) const override;
virtual std::vector<String> GetArgumentSuggestions(const String& argument, const String& word) const override;
REGISTER_CLICOMMAND("pki/save-cert", PKISaveCertCommand);
-String PKISaveCertCommand::GetDescription(void) const
+String PKISaveCertCommand::GetDescription() const
{
return "Saves another Icinga 2 instance's certificate.";
}
-String PKISaveCertCommand::GetShortDescription(void) const
+String PKISaveCertCommand::GetShortDescription() const
{
return "saves another Icinga 2 instance's certificate";
}
public:
DECLARE_PTR_TYPEDEFS(PKISaveCertCommand);
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
virtual void InitParameters(boost::program_options::options_description& visibleDesc,
boost::program_options::options_description& hiddenDesc) const override;
virtual std::vector<String> GetArgumentSuggestions(const String& argument, const String& word) const override;
REGISTER_CLICOMMAND("pki/sign-csr", PKISignCSRCommand);
-String PKISignCSRCommand::GetDescription(void) const
+String PKISignCSRCommand::GetDescription() const
{
return "Reads a Certificate Signing Request from stdin and prints a signed certificate on stdout.";
}
-String PKISignCSRCommand::GetShortDescription(void) const
+String PKISignCSRCommand::GetShortDescription() const
{
return "signs a CSR";
}
public:
DECLARE_PTR_TYPEDEFS(PKISignCSRCommand);
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
virtual void InitParameters(boost::program_options::options_description& visibleDesc,
boost::program_options::options_description& hiddenDesc) const override;
virtual std::vector<String> GetArgumentSuggestions(const String& argument, const String& word) const override;
REGISTER_CLICOMMAND("pki/ticket", PKITicketCommand);
-String PKITicketCommand::GetDescription(void) const
+String PKITicketCommand::GetDescription() const
{
return "Generates an Icinga 2 ticket";
}
-String PKITicketCommand::GetShortDescription(void) const
+String PKITicketCommand::GetShortDescription() const
{
return "generates a ticket";
}
public:
DECLARE_PTR_TYPEDEFS(PKITicketCommand);
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
virtual void InitParameters(boost::program_options::options_description& visibleDesc,
boost::program_options::options_description& hiddenDesc) const override;
virtual int Run(const boost::program_options::variables_map& vm, const std::vector<std::string>& ap) const override;
REGISTER_CLICOMMAND("troubleshoot", TroubleshootCommand);
-String TroubleshootCommand::GetDescription(void) const
+String TroubleshootCommand::GetDescription() const
{
return "Collect logs and other relevant information for troubleshooting purposes.";
}
-String TroubleshootCommand::GetShortDescription(void) const
+String TroubleshootCommand::GetShortDescription() const
{
return "collect information for troubleshooting";
}
}
}
- ~InfoLog(void)
+ ~InfoLog()
{
delete m_Stream;
}
<< ConsoleColorTag(Console_Normal, m_ConsoleType);
}
- bool GetStreamHealth(void) const
+ bool GetStreamHealth() const
{
return m_Stream->good();
}
InfoLogLine(InfoLog& log, int col = Console_Normal, LogSeverity sev = LogInformation)
: m_Log(log), m_Color(col), m_Sev(sev) {}
- ~InfoLogLine(void)
+ ~InfoLogLine()
{
m_Log.WriteLine(m_Sev, m_Color, m_String.str());
}
return true;
}
-bool TroubleshootCommand::CheckConfig(void)
+bool TroubleshootCommand::CheckConfig()
{
return DaemonUtility::ValidateConfigFiles({ Application::GetSysconfDir() + "/icinga2/icinga2.conf" }, Application::GetObjectsPath());
}
public:
DECLARE_PTR_TYPEDEFS(TroubleshootCommand);
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
virtual int Run(const boost::program_options::variables_map& vm, const std::vector<std::string>& ap) const override;
virtual void InitParameters(boost::program_options::options_description& visibleDesc,
boost::program_options::options_description& hiddenDesc) const override;
static void GetLatestReport(const String& filename, time_t& bestTimestamp, String& bestFilename);
static bool PrintCrashReports(InfoLog& log);
static bool PrintFile(InfoLog& log, const String& path);
- static bool CheckConfig(void);
+ static bool CheckConfig();
static void CheckObjectFile(const String& objectfile, InfoLog& log, InfoLog *OFile, const bool objectConsole,
Dictionary::Ptr& logs, std::set<String>& configs);
static bool PrintVarsFile(const String& path, const bool console);
REGISTER_CLICOMMAND("variable/get", VariableGetCommand);
-String VariableGetCommand::GetDescription(void) const
+String VariableGetCommand::GetDescription() const
{
return "Prints the value of an Icinga 2 variable.";
}
-String VariableGetCommand::GetShortDescription(void) const
+String VariableGetCommand::GetShortDescription() const
{
return "gets a variable";
}
("current", "Uses the current value (i.e. from the running process, rather than from the vars file)");
}
-int VariableGetCommand::GetMinArguments(void) const
+int VariableGetCommand::GetMinArguments() const
{
return 1;
}
public:
DECLARE_PTR_TYPEDEFS(VariableGetCommand);
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
- virtual int GetMinArguments(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
+ virtual int GetMinArguments() const override;
void InitParameters(boost::program_options::options_description& visibleDesc,
boost::program_options::options_description& hiddenDesc) const override;
virtual int Run(const boost::program_options::variables_map& vm, const std::vector<std::string>& ap) const override;
REGISTER_CLICOMMAND("variable/list", VariableListCommand);
-String VariableListCommand::GetDescription(void) const
+String VariableListCommand::GetDescription() const
{
return "Lists all Icinga 2 variables.";
}
-String VariableListCommand::GetShortDescription(void) const
+String VariableListCommand::GetShortDescription() const
{
return "lists all variables";
}
public:
DECLARE_PTR_TYPEDEFS(VariableListCommand);
- virtual String GetDescription(void) const override;
- virtual String GetShortDescription(void) const override;
+ virtual String GetDescription() const override;
+ virtual String GetShortDescription() const override;
virtual int Run(const boost::program_options::variables_map& vm, const std::vector<std::string>& ap) const override;
private:
static void PrintVariables(std::ostream& outfp);
private:
- VariableUtility(void);
+ VariableUtility();
};
/**
* @threadsafety Always.
*/
-void CheckResultReader::ReadTimerHandler(void) const
+void CheckResultReader::ReadTimerHandler() const
{
CONTEXT("Processing check result files in '" + GetSpoolDir() + "'");
private:
Timer::Ptr m_ReadTimer;
- void ReadTimerHandler(void) const;
+ void ReadTimerHandler() const;
void ProcessCheckResultFile(const String& path) const;
};
m_OutputFile << "[" << (long)Utility::GetTime() << "] " << line << "\n";
}
-void CompatLogger::Flush(void)
+void CompatLogger::Flush()
{
ASSERT(OwnsLock());
Flush();
}
-void CompatLogger::ScheduleNextRotation(void)
+void CompatLogger::ScheduleNextRotation()
{
time_t now = (time_t)Utility::GetTime();
String method = GetRotationMethod();
/**
* @threadsafety Always.
*/
-void CompatLogger::RotationTimerHandler(void)
+void CompatLogger::RotationTimerHandler()
{
try {
ReopenFile(true);
private:
void WriteLine(const String& line);
- void Flush(void);
+ void Flush();
void CheckResultHandler(const Checkable::Ptr& service, const CheckResult::Ptr& cr);
void NotificationSentHandler(const Notification::Ptr& notification, const Checkable::Ptr& service,
void EventCommandHandler(const Checkable::Ptr& service);
Timer::Ptr m_RotationTimer;
- void RotationTimerHandler(void);
- void ScheduleNextRotation(void);
+ void RotationTimerHandler();
+ void ScheduleNextRotation();
std::ofstream m_OutputFile;
void ReopenFile(bool rotate);
fp << "\t" "_is_json" "\t" "1" "\n";
}
-void StatusDataWriter::UpdateObjectsCache(void)
+void StatusDataWriter::UpdateObjectsCache()
{
CONTEXT("Writing objects.cache file");
/**
* Periodically writes the status.dat and objects.cache files.
*/
-void StatusDataWriter::StatusTimerHandler(void)
+void StatusDataWriter::StatusTimerHandler()
{
if (m_ObjectsCacheOutdated) {
UpdateObjectsCache();
<< "Writing status.dat file took " << Utility::FormatDuration(Utility::GetTime() - start);
}
-void StatusDataWriter::ObjectHandler(void)
+void StatusDataWriter::ObjectHandler()
{
m_ObjectsCacheOutdated = true;
}
void DumpCustomAttributes(std::ostream& fp, const CustomVarObject::Ptr& object);
- void UpdateObjectsCache(void);
- void StatusTimerHandler(void);
- void ObjectHandler(void);
+ void UpdateObjectsCache();
+ void StatusTimerHandler();
+ void ObjectHandler();
};
}
boost::thread_specific_ptr<std::stack<ActivationContext::Ptr> > ActivationContext::m_ActivationStack;
-std::stack<ActivationContext::Ptr>& ActivationContext::GetActivationStack(void)
+std::stack<ActivationContext::Ptr>& ActivationContext::GetActivationStack()
{
std::stack<ActivationContext::Ptr> *actx = m_ActivationStack.get();
GetActivationStack().push(context);
}
-void ActivationContext::PopContext(void)
+void ActivationContext::PopContext()
{
ASSERT(!GetActivationStack().empty());
GetActivationStack().pop();
}
-ActivationContext::Ptr ActivationContext::GetCurrentContext(void)
+ActivationContext::Ptr ActivationContext::GetCurrentContext()
{
std::stack<ActivationContext::Ptr>& astack = GetActivationStack();
ActivationContext::PushContext(m_Context);
}
-ActivationScope::~ActivationScope(void)
+ActivationScope::~ActivationScope()
{
ActivationContext::PopContext();
}
-ActivationContext::Ptr ActivationScope::GetContext(void) const
+ActivationContext::Ptr ActivationScope::GetContext() const
{
return m_Context;
}
public:
DECLARE_PTR_TYPEDEFS(ActivationContext);
- static ActivationContext::Ptr GetCurrentContext(void);
+ static ActivationContext::Ptr GetCurrentContext();
private:
static void PushContext(const ActivationContext::Ptr& context);
- static void PopContext(void);
+ static void PopContext();
- static std::stack<ActivationContext::Ptr>& GetActivationStack(void);
+ static std::stack<ActivationContext::Ptr>& GetActivationStack();
static boost::thread_specific_ptr<std::stack<ActivationContext::Ptr> > m_ActivationStack;
{
public:
ActivationScope(const ActivationContext::Ptr& context = nullptr);
- ~ActivationScope(void);
+ ~ActivationScope();
- ActivationContext::Ptr GetContext(void) const;
+ ActivationContext::Ptr GetContext() const;
private:
ActivationContext::Ptr m_Context;
m_FVVar(fvvar), m_FTerm(fterm), m_IgnoreOnError(ignoreOnError), m_DebugInfo(di), m_Scope(scope), m_HasMatches(false)
{ }
-String ApplyRule::GetTargetType(void) const
+String ApplyRule::GetTargetType() const
{
return m_TargetType;
}
-String ApplyRule::GetName(void) const
+String ApplyRule::GetName() const
{
return m_Name;
}
-std::shared_ptr<Expression> ApplyRule::GetExpression(void) const
+std::shared_ptr<Expression> ApplyRule::GetExpression() const
{
return m_Expression;
}
-std::shared_ptr<Expression> ApplyRule::GetFilter(void) const
+std::shared_ptr<Expression> ApplyRule::GetFilter() const
{
return m_Filter;
}
-String ApplyRule::GetPackage(void) const
+String ApplyRule::GetPackage() const
{
return m_Package;
}
-String ApplyRule::GetFKVar(void) const
+String ApplyRule::GetFKVar() const
{
return m_FKVar;
}
-String ApplyRule::GetFVVar(void) const
+String ApplyRule::GetFVVar() const
{
return m_FVVar;
}
-std::shared_ptr<Expression> ApplyRule::GetFTerm(void) const
+std::shared_ptr<Expression> ApplyRule::GetFTerm() const
{
return m_FTerm;
}
-bool ApplyRule::GetIgnoreOnError(void) const
+bool ApplyRule::GetIgnoreOnError() const
{
return m_IgnoreOnError;
}
-DebugInfo ApplyRule::GetDebugInfo(void) const
+DebugInfo ApplyRule::GetDebugInfo() const
{
return m_DebugInfo;
}
-Dictionary::Ptr ApplyRule::GetScope(void) const
+Dictionary::Ptr ApplyRule::GetScope() const
{
return m_Scope;
}
return it->second;
}
-void ApplyRule::AddMatch(void)
+void ApplyRule::AddMatch()
{
m_HasMatches = true;
}
-bool ApplyRule::HasMatches(void) const
+bool ApplyRule::HasMatches() const
{
return m_HasMatches;
}
return it->second;
}
-void ApplyRule::CheckMatches(void)
+void ApplyRule::CheckMatches()
{
for (const RuleMap::value_type& kv : m_Rules) {
for (const ApplyRule& rule : kv.second) {
typedef std::map<String, std::vector<String> > TypeMap;
typedef std::map<String, std::vector<ApplyRule> > RuleMap;
- String GetTargetType(void) const;
- String GetName(void) const;
- std::shared_ptr<Expression> GetExpression(void) const;
- std::shared_ptr<Expression> GetFilter(void) const;
- String GetPackage(void) const;
- String GetFKVar(void) const;
- String GetFVVar(void) const;
- std::shared_ptr<Expression> GetFTerm(void) const;
- bool GetIgnoreOnError(void) const;
- DebugInfo GetDebugInfo(void) const;
- Dictionary::Ptr GetScope(void) const;
- void AddMatch(void);
- bool HasMatches(void) const;
+ String GetTargetType() const;
+ String GetName() const;
+ std::shared_ptr<Expression> GetExpression() const;
+ std::shared_ptr<Expression> GetFilter() const;
+ String GetPackage() const;
+ String GetFKVar() const;
+ String GetFVVar() const;
+ std::shared_ptr<Expression> GetFTerm() const;
+ bool GetIgnoreOnError() const;
+ DebugInfo GetDebugInfo() const;
+ Dictionary::Ptr GetScope() const;
+ void AddMatch();
+ bool HasMatches() const;
bool EvaluateFilter(ScriptFrame& frame) const;
static bool IsValidTargetType(const String& sourceType, const String& targetType);
static std::vector<String> GetTargetTypes(const String& sourceType);
- static void CheckMatches(void);
+ static void CheckMatches();
private:
String m_TargetType;
%%
-void ConfigCompiler::InitializeScanner(void)
+void ConfigCompiler::InitializeScanner()
{
yylex_init(&m_Scanner);
yyset_extra(this, m_Scanner);
}
-void ConfigCompiler::DestroyScanner(void)
+void ConfigCompiler::DestroyScanner()
{
yylex_destroy(m_Scanner);
}
BOOST_THROW_EXCEPTION(ScriptError("Invalid flow control statement.", location));
}
-std::unique_ptr<Expression> ConfigCompiler::Compile(void)
+std::unique_ptr<Expression> ConfigCompiler::Compile()
{
std::vector<std::pair<std::unique_ptr<Expression>, EItemInfo> > llist;
/**
* Destructor for the ConfigCompiler class.
*/
-ConfigCompiler::~ConfigCompiler(void)
+ConfigCompiler::~ConfigCompiler()
{
DestroyScanner();
}
*
* @returns The scanner object.
*/
-void *ConfigCompiler::GetScanner(void) const
+void *ConfigCompiler::GetScanner() const
{
return m_Scanner;
}
*
* @returns The path.
*/
-const char *ConfigCompiler::GetPath(void) const
+const char *ConfigCompiler::GetPath() const
{
return m_Path.CStr();
}
m_Zone = zone;
}
-String ConfigCompiler::GetZone(void) const
+String ConfigCompiler::GetZone() const
{
return m_Zone;
}
m_Package = package;
}
-String ConfigCompiler::GetPackage(void) const
+String ConfigCompiler::GetPackage() const
{
return m_Package;
}
int LastLine;
int LastColumn;
- operator DebugInfo(void) const
+ operator DebugInfo() const
{
DebugInfo di;
di.Path = Path;
public:
explicit ConfigCompiler(const String& path, std::istream *input,
const String& zone = String(), const String& package = String());
- virtual ~ConfigCompiler(void);
+ virtual ~ConfigCompiler();
- std::unique_ptr<Expression> Compile(void);
+ std::unique_ptr<Expression> Compile();
static std::unique_ptr<Expression>CompileStream(const String& path, std::istream *stream,
const String& zone = String(), const String& package = String());
static void AddIncludeSearchDir(const String& dir);
- const char *GetPath(void) const;
+ const char *GetPath() const;
void SetZone(const String& zone);
- String GetZone(void) const;
+ String GetZone() const;
void SetPackage(const String& package);
- String GetPackage(void) const;
+ String GetPackage() const;
static void CollectIncludes(std::vector<std::unique_ptr<Expression> >& expressions,
const String& file, const String& zone, const String& package);
const String& path, const String& pattern, const String& package, const DebugInfo& debuginfo = DebugInfo());
size_t ReadInput(char *buffer, size_t max_bytes);
- void *GetScanner(void) const;
+ void *GetScanner() const;
static std::vector<ZoneFragment> GetZoneDirs(const String& zone);
static void RegisterZoneDir(const String& tag, const String& ppath, const String& zoneName);
static boost::mutex m_ZoneDirsMutex;
static std::map<String, std::vector<ZoneFragment> > m_ZoneDirs;
- void InitializeScanner(void);
- void DestroyScanner(void);
+ void InitializeScanner();
+ void DestroyScanner();
static void HandleIncludeZone(const String& relativeBase, const String& tag, const String& path, const String& pattern, const String& package, std::vector<std::unique_ptr<Expression> >& expressions);
using namespace icinga;
-ConfigCompilerContext *ConfigCompilerContext::GetInstance(void)
+ConfigCompilerContext *ConfigCompilerContext::GetInstance()
{
return Singleton<ConfigCompilerContext>::GetInstance();
}
-ConfigCompilerContext::ConfigCompilerContext(void)
+ConfigCompilerContext::ConfigCompilerContext()
: m_ObjectsFP(nullptr)
{ }
}
}
-void ConfigCompilerContext::CancelObjectsFile(void)
+void ConfigCompilerContext::CancelObjectsFile()
{
delete m_ObjectsFP;
m_ObjectsFP = nullptr;
#endif /* _WIN32 */
}
-void ConfigCompilerContext::FinishObjectsFile(void)
+void ConfigCompilerContext::FinishObjectsFile()
{
delete m_ObjectsFP;
m_ObjectsFP = nullptr;
class ConfigCompilerContext
{
public:
- ConfigCompilerContext(void);
+ ConfigCompilerContext();
void OpenObjectsFile(const String& filename);
void WriteObject(const Dictionary::Ptr& object);
- void CancelObjectsFile(void);
- void FinishObjectsFile(void);
+ void CancelObjectsFile();
+ void FinishObjectsFile();
- static ConfigCompilerContext *GetInstance(void);
+ static ConfigCompilerContext *GetInstance();
private:
String m_ObjectsPath;
*
* @returns The type.
*/
-Type::Ptr ConfigItem::GetType(void) const
+Type::Ptr ConfigItem::GetType() const
{
return m_Type;
}
*
* @returns The name.
*/
-String ConfigItem::GetName(void) const
+String ConfigItem::GetName() const
{
return m_Name;
}
*
* @returns true if the item is abstract, false otherwise.
*/
-bool ConfigItem::IsAbstract(void) const
+bool ConfigItem::IsAbstract() const
{
return m_Abstract;
}
-bool ConfigItem::IsDefaultTemplate(void) const
+bool ConfigItem::IsDefaultTemplate() const
{
return m_DefaultTmpl;
}
-bool ConfigItem::IsIgnoreOnError(void) const
+bool ConfigItem::IsIgnoreOnError() const
{
return m_IgnoreOnError;
}
*
* @returns The debug information.
*/
-DebugInfo ConfigItem::GetDebugInfo(void) const
+DebugInfo ConfigItem::GetDebugInfo() const
{
return m_DebugInfo;
}
-Dictionary::Ptr ConfigItem::GetScope(void) const
+Dictionary::Ptr ConfigItem::GetScope() const
{
return m_Scope;
}
-ConfigObject::Ptr ConfigItem::GetObject(void) const
+ConfigObject::Ptr ConfigItem::GetObject() const
{
return m_Object;
}
*
* @returns The expression list.
*/
-std::shared_ptr<Expression> ConfigItem::GetExpression(void) const
+std::shared_ptr<Expression> ConfigItem::GetExpression() const
{
return m_Expression;
}
*
* @returns The filter expression.
*/
-std::shared_ptr<Expression> ConfigItem::GetFilter(void) const
+std::shared_ptr<Expression> ConfigItem::GetFilter() const
{
return m_Filter;
}
/**
* Registers the configuration item.
*/
-void ConfigItem::Register(void)
+void ConfigItem::Register()
{
m_ActivationContext = ActivationContext::GetCurrentContext();
/**
* Unregisters the configuration item.
*/
-void ConfigItem::Unregister(void)
+void ConfigItem::Unregister()
{
if (m_Object) {
m_Object->Unregister();
const Dictionary::Ptr& scope, const String& zone,
const String& package);
- Type::Ptr GetType(void) const;
- String GetName(void) const;
- bool IsAbstract(void) const;
- bool IsDefaultTemplate(void) const;
- bool IsIgnoreOnError(void) const;
+ Type::Ptr GetType() const;
+ String GetName() const;
+ bool IsAbstract() const;
+ bool IsDefaultTemplate() const;
+ bool IsIgnoreOnError() const;
- std::vector<ConfigItem::Ptr> GetParents(void) const;
+ std::vector<ConfigItem::Ptr> GetParents() const;
- std::shared_ptr<Expression> GetExpression(void) const;
- std::shared_ptr<Expression> GetFilter(void) const;
+ std::shared_ptr<Expression> GetExpression() const;
+ std::shared_ptr<Expression> GetFilter() const;
- void Register(void);
- void Unregister(void);
+ void Register();
+ void Unregister();
- DebugInfo GetDebugInfo(void) const;
- Dictionary::Ptr GetScope(void) const;
+ DebugInfo GetDebugInfo() const;
+ Dictionary::Ptr GetScope() const;
- ConfigObject::Ptr GetObject(void) const;
+ ConfigObject::Ptr GetObject() const;
static ConfigItem::Ptr GetByTypeAndName(const Type::Ptr& type,
const String& name);
using namespace icinga;
-ConfigItemBuilder::ConfigItemBuilder(void)
+ConfigItemBuilder::ConfigItemBuilder()
: m_Abstract(false), m_DefaultTmpl(false), m_IgnoreOnError(false)
{
m_DebugInfo.FirstLine = 0;
m_IgnoreOnError = ignoreOnError;
}
-ConfigItem::Ptr ConfigItemBuilder::Compile(void)
+ConfigItem::Ptr ConfigItemBuilder::Compile()
{
if (!m_Type) {
std::ostringstream msgbuf;
public:
DECLARE_PTR_TYPEDEFS(ConfigItemBuilder);
- ConfigItemBuilder(void);
+ ConfigItemBuilder();
explicit ConfigItemBuilder(const DebugInfo& debugInfo);
void SetType(const Type::Ptr& type);
void AddExpression(Expression *expr);
void SetFilter(const std::shared_ptr<Expression>& filter);
- ConfigItem::Ptr Compile(void);
+ ConfigItem::Ptr Compile();
private:
Type::Ptr m_Type; /**< The object type. */
boost::signals2::signal<void (ScriptFrame&, ScriptError *ex, const DebugInfo&)> Expression::OnBreakpoint;
boost::thread_specific_ptr<bool> l_InBreakpointHandler;
-Expression::~Expression(void)
+Expression::~Expression()
{ }
void Expression::ScriptBreakpoint(ScriptFrame& frame, ScriptError *ex, const DebugInfo& di)
return false;
}
-const DebugInfo& Expression::GetDebugInfo(void) const
+const DebugInfo& Expression::GetDebugInfo() const
{
static DebugInfo debugInfo;
return debugInfo;
return std::unique_ptr<Expression>(new IndexerExpression(std::move(scope), MakeLiteral(index)));
}
-void DictExpression::MakeInline(void)
+void DictExpression::MakeInline()
{
m_Inline = true;
}
return m_Value;
}
-const DebugInfo& DebuggableExpression::GetDebugInfo(void) const
+const DebugInfo& DebuggableExpression::GetDebugInfo() const
{
return m_DebugInfo;
}
return DebugHint(child);
}
- Dictionary::Ptr ToDictionary(void) const
+ Dictionary::Ptr ToDictionary() const
{
return m_Hints;
}
Array::Ptr m_Messages;
Dictionary::Ptr m_Children;
- const Array::Ptr& GetMessages(void)
+ const Array::Ptr& GetMessages()
{
if (m_Messages)
return m_Messages;
return m_Messages;
}
- const Dictionary::Ptr& GetChildren(void)
+ const Dictionary::Ptr& GetChildren()
{
if (m_Children)
return m_Children;
: m_Value(value), m_Code(code)
{ }
- operator const Value&(void) const
+ operator const Value&() const
{
return m_Value;
}
- const Value& GetValue(void) const
+ const Value& GetValue() const
{
return m_Value;
}
- ExpressionResultCode GetCode(void) const
+ ExpressionResultCode GetCode() const
{
return m_Code;
}
class Expression
{
public:
- Expression(void) = default;
+ Expression() = default;
Expression(const Expression&) = delete;
- virtual ~Expression(void);
+ virtual ~Expression();
Expression& operator=(const Expression&) = delete;
ExpressionResult Evaluate(ScriptFrame& frame, DebugHint *dhint = nullptr) const;
virtual bool GetReference(ScriptFrame& frame, bool init_dict, Value *parent, String *index, DebugHint **dhint = nullptr) const;
- virtual const DebugInfo& GetDebugInfo(void) const;
+ virtual const DebugInfo& GetDebugInfo() const;
virtual ExpressionResult DoEvaluate(ScriptFrame& frame, DebugHint *dhint) const = 0;
return m_Expression->DoEvaluate(frame, dhint);
}
- virtual const DebugInfo& GetDebugInfo(void) const override
+ virtual const DebugInfo& GetDebugInfo() const override
{
return m_Expression->GetDebugInfo();
}
public:
LiteralExpression(const Value& value = Value());
- const Value& GetValue(void) const
+ const Value& GetValue() const
{
return m_Value;
}
{ }
protected:
- virtual const DebugInfo& GetDebugInfo(void) const override final;
+ const DebugInfo& GetDebugInfo(void) const final;
DebugInfo m_DebugInfo;
};
: DebuggableExpression(debugInfo), m_Variable(variable)
{ }
- String GetVariable(void) const
+ String GetVariable() const
{
return m_Variable;
}
: DebuggableExpression(debugInfo), m_Expressions(std::move(expressions)), m_Inline(false)
{ }
- void MakeInline(void);
+ void MakeInline();
protected:
virtual ExpressionResult DoEvaluate(ScriptFrame& frame, DebugHint *dhint) const override;
static bool IsValidSourceType(const String& sourceType);
private:
- ObjectRule(void);
+ ObjectRule();
static TypeSet m_Types;
};
: DbObject(type, name1, name2)
{ }
-Dictionary::Ptr CommandDbObject::GetConfigFields(void) const
+Dictionary::Ptr CommandDbObject::GetConfigFields() const
{
Dictionary::Ptr fields = new Dictionary();
Command::Ptr command = static_pointer_cast<Command>(GetObject());
return fields;
}
-Dictionary::Ptr CommandDbObject::GetStatusFields(void) const
+Dictionary::Ptr CommandDbObject::GetStatusFields() const
{
return nullptr;
}
CommandDbObject(const DbType::Ptr& type, const String& name1, const String& name2);
- virtual Dictionary::Ptr GetConfigFields(void) const override;
- virtual Dictionary::Ptr GetStatusFields(void) const override;
+ virtual Dictionary::Ptr GetConfigFields() const override;
+ virtual Dictionary::Ptr GetStatusFields() const override;
};
}
Timer::Ptr DbConnection::m_ProgramStatusTimer;
boost::once_flag DbConnection::m_OnceFlag = BOOST_ONCE_INIT;
-DbConnection::DbConnection(void)
+DbConnection::DbConnection()
: m_IDCacheValid(false), m_QueryStats(15 * 60), m_ActiveChangedHandler(false)
{ }
-void DbConnection::OnConfigLoaded(void)
+void DbConnection::OnConfigLoaded()
{
ConfigObject::OnConfigLoaded();
ObjectImpl<DbConnection>::Stop(runtimeRemoved);
}
-void DbConnection::EnableActiveChangedHandler(void)
+void DbConnection::EnableActiveChangedHandler()
{
if (!m_ActiveChangedHandler) {
ConfigObject::OnActiveChanged.connect(std::bind(&DbConnection::UpdateObject, this, _1));
}
}
-void DbConnection::Resume(void)
+void DbConnection::Resume()
{
ConfigObject::Resume();
m_CleanUpTimer->Start();
}
-void DbConnection::Pause(void)
+void DbConnection::Pause()
{
ConfigObject::Pause();
NewTransaction();
}
-void DbConnection::InitializeDbTimer(void)
+void DbConnection::InitializeDbTimer()
{
m_ProgramStatusTimer = new Timer();
m_ProgramStatusTimer->SetInterval(10);
DbObject::OnQuery(query);
}
-void DbConnection::UpdateProgramStatus(void)
+void DbConnection::UpdateProgramStatus()
{
Log(LogNotice, "DbConnection")
<< "Updating programstatus table.";
InsertRuntimeVariable("total_scheduled_hosts", ConfigType::Get<Host>()->GetObjectCount());
}
-void DbConnection::CleanUpHandler(void)
+void DbConnection::CleanUpHandler()
{
long now = static_cast<long>(Utility::GetTime());
return (m_ActiveObjects.find(dbobj) != m_ActiveObjects.end());
}
-void DbConnection::ClearIDCache(void)
+void DbConnection::ClearIDCache()
{
SetIDCacheValid(false);
}
}
-void DbConnection::UpdateAllObjects(void)
+void DbConnection::UpdateAllObjects()
{
for (const Type::Ptr& type : Type::GetAllTypes()) {
ConfigType *dtype = dynamic_cast<ConfigType *>(type.get());
}
}
-void DbConnection::PrepareDatabase(void)
+void DbConnection::PrepareDatabase()
{
for (const DbType::Ptr& type : DbType::GetAllTypes()) {
FillIDCache(type);
BOOST_THROW_EXCEPTION(ValidationError(this, { "categories" }, "categories filter is invalid."));
}
-void DbConnection::IncreaseQueryCount(void)
+void DbConnection::IncreaseQueryCount()
{
double now = Utility::GetTime();
return m_QueryStats.UpdateAndGetValues(Utility::GetTime(), span);
}
-bool DbConnection::IsIDCacheValid(void) const
+bool DbConnection::IsIDCacheValid() const
{
return m_IDCacheValid;
}
m_IDCacheValid = valid;
}
-int DbConnection::GetSessionToken(void)
+int DbConnection::GetSessionToken()
{
return Application::GetStartTime();
}
public:
DECLARE_OBJECT(DbConnection);
- DbConnection(void);
+ DbConnection();
- static void InitializeDbTimer(void);
+ static void InitializeDbTimer();
void SetConfigHash(const DbObject::Ptr& dbobj, const String& hash);
void SetConfigHash(const DbType::Ptr& type, const DbReference& objid, const String& hash);
void SetObjectActive(const DbObject::Ptr& dbobj, bool active);
bool GetObjectActive(const DbObject::Ptr& dbobj) const;
- void ClearIDCache(void);
+ void ClearIDCache();
void SetConfigUpdate(const DbObject::Ptr& dbobj, bool hasupdate);
bool GetConfigUpdate(const DbObject::Ptr& dbobj) const;
bool GetStatusUpdate(const DbObject::Ptr& dbobj) const;
int GetQueryCount(RingBuffer::SizeType span);
- virtual int GetPendingQueryCount(void) const = 0;
+ virtual int GetPendingQueryCount() const = 0;
virtual void ValidateFailoverTimeout(double value, const ValidationUtils& utils) override final;
virtual void ValidateCategories(const Array::Ptr& value, const ValidationUtils& utils) override final;
protected:
- virtual void OnConfigLoaded(void) override;
+ virtual void OnConfigLoaded() override;
virtual void Start(bool runtimeCreated) override;
virtual void Stop(bool runtimeRemoved) override;
- virtual void Resume(void) override;
- virtual void Pause(void) override;
+ virtual void Resume() override;
+ virtual void Pause() override;
virtual void ExecuteQuery(const DbQuery& query) = 0;
virtual void ExecuteMultipleQueries(const std::vector<DbQuery>&) = 0;
virtual void CleanUpExecuteQuery(const String& table, const String& time_column, double max_age);
virtual void FillIDCache(const DbType::Ptr& type) = 0;
- virtual void NewTransaction(void) = 0;
+ virtual void NewTransaction() = 0;
void UpdateObject(const ConfigObject::Ptr& object);
- void UpdateAllObjects(void);
+ void UpdateAllObjects();
- void PrepareDatabase(void);
+ void PrepareDatabase();
- void IncreaseQueryCount(void);
+ void IncreaseQueryCount();
- bool IsIDCacheValid(void) const;
+ bool IsIDCacheValid() const;
void SetIDCacheValid(bool valid);
- void EnableActiveChangedHandler(void);
+ void EnableActiveChangedHandler();
- static void UpdateProgramStatus(void);
+ static void UpdateProgramStatus();
- static int GetSessionToken(void);
+ static int GetSessionToken();
private:
bool m_IDCacheValid;
std::set<DbObject::Ptr> m_StatusUpdates;
Timer::Ptr m_CleanUpTimer;
- void CleanUpHandler(void);
+ void CleanUpHandler();
static Timer::Ptr m_ProgramStatusTimer;
static boost::once_flag m_OnceFlag;
INITIALIZE_ONCE(&DbEvents::StaticInitialize);
-void DbEvents::StaticInitialize(void)
+void DbEvents::StaticInitialize()
{
/* Status */
Comment::OnCommentAdded.connect(std::bind(&DbEvents::AddComment, _1));
class DbEvents
{
public:
- static void StaticInitialize(void);
+ static void StaticInitialize();
static void AddComments(const Checkable::Ptr& checkable);
static void AddExternalCommandHistory(double time, const String& command, const std::vector<String>& arguments);
private:
- DbEvents(void);
+ DbEvents();
static void AddCommentInternal(std::vector<DbQuery>& queries, const Comment::Ptr& comment, bool historical);
static void RemoveCommentInternal(std::vector<DbQuery>& queries, const Comment::Ptr& comment);
: m_Name1(name1), m_Name2(name2), m_Type(type), m_LastConfigUpdate(0), m_LastStatusUpdate(0)
{ }
-void DbObject::StaticInitialize(void)
+void DbObject::StaticInitialize()
{
/* triggered in ProcessCheckResult(), requires UpdateNextCheck() to be called before */
ConfigObject::OnStateChanged.connect(std::bind(&DbObject::StateChangedHandler, _1));
m_Object = object;
}
-ConfigObject::Ptr DbObject::GetObject(void) const
+ConfigObject::Ptr DbObject::GetObject() const
{
return m_Object;
}
-String DbObject::GetName1(void) const
+String DbObject::GetName1() const
{
return m_Name1;
}
-String DbObject::GetName2(void) const
+String DbObject::GetName2() const
{
return m_Name2;
}
-DbType::Ptr DbObject::GetType(void) const
+DbType::Ptr DbObject::GetType() const
{
return m_Type;
}
OnConfigUpdateHeavy();
}
-void DbObject::SendConfigUpdateLight(void)
+void DbObject::SendConfigUpdateLight()
{
OnConfigUpdateLight();
}
-void DbObject::SendStatusUpdate(void)
+void DbObject::SendStatusUpdate()
{
/* status attributes */
Dictionary::Ptr fields = GetStatusFields();
OnStatusUpdate();
}
-void DbObject::SendVarsConfigUpdateHeavy(void)
+void DbObject::SendVarsConfigUpdateHeavy()
{
ConfigObject::Ptr obj = GetObject();
OnMultipleQueries(queries);
}
-void DbObject::SendVarsStatusUpdate(void)
+void DbObject::SendVarsStatusUpdate()
{
ConfigObject::Ptr obj = GetObject();
}
}
-double DbObject::GetLastConfigUpdate(void) const
+double DbObject::GetLastConfigUpdate() const
{
return m_LastConfigUpdate;
}
-double DbObject::GetLastStatusUpdate(void) const
+double DbObject::GetLastStatusUpdate() const
{
return m_LastStatusUpdate;
}
-void DbObject::OnConfigUpdateHeavy(void)
+void DbObject::OnConfigUpdateHeavy()
{
/* Default handler does nothing. */
}
-void DbObject::OnConfigUpdateLight(void)
+void DbObject::OnConfigUpdateLight()
{
/* Default handler does nothing. */
}
-void DbObject::OnStatusUpdate(void)
+void DbObject::OnStatusUpdate()
{
/* Default handler does nothing. */
}
}
}
-boost::mutex& DbObject::GetStaticMutex(void)
+boost::mutex& DbObject::GetStaticMutex()
{
static boost::mutex mutex;
return mutex;
public:
DECLARE_PTR_TYPEDEFS(DbObject);
- static void StaticInitialize(void);
+ static void StaticInitialize();
void SetObject(const ConfigObject::Ptr& object);
- ConfigObject::Ptr GetObject(void) const;
+ ConfigObject::Ptr GetObject() const;
- String GetName1(void) const;
- String GetName2(void) const;
- intrusive_ptr<DbType> GetType(void) const;
+ String GetName1() const;
+ String GetName2() const;
+ intrusive_ptr<DbType> GetType() const;
- virtual Dictionary::Ptr GetConfigFields(void) const = 0;
- virtual Dictionary::Ptr GetStatusFields(void) const = 0;
+ virtual Dictionary::Ptr GetConfigFields() const = 0;
+ virtual Dictionary::Ptr GetStatusFields() const = 0;
static DbObject::Ptr GetOrCreateByObject(const ConfigObject::Ptr& object);
static boost::signals2::signal<void (const std::vector<DbQuery>&)> OnMultipleQueries;
void SendConfigUpdateHeavy(const Dictionary::Ptr& configFields);
- void SendConfigUpdateLight(void);
- void SendStatusUpdate(void);
- void SendVarsConfigUpdateHeavy(void);
- void SendVarsStatusUpdate(void);
+ void SendConfigUpdateLight();
+ void SendStatusUpdate();
+ void SendVarsConfigUpdateHeavy();
+ void SendVarsStatusUpdate();
- double GetLastConfigUpdate(void) const;
- double GetLastStatusUpdate(void) const;
+ double GetLastConfigUpdate() const;
+ double GetLastStatusUpdate() const;
virtual String CalculateConfigHash(const Dictionary::Ptr& configFields) const;
protected:
DbObject(const intrusive_ptr<DbType>& type, const String& name1, const String& name2);
- virtual void OnConfigUpdateHeavy(void);
- virtual void OnConfigUpdateLight(void);
- virtual void OnStatusUpdate(void);
+ virtual void OnConfigUpdateHeavy();
+ virtual void OnConfigUpdateLight();
+ virtual void OnStatusUpdate();
static String HashValue(const Value& value);
static void VarsChangedHandler(const CustomVarObject::Ptr& object);
static void VersionChangedHandler(const ConfigObject::Ptr& object);
- static boost::mutex& GetStaticMutex(void);
+ static boost::mutex& GetStaticMutex();
friend class DbType;
};
std::map<String, int> DbQuery::m_CategoryFilterMap;
-void DbQuery::StaticInitialize(void)
+void DbQuery::StaticInitialize()
{
ScriptGlobal::Set("DbCatConfig", DbCatConfig);
ScriptGlobal::Set("DbCatState", DbCatState);
m_CategoryFilterMap["DbCatEverything"] = DbCatEverything;
}
-const std::map<String, int>& DbQuery::GetCategoryFilterMap(void)
+const std::map<String, int>& DbQuery::GetCategoryFilterMap()
{
return m_CategoryFilterMap;
}
bool StatusUpdate;
WorkQueuePriority Priority;
- static void StaticInitialize(void);
+ static void StaticInitialize();
- DbQuery(void)
+ DbQuery()
: Type(0), Category(DbCatInvalid), ConfigUpdate(false), StatusUpdate(false), Priority(PriorityNormal)
{ }
- static const std::map<String, int>& GetCategoryFilterMap(void);
+ static const std::map<String, int>& GetCategoryFilterMap();
private:
static std::map<String, int> m_CategoryFilterMap;
using namespace icinga;
-DbReference::DbReference(void)
+DbReference::DbReference()
: m_Id(-1)
{ }
: m_Id(id)
{ }
-bool DbReference::IsValid(void) const
+bool DbReference::IsValid() const
{
return (m_Id != -1);
}
-DbReference::operator long(void) const
+DbReference::operator long() const
{
return m_Id;
}
struct DbReference
{
public:
- DbReference(void);
+ DbReference();
DbReference(long id);
- bool IsValid(void) const;
- operator long(void) const;
+ bool IsValid() const;
+ operator long() const;
private:
long m_Id;
};
: m_Name(name), m_Table(table), m_TypeID(tid), m_IDColumn(idcolumn), m_ObjectFactory(factory)
{ }
-String DbType::GetName(void) const
+String DbType::GetName() const
{
return m_Name;
}
-String DbType::GetTable(void) const
+String DbType::GetTable() const
{
return m_Table;
}
-long DbType::GetTypeID(void) const
+long DbType::GetTypeID() const
{
return m_TypeID;
}
-String DbType::GetIDColumn(void) const
+String DbType::GetIDColumn() const
{
return m_IDColumn;
}
return dbobj;
}
-boost::mutex& DbType::GetStaticMutex(void)
+boost::mutex& DbType::GetStaticMutex()
{
static boost::mutex mutex;
return mutex;
/**
* Caller must hold static mutex.
*/
-DbType::TypeMap& DbType::GetTypes(void)
+DbType::TypeMap& DbType::GetTypes()
{
static DbType::TypeMap tm;
return tm;
}
-std::set<DbType::Ptr> DbType::GetAllTypes(void)
+std::set<DbType::Ptr> DbType::GetAllTypes()
{
std::set<DbType::Ptr> result;
return result;
}
-DbTypeRegistry *DbTypeRegistry::GetInstance(void)
+DbTypeRegistry *DbTypeRegistry::GetInstance()
{
return Singleton<DbTypeRegistry>::GetInstance();
}
DbType(const String& name, const String& table, long tid, const String& idcolumn, const ObjectFactory& factory);
- String GetName(void) const;
- String GetTable(void) const;
- long GetTypeID(void) const;
- String GetIDColumn(void) const;
+ String GetName() const;
+ String GetTable() const;
+ long GetTypeID() const;
+ String GetIDColumn() const;
static void RegisterType(const DbType::Ptr& type);
intrusive_ptr<DbObject> GetOrCreateObjectByName(const String& name1, const String& name2);
- static std::set<DbType::Ptr> GetAllTypes(void);
+ static std::set<DbType::Ptr> GetAllTypes();
private:
String m_Name;
String m_IDColumn;
ObjectFactory m_ObjectFactory;
- static boost::mutex& GetStaticMutex(void);
- static TypeMap& GetTypes(void);
+ static boost::mutex& GetStaticMutex();
+ static TypeMap& GetTypes();
ObjectMap m_Objects;
};
class DbTypeRegistry : public Registry<DbTypeRegistry, DbType::Ptr>
{
public:
- static DbTypeRegistry *GetInstance(void);
+ static DbTypeRegistry *GetInstance();
};
/**
return new DbValue(DbValueTimestamp, ts);
}
-Value DbValue::FromTimestampNow(void)
+Value DbValue::FromTimestampNow()
{
return new DbValue(DbValueTimestampNow, Empty);
}
return dbv->GetValue();
}
-DbValueType DbValue::GetType(void) const
+DbValueType DbValue::GetType() const
{
return m_Type;
}
-Value DbValue::GetValue(void) const
+Value DbValue::GetValue() const
{
return m_Value;
}
DbValue(DbValueType type, const Value& value);
static Value FromTimestamp(const Value& ts);
- static Value FromTimestampNow(void);
+ static Value FromTimestampNow();
static Value FromValue(const Value& value);
static Value FromObjectInsertID(const Value& value);
static Value ExtractValue(const Value& value);
- DbValueType GetType(void) const;
+ DbValueType GetType() const;
- Value GetValue(void) const;
+ Value GetValue() const;
void SetValue(const Value& value);
private:
INITIALIZE_ONCE(&EndpointDbObject::StaticInitialize);
-void EndpointDbObject::StaticInitialize(void)
+void EndpointDbObject::StaticInitialize()
{
Endpoint::OnConnected.connect(std::bind(&EndpointDbObject::UpdateConnectedStatus, _1));
Endpoint::OnDisconnected.connect(std::bind(&EndpointDbObject::UpdateConnectedStatus, _1));
: DbObject(type, name1, name2)
{ }
-Dictionary::Ptr EndpointDbObject::GetConfigFields(void) const
+Dictionary::Ptr EndpointDbObject::GetConfigFields() const
{
Dictionary::Ptr fields = new Dictionary();
Endpoint::Ptr endpoint = static_pointer_cast<Endpoint>(GetObject());
return fields;
}
-Dictionary::Ptr EndpointDbObject::GetStatusFields(void) const
+Dictionary::Ptr EndpointDbObject::GetStatusFields() const
{
Dictionary::Ptr fields = new Dictionary();
Endpoint::Ptr endpoint = static_pointer_cast<Endpoint>(GetObject());
EndpointDbObject(const intrusive_ptr<DbType>& type, const String& name1, const String& name2);
- static void StaticInitialize(void);
+ static void StaticInitialize();
- virtual Dictionary::Ptr GetConfigFields(void) const override;
- virtual Dictionary::Ptr GetStatusFields(void) const override;
+ virtual Dictionary::Ptr GetConfigFields() const override;
+ virtual Dictionary::Ptr GetStatusFields() const override;
private:
static void UpdateConnectedStatus(const Endpoint::Ptr& endpoint);
: DbObject(type, name1, name2)
{ }
-Dictionary::Ptr HostDbObject::GetConfigFields(void) const
+Dictionary::Ptr HostDbObject::GetConfigFields() const
{
Dictionary::Ptr fields = new Dictionary();
Host::Ptr host = static_pointer_cast<Host>(GetObject());
return fields;
}
-Dictionary::Ptr HostDbObject::GetStatusFields(void) const
+Dictionary::Ptr HostDbObject::GetStatusFields() const
{
Dictionary::Ptr fields = new Dictionary();
Host::Ptr host = static_pointer_cast<Host>(GetObject());
return fields;
}
-void HostDbObject::OnConfigUpdateHeavy(void)
+void HostDbObject::OnConfigUpdateHeavy()
{
Host::Ptr host = static_pointer_cast<Host>(GetObject());
DoCommonConfigUpdate();
}
-void HostDbObject::OnConfigUpdateLight(void)
+void HostDbObject::OnConfigUpdateLight()
{
DoCommonConfigUpdate();
}
-void HostDbObject::DoCommonConfigUpdate(void)
+void HostDbObject::DoCommonConfigUpdate()
{
Host::Ptr host = static_pointer_cast<Host>(GetObject());
HostDbObject(const DbType::Ptr& type, const String& name1, const String& name2);
- virtual Dictionary::Ptr GetConfigFields(void) const override;
- virtual Dictionary::Ptr GetStatusFields(void) const override;
+ virtual Dictionary::Ptr GetConfigFields() const override;
+ virtual Dictionary::Ptr GetStatusFields() const override;
- virtual void OnConfigUpdateHeavy(void) override;
- virtual void OnConfigUpdateLight(void) override;
+ virtual void OnConfigUpdateHeavy() override;
+ virtual void OnConfigUpdateLight() override;
virtual String CalculateConfigHash(const Dictionary::Ptr& configFields) const override;
private:
- void DoCommonConfigUpdate(void);
+ void DoCommonConfigUpdate();
};
}
: DbObject(type, name1, name2)
{ }
-Dictionary::Ptr HostGroupDbObject::GetConfigFields(void) const
+Dictionary::Ptr HostGroupDbObject::GetConfigFields() const
{
Dictionary::Ptr fields = new Dictionary();
HostGroup::Ptr group = static_pointer_cast<HostGroup>(GetObject());
return fields;
}
-Dictionary::Ptr HostGroupDbObject::GetStatusFields(void) const
+Dictionary::Ptr HostGroupDbObject::GetStatusFields() const
{
return nullptr;
}
HostGroupDbObject(const DbType::Ptr& type, const String& name1, const String& name2);
- virtual Dictionary::Ptr GetConfigFields(void) const override;
- virtual Dictionary::Ptr GetStatusFields(void) const override;
+ virtual Dictionary::Ptr GetConfigFields() const override;
+ virtual Dictionary::Ptr GetStatusFields() const override;
private:
static void MembersChangedHandler(const HostGroup::Ptr& hgfilter);
const Dictionary::Ptr& resolvedMacros, bool useResolvedMacros);
private:
- IdoCheckTask(void);
+ IdoCheckTask();
};
}
: DbObject(type, name1, name2)
{ }
-Dictionary::Ptr ServiceDbObject::GetConfigFields(void) const
+Dictionary::Ptr ServiceDbObject::GetConfigFields() const
{
Dictionary::Ptr fields = new Dictionary();
Service::Ptr service = static_pointer_cast<Service>(GetObject());
return fields;
}
-Dictionary::Ptr ServiceDbObject::GetStatusFields(void) const
+Dictionary::Ptr ServiceDbObject::GetStatusFields() const
{
Dictionary::Ptr fields = new Dictionary();
Service::Ptr service = static_pointer_cast<Service>(GetObject());
return fields;
}
-void ServiceDbObject::OnConfigUpdateHeavy(void)
+void ServiceDbObject::OnConfigUpdateHeavy()
{
Service::Ptr service = static_pointer_cast<Service>(GetObject());
DoCommonConfigUpdate();
}
-void ServiceDbObject::OnConfigUpdateLight(void)
+void ServiceDbObject::OnConfigUpdateLight()
{
DoCommonConfigUpdate();
}
-void ServiceDbObject::DoCommonConfigUpdate(void)
+void ServiceDbObject::DoCommonConfigUpdate()
{
Service::Ptr service = static_pointer_cast<Service>(GetObject());
ServiceDbObject(const DbType::Ptr& type, const String& name1, const String& name2);
- static void StaticInitialize(void);
+ static void StaticInitialize();
- virtual Dictionary::Ptr GetConfigFields(void) const override;
- virtual Dictionary::Ptr GetStatusFields(void) const override;
+ virtual Dictionary::Ptr GetConfigFields() const override;
+ virtual Dictionary::Ptr GetStatusFields() const override;
- virtual void OnConfigUpdateHeavy(void) override;
- virtual void OnConfigUpdateLight(void) override;
+ virtual void OnConfigUpdateHeavy() override;
+ virtual void OnConfigUpdateLight() override;
virtual String CalculateConfigHash(const Dictionary::Ptr& configFields) const override;
private:
- void DoCommonConfigUpdate(void);
+ void DoCommonConfigUpdate();
};
}
: DbObject(type, name1, name2)
{ }
-Dictionary::Ptr ServiceGroupDbObject::GetConfigFields(void) const
+Dictionary::Ptr ServiceGroupDbObject::GetConfigFields() const
{
Dictionary::Ptr fields = new Dictionary();
ServiceGroup::Ptr group = static_pointer_cast<ServiceGroup>(GetObject());
return fields;
}
-Dictionary::Ptr ServiceGroupDbObject::GetStatusFields(void) const
+Dictionary::Ptr ServiceGroupDbObject::GetStatusFields() const
{
return nullptr;
}
ServiceGroupDbObject(const DbType::Ptr& type, const String& name1, const String& name2);
- virtual Dictionary::Ptr GetConfigFields(void) const override;
- virtual Dictionary::Ptr GetStatusFields(void) const override;
+ virtual Dictionary::Ptr GetConfigFields() const override;
+ virtual Dictionary::Ptr GetStatusFields() const override;
};
}
: DbObject(type, name1, name2)
{ }
-Dictionary::Ptr TimePeriodDbObject::GetConfigFields(void) const
+Dictionary::Ptr TimePeriodDbObject::GetConfigFields() const
{
Dictionary::Ptr fields = new Dictionary();
TimePeriod::Ptr tp = static_pointer_cast<TimePeriod>(GetObject());
return fields;
}
-Dictionary::Ptr TimePeriodDbObject::GetStatusFields(void) const
+Dictionary::Ptr TimePeriodDbObject::GetStatusFields() const
{
return Empty;
}
-void TimePeriodDbObject::OnConfigUpdateHeavy(void)
+void TimePeriodDbObject::OnConfigUpdateHeavy()
{
TimePeriod::Ptr tp = static_pointer_cast<TimePeriod>(GetObject());
TimePeriodDbObject(const DbType::Ptr& type, const String& name1, const String& name2);
protected:
- virtual Dictionary::Ptr GetConfigFields(void) const override;
- virtual Dictionary::Ptr GetStatusFields(void) const override;
+ virtual Dictionary::Ptr GetConfigFields() const override;
+ virtual Dictionary::Ptr GetStatusFields() const override;
- virtual void OnConfigUpdateHeavy(void) override;
+ virtual void OnConfigUpdateHeavy() override;
};
}
: DbObject(type, name1, name2)
{ }
-Dictionary::Ptr UserDbObject::GetConfigFields(void) const
+Dictionary::Ptr UserDbObject::GetConfigFields() const
{
Dictionary::Ptr fields = new Dictionary();
User::Ptr user = static_pointer_cast<User>(GetObject());
return fields;
}
-Dictionary::Ptr UserDbObject::GetStatusFields(void) const
+Dictionary::Ptr UserDbObject::GetStatusFields() const
{
Dictionary::Ptr fields = new Dictionary();
User::Ptr user = static_pointer_cast<User>(GetObject());
return fields;
}
-void UserDbObject::OnConfigUpdateHeavy(void)
+void UserDbObject::OnConfigUpdateHeavy()
{
User::Ptr user = static_pointer_cast<User>(GetObject());
UserDbObject(const DbType::Ptr& type, const String& name1, const String& name2);
protected:
- virtual Dictionary::Ptr GetConfigFields(void) const override;
- virtual Dictionary::Ptr GetStatusFields(void) const override;
+ virtual Dictionary::Ptr GetConfigFields() const override;
+ virtual Dictionary::Ptr GetStatusFields() const override;
- virtual void OnConfigUpdateHeavy(void) override;
+ virtual void OnConfigUpdateHeavy() override;
virtual String CalculateConfigHash(const Dictionary::Ptr& configFields) const override;
};
: DbObject(type, name1, name2)
{ }
-Dictionary::Ptr UserGroupDbObject::GetConfigFields(void) const
+Dictionary::Ptr UserGroupDbObject::GetConfigFields() const
{
Dictionary::Ptr fields = new Dictionary();
UserGroup::Ptr group = static_pointer_cast<UserGroup>(GetObject());
return fields;
}
-Dictionary::Ptr UserGroupDbObject::GetStatusFields(void) const
+Dictionary::Ptr UserGroupDbObject::GetStatusFields() const
{
return nullptr;
}
UserGroupDbObject(const DbType::Ptr& type, const String& name1, const String& name2);
- virtual Dictionary::Ptr GetConfigFields(void) const override;
- virtual Dictionary::Ptr GetStatusFields(void) const override;
+ virtual Dictionary::Ptr GetConfigFields() const override;
+ virtual Dictionary::Ptr GetStatusFields() const override;
};
}
: DbObject(type, name1, name2)
{ }
-Dictionary::Ptr ZoneDbObject::GetConfigFields(void) const
+Dictionary::Ptr ZoneDbObject::GetConfigFields() const
{
Dictionary::Ptr fields = new Dictionary();
Zone::Ptr zone = static_pointer_cast<Zone>(GetObject());
return fields;
}
-Dictionary::Ptr ZoneDbObject::GetStatusFields(void) const
+Dictionary::Ptr ZoneDbObject::GetStatusFields() const
{
Zone::Ptr zone = static_pointer_cast<Zone>(GetObject());
ZoneDbObject(const intrusive_ptr<DbType>& type, const String& name1, const String& name2);
- virtual Dictionary::Ptr GetConfigFields(void) const override;
- virtual Dictionary::Ptr GetStatusFields(void) const override;
+ virtual Dictionary::Ptr GetConfigFields() const override;
+ virtual Dictionary::Ptr GetStatusFields() const override;
};
}
REGISTER_TYPE(IdoMysqlConnection);
REGISTER_STATSFUNCTION(IdoMysqlConnection, &IdoMysqlConnection::StatsFunc);
-IdoMysqlConnection::IdoMysqlConnection(void)
+IdoMysqlConnection::IdoMysqlConnection()
: m_QueryQueue(10000000)
{ }
-void IdoMysqlConnection::OnConfigLoaded(void)
+void IdoMysqlConnection::OnConfigLoaded()
{
ObjectImpl<IdoMysqlConnection>::OnConfigLoaded();
status->Set("idomysqlconnection", nodes);
}
-void IdoMysqlConnection::Resume(void)
+void IdoMysqlConnection::Resume()
{
DbConnection::Resume();
ASSERT(m_Mysql->thread_safe());
}
-void IdoMysqlConnection::Pause(void)
+void IdoMysqlConnection::Pause()
{
Log(LogInformation, "IdoMysqlConnection")
<< "'" << GetName() << "' paused.";
}
}
-void IdoMysqlConnection::AssertOnWorkQueue(void)
+void IdoMysqlConnection::AssertOnWorkQueue()
{
ASSERT(m_QueryQueue.IsWorkerThread());
}
-void IdoMysqlConnection::Disconnect(void)
+void IdoMysqlConnection::Disconnect()
{
AssertOnWorkQueue();
SetConnected(false);
}
-void IdoMysqlConnection::TxTimerHandler(void)
+void IdoMysqlConnection::TxTimerHandler()
{
NewTransaction();
}
-void IdoMysqlConnection::NewTransaction(void)
+void IdoMysqlConnection::NewTransaction()
{
#ifdef I2_DEBUG /* I2_DEBUG */
Log(LogDebug, "IdoMysqlConnection")
m_QueryQueue.Enqueue(std::bind(&IdoMysqlConnection::FinishAsyncQueries, this), PriorityHigh);
}
-void IdoMysqlConnection::InternalNewTransaction(void)
+void IdoMysqlConnection::InternalNewTransaction()
{
AssertOnWorkQueue();
AsyncQuery("BEGIN");
}
-void IdoMysqlConnection::ReconnectTimerHandler(void)
+void IdoMysqlConnection::ReconnectTimerHandler()
{
#ifdef I2_DEBUG /* I2_DEBUG */
Log(LogDebug, "IdoMysqlConnection")
m_QueryQueue.Enqueue(std::bind(&IdoMysqlConnection::Reconnect, this), PriorityLow);
}
-void IdoMysqlConnection::Reconnect(void)
+void IdoMysqlConnection::Reconnect()
{
AssertOnWorkQueue();
Query("BEGIN");
}
-void IdoMysqlConnection::ClearTablesBySession(void)
+void IdoMysqlConnection::ClearTablesBySession()
{
/* delete all comments and downtimes without current session token */
ClearTableBySession("comments");
}
}
-void IdoMysqlConnection::FinishAsyncQueries(void)
+void IdoMysqlConnection::FinishAsyncQueries()
{
std::vector<IdoAsyncQuery> queries;
m_AsyncQueries.swap(queries);
return IdoMysqlResult(result, std::bind(&MysqlInterface::free_result, std::cref(m_Mysql), _1));
}
-DbReference IdoMysqlConnection::GetLastInsertID(void)
+DbReference IdoMysqlConnection::GetLastInsertID()
{
AssertOnWorkQueue();
return DbReference(m_Mysql->insert_id(&m_Connection));
}
-int IdoMysqlConnection::GetAffectedRows(void)
+int IdoMysqlConnection::GetAffectedRows()
{
AssertOnWorkQueue();
}
}
-int IdoMysqlConnection::GetPendingQueryCount(void) const
+int IdoMysqlConnection::GetPendingQueryCount() const
{
return m_QueryQueue.GetLength();
}
DECLARE_OBJECT(IdoMysqlConnection);
DECLARE_OBJECTNAME(IdoMysqlConnection);
- IdoMysqlConnection(void);
+ IdoMysqlConnection();
static void StatsFunc(const Dictionary::Ptr& status, const Array::Ptr& perfdata);
- virtual int GetPendingQueryCount(void) const override;
+ virtual int GetPendingQueryCount() const override;
protected:
- virtual void OnConfigLoaded(void) override;
- virtual void Resume(void) override;
- virtual void Pause(void) override;
+ virtual void OnConfigLoaded() override;
+ virtual void Resume() override;
+ virtual void Pause() override;
virtual void ActivateObject(const DbObject::Ptr& dbobj) override;
virtual void DeactivateObject(const DbObject::Ptr& dbobj) override;
virtual void ExecuteMultipleQueries(const std::vector<DbQuery>& queries) override;
virtual void CleanUpExecuteQuery(const String& table, const String& time_key, double time_value) override;
virtual void FillIDCache(const DbType::Ptr& type) override;
- virtual void NewTransaction(void) override;
+ virtual void NewTransaction() override;
private:
DbReference m_InstanceID;
Timer::Ptr m_TxTimer;
IdoMysqlResult Query(const String& query);
- DbReference GetLastInsertID(void);
- int GetAffectedRows(void);
+ DbReference GetLastInsertID();
+ int GetAffectedRows();
String Escape(const String& s);
Dictionary::Ptr FetchRow(const IdoMysqlResult& result);
void DiscardRows(const IdoMysqlResult& result);
void AsyncQuery(const String& query, const IdoAsyncCallback& callback = IdoAsyncCallback());
- void FinishAsyncQueries(void);
+ void FinishAsyncQueries();
bool FieldToEscapedString(const String& key, const Value& value, Value *result);
void InternalActivateObject(const DbObject::Ptr& dbobj);
void InternalDeactivateObject(const DbObject::Ptr& dbobj);
- void Disconnect(void);
- void Reconnect(void);
+ void Disconnect();
+ void Reconnect();
- void AssertOnWorkQueue(void);
+ void AssertOnWorkQueue();
- void TxTimerHandler(void);
- void ReconnectTimerHandler(void);
+ void TxTimerHandler();
+ void ReconnectTimerHandler();
bool CanExecuteQuery(const DbQuery& query);
void FinishExecuteQuery(const DbQuery& query, int type, bool upsert);
void InternalCleanUpExecuteQuery(const String& table, const String& time_key, double time_value);
- void InternalNewTransaction(void);
+ void InternalNewTransaction();
void ClearTableBySession(const String& table);
- void ClearTablesBySession(void);
+ void ClearTablesBySession();
void ExceptionHandler(boost::exception_ptr exp);
REGISTER_STATSFUNCTION(IdoPgsqlConnection, &IdoPgsqlConnection::StatsFunc);
-IdoPgsqlConnection::IdoPgsqlConnection(void)
+IdoPgsqlConnection::IdoPgsqlConnection()
: m_QueryQueue(1000000)
{
m_QueryQueue.SetName("IdoPgsqlConnection, " + GetName());
}
-void IdoPgsqlConnection::OnConfigLoaded(void)
+void IdoPgsqlConnection::OnConfigLoaded()
{
ObjectImpl<IdoPgsqlConnection>::OnConfigLoaded();
status->Set("idopgsqlconnection", nodes);
}
-void IdoPgsqlConnection::Resume(void)
+void IdoPgsqlConnection::Resume()
{
DbConnection::Resume();
ASSERT(m_Pgsql->isthreadsafe());
}
-void IdoPgsqlConnection::Pause(void)
+void IdoPgsqlConnection::Pause()
{
Log(LogInformation, "IdoPgsqlConnection")
<< "'" << GetName() << "' paused.";
}
}
-void IdoPgsqlConnection::AssertOnWorkQueue(void)
+void IdoPgsqlConnection::AssertOnWorkQueue()
{
ASSERT(m_QueryQueue.IsWorkerThread());
}
-void IdoPgsqlConnection::Disconnect(void)
+void IdoPgsqlConnection::Disconnect()
{
AssertOnWorkQueue();
SetConnected(false);
}
-void IdoPgsqlConnection::TxTimerHandler(void)
+void IdoPgsqlConnection::TxTimerHandler()
{
NewTransaction();
}
-void IdoPgsqlConnection::NewTransaction(void)
+void IdoPgsqlConnection::NewTransaction()
{
m_QueryQueue.Enqueue(std::bind(&IdoPgsqlConnection::InternalNewTransaction, this), PriorityHigh, true);
}
-void IdoPgsqlConnection::InternalNewTransaction(void)
+void IdoPgsqlConnection::InternalNewTransaction()
{
AssertOnWorkQueue();
Query("BEGIN");
}
-void IdoPgsqlConnection::ReconnectTimerHandler(void)
+void IdoPgsqlConnection::ReconnectTimerHandler()
{
m_QueryQueue.Enqueue(std::bind(&IdoPgsqlConnection::Reconnect, this), PriorityLow);
}
-void IdoPgsqlConnection::Reconnect(void)
+void IdoPgsqlConnection::Reconnect()
{
AssertOnWorkQueue();
Query("BEGIN");
}
-void IdoPgsqlConnection::ClearTablesBySession(void)
+void IdoPgsqlConnection::ClearTablesBySession()
{
/* delete all comments and downtimes without current session token */
ClearTableBySession("comments");
return DbReference(Convert::ToLong(row->Get("id")));
}
-int IdoPgsqlConnection::GetAffectedRows(void)
+int IdoPgsqlConnection::GetAffectedRows()
{
AssertOnWorkQueue();
}
}
-int IdoPgsqlConnection::GetPendingQueryCount(void) const
+int IdoPgsqlConnection::GetPendingQueryCount() const
{
return m_QueryQueue.GetLength();
}
DECLARE_OBJECT(IdoPgsqlConnection);
DECLARE_OBJECTNAME(IdoPgsqlConnection);
- IdoPgsqlConnection(void);
+ IdoPgsqlConnection();
static void StatsFunc(const Dictionary::Ptr& status, const Array::Ptr& perfdata);
- virtual int GetPendingQueryCount(void) const override;
+ virtual int GetPendingQueryCount() const override;
protected:
- virtual void OnConfigLoaded(void) override;
- virtual void Resume(void) override;
- virtual void Pause(void) override;
+ virtual void OnConfigLoaded() override;
+ virtual void Resume() override;
+ virtual void Pause() override;
virtual void ActivateObject(const DbObject::Ptr& dbobj) override;
virtual void DeactivateObject(const DbObject::Ptr& dbobj) override;
virtual void ExecuteMultipleQueries(const std::vector<DbQuery>& queries) override;
virtual void CleanUpExecuteQuery(const String& table, const String& time_key, double time_value) override;
virtual void FillIDCache(const DbType::Ptr& type) override;
- virtual void NewTransaction(void) override;
+ virtual void NewTransaction() override;
private:
DbReference m_InstanceID;
IdoPgsqlResult Query(const String& query);
DbReference GetSequenceValue(const String& table, const String& column);
- int GetAffectedRows(void);
+ int GetAffectedRows();
String Escape(const String& s);
Dictionary::Ptr FetchRow(const IdoPgsqlResult& result, int row);
void InternalActivateObject(const DbObject::Ptr& dbobj);
void InternalDeactivateObject(const DbObject::Ptr& dbobj);
- void Disconnect(void);
- void InternalNewTransaction(void);
- void Reconnect(void);
+ void Disconnect();
+ void InternalNewTransaction();
+ void Reconnect();
- void AssertOnWorkQueue(void);
+ void AssertOnWorkQueue();
- void TxTimerHandler(void);
- void ReconnectTimerHandler(void);
+ void TxTimerHandler();
+ void ReconnectTimerHandler();
- void StatsLoggerTimerHandler(void);
+ void StatsLoggerTimerHandler();
bool CanExecuteQuery(const DbQuery& query);
void InternalCleanUpExecuteQuery(const String& table, const String& time_key, double time_value);
void ClearTableBySession(const String& table);
- void ClearTablesBySession(void);
+ void ClearTablesBySession();
void ExceptionHandler(boost::exception_ptr exp);
/**
* Periodically broadcasts an API message.
*/
-void Demo::DemoTimerHandler(void)
+void Demo::DemoTimerHandler()
{
Dictionary::Ptr message = new Dictionary();
message->Set("method", "demo::HelloWorld");
private:
Timer::Ptr m_DemoTimer;
- void DemoTimerHandler(void);
+ void DemoTimerHandler();
};
}
*
* @returns An exit status.
*/
-int HelloApplication::Main(void)
+int HelloApplication::Main()
{
Log(LogInformation, "HelloApplication", "Hello World!");
DECLARE_OBJECT(HelloApplication);
DECLARE_OBJECTNAME(HelloApplication);
- virtual int Main(void) override;
+ virtual int Main() override;
};
}
INITIALIZE_ONCE(&ApiEvents::StaticInitialize);
-void ApiEvents::StaticInitialize(void)
+void ApiEvents::StaticInitialize()
{
Checkable::OnNewCheckResult.connect(&ApiEvents::CheckResultHandler);
Checkable::OnStateChange.connect(&ApiEvents::StateChangeHandler);
class ApiEvents
{
public:
- static void StaticInitialize(void);
+ static void StaticInitialize();
static void CheckResultHandler(const Checkable::Ptr& checkable, const CheckResult::Ptr& cr, const MessageOrigin::Ptr& origin);
static void StateChangeHandler(const Checkable::Ptr& checkable, const CheckResult::Ptr& cr, StateType type, const MessageOrigin::Ptr& origin);
boost::mutex Checkable::m_StatsMutex;
int Checkable::m_PendingChecks = 0;
-CheckCommand::Ptr Checkable::GetCheckCommand(void) const
+CheckCommand::Ptr Checkable::GetCheckCommand() const
{
return dynamic_pointer_cast<CheckCommand>(NavigateCheckCommandRaw());
}
-TimePeriod::Ptr Checkable::GetCheckPeriod(void) const
+TimePeriod::Ptr Checkable::GetCheckPeriod() const
{
return TimePeriod::GetByName(GetCheckPeriodRaw());
}
m_SchedulingOffset = offset;
}
-long Checkable::GetSchedulingOffset(void)
+long Checkable::GetSchedulingOffset()
{
return m_SchedulingOffset;
}
SetNextCheck(now - adj + interval, false, origin);
}
-bool Checkable::HasBeenChecked(void) const
+bool Checkable::HasBeenChecked() const
{
return GetLastCheckResult() != nullptr;
}
-double Checkable::GetLastCheck(void) const
+double Checkable::GetLastCheck() const
{
CheckResult::Ptr cr = GetLastCheckResult();
double schedule_end = -1;
GetCheckCommand()->Execute(this, cr, resolvedMacros, true);
}
-void Checkable::ExecuteCheck(void)
+void Checkable::ExecuteCheck()
{
CONTEXT("Executing check for object '" + GetName() + "'");
}
}
-void Checkable::IncreasePendingChecks(void)
+void Checkable::IncreasePendingChecks()
{
boost::mutex::scoped_lock lock(m_StatsMutex);
m_PendingChecks++;
}
-void Checkable::DecreasePendingChecks(void)
+void Checkable::DecreasePendingChecks()
{
boost::mutex::scoped_lock lock(m_StatsMutex);
m_PendingChecks--;
}
-int Checkable::GetPendingChecks(void)
+int Checkable::GetPendingChecks()
{
boost::mutex::scoped_lock lock(m_StatsMutex);
return m_PendingChecks;
using namespace icinga;
-void Checkable::RemoveAllComments(void)
+void Checkable::RemoveAllComments()
{
for (const Comment::Ptr& comment : GetComments()) {
Comment::RemoveComment(comment->GetName());
}
}
-std::set<Comment::Ptr> Checkable::GetComments(void) const
+std::set<Comment::Ptr> Checkable::GetComments() const
{
boost::mutex::scoped_lock lock(m_CommentMutex);
return m_Comments;
m_Dependencies.erase(dep);
}
-std::vector<Dependency::Ptr> Checkable::GetDependencies(void) const
+std::vector<Dependency::Ptr> Checkable::GetDependencies() const
{
boost::mutex::scoped_lock lock(m_DependencyMutex);
return std::vector<Dependency::Ptr>(m_Dependencies.begin(), m_Dependencies.end());
m_ReverseDependencies.erase(dep);
}
-std::vector<Dependency::Ptr> Checkable::GetReverseDependencies(void) const
+std::vector<Dependency::Ptr> Checkable::GetReverseDependencies() const
{
boost::mutex::scoped_lock lock(m_DependencyMutex);
return std::vector<Dependency::Ptr>(m_ReverseDependencies.begin(), m_ReverseDependencies.end());
return true;
}
-std::set<Checkable::Ptr> Checkable::GetParents(void) const
+std::set<Checkable::Ptr> Checkable::GetParents() const
{
std::set<Checkable::Ptr> parents;
return parents;
}
-std::set<Checkable::Ptr> Checkable::GetChildren(void) const
+std::set<Checkable::Ptr> Checkable::GetChildren() const
{
std::set<Checkable::Ptr> parents;
return parents;
}
-std::set<Checkable::Ptr> Checkable::GetAllChildren(void) const
+std::set<Checkable::Ptr> Checkable::GetAllChildren() const
{
std::set<Checkable::Ptr> children = GetChildren();
using namespace icinga;
-void Checkable::RemoveAllDowntimes(void)
+void Checkable::RemoveAllDowntimes()
{
for (const Downtime::Ptr& downtime : GetDowntimes()) {
Downtime::RemoveDowntime(downtime->GetName(), true, true);
}
}
-void Checkable::TriggerDowntimes(void)
+void Checkable::TriggerDowntimes()
{
for (const Downtime::Ptr& downtime : GetDowntimes()) {
downtime->TriggerDowntime();
}
}
-bool Checkable::IsInDowntime(void) const
+bool Checkable::IsInDowntime() const
{
for (const Downtime::Ptr& downtime : GetDowntimes()) {
if (downtime->IsInEffect())
return false;
}
-int Checkable::GetDowntimeDepth(void) const
+int Checkable::GetDowntimeDepth() const
{
int downtime_depth = 0;
return downtime_depth;
}
-std::set<Downtime::Ptr> Checkable::GetDowntimes(void) const
+std::set<Downtime::Ptr> Checkable::GetDowntimes() const
{
boost::mutex::scoped_lock lock(m_DowntimeMutex);
return m_Downtimes;
boost::signals2::signal<void (const Checkable::Ptr&)> Checkable::OnEventCommandExecuted;
-EventCommand::Ptr Checkable::GetEventCommand(void) const
+EventCommand::Ptr Checkable::GetEventCommand() const
{
return EventCommand::GetByName(GetEventCommandRaw());
}
#endif /* _WIN32 */
}
-bool Checkable::IsFlapping(void) const
+bool Checkable::IsFlapping() const
{
if (!GetEnableFlapping() || !IcingaApplication::GetInstance()->GetEnableFlapping())
return false;
const NotificationType&, const CheckResult::Ptr&, const String&, const String&, const String&,
const MessageOrigin::Ptr&)> Checkable::OnNotificationSentToUser;
-void Checkable::ResetNotificationNumbers(void)
+void Checkable::ResetNotificationNumbers()
{
for (const Notification::Ptr& notification : GetNotifications()) {
ObjectLock olock(notification);
}
}
-std::set<Notification::Ptr> Checkable::GetNotifications(void) const
+std::set<Notification::Ptr> Checkable::GetNotifications() const
{
boost::mutex::scoped_lock lock(m_NotificationMutex);
return m_Notifications;
self->ProcessCheckResult(cr);
}
-Object::Ptr Checkable::GetPrototype(void)
+Object::Ptr Checkable::GetPrototype()
{
static Dictionary::Ptr prototype;
boost::signals2::signal<void (const Checkable::Ptr&, const String&, const String&, AcknowledgementType, bool, bool, double, const MessageOrigin::Ptr&)> Checkable::OnAcknowledgementSet;
boost::signals2::signal<void (const Checkable::Ptr&, const MessageOrigin::Ptr&)> Checkable::OnAcknowledgementCleared;
-void Checkable::StaticInitialize(void)
+void Checkable::StaticInitialize()
{
/* fixed downtime start */
Downtime::OnDowntimeStarted.connect(std::bind(&Checkable::NotifyFixedDowntimeStart, _1));
Downtime::OnDowntimeRemoved.connect(std::bind(&Checkable::NotifyDowntimeEnd, _1));
}
-Checkable::Checkable(void)
+Checkable::Checkable()
: m_CheckRunning(false)
{
SetSchedulingOffset(Utility::Random());
}
-void Checkable::OnAllConfigLoaded(void)
+void Checkable::OnAllConfigLoaded()
{
ObjectImpl<Checkable>::OnAllConfigLoaded();
groups->Add(name);
}
-AcknowledgementType Checkable::GetAcknowledgement(void)
+AcknowledgementType Checkable::GetAcknowledgement()
{
AcknowledgementType avalue = static_cast<AcknowledgementType>(GetAcknowledgementRaw());
return avalue;
}
-bool Checkable::IsAcknowledged(void) const
+bool Checkable::IsAcknowledged() const
{
return const_cast<Checkable *>(this)->GetAcknowledgement() != AcknowledgementNone;
}
OnAcknowledgementCleared(this, origin);
}
-Endpoint::Ptr Checkable::GetCommandEndpoint(void) const
+Endpoint::Ptr Checkable::GetCommandEndpoint() const
{
return Endpoint::GetByName(GetCommandEndpointRaw());
}
-int Checkable::GetSeverity(void) const
+int Checkable::GetSeverity() const
{
/* overridden in Host/Service class. */
return 0;
DECLARE_OBJECT(Checkable);
DECLARE_OBJECTNAME(Checkable);
- static void StaticInitialize(void);
+ static void StaticInitialize();
- Checkable(void);
+ Checkable();
- std::set<Checkable::Ptr> GetParents(void) const;
- std::set<Checkable::Ptr> GetChildren(void) const;
- std::set<Checkable::Ptr> GetAllChildren(void) const;
+ std::set<Checkable::Ptr> GetParents() const;
+ std::set<Checkable::Ptr> GetChildren() const;
+ std::set<Checkable::Ptr> GetAllChildren() const;
void AddGroup(const String& name);
bool IsReachable(DependencyType dt = DependencyState, intrusive_ptr<Dependency> *failedDependency = nullptr, int rstack = 0) const;
- AcknowledgementType GetAcknowledgement(void);
+ AcknowledgementType GetAcknowledgement();
void AcknowledgeProblem(const String& author, const String& comment, AcknowledgementType type, bool notify = true, bool persistent = false, double expiry = 0, const MessageOrigin::Ptr& origin = nullptr);
void ClearAcknowledgement(const MessageOrigin::Ptr& origin = nullptr);
- virtual int GetSeverity(void) const override;
+ virtual int GetSeverity() const override;
/* Checks */
- intrusive_ptr<CheckCommand> GetCheckCommand(void) const;
- TimePeriod::Ptr GetCheckPeriod(void) const;
+ intrusive_ptr<CheckCommand> GetCheckCommand() const;
+ TimePeriod::Ptr GetCheckPeriod() const;
- long GetSchedulingOffset(void);
+ long GetSchedulingOffset();
void SetSchedulingOffset(long offset);
void UpdateNextCheck(const MessageOrigin::Ptr& origin = nullptr);
- bool HasBeenChecked(void) const;
+ bool HasBeenChecked() const;
virtual bool IsStateOK(ServiceState state) = 0;
- virtual double GetLastCheck(void) const override final;
+ double GetLastCheck(void) const final;
virtual void SaveLastState(ServiceState state, double timestamp) = 0;
void ExecuteCheck();
void ProcessCheckResult(const CheckResult::Ptr& cr, const MessageOrigin::Ptr& origin = nullptr);
- Endpoint::Ptr GetCommandEndpoint(void) const;
+ Endpoint::Ptr GetCommandEndpoint() const;
static boost::signals2::signal<void (const Checkable::Ptr&, const CheckResult::Ptr&, const MessageOrigin::Ptr&)> OnNewCheckResult;
static boost::signals2::signal<void (const Checkable::Ptr&, const CheckResult::Ptr&, StateType, const MessageOrigin::Ptr&)> OnStateChange;
static boost::signals2::signal<void (const Checkable::Ptr&)> OnEventCommandExecuted;
/* Downtimes */
- virtual int GetDowntimeDepth(void) const override final;
+ int GetDowntimeDepth(void) const final;
- void RemoveAllDowntimes(void);
- void TriggerDowntimes(void);
- bool IsInDowntime(void) const;
- bool IsAcknowledged(void) const;
+ void RemoveAllDowntimes();
+ void TriggerDowntimes();
+ bool IsInDowntime() const;
+ bool IsAcknowledged() const;
- std::set<Downtime::Ptr> GetDowntimes(void) const;
+ std::set<Downtime::Ptr> GetDowntimes() const;
void RegisterDowntime(const Downtime::Ptr& downtime);
void UnregisterDowntime(const Downtime::Ptr& downtime);
/* Comments */
- void RemoveAllComments(void);
+ void RemoveAllComments();
void RemoveCommentsByType(int type);
- std::set<Comment::Ptr> GetComments(void) const;
+ std::set<Comment::Ptr> GetComments() const;
void RegisterComment(const Comment::Ptr& comment);
void UnregisterComment(const Comment::Ptr& comment);
/* Notifications */
void SendNotifications(NotificationType type, const CheckResult::Ptr& cr, const String& author = "", const String& text = "");
- std::set<Notification::Ptr> GetNotifications(void) const;
+ std::set<Notification::Ptr> GetNotifications() const;
void RegisterNotification(const Notification::Ptr& notification);
void UnregisterNotification(const Notification::Ptr& notification);
- void ResetNotificationNumbers(void);
+ void ResetNotificationNumbers();
/* Event Handler */
void ExecuteEventHandler(const Dictionary::Ptr& resolvedMacros = nullptr,
bool useResolvedMacros = false);
- intrusive_ptr<EventCommand> GetEventCommand(void) const;
+ intrusive_ptr<EventCommand> GetEventCommand() const;
/* Flapping Detection */
- bool IsFlapping(void) const;
+ bool IsFlapping() const;
/* Dependencies */
void AddDependency(const intrusive_ptr<Dependency>& dep);
void RemoveDependency(const intrusive_ptr<Dependency>& dep);
- std::vector<intrusive_ptr<Dependency> > GetDependencies(void) const;
+ std::vector<intrusive_ptr<Dependency> > GetDependencies() const;
void AddReverseDependency(const intrusive_ptr<Dependency>& dep);
void RemoveReverseDependency(const intrusive_ptr<Dependency>& dep);
- std::vector<intrusive_ptr<Dependency> > GetReverseDependencies(void) const;
+ std::vector<intrusive_ptr<Dependency> > GetReverseDependencies() const;
virtual void ValidateCheckInterval(double value, const ValidationUtils& utils) override final;
virtual void ValidateMaxCheckAttempts(int value, const ValidationUtils& utils) override final;
- static void IncreasePendingChecks(void);
- static void DecreasePendingChecks(void);
- static int GetPendingChecks(void);
+ static void IncreasePendingChecks();
+ static void DecreasePendingChecks();
+ static int GetPendingChecks();
- static Object::Ptr GetPrototype(void);
+ static Object::Ptr GetPrototype();
protected:
virtual void Start(bool runtimeCreated) override;
- virtual void OnAllConfigLoaded(void) override;
+ virtual void OnAllConfigLoaded() override;
private:
mutable boost::mutex m_CheckableMutex;
ScriptGlobal::Set("HostDown", HostDown);
})
-double CheckResult::CalculateExecutionTime(void) const
+double CheckResult::CalculateExecutionTime() const
{
return GetExecutionEnd() - GetExecutionStart();
}
-double CheckResult::CalculateLatency(void) const
+double CheckResult::CalculateLatency() const
{
double latency = (GetScheduleEnd() - GetScheduleStart()) - CalculateExecutionTime();
public:
DECLARE_OBJECT(CheckResult);
- double CalculateExecutionTime(void) const;
- double CalculateLatency(void) const;
+ double CalculateExecutionTime() const;
+ double CalculateLatency() const;
};
}
return m_PassiveServiceChecksStatistics.UpdateAndGetValues(Utility::GetTime(), timespan);
}
-CheckableCheckStatistics CIB::CalculateHostCheckStats(void)
+CheckableCheckStatistics CIB::CalculateHostCheckStats()
{
double min_latency = -1, max_latency = 0, sum_latency = 0;
int count_latency = 0;
return ccs;
}
-CheckableCheckStatistics CIB::CalculateServiceCheckStats(void)
+CheckableCheckStatistics CIB::CalculateServiceCheckStats()
{
double min_latency = -1, max_latency = 0, sum_latency = 0;
int count_latency = 0;
return ccs;
}
-ServiceStatistics CIB::CalculateServiceStats(void)
+ServiceStatistics CIB::CalculateServiceStats()
{
ServiceStatistics ss = {};
return ss;
}
-HostStatistics CIB::CalculateHostStats(void)
+HostStatistics CIB::CalculateHostStats()
{
HostStatistics hs = {};
* 'perfdata' must be a flat dictionary with double values
* 'status' dictionary can contain multiple levels of dictionaries
*/
-std::pair<Dictionary::Ptr, Array::Ptr> CIB::GetFeatureStats(void)
+std::pair<Dictionary::Ptr, Array::Ptr> CIB::GetFeatureStats()
{
Dictionary::Ptr status = new Dictionary();
Array::Ptr perfdata = new Array();
static void UpdatePassiveServiceChecksStatistics(long tv, int num);
static int GetPassiveServiceChecksStatistics(long timespan);
- static CheckableCheckStatistics CalculateHostCheckStats(void);
- static CheckableCheckStatistics CalculateServiceCheckStats(void);
- static HostStatistics CalculateHostStats(void);
- static ServiceStatistics CalculateServiceStats(void);
+ static CheckableCheckStatistics CalculateHostCheckStats();
+ static CheckableCheckStatistics CalculateServiceCheckStats();
+ static HostStatistics CalculateHostStats();
+ static ServiceStatistics CalculateServiceStats();
- static std::pair<Dictionary::Ptr, Array::Ptr> GetFeatureStats(void);
+ static std::pair<Dictionary::Ptr, Array::Ptr> GetFeatureStats();
static void StatsFunc(const Dictionary::Ptr& status, const Array::Ptr& perfdata);
private:
- CIB(void);
+ CIB();
static boost::mutex m_Mutex;
static RingBuffer m_ActiveHostChecksStatistics;
REGISTER_APIFUNCTION(NotificationSentUser, event, &ClusterEvents::NotificationSentUserAPIHandler);
REGISTER_APIFUNCTION(NotificationSentToAllUsers, event, &ClusterEvents::NotificationSentToAllUsersAPIHandler);
-void ClusterEvents::StaticInitialize(void)
+void ClusterEvents::StaticInitialize()
{
Checkable::OnNewCheckResult.connect(&ClusterEvents::CheckResultHandler);
Checkable::OnNextCheckChanged.connect(&ClusterEvents::NextCheckChangedHandler);
class ClusterEvents
{
public:
- static void StaticInitialize(void);
+ static void StaticInitialize();
static void CheckResultHandler(const Checkable::Ptr& checkable, const CheckResult::Ptr& cr, const MessageOrigin::Ptr& origin);
static Value CheckResultAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
return result;
}
-void Comment::OnAllConfigLoaded(void)
+void Comment::OnAllConfigLoaded()
{
ConfigObject::OnAllConfigLoaded();
ObjectImpl<Comment>::Stop(runtimeRemoved);
}
-Checkable::Ptr Comment::GetCheckable(void) const
+Checkable::Ptr Comment::GetCheckable() const
{
return static_pointer_cast<Checkable>(m_Checkable);
}
-bool Comment::IsExpired(void) const
+bool Comment::IsExpired() const
{
double expire_time = GetExpireTime();
return (expire_time != 0 && expire_time < Utility::GetTime());
}
-int Comment::GetNextCommentID(void)
+int Comment::GetNextCommentID()
{
boost::mutex::scoped_lock lock(l_CommentMutex);
return it->second;
}
-void Comment::CommentsExpireTimerHandler(void)
+void Comment::CommentsExpireTimerHandler()
{
std::vector<Comment::Ptr> comments;
static boost::signals2::signal<void (const Comment::Ptr&)> OnCommentAdded;
static boost::signals2::signal<void (const Comment::Ptr&)> OnCommentRemoved;
- intrusive_ptr<Checkable> GetCheckable(void) const;
+ intrusive_ptr<Checkable> GetCheckable() const;
- bool IsExpired(void) const;
+ bool IsExpired() const;
- static int GetNextCommentID(void);
+ static int GetNextCommentID();
static String AddComment(const intrusive_ptr<Checkable>& checkable, CommentType entryType,
const String& author, const String& text, bool persistent, double expireTime,
static String GetCommentIDFromLegacyID(int id);
protected:
- virtual void OnAllConfigLoaded(void) override;
+ virtual void OnAllConfigLoaded() override;
virtual void Start(bool runtimeCreated) override;
virtual void Stop(bool runtimeRemoved) override;
private:
ObjectImpl<Checkable>::Ptr m_Checkable;
- static void CommentsExpireTimerHandler(void);
+ static void CommentsExpireTimerHandler();
};
}
static String UnEscapeString(const String& str);
private:
- CompatUtility(void);
+ CompatUtility();
static String GetCommandNamePrefix(const Command::Ptr command);
};
return result;
}
-void Dependency::OnConfigLoaded(void)
+void Dependency::OnConfigLoaded()
{
Value defaultFilter;
SetStateFilter(FilterArrayToInt(GetStates(), Notification::GetStateFilterMap(), defaultFilter));
}
-void Dependency::OnAllConfigLoaded(void)
+void Dependency::OnAllConfigLoaded()
{
ObjectImpl<Dependency>::OnAllConfigLoaded();
return false;
}
-Checkable::Ptr Dependency::GetChild(void) const
+Checkable::Ptr Dependency::GetChild() const
{
return m_Child;
}
-Checkable::Ptr Dependency::GetParent(void) const
+Checkable::Ptr Dependency::GetParent() const
{
return m_Parent;
}
-TimePeriod::Ptr Dependency::GetPeriod(void) const
+TimePeriod::Ptr Dependency::GetPeriod() const
{
return TimePeriod::GetByName(GetPeriodRaw());
}
DECLARE_OBJECT(Dependency);
DECLARE_OBJECTNAME(Dependency);
- intrusive_ptr<Checkable> GetParent(void) const;
- intrusive_ptr<Checkable> GetChild(void) const;
+ intrusive_ptr<Checkable> GetParent() const;
+ intrusive_ptr<Checkable> GetChild() const;
- TimePeriod::Ptr GetPeriod(void) const;
+ TimePeriod::Ptr GetPeriod() const;
bool IsAvailable(DependencyType dt) const;
static void EvaluateApplyRules(const intrusive_ptr<Service>& service);
protected:
- virtual void OnConfigLoaded(void) override;
- virtual void OnAllConfigLoaded(void) override;
+ virtual void OnConfigLoaded() override;
+ virtual void OnAllConfigLoaded() override;
virtual void Stop(bool runtimeRemoved) override;
private:
return result;
}
-void Downtime::OnAllConfigLoaded(void)
+void Downtime::OnAllConfigLoaded()
{
ObjectImpl<Downtime>::OnAllConfigLoaded();
ObjectImpl<Downtime>::Stop(runtimeRemoved);
}
-Checkable::Ptr Downtime::GetCheckable(void) const
+Checkable::Ptr Downtime::GetCheckable() const
{
return static_pointer_cast<Checkable>(m_Checkable);
}
-bool Downtime::IsInEffect(void) const
+bool Downtime::IsInEffect() const
{
double now = Utility::GetTime();
return (now < triggerTime + GetDuration());
}
-bool Downtime::IsTriggered(void) const
+bool Downtime::IsTriggered() const
{
double now = Utility::GetTime();
return (triggerTime > 0 && triggerTime <= now);
}
-bool Downtime::IsExpired(void) const
+bool Downtime::IsExpired() const
{
double now = Utility::GetTime();
}
}
-bool Downtime::HasValidConfigOwner(void) const
+bool Downtime::HasValidConfigOwner() const
{
String configOwner = GetConfigOwner();
return configOwner.IsEmpty() || GetObject<ScheduledDowntime>(configOwner);
}
-int Downtime::GetNextDowntimeID(void)
+int Downtime::GetNextDowntimeID()
{
boost::mutex::scoped_lock lock(l_DowntimeMutex);
}
}
-bool Downtime::CanBeTriggered(void)
+bool Downtime::CanBeTriggered()
{
if (IsInEffect() && IsTriggered())
return false;
return true;
}
-void Downtime::TriggerDowntime(void)
+void Downtime::TriggerDowntime()
{
if (!CanBeTriggered())
return;
return it->second;
}
-void Downtime::DowntimesStartTimerHandler(void)
+void Downtime::DowntimesStartTimerHandler()
{
/* Start fixed downtimes. Flexible downtimes will be triggered on-demand. */
for (const Downtime::Ptr& downtime : ConfigType::GetObjectsByType<Downtime>()) {
}
}
-void Downtime::DowntimesExpireTimerHandler(void)
+void Downtime::DowntimesExpireTimerHandler()
{
std::vector<Downtime::Ptr> downtimes;
static boost::signals2::signal<void (const Downtime::Ptr&)> OnDowntimeStarted;
static boost::signals2::signal<void (const Downtime::Ptr&)> OnDowntimeTriggered;
- intrusive_ptr<Checkable> GetCheckable(void) const;
+ intrusive_ptr<Checkable> GetCheckable() const;
- bool IsInEffect(void) const;
- bool IsTriggered(void) const;
- bool IsExpired(void) const;
- bool HasValidConfigOwner(void) const;
+ bool IsInEffect() const;
+ bool IsTriggered() const;
+ bool IsExpired() const;
+ bool HasValidConfigOwner() const;
- static int GetNextDowntimeID(void);
+ static int GetNextDowntimeID();
static String AddDowntime(const intrusive_ptr<Checkable>& checkable, const String& author,
const String& comment, double startTime, double endTime, bool fixed,
static void RemoveDowntime(const String& id, bool cancelled, bool expired = false, const MessageOrigin::Ptr& origin = nullptr);
- void TriggerDowntime(void);
+ void TriggerDowntime();
static String GetDowntimeIDFromLegacyID(int id);
protected:
- virtual void OnAllConfigLoaded(void) override;
+ virtual void OnAllConfigLoaded() override;
virtual void Start(bool runtimeCreated) override;
virtual void Stop(bool runtimeRemoved) override;
private:
ObjectImpl<Checkable>::Ptr m_Checkable;
- bool CanBeTriggered(void);
+ bool CanBeTriggered();
- static void DowntimesStartTimerHandler(void);
- static void DowntimesExpireTimerHandler(void);
+ static void DowntimesStartTimerHandler();
+ static void DowntimesExpireTimerHandler();
};
}
GetCommands()[command] = eci;
}
-void ExternalCommandProcessor::RegisterCommands(void)
+void ExternalCommandProcessor::RegisterCommands()
{
RegisterCommand("PROCESS_HOST_CHECK_RESULT", &ExternalCommandProcessor::ProcessHostCheckResult, 3);
RegisterCommand("PROCESS_SERVICE_CHECK_RESULT", &ExternalCommandProcessor::ProcessServiceCheckResult, 4);
}
}
-boost::mutex& ExternalCommandProcessor::GetMutex(void)
+boost::mutex& ExternalCommandProcessor::GetMutex()
{
static boost::mutex mtx;
return mtx;
}
-std::map<String, ExternalCommandInfo>& ExternalCommandProcessor::GetCommands(void)
+std::map<String, ExternalCommandInfo>& ExternalCommandProcessor::GetCommands()
{
static std::map<String, ExternalCommandInfo> commands;
return commands;
static boost::signals2::signal<void(double, const String&, const std::vector<String>&)> OnNewExternalCommand;
private:
- ExternalCommandProcessor(void);
+ ExternalCommandProcessor();
static void ExecuteFromFile(const String& line, std::deque< std::vector<String> >& file_queue);
static void ChangeCustomCommandVarInternal(const Command::Ptr& command, const String& name, const Value& value);
static void RegisterCommand(const String& command, const ExternalCommandCallback& callback, size_t minArgs = 0, size_t maxArgs = UINT_MAX);
- static void RegisterCommands(void);
+ static void RegisterCommands();
- static boost::mutex& GetMutex(void);
- static std::map<String, ExternalCommandInfo>& GetCommands(void);
+ static boost::mutex& GetMutex();
+ static std::map<String, ExternalCommandInfo>& GetCommands();
};
REGISTER_TYPE(Host);
-void Host::OnAllConfigLoaded(void)
+void Host::OnAllConfigLoaded()
{
ObjectImpl<Host>::OnAllConfigLoaded();
// TODO: unregister slave services/notifications?
}
-std::vector<Service::Ptr> Host::GetServices(void) const
+std::vector<Service::Ptr> Host::GetServices() const
{
boost::mutex::scoped_lock lock(m_ServicesMutex);
m_Services.erase(service->GetShortName());
}
-int Host::GetTotalServices(void) const
+int Host::GetTotalServices() const
{
return GetServices().size();
}
}
}
-HostState Host::GetState(void) const
+HostState Host::GetState() const
{
return CalculateState(GetStateRaw());
}
-HostState Host::GetLastState(void) const
+HostState Host::GetLastState() const
{
return CalculateState(GetLastStateRaw());
}
-HostState Host::GetLastHardState(void) const
+HostState Host::GetLastHardState() const
{
return CalculateState(GetLastHardStateRaw());
}
/* keep in sync with Service::GetSeverity() */
-int Host::GetSeverity(void) const
+int Host::GetSeverity() const
{
int severity = 0;
intrusive_ptr<Service> GetServiceByShortName(const Value& name);
- std::vector<intrusive_ptr<Service> > GetServices(void) const;
+ std::vector<intrusive_ptr<Service> > GetServices() const;
void AddService(const intrusive_ptr<Service>& service);
void RemoveService(const intrusive_ptr<Service>& service);
- int GetTotalServices(void) const;
+ int GetTotalServices() const;
static HostState CalculateState(ServiceState state);
- virtual HostState GetState(void) const override;
- virtual HostState GetLastState(void) const override;
- virtual HostState GetLastHardState(void) const override;
- virtual int GetSeverity(void) const override;
+ virtual HostState GetState() const override;
+ virtual HostState GetLastState() const override;
+ virtual HostState GetLastHardState() const override;
+ virtual int GetSeverity() const override;
virtual bool IsStateOK(ServiceState state) override;
virtual void SaveLastState(ServiceState state, double timestamp) override;
protected:
virtual void Stop(bool runtimeRemoved) override;
- virtual void OnAllConfigLoaded(void) override;
+ virtual void OnAllConfigLoaded() override;
virtual void CreateChildObjects(const Type::Ptr& childType) override;
private:
mutable boost::mutex m_ServicesMutex;
std::map<String, intrusive_ptr<Service> > m_Services;
- static void RefreshServicesCache(void);
+ static void RefreshServicesCache();
};
}
}
}
-std::set<Host::Ptr> HostGroup::GetMembers(void) const
+std::set<Host::Ptr> HostGroup::GetMembers() const
{
boost::mutex::scoped_lock lock(m_HostGroupMutex);
return m_Members;
DECLARE_OBJECT(HostGroup);
DECLARE_OBJECTNAME(HostGroup);
- std::set<Host::Ptr> GetMembers(void) const;
+ std::set<Host::Ptr> GetMembers() const;
void AddMember(const Host::Ptr& host);
void RemoveMember(const Host::Ptr& host);
REGISTER_TYPE(IcingaApplication);
INITIALIZE_ONCE(&IcingaApplication::StaticInitialize);
-void IcingaApplication::StaticInitialize(void)
+void IcingaApplication::StaticInitialize()
{
String node_name = Utility::GetFQDN();
*
* @returns An exit status.
*/
-int IcingaApplication::Main(void)
+int IcingaApplication::Main()
{
Log(LogDebug, "IcingaApplication", "In IcingaApplication::Main()");
return EXIT_SUCCESS;
}
-void IcingaApplication::OnShutdown(void)
+void IcingaApplication::OnShutdown()
{
{
ObjectLock olock(this);
previousObject = object;
}
-void IcingaApplication::DumpProgramState(void)
+void IcingaApplication::DumpProgramState()
{
ConfigObject::DumpObjects(GetStatePath());
DumpModifiedAttributes();
}
-void IcingaApplication::DumpModifiedAttributes(void)
+void IcingaApplication::DumpModifiedAttributes()
{
String path = GetModAttrPath();
}
}
-IcingaApplication::Ptr IcingaApplication::GetInstance(void)
+IcingaApplication::Ptr IcingaApplication::GetInstance()
{
return static_pointer_cast<IcingaApplication>(Application::GetInstance());
}
return false;
}
-String IcingaApplication::GetNodeName(void) const
+String IcingaApplication::GetNodeName() const
{
return ScriptGlobal::Get("NodeName");
}
DECLARE_OBJECT(IcingaApplication);
DECLARE_OBJECTNAME(IcingaApplication);
- static void StaticInitialize(void);
+ static void StaticInitialize();
- virtual int Main(void) override;
+ virtual int Main() override;
static void StatsFunc(const Dictionary::Ptr& status, const Array::Ptr& perfdata);
- static IcingaApplication::Ptr GetInstance(void);
+ static IcingaApplication::Ptr GetInstance();
- String GetPidPath(void) const;
+ String GetPidPath() const;
virtual bool ResolveMacro(const String& macro, const CheckResult::Ptr& cr, Value *result) const override;
- String GetNodeName(void) const;
+ String GetNodeName() const;
virtual void ValidateVars(const Dictionary::Ptr& value, const ValidationUtils& utils) override;
private:
- void DumpProgramState(void);
- void DumpModifiedAttributes(void);
+ void DumpProgramState();
+ void DumpModifiedAttributes();
- virtual void OnShutdown(void) override;
+ virtual void OnShutdown() override;
};
}
static Dictionary::Ptr FindNextSegment(const String& daydef, const String& timeranges, tm *reference);
private:
- LegacyTimePeriod(void);
+ LegacyTimePeriod();
};
}
String Key;
Value AValue;
- CommandArgument(void)
+ CommandArgument()
: Order(0), SkipKey(false), RepeatKey(true), SkipValue(false)
{ }
static void ValidateCustomVars(const ConfigObject::Ptr& object, const Dictionary::Ptr& value);
private:
- MacroProcessor(void);
+ MacroProcessor();
static bool ResolveMacro(const String& macro, const ResolverList& resolvers,
const CheckResult::Ptr& cr, Value *result, bool *recursive_macro);
return result;
}
-void Notification::StaticInitialize(void)
+void Notification::StaticInitialize()
{
ScriptGlobal::Set("OK", "OK");
ScriptGlobal::Set("Warning", "Warning");
m_TypeFilterMap["FlappingEnd"] = NotificationFlappingEnd;
}
-void Notification::OnConfigLoaded(void)
+void Notification::OnConfigLoaded()
{
ObjectImpl<Notification>::OnConfigLoaded();
SetStateFilter(FilterArrayToInt(GetStates(), GetStateFilterMap(), ~0));
}
-void Notification::OnAllConfigLoaded(void)
+void Notification::OnAllConfigLoaded()
{
ObjectImpl<Notification>::OnAllConfigLoaded();
obj->UnregisterNotification(this);
}
-Checkable::Ptr Notification::GetCheckable(void) const
+Checkable::Ptr Notification::GetCheckable() const
{
return static_pointer_cast<Checkable>(m_Checkable);
}
-NotificationCommand::Ptr Notification::GetCommand(void) const
+NotificationCommand::Ptr Notification::GetCommand() const
{
return NotificationCommand::GetByName(GetCommandRaw());
}
-std::set<User::Ptr> Notification::GetUsers(void) const
+std::set<User::Ptr> Notification::GetUsers() const
{
std::set<User::Ptr> result;
return result;
}
-std::set<UserGroup::Ptr> Notification::GetUserGroups(void) const
+std::set<UserGroup::Ptr> Notification::GetUserGroups() const
{
std::set<UserGroup::Ptr> result;
return result;
}
-TimePeriod::Ptr Notification::GetPeriod(void) const
+TimePeriod::Ptr Notification::GetPeriod() const
{
return TimePeriod::GetByName(GetPeriodRaw());
}
-void Notification::UpdateNotificationNumber(void)
+void Notification::UpdateNotificationNumber()
{
SetNotificationNumber(GetNotificationNumber() + 1);
}
-void Notification::ResetNotificationNumber(void)
+void Notification::ResetNotificationNumber()
{
SetNotificationNumber(0);
}
BOOST_THROW_EXCEPTION(ValidationError(this, { "types" }, "Type filter is invalid."));
}
-Endpoint::Ptr Notification::GetCommandEndpoint(void) const
+Endpoint::Ptr Notification::GetCommandEndpoint() const
{
return Endpoint::GetByName(GetCommandEndpointRaw());
}
-const std::map<String, int>& Notification::GetStateFilterMap(void)
+const std::map<String, int>& Notification::GetStateFilterMap()
{
return m_StateFilterMap;
}
-const std::map<String, int>& Notification::GetTypeFilterMap(void)
+const std::map<String, int>& Notification::GetTypeFilterMap()
{
return m_TypeFilterMap;
}
DECLARE_OBJECT(Notification);
DECLARE_OBJECTNAME(Notification);
- static void StaticInitialize(void);
+ static void StaticInitialize();
- intrusive_ptr<Checkable> GetCheckable(void) const;
- intrusive_ptr<NotificationCommand> GetCommand(void) const;
- TimePeriod::Ptr GetPeriod(void) const;
- std::set<User::Ptr> GetUsers(void) const;
- std::set<UserGroup::Ptr> GetUserGroups(void) const;
+ intrusive_ptr<Checkable> GetCheckable() const;
+ intrusive_ptr<NotificationCommand> GetCommand() const;
+ TimePeriod::Ptr GetPeriod() const;
+ std::set<User::Ptr> GetUsers() const;
+ std::set<UserGroup::Ptr> GetUserGroups() const;
- void UpdateNotificationNumber(void);
- void ResetNotificationNumber(void);
+ void UpdateNotificationNumber();
+ void ResetNotificationNumber();
void BeginExecuteNotification(NotificationType type, const CheckResult::Ptr& cr, bool force,
bool reminder = false, const String& author = "", const String& text = "");
- Endpoint::Ptr GetCommandEndpoint(void) const;
+ Endpoint::Ptr GetCommandEndpoint() const;
static String NotificationTypeToString(NotificationType type);
static String NotificationFilterToString(int filter, const std::map<String, int>& filterMap);
static void EvaluateApplyRules(const intrusive_ptr<Host>& host);
static void EvaluateApplyRules(const intrusive_ptr<Service>& service);
- static const std::map<String, int>& GetStateFilterMap(void);
- static const std::map<String, int>& GetTypeFilterMap(void);
+ static const std::map<String, int>& GetStateFilterMap();
+ static const std::map<String, int>& GetTypeFilterMap();
protected:
- virtual void OnConfigLoaded(void) override;
- virtual void OnAllConfigLoaded(void) override;
+ virtual void OnConfigLoaded() override;
+ virtual void OnAllConfigLoaded() override;
virtual void Start(bool runtimeCreated) override;
virtual void Stop(bool runtimeRemoved) override;
static Array::Ptr GetServices(const Value& host);
private:
- ObjectUtils(void);
+ ObjectUtils();
};
}
static String FormatPerfdata(const Array::Ptr& perfdata);
private:
- PluginUtility(void);
+ PluginUtility();
};
}
return result;
}
-void ScheduledDowntime::OnAllConfigLoaded(void)
+void ScheduledDowntime::OnAllConfigLoaded()
{
ObjectImpl<ScheduledDowntime>::OnAllConfigLoaded();
Utility::QueueAsyncCallback(std::bind(&ScheduledDowntime::CreateNextDowntime, this));
}
-void ScheduledDowntime::TimerProc(void)
+void ScheduledDowntime::TimerProc()
{
for (const ScheduledDowntime::Ptr& sd : ConfigType::GetObjectsByType<ScheduledDowntime>()) {
if (sd->IsActive())
}
}
-Checkable::Ptr ScheduledDowntime::GetCheckable(void) const
+Checkable::Ptr ScheduledDowntime::GetCheckable() const
{
Host::Ptr host = Host::GetByName(GetHostName());
return host->GetServiceByShortName(GetServiceName());
}
-std::pair<double, double> ScheduledDowntime::FindNextSegment(void)
+std::pair<double, double> ScheduledDowntime::FindNextSegment()
{
time_t refts = Utility::GetTime();
tm reference = Utility::LocalTime(refts);
return std::make_pair(0, 0);
}
-void ScheduledDowntime::CreateNextDowntime(void)
+void ScheduledDowntime::CreateNextDowntime()
{
for (const Downtime::Ptr& downtime : GetCheckable()->GetDowntimes()) {
if (downtime->GetScheduledBy() != GetName() ||
DECLARE_OBJECT(ScheduledDowntime);
DECLARE_OBJECTNAME(ScheduledDowntime);
- Checkable::Ptr GetCheckable(void) const;
+ Checkable::Ptr GetCheckable() const;
static void EvaluateApplyRules(const intrusive_ptr<Host>& host);
static void EvaluateApplyRules(const intrusive_ptr<Service>& service);
virtual void ValidateRanges(const Dictionary::Ptr& value, const ValidationUtils& utils) override;
protected:
- virtual void OnAllConfigLoaded(void) override;
+ virtual void OnAllConfigLoaded() override;
virtual void Start(bool runtimeCreated) override;
private:
- static void TimerProc(void);
+ static void TimerProc();
- std::pair<double, double> FindNextSegment(void);
- void CreateNextDowntime(void);
+ std::pair<double, double> FindNextSegment();
+ void CreateNextDowntime();
static bool EvaluateApplyRuleInstance(const Checkable::Ptr& checkable, const String& name, ScriptFrame& frame, const ApplyRule& rule);
static bool EvaluateApplyRule(const Checkable::Ptr& checkable, const ApplyRule& rule);
return result;
}
-void Service::OnAllConfigLoaded(void)
+void Service::OnAllConfigLoaded()
{
ObjectImpl<Service>::OnAllConfigLoaded();
}
}
-Host::Ptr Service::GetHost(void) const
+Host::Ptr Service::GetHost() const
{
return m_Host;
}
/* keep in sync with Host::GetSeverity() */
-int Service::GetSeverity(void) const
+int Service::GetSeverity() const
{
int severity = 0;
static Service::Ptr GetByNamePair(const String& hostName, const String& serviceName);
- virtual Host::Ptr GetHost(void) const override;
- virtual int GetSeverity(void) const override;
+ virtual Host::Ptr GetHost() const override;
+ virtual int GetSeverity() const override;
virtual bool ResolveMacro(const String& macro, const CheckResult::Ptr& cr, Value *result) const override;
static void EvaluateApplyRules(const Host::Ptr& host);
protected:
- virtual void OnAllConfigLoaded(void) override;
+ virtual void OnAllConfigLoaded() override;
virtual void CreateChildObjects(const Type::Ptr& childType) override;
private:
}
}
-std::set<Service::Ptr> ServiceGroup::GetMembers(void) const
+std::set<Service::Ptr> ServiceGroup::GetMembers() const
{
boost::mutex::scoped_lock lock(m_ServiceGroupMutex);
return m_Members;
DECLARE_OBJECT(ServiceGroup);
DECLARE_OBJECTNAME(ServiceGroup);
- std::set<Service::Ptr> GetMembers(void) const;
+ std::set<Service::Ptr> GetMembers() const;
void AddMember(const Service::Ptr& service);
void RemoveMember(const Service::Ptr& service);
}
}
-bool TimePeriod::GetIsInside(void) const
+bool TimePeriod::GetIsInside() const
{
return IsInside(Utility::GetTime());
}
return closestTransition;
}
-void TimePeriod::UpdateTimerHandler(void)
+void TimePeriod::UpdateTimerHandler()
{
double now = Utility::GetTime();
}
}
-void TimePeriod::Dump(void)
+void TimePeriod::Dump()
{
Array::Ptr segments = GetSegments();
void UpdateRegion(double begin, double end, bool clearExisting);
- virtual bool GetIsInside(void) const override;
+ virtual bool GetIsInside() const override;
bool IsInside(double ts) const;
double FindNextTransition(double begin);
void Merge(const TimePeriod::Ptr& timeperiod, bool include = true);
- void Dump(void);
+ void Dump();
- static void UpdateTimerHandler(void);
+ static void UpdateTimerHandler();
};
}
REGISTER_TYPE(User);
-void User::OnConfigLoaded(void)
+void User::OnConfigLoaded()
{
ObjectImpl<User>::OnConfigLoaded();
SetStateFilter(FilterArrayToInt(GetStates(), Notification::GetStateFilterMap(), ~0));
}
-void User::OnAllConfigLoaded(void)
+void User::OnAllConfigLoaded()
{
ObjectImpl<User>::OnAllConfigLoaded();
groups->Add(name);
}
-TimePeriod::Ptr User::GetPeriod(void) const
+TimePeriod::Ptr User::GetPeriod() const
{
return TimePeriod::GetByName(GetPeriodRaw());
}
void AddGroup(const String& name);
/* Notifications */
- TimePeriod::Ptr GetPeriod(void) const;
+ TimePeriod::Ptr GetPeriod() const;
virtual void ValidateStates(const Array::Ptr& value, const ValidationUtils& utils) override;
virtual void ValidateTypes(const Array::Ptr& value, const ValidationUtils& utils) override;
protected:
virtual void Stop(bool runtimeRemoved) override;
- virtual void OnConfigLoaded(void) override;
- virtual void OnAllConfigLoaded(void) override;
+ virtual void OnConfigLoaded() override;
+ virtual void OnAllConfigLoaded() override;
private:
mutable boost::mutex m_UserMutex;
};
}
}
-std::set<User::Ptr> UserGroup::GetMembers(void) const
+std::set<User::Ptr> UserGroup::GetMembers() const
{
boost::mutex::scoped_lock lock(m_UserGroupMutex);
return m_Members;
DECLARE_OBJECT(UserGroup);
DECLARE_OBJECTNAME(UserGroup);
- std::set<User::Ptr> GetMembers(void) const;
+ std::set<User::Ptr> GetMembers() const;
void AddMember(const User::Ptr& user);
void RemoveMember(const User::Ptr& user);
using namespace icinga;
-Aggregator::Aggregator(void)
+Aggregator::Aggregator()
{ }
void Aggregator::SetFilter(const Filter::Ptr& filter)
m_Filter = filter;
}
-Filter::Ptr Aggregator::GetFilter(void) const
+Filter::Ptr Aggregator::GetFilter() const
{
return m_Filter;
}
-AggregatorState::~AggregatorState(void)
+AggregatorState::~AggregatorState()
{ }
*/
struct AggregatorState
{
- virtual ~AggregatorState(void);
+ virtual ~AggregatorState();
};
/**
void SetFilter(const Filter::Ptr& filter);
protected:
- Aggregator(void);
+ Aggregator();
- Filter::Ptr GetFilter(void) const;
+ Filter::Ptr GetFilter() const;
private:
Filter::Ptr m_Filter;
using namespace icinga;
-AndFilter::AndFilter(void)
+AndFilter::AndFilter()
{ }
bool AndFilter::Apply(const Table::Ptr& table, const Value& row)
public:
DECLARE_PTR_TYPEDEFS(AndFilter);
- AndFilter(void);
+ AndFilter();
virtual bool Apply(const Table::Ptr& table, const Value& row) override;
};
*/
struct AvgAggregatorState final : public AggregatorState
{
- AvgAggregatorState(void)
+ AvgAggregatorState()
: Avg(0), AvgCount(0)
{ }
using namespace icinga;
-CombinerFilter::CombinerFilter(void)
+CombinerFilter::CombinerFilter()
{ }
void CombinerFilter::AddSubFilter(const Filter::Ptr& filter)
protected:
std::vector<Filter::Ptr> m_Filters;
- CombinerFilter(void);
+ CombinerFilter();
};
}
using namespace icinga;
-CommandsTable::CommandsTable(void)
+CommandsTable::CommandsTable()
{
AddColumns(this);
}
table->AddColumn(prefix + "modified_attributes_list", Column(&Table::ZeroAccessor, objectAccessor));
}
-String CommandsTable::GetName(void) const
+String CommandsTable::GetName() const
{
return "commands";
}
-String CommandsTable::GetPrefix(void) const
+String CommandsTable::GetPrefix() const
{
return "command";
}
public:
DECLARE_PTR_TYPEDEFS(CommandsTable);
- CommandsTable(void);
+ CommandsTable();
static void AddColumns(Table *table, const String& prefix = String(),
const Column::ObjectAccessor& objectAccessor = Column::ObjectAccessor());
- virtual String GetName(void) const override;
- virtual String GetPrefix(void) const override;
+ virtual String GetName() const override;
+ virtual String GetPrefix() const override;
protected:
virtual void FetchRows(const AddRowFunction& addRowFn) override;
using namespace icinga;
-CommentsTable::CommentsTable(void)
+CommentsTable::CommentsTable()
{
AddColumns(this);
}
HostsTable::AddColumns(table, "host_", std::bind(&CommentsTable::HostAccessor, _1, objectAccessor));
}
-String CommentsTable::GetName(void) const
+String CommentsTable::GetName() const
{
return "comments";
}
-String CommentsTable::GetPrefix(void) const
+String CommentsTable::GetPrefix() const
{
return "comment";
}
public:
DECLARE_PTR_TYPEDEFS(CommentsTable);
- CommentsTable(void);
+ CommentsTable();
static void AddColumns(Table *table, const String& prefix = String(),
const Column::ObjectAccessor& objectAccessor = Column::ObjectAccessor());
- virtual String GetName(void) const override;
- virtual String GetPrefix(void) const override;
+ virtual String GetName() const override;
+ virtual String GetPrefix() const override;
protected:
virtual void FetchRows(const AddRowFunction& addRowFn) override;
using namespace icinga;
-ContactGroupsTable::ContactGroupsTable(void)
+ContactGroupsTable::ContactGroupsTable()
{
AddColumns(this);
}
table->AddColumn(prefix + "members", Column(&ContactGroupsTable::MembersAccessor, objectAccessor));
}
-String ContactGroupsTable::GetName(void) const
+String ContactGroupsTable::GetName() const
{
return "contactgroups";
}
-String ContactGroupsTable::GetPrefix(void) const
+String ContactGroupsTable::GetPrefix() const
{
return "contactgroup";
}
public:
DECLARE_PTR_TYPEDEFS(ContactGroupsTable);
- ContactGroupsTable(void);
+ ContactGroupsTable();
static void AddColumns(Table *table, const String& prefix = String(),
const Column::ObjectAccessor& objectAccessor = Column::ObjectAccessor());
- virtual String GetName(void) const override;
- virtual String GetPrefix(void) const override;
+ virtual String GetName() const override;
+ virtual String GetPrefix() const override;
protected:
virtual void FetchRows(const AddRowFunction& addRowFn) override;
using namespace icinga;
-ContactsTable::ContactsTable(void)
+ContactsTable::ContactsTable()
{
AddColumns(this);
}
}
-String ContactsTable::GetName(void) const
+String ContactsTable::GetName() const
{
return "contacts";
}
-String ContactsTable::GetPrefix(void) const
+String ContactsTable::GetPrefix() const
{
return "contact";
}
public:
DECLARE_PTR_TYPEDEFS(ContactsTable);
- ContactsTable(void);
+ ContactsTable();
static void AddColumns(Table *table, const String& prefix = String(),
const Column::ObjectAccessor& objectAccessor = Column::ObjectAccessor());
- virtual String GetName(void) const override;
- virtual String GetPrefix(void) const override;
+ virtual String GetName() const override;
+ virtual String GetPrefix() const override;
protected:
virtual void FetchRows(const AddRowFunction& addRowFn) override;
*/
struct CountAggregatorState final : public AggregatorState
{
- CountAggregatorState(void)
+ CountAggregatorState()
: Count(0)
{ }
using namespace icinga;
-DowntimesTable::DowntimesTable(void)
+DowntimesTable::DowntimesTable()
{
AddColumns(this);
}
HostsTable::AddColumns(table, "host_", std::bind(&DowntimesTable::HostAccessor, _1, objectAccessor));
}
-String DowntimesTable::GetName(void) const
+String DowntimesTable::GetName() const
{
return "downtimes";
}
-String DowntimesTable::GetPrefix(void) const
+String DowntimesTable::GetPrefix() const
{
return "downtime";
}
public:
DECLARE_PTR_TYPEDEFS(DowntimesTable);
- DowntimesTable(void);
+ DowntimesTable();
static void AddColumns(Table *table, const String& prefix = String(),
const Column::ObjectAccessor& objectAccessor = Column::ObjectAccessor());
- virtual String GetName(void) const override;
- virtual String GetPrefix(void) const override;
+ virtual String GetName() const override;
+ virtual String GetPrefix() const override;
protected:
virtual void FetchRows(const AddRowFunction& addRowFn) override;
using namespace icinga;
-EndpointsTable::EndpointsTable(void)
+EndpointsTable::EndpointsTable()
{
AddColumns(this);
}
table->AddColumn(prefix + "zone", Column(&EndpointsTable::ZoneAccessor, objectAccessor));
}
-String EndpointsTable::GetName(void) const
+String EndpointsTable::GetName() const
{
return "endpoints";
}
-String EndpointsTable::GetPrefix(void) const
+String EndpointsTable::GetPrefix() const
{
return "endpoint";
}
public:
DECLARE_PTR_TYPEDEFS(EndpointsTable);
- EndpointsTable(void);
+ EndpointsTable();
static void AddColumns(Table *table, const String& prefix = String(),
const Column::ObjectAccessor& objectAccessor = Column::ObjectAccessor());
- virtual String GetName(void) const override;
- virtual String GetPrefix(void) const override;
+ virtual String GetName() const override;
+ virtual String GetPrefix() const override;
protected:
virtual void FetchRows(const AddRowFunction& addRowFn) override;
DECLARE_PTR_TYPEDEFS(Filter);
virtual bool Apply(const Table::Ptr& table, const Value& row) = 0;
+
+protected:
+ Filter();
};
}
using namespace icinga;
-HostGroupsTable::HostGroupsTable(void)
+HostGroupsTable::HostGroupsTable()
{
AddColumns(this);
}
table->AddColumn(prefix + "num_services_hard_unknown", Column(&HostGroupsTable::NumServicesHardUnknownAccessor, objectAccessor));
}
-String HostGroupsTable::GetName(void) const
+String HostGroupsTable::GetName() const
{
return "hostgroups";
}
-String HostGroupsTable::GetPrefix(void) const
+String HostGroupsTable::GetPrefix() const
{
return "hostgroup";
}
public:
DECLARE_PTR_TYPEDEFS(HostGroupsTable);
- HostGroupsTable(void);
+ HostGroupsTable();
static void AddColumns(Table *table, const String& prefix = String(),
const Column::ObjectAccessor& objectAccessor = Column::ObjectAccessor());
- virtual String GetName(void) const override;
- virtual String GetPrefix(void) const override;
+ virtual String GetName() const override;
+ virtual String GetPrefix() const override;
protected:
virtual void FetchRows(const AddRowFunction& addRowFn) override;
}
}
-String HostsTable::GetName(void) const
+String HostsTable::GetName() const
{
return "hosts";
}
-String HostsTable::GetPrefix(void) const
+String HostsTable::GetPrefix() const
{
return "host";
}
static void AddColumns(Table *table, const String& prefix = String(),
const Column::ObjectAccessor& objectAccessor = Column::ObjectAccessor());
- virtual String GetName(void) const override;
- virtual String GetPrefix(void) const override;
+ virtual String GetName() const override;
+ virtual String GetPrefix() const override;
protected:
virtual void FetchRows(const AddRowFunction& addRowFn) override;
*/
struct InvAvgAggregatorState final : public AggregatorState
{
- InvAvgAggregatorState(void)
+ InvAvgAggregatorState()
: InvAvg(0), InvAvgCount(0)
{ }
*/
struct InvSumAggregatorState final : public AggregatorState
{
- InvSumAggregatorState(void)
+ InvSumAggregatorState()
: InvSum(0)
{ }
m_Thread.join();
}
-int LivestatusListener::GetClientsConnected(void)
+int LivestatusListener::GetClientsConnected()
{
boost::mutex::scoped_lock lock(l_ComponentMutex);
return l_ClientsConnected;
}
-int LivestatusListener::GetConnections(void)
+int LivestatusListener::GetConnections()
{
boost::mutex::scoped_lock lock(l_ComponentMutex);
return l_Connections;
}
-void LivestatusListener::ServerThreadProc(void)
+void LivestatusListener::ServerThreadProc()
{
m_Listener->Listen();
static void StatsFunc(const Dictionary::Ptr& status, const Array::Ptr& perfdata);
- static int GetClientsConnected(void);
- static int GetConnections(void);
+ static int GetClientsConnected();
+ static int GetConnections();
virtual void ValidateSocketType(const String& value, const ValidationUtils& utils) override;
virtual void Stop(bool runtimeRemoved) override;
private:
- void ServerThreadProc(void);
+ void ServerThreadProc();
void ClientHandler(const Socket::Ptr& client);
Socket::Ptr m_Listener;
static Dictionary::Ptr GetAttributes(const String& text);
private:
- LivestatusLogUtility(void);
+ LivestatusLogUtility();
};
}
m_Aggregators.swap(aggregators);
}
-int LivestatusQuery::GetExternalCommands(void)
+int LivestatusQuery::GetExternalCommands()
{
boost::mutex::scoped_lock lock(l_QueryMutex);
bool Execute(const Stream::Ptr& stream);
- static int GetExternalCommands(void);
+ static int GetExternalCommands();
private:
String m_Verb;
CommandsTable::AddColumns(table, "current_command_", std::bind(&LogTable::CommandAccessor, _1, objectAccessor));
}
-String LogTable::GetName(void) const
+String LogTable::GetName() const
{
return "log";
}
-String LogTable::GetPrefix(void) const
+String LogTable::GetPrefix() const
{
return "log";
}
static void AddColumns(Table *table, const String& prefix = String(),
const Column::ObjectAccessor& objectAccessor = Column::ObjectAccessor());
- virtual String GetName(void) const override;
- virtual String GetPrefix(void) const override;
+ virtual String GetName() const override;
+ virtual String GetPrefix() const override;
void UpdateLogEntries(const Dictionary::Ptr& log_entry_attrs, int line_count, int lineno, const AddRowFunction& addRowFn) override;
*/
struct MaxAggregatorState final : public AggregatorState
{
- MaxAggregatorState(void)
+ MaxAggregatorState()
: Max(0)
{ }
*/
struct MinAggregatorState final : public AggregatorState
{
- MinAggregatorState(void)
+ MinAggregatorState()
: Min(DBL_MAX)
{ }
using namespace icinga;
-OrFilter::OrFilter(void)
+OrFilter::OrFilter()
{ }
bool OrFilter::Apply(const Table::Ptr& table, const Value& row)
public:
DECLARE_PTR_TYPEDEFS(OrFilter);
- OrFilter(void);
+ OrFilter();
virtual bool Apply(const Table::Ptr& table, const Value& row) override;
};
using namespace icinga;
-ServiceGroupsTable::ServiceGroupsTable(void)
+ServiceGroupsTable::ServiceGroupsTable()
{
AddColumns(this);
}
table->AddColumn(prefix + "num_services_hard_unknown", Column(&ServiceGroupsTable::NumServicesHardUnknownAccessor, objectAccessor));
}
-String ServiceGroupsTable::GetName(void) const
+String ServiceGroupsTable::GetName() const
{
return "servicegroups";
}
-String ServiceGroupsTable::GetPrefix(void) const
+String ServiceGroupsTable::GetPrefix() const
{
return "servicegroup";
}
public:
DECLARE_PTR_TYPEDEFS(ServiceGroupsTable);
- ServiceGroupsTable(void);
+ ServiceGroupsTable();
static void AddColumns(Table *table, const String& prefix = String(),
const Column::ObjectAccessor& objectAccessor = Column::ObjectAccessor());
- virtual String GetName(void) const override;
- virtual String GetPrefix(void) const override;
+ virtual String GetName() const override;
+ virtual String GetPrefix() const override;
protected:
virtual void FetchRows(const AddRowFunction& addRowFn) override;
}
}
-String ServicesTable::GetName(void) const
+String ServicesTable::GetName() const
{
return "services";
}
-String ServicesTable::GetPrefix(void) const
+String ServicesTable::GetPrefix() const
{
return "service";
}
static void AddColumns(Table *table, const String& prefix = String(),
const Column::ObjectAccessor& objectAccessor = Column::ObjectAccessor());
- virtual String GetName(void) const override;
- virtual String GetPrefix(void) const override;
+ virtual String GetName() const override;
+ virtual String GetPrefix() const override;
protected:
virtual void FetchRows(const AddRowFunction& addRowFn) override;
ServicesTable::AddColumns(table, "current_service_", std::bind(&StateHistTable::ServiceAccessor, _1, objectAccessor));
}
-String StateHistTable::GetName(void) const
+String StateHistTable::GetName() const
{
return "log";
}
-String StateHistTable::GetPrefix(void) const
+String StateHistTable::GetPrefix() const
{
return "log";
}
static void AddColumns(Table *table, const String& prefix = String(),
const Column::ObjectAccessor& objectAccessor = Column::ObjectAccessor());
- virtual String GetName(void) const override;
- virtual String GetPrefix(void) const override;
+ virtual String GetName() const override;
+ virtual String GetPrefix() const override;
void UpdateLogEntries(const Dictionary::Ptr& log_entry_attrs, int line_count, int lineno, const AddRowFunction& addRowFn) override;
using namespace icinga;
-StatusTable::StatusTable(void)
+StatusTable::StatusTable()
{
AddColumns(this);
}
table->AddColumn(prefix + "custom_variables", Column(&StatusTable::CustomVariablesAccessor, objectAccessor));
}
-String StatusTable::GetName(void) const
+String StatusTable::GetName() const
{
return "status";
}
-String StatusTable::GetPrefix(void) const
+String StatusTable::GetPrefix() const
{
return "status";
}
public:
DECLARE_PTR_TYPEDEFS(StatusTable);
- StatusTable(void);
+ StatusTable();
static void AddColumns(Table *table, const String& prefix = String(),
const Column::ObjectAccessor& objectAccessor = Column::ObjectAccessor());
- virtual String GetName(void) const override;
- virtual String GetPrefix(void) const override;
+ virtual String GetName() const override;
+ virtual String GetPrefix() const override;
protected:
virtual void FetchRows(const AddRowFunction& addRowFn) override;
*/
struct StdAggregatorState final : public AggregatorState
{
- StdAggregatorState(void)
+ StdAggregatorState()
: StdSum(0), StdQSum(0), StdCount(0)
{ }
*/
struct SumAggregatorState final : public AggregatorState
{
- SumAggregatorState(void)
+ SumAggregatorState()
: Sum(0)
{ }
return it->second;
}
-std::vector<String> Table::GetColumnNames(void) const
+std::vector<String> Table::GetColumnNames() const
{
std::vector<String> names;
return new Dictionary();
}
-LivestatusGroupByType Table::GetGroupByType(void) const
+LivestatusGroupByType Table::GetGroupByType() const
{
return m_GroupByType;
}
static Table::Ptr GetByName(const String& name, const String& compat_log_path = "", const unsigned long& from = 0, const unsigned long& until = 0);
- virtual String GetName(void) const = 0;
- virtual String GetPrefix(void) const = 0;
+ virtual String GetName() const = 0;
+ virtual String GetPrefix() const = 0;
std::vector<LivestatusRowValue> FilterRows(const intrusive_ptr<Filter>& filter, int limit = -1);
void AddColumn(const String& name, const Column& column);
Column GetColumn(const String& name) const;
- std::vector<String> GetColumnNames(void) const;
+ std::vector<String> GetColumnNames() const;
- LivestatusGroupByType GetGroupByType(void) const;
+ LivestatusGroupByType GetGroupByType() const;
protected:
Table(LivestatusGroupByType type = LivestatusGroupByNone);
using namespace icinga;
-TimePeriodsTable::TimePeriodsTable(void)
+TimePeriodsTable::TimePeriodsTable()
{
AddColumns(this);
}
table->AddColumn(prefix + "in", Column(&TimePeriodsTable::InAccessor, objectAccessor));
}
-String TimePeriodsTable::GetName(void) const
+String TimePeriodsTable::GetName() const
{
return "timeperiod";
}
-String TimePeriodsTable::GetPrefix(void) const
+String TimePeriodsTable::GetPrefix() const
{
return "timeperiod";
}
public:
DECLARE_PTR_TYPEDEFS(TimePeriodsTable);
- TimePeriodsTable(void);
+ TimePeriodsTable();
static void AddColumns(Table *table, const String& prefix = String(),
const Column::ObjectAccessor& objectAccessor = Column::ObjectAccessor());
- virtual String GetName(void) const override;
- virtual String GetPrefix(void) const override;
+ virtual String GetName() const override;
+ virtual String GetPrefix() const override;
protected:
virtual void FetchRows(const AddRowFunction& addRowFn) override;
using namespace icinga;
-ZonesTable::ZonesTable(void)
+ZonesTable::ZonesTable()
{
AddColumns(this);
}
table->AddColumn(prefix + "global", Column(&ZonesTable::GlobalAccessor, objectAccessor));
}
-String ZonesTable::GetName(void) const
+String ZonesTable::GetName() const
{
return "zones";
}
-String ZonesTable::GetPrefix(void) const
+String ZonesTable::GetPrefix() const
{
return "zone";
}
public:
DECLARE_PTR_TYPEDEFS(ZonesTable);
- ZonesTable(void);
+ ZonesTable();
static void AddColumns(Table *table, const String& prefix = String(),
const Column::ObjectAccessor& objectAccessor = Column::ObjectAccessor());
- virtual String GetName(void) const override;
- virtual String GetPrefix(void) const override;
+ virtual String GetName() const override;
+ virtual String GetPrefix() const override;
protected:
virtual void FetchRows(const AddRowFunction& addRowFn) override;
static mscorlib::_AppDomainPtr l_AppDomain;
-static void InitializeClr(void)
+static void InitializeClr()
{
ICorRuntimeHost *runtimeHost;
const Dictionary::Ptr& resolvedMacros, bool useResolvedMacros);
private:
- ClrCheckTask(void);
+ ClrCheckTask();
};
}
const Dictionary::Ptr& resolvedMacros, bool useResolvedMacros);
private:
- ClusterCheckTask(void);
+ ClusterCheckTask();
static String FormatArray(const Array::Ptr& arr);
};
const Dictionary::Ptr& resolvedMacros, bool useResolvedMacros);
private:
- ClusterZoneCheckTask(void);
+ ClusterZoneCheckTask();
};
}
const Dictionary::Ptr& resolvedMacros, bool useResolvedMacros);
private:
- DummyCheckTask(void);
+ DummyCheckTask();
};
}
const Dictionary::Ptr& resolvedMacros, bool useResolvedMacros);
private:
- ExceptionCheckTask(void);
+ ExceptionCheckTask();
};
}
const Dictionary::Ptr& resolvedMacros, bool useResolvedMacros);
private:
- IcingaCheckTask(void);
+ IcingaCheckTask();
};
}
const Dictionary::Ptr& resolvedMacros, bool useResolvedMacros);
private:
- NullCheckTask(void);
+ NullCheckTask();
};
}
const Dictionary::Ptr& resolvedMacros, bool useResolvedMacros);
private:
- NullEventTask(void);
+ NullEventTask();
};
}
const Dictionary::Ptr& resolvedMacros, bool useResolvedMacros);
private:
- PluginCheckTask(void);
+ PluginCheckTask();
static void ProcessFinishedHandler(const Checkable::Ptr& service,
const CheckResult::Ptr& cr, const Value& commandLine, const ProcessResult& pr);
const Dictionary::Ptr& resolvedMacros, bool useResolvedMacros);
private:
- PluginEventTask(void);
+ PluginEventTask();
static void ProcessFinishedHandler(const Checkable::Ptr& checkable,
const Value& commandLine, const ProcessResult& pr);
const Dictionary::Ptr& resolvedMacros, bool useResolvedMacros);
private:
- PluginNotificationTask(void);
+ PluginNotificationTask();
static void ProcessFinishedHandler(const Checkable::Ptr& checkable,
const Value& commandLine, const ProcessResult& pr);
const Dictionary::Ptr& resolvedMacros, bool useResolvedMacros);
private:
- RandomCheckTask(void);
+ RandomCheckTask();
};
}
static Array::Ptr EvenMinutesTimePeriodUpdate(const TimePeriod::Ptr& tp, double begin, double end);
private:
- TimePeriodTask(void);
+ TimePeriodTask();
};
}
struct MysqlInterfaceImpl final : public MysqlInterface
{
- void Destroy(void) override
+ void Destroy() override
{
delete this;
}
return mysql_store_result(mysql);
}
- unsigned int thread_safe(void) const override
+ unsigned int thread_safe() const override
{
return mysql_thread_safe();
}
};
-MysqlInterface *create_mysql_shim(void)
+MysqlInterface *create_mysql_shim()
{
return new MysqlInterfaceImpl();
}
MysqlInterface(const MysqlInterface&) = delete;
MysqlInterface& operator=(MysqlInterface&) = delete;
- virtual void Destroy(void) = 0;
+ virtual void Destroy() = 0;
virtual my_ulonglong affected_rows(MYSQL *mysql) const = 0;
virtual void close(MYSQL *sock) const = 0;
virtual unsigned long real_escape_string(MYSQL *mysql, char *to, const char *from, unsigned long length) const = 0;
virtual my_bool ssl_set(MYSQL *mysql, const char *key, const char *cert, const char *ca, const char *capath, const char *cipher) const = 0;
virtual MYSQL_RES *store_result(MYSQL *mysql) const = 0;
- virtual unsigned int thread_safe(void) const = 0;
+ virtual unsigned int thread_safe() const = 0;
protected:
- MysqlInterface(void) = default;
- ~MysqlInterface(void) = default;
+ MysqlInterface() = default;
+ ~MysqlInterface() = default;
};
struct MysqlInterfaceDeleter
extern "C"
{
- MYSQL_SHIM_EXPORT icinga::MysqlInterface *create_mysql_shim(void);
+ MYSQL_SHIM_EXPORT icinga::MysqlInterface *create_mysql_shim();
}
-typedef icinga::MysqlInterface *(*create_mysql_shim_ptr)(void);
+typedef icinga::MysqlInterface *(*create_mysql_shim_ptr)();
#endif /* MYSQLINTERFACE_H */
*
* @param - Event arguments for the timer.
*/
-void NotificationComponent::NotificationTimerHandler(void)
+void NotificationComponent::NotificationTimerHandler()
{
double now = Utility::GetTime();
private:
Timer::Ptr m_NotificationTimer;
- void NotificationTimerHandler(void);
+ void NotificationTimerHandler();
void SendNotificationsHandler(const Checkable::Ptr& checkable, NotificationType type,
const CheckResult::Ptr& cr, const String& author, const String& text);
};
REGISTER_STATSFUNCTION(ElasticsearchWriter, &ElasticsearchWriter::StatsFunc);
-ElasticsearchWriter::ElasticsearchWriter(void)
+ElasticsearchWriter::ElasticsearchWriter()
: m_WorkQueue(10000000, 1)
{ }
-void ElasticsearchWriter::OnConfigLoaded(void)
+void ElasticsearchWriter::OnConfigLoaded()
{
ObjectImpl<ElasticsearchWriter>::OnConfigLoaded();
}
}
-void ElasticsearchWriter::FlushTimeout(void)
+void ElasticsearchWriter::FlushTimeout()
{
/* Prevent new data points from being added to the array, there is a
* race condition where they could disappear.
}
}
-void ElasticsearchWriter::Flush(void)
+void ElasticsearchWriter::Flush()
{
/* Ensure you hold a lock against m_DataBuffer so that things
* don't go missing after creating the body and clearing the buffer.
}
}
-Stream::Ptr ElasticsearchWriter::Connect(void)
+Stream::Ptr ElasticsearchWriter::Connect()
{
TcpSocket::Ptr socket = new TcpSocket();
}
}
-void ElasticsearchWriter::AssertOnWorkQueue(void)
+void ElasticsearchWriter::AssertOnWorkQueue()
{
ASSERT(m_WorkQueue.IsWorkerThread());
}
DECLARE_OBJECT(ElasticsearchWriter);
DECLARE_OBJECTNAME(ElasticsearchWriter);
- ElasticsearchWriter(void);
+ ElasticsearchWriter();
static void StatsFunc(const Dictionary::Ptr& status, const Array::Ptr& perfdata);
static String FormatTimestamp(double ts);
protected:
- virtual void OnConfigLoaded(void) override;
+ virtual void OnConfigLoaded() override;
virtual void Start(bool runtimeCreated) override;
virtual void Stop(bool runtimeRemoved) override;
void Enqueue(String type, const Dictionary::Ptr& fields, double ts);
- Stream::Ptr Connect(void);
- void AssertOnWorkQueue(void);
+ Stream::Ptr Connect();
+ void AssertOnWorkQueue();
void ExceptionHandler(boost::exception_ptr exp);
- void FlushTimeout(void);
- void Flush(void);
+ void FlushTimeout();
+ void Flush();
void SendRequest(const String& body);
};
REGISTER_STATSFUNCTION(GelfWriter, &GelfWriter::StatsFunc);
-GelfWriter::GelfWriter(void)
+GelfWriter::GelfWriter()
: m_WorkQueue(10000000, 1)
{ }
-void GelfWriter::OnConfigLoaded(void)
+void GelfWriter::OnConfigLoaded()
{
ObjectImpl<GelfWriter>::OnConfigLoaded();
ObjectImpl<GelfWriter>::Stop(runtimeRemoved);
}
-void GelfWriter::AssertOnWorkQueue(void)
+void GelfWriter::AssertOnWorkQueue()
{
ASSERT(m_WorkQueue.IsWorkerThread());
}
}
}
-void GelfWriter::Reconnect(void)
+void GelfWriter::Reconnect()
{
AssertOnWorkQueue();
<< "Finished reconnecting to Graylog Gelf in " << std::setw(2) << Utility::GetTime() - startTime << " second(s).";
}
-void GelfWriter::ReconnectTimerHandler(void)
+void GelfWriter::ReconnectTimerHandler()
{
m_WorkQueue.Enqueue(std::bind(&GelfWriter::Reconnect, this), PriorityNormal);
}
-void GelfWriter::Disconnect(void)
+void GelfWriter::Disconnect()
{
AssertOnWorkQueue();
DECLARE_OBJECT(GelfWriter);
DECLARE_OBJECTNAME(GelfWriter);
- GelfWriter(void);
+ GelfWriter();
static void StatsFunc(const Dictionary::Ptr& status, const Array::Ptr& perfdata);
protected:
- virtual void OnConfigLoaded(void) override;
+ virtual void OnConfigLoaded() override;
virtual void Start(bool runtimeCreated) override;
virtual void Stop(bool runtimeRemoved) override;
String ComposeGelfMessage(const Dictionary::Ptr& fields, const String& source, double ts);
void SendLogMessage(const String& gelfMessage);
- void ReconnectTimerHandler(void);
+ void ReconnectTimerHandler();
- void Disconnect(void);
- void Reconnect(void);
+ void Disconnect();
+ void Reconnect();
- void AssertOnWorkQueue(void);
+ void AssertOnWorkQueue();
void ExceptionHandler(boost::exception_ptr exp);
};
REGISTER_STATSFUNCTION(GraphiteWriter, &GraphiteWriter::StatsFunc);
-GraphiteWriter::GraphiteWriter(void)
+GraphiteWriter::GraphiteWriter()
: m_WorkQueue(10000000, 1)
{ }
-void GraphiteWriter::OnConfigLoaded(void)
+void GraphiteWriter::OnConfigLoaded()
{
ObjectImpl<GraphiteWriter>::OnConfigLoaded();
ObjectImpl<GraphiteWriter>::Stop(runtimeRemoved);
}
-void GraphiteWriter::AssertOnWorkQueue(void)
+void GraphiteWriter::AssertOnWorkQueue()
{
ASSERT(m_WorkQueue.IsWorkerThread());
}
}
}
-void GraphiteWriter::Reconnect(void)
+void GraphiteWriter::Reconnect()
{
AssertOnWorkQueue();
<< "Finished reconnecting to Graphite in " << std::setw(2) << Utility::GetTime() - startTime << " second(s).";
}
-void GraphiteWriter::ReconnectTimerHandler(void)
+void GraphiteWriter::ReconnectTimerHandler()
{
m_WorkQueue.Enqueue(std::bind(&GraphiteWriter::Reconnect, this), PriorityNormal);
}
-void GraphiteWriter::Disconnect(void)
+void GraphiteWriter::Disconnect()
{
AssertOnWorkQueue();
DECLARE_OBJECT(GraphiteWriter);
DECLARE_OBJECTNAME(GraphiteWriter);
- GraphiteWriter(void);
+ GraphiteWriter();
static void StatsFunc(const Dictionary::Ptr& status, const Array::Ptr& perfdata);
virtual void ValidateServiceNameTemplate(const String& value, const ValidationUtils& utils) override;
protected:
- virtual void OnConfigLoaded(void) override;
+ virtual void OnConfigLoaded() override;
virtual void Start(bool runtimeCreated) override;
virtual void Stop(bool runtimeRemoved) override;
static String EscapeMetricLabel(const String& str);
static Value EscapeMacroMetric(const Value& value);
- void ReconnectTimerHandler(void);
+ void ReconnectTimerHandler();
- void Disconnect(void);
- void Reconnect(void);
+ void Disconnect();
+ void Reconnect();
- void AssertOnWorkQueue(void);
+ void AssertOnWorkQueue();
void ExceptionHandler(boost::exception_ptr exp);
};
: m_Value(value)
{ }
- int GetValue(void) const
+ int GetValue() const
{
return m_Value;
}
REGISTER_STATSFUNCTION(InfluxdbWriter, &InfluxdbWriter::StatsFunc);
-InfluxdbWriter::InfluxdbWriter(void)
+InfluxdbWriter::InfluxdbWriter()
: m_WorkQueue(10000000, 1)
{ }
-void InfluxdbWriter::OnConfigLoaded(void)
+void InfluxdbWriter::OnConfigLoaded()
{
ObjectImpl<InfluxdbWriter>::OnConfigLoaded();
ObjectImpl<InfluxdbWriter>::Stop(runtimeRemoved);
}
-void InfluxdbWriter::AssertOnWorkQueue(void)
+void InfluxdbWriter::AssertOnWorkQueue()
{
ASSERT(m_WorkQueue.IsWorkerThread());
}
//TODO: Close the connection, if we keep it open.
}
-Stream::Ptr InfluxdbWriter::Connect(void)
+Stream::Ptr InfluxdbWriter::Connect()
{
TcpSocket::Ptr socket = new TcpSocket();
}
}
-void InfluxdbWriter::FlushTimeout(void)
+void InfluxdbWriter::FlushTimeout()
{
m_WorkQueue.Enqueue(boost::bind(&InfluxdbWriter::FlushTimeoutWQ, this), PriorityHigh);
}
-void InfluxdbWriter::FlushTimeoutWQ(void)
+void InfluxdbWriter::FlushTimeoutWQ()
{
AssertOnWorkQueue();
Flush();
}
-void InfluxdbWriter::Flush(void)
+void InfluxdbWriter::Flush()
{
String body = boost::algorithm::join(m_DataBuffer, "\n");
m_DataBuffer.clear();
DECLARE_OBJECT(InfluxdbWriter);
DECLARE_OBJECTNAME(InfluxdbWriter);
- InfluxdbWriter(void);
+ InfluxdbWriter();
static void StatsFunc(const Dictionary::Ptr& status, const Array::Ptr& perfdata);
virtual void ValidateServiceTemplate(const Dictionary::Ptr& value, const ValidationUtils& utils) override;
protected:
- virtual void OnConfigLoaded(void) override;
+ virtual void OnConfigLoaded() override;
virtual void Start(bool runtimeCreated) override;
virtual void Stop(bool runtimeRemoved) override;
void CheckResultHandler(const Checkable::Ptr& checkable, const CheckResult::Ptr& cr);
void CheckResultHandlerWQ(const Checkable::Ptr& checkable, const CheckResult::Ptr& cr);
void SendMetric(const Dictionary::Ptr& tmpl, const String& label, const Dictionary::Ptr& fields, double ts);
- void FlushTimeout(void);
- void FlushTimeoutWQ(void);
- void Flush(void);
+ void FlushTimeout();
+ void FlushTimeoutWQ();
+ void Flush();
static String EscapeKeyOrTagValue(const String& str);
static String EscapeValue(const Value& value);
Stream::Ptr Connect();
- void AssertOnWorkQueue(void);
+ void AssertOnWorkQueue();
void ExceptionHandler(boost::exception_ptr exp);
};
ObjectImpl<OpenTsdbWriter>::Stop(runtimeRemoved);
}
-void OpenTsdbWriter::ReconnectTimerHandler(void)
+void OpenTsdbWriter::ReconnectTimerHandler()
{
if (m_Stream)
return;
static String EscapeTag(const String& str);
static String EscapeMetric(const String& str);
- void ReconnectTimerHandler(void);
+ void ReconnectTimerHandler();
};
}
<< "Could not open perfdata file '" << temp_path << "' for writing. Perfdata will be lost.";
}
-void PerfdataWriter::RotationTimerHandler(void)
+void PerfdataWriter::RotationTimerHandler()
{
RotateFile(m_ServiceOutputFile, GetServiceTempPath(), GetServicePerfdataPath());
RotateFile(m_HostOutputFile, GetHostTempPath(), GetHostPerfdataPath());
static Value EscapeMacroMetric(const Value& value);
Timer::Ptr m_RotationTimer;
- void RotationTimerHandler(void);
+ void RotationTimerHandler();
std::ofstream m_ServiceOutputFile;
std::ofstream m_HostOutputFile;
struct PgsqlInterfaceImpl final : public PgsqlInterface
{
- void Destroy(void) override
+ void Destroy() override
{
delete this;
}
return PQgetvalue(res, tup_num, field_num);
}
- int isthreadsafe(void) const override
+ int isthreadsafe() const override
{
return PQisthreadsafe();
}
}
};
-PgsqlInterface *create_pgsql_shim(void)
+PgsqlInterface *create_pgsql_shim()
{
return new PgsqlInterfaceImpl();
}
PgsqlInterface(const PgsqlInterface&) = delete;
PgsqlInterface& operator=(PgsqlInterface&) = delete;
- virtual void Destroy(void) = 0;
+ virtual void Destroy() = 0;
virtual void clear(PGresult *res) const = 0;
virtual char *cmdTuples(PGresult *res) const = 0;
virtual char *fname(const PGresult *res, int field_num) const = 0;
virtual int getisnull(const PGresult *res, int tup_num, int field_num) const = 0;
virtual char *getvalue(const PGresult *res, int tup_num, int field_num) const = 0;
- virtual int isthreadsafe(void) const = 0;
+ virtual int isthreadsafe() const = 0;
virtual int nfields(const PGresult *res) const = 0;
virtual int ntuples(const PGresult *res) const = 0;
virtual char *resultErrorMessage(const PGresult *res) const = 0;
virtual ConnStatusType status(const PGconn *conn) const = 0;
protected:
- PgsqlInterface(void) = default;
- ~PgsqlInterface(void) = default;
+ PgsqlInterface() = default;
+ ~PgsqlInterface() = default;
};
struct PgsqlInterfaceDeleter
extern "C"
{
- PGSQL_SHIM_EXPORT icinga::PgsqlInterface *create_pgsql_shim(void);
+ PGSQL_SHIM_EXPORT icinga::PgsqlInterface *create_pgsql_shim();
}
-typedef icinga::PgsqlInterface *(*create_pgsql_shim_ptr)(void);
+typedef icinga::PgsqlInterface *(*create_pgsql_shim_ptr)();
#endif /* PGSQLINTERFACE_H */
return m_Callback(target, params);
}
-const std::vector<String>& ApiAction::GetTypes(void) const
+const std::vector<String>& ApiAction::GetTypes() const
{
return m_Types;
}
ApiActionRegistry::GetInstance()->Unregister(name);
}
-ApiActionRegistry *ApiActionRegistry::GetInstance(void)
+ApiActionRegistry *ApiActionRegistry::GetInstance()
{
return Singleton<ApiActionRegistry>::GetInstance();
}
Value Invoke(const ConfigObject::Ptr& target, const Dictionary::Ptr& params);
- const std::vector<String>& GetTypes(void) const;
+ const std::vector<String>& GetTypes() const;
static ApiAction::Ptr GetByName(const String& name);
static void Register(const String& name, const ApiAction::Ptr& action);
class ApiActionRegistry : public Registry<ApiActionRegistry, ApiAction::Ptr>
{
public:
- static ApiActionRegistry *GetInstance(void);
+ static ApiActionRegistry *GetInstance();
};
#define REGISTER_APIACTION(name, types, callback) \
ApiFunctionRegistry::GetInstance()->Unregister(name);
}
-ApiFunctionRegistry *ApiFunctionRegistry::GetInstance(void)
+ApiFunctionRegistry *ApiFunctionRegistry::GetInstance()
{
return Singleton<ApiFunctionRegistry>::GetInstance();
}
class ApiFunctionRegistry : public Registry<ApiFunctionRegistry, ApiFunction::Ptr>
{
public:
- static ApiFunctionRegistry *GetInstance(void);
+ static ApiFunctionRegistry *GetInstance();
};
#define REGISTER_APIFUNCTION(name, ns, callback) \
UpdateConfigDir(oldConfigInfo, newConfigInfo, oldDir, true);
}
-void ApiListener::SyncZoneDirs(void) const
+void ApiListener::SyncZoneDirs() const
{
for (const Zone::Ptr& zone : ConfigType::GetObjectsByType<Zone>()) {
try {
REGISTER_APIFUNCTION(Hello, icinga, &ApiListener::HelloAPIHandler);
-ApiListener::ApiListener(void)
+ApiListener::ApiListener()
: m_SyncQueue(0, 4), m_LogMessageCount(0)
{
m_RelayQueue.SetName("ApiListener, RelayQueue");
m_SyncQueue.SetName("ApiListener, SyncQueue");
}
-String ApiListener::GetApiDir(void)
+String ApiListener::GetApiDir()
{
return Application::GetLocalStateDir() + "/lib/icinga2/api/";
}
-String ApiListener::GetCertsDir(void)
+String ApiListener::GetCertsDir()
{
return Application::GetLocalStateDir() + "/lib/icinga2/certs/";
}
-String ApiListener::GetCaDir(void)
+String ApiListener::GetCaDir()
{
return Application::GetLocalStateDir() + "/lib/icinga2/ca/";
}
-String ApiListener::GetCertificateRequestsDir(void)
+String ApiListener::GetCertificateRequestsDir()
{
return Application::GetLocalStateDir() + "/lib/icinga2/certificate-requests/";
}
-String ApiListener::GetDefaultCertPath(void)
+String ApiListener::GetDefaultCertPath()
{
return GetCertsDir() + "/" + ScriptGlobal::Get("NodeName") + ".crt";
}
-String ApiListener::GetDefaultKeyPath(void)
+String ApiListener::GetDefaultKeyPath()
{
return GetCertsDir() + "/" + ScriptGlobal::Get("NodeName") + ".key";
}
-String ApiListener::GetDefaultCaPath(void)
+String ApiListener::GetDefaultCaPath()
{
return GetCertsDir() + "/ca.crt";
}
}
}
-void ApiListener::OnConfigLoaded(void)
+void ApiListener::OnConfigLoaded()
{
if (m_Instance)
BOOST_THROW_EXCEPTION(ScriptError("Only one ApiListener object is allowed.", GetDebugInfo()));
UpdateSSLContext();
}
-void ApiListener::UpdateSSLContext(void)
+void ApiListener::UpdateSSLContext()
{
std::shared_ptr<SSL_CTX> context;
}
}
-void ApiListener::OnAllConfigLoaded(void)
+void ApiListener::OnAllConfigLoaded()
{
m_LocalEndpoint = Endpoint::GetByName(GetIdentity());
CloseLogFile();
}
-ApiListener::Ptr ApiListener::GetInstance(void)
+ApiListener::Ptr ApiListener::GetInstance()
{
return m_Instance;
}
-Endpoint::Ptr ApiListener::GetMaster(void) const
+Endpoint::Ptr ApiListener::GetMaster() const
{
Zone::Ptr zone = Zone::GetLocalZone();
return Endpoint::GetByName(*names.begin());
}
-bool ApiListener::IsMaster(void) const
+bool ApiListener::IsMaster() const
{
Endpoint::Ptr master = GetMaster();
<< "Finished syncing endpoint '" << endpoint->GetName() << "' in zone '" << eZone->GetName() << "'.";
}
-void ApiListener::ApiTimerHandler(void)
+void ApiListener::ApiTimerHandler()
{
double now = Utility::GetTime();
}
}
-void ApiListener::ApiReconnectTimerHandler(void)
+void ApiListener::ApiReconnectTimerHandler()
{
Zone::Ptr my_zone = Zone::GetLocalZone();
(void) unlink(path.CStr());
}
-void ApiListener::CleanupCertificateRequestsTimerHandler(void)
+void ApiListener::CleanupCertificateRequestsTimerHandler()
{
String requestsDir = GetCertificateRequestsDir();
}
/* must hold m_LogLock */
-void ApiListener::OpenLogFile(void)
+void ApiListener::OpenLogFile()
{
String path = GetApiDir() + "log/current";
}
/* must hold m_LogLock */
-void ApiListener::CloseLogFile(void)
+void ApiListener::CloseLogFile()
{
if (!m_LogFile)
return;
}
/* must hold m_LogLock */
-void ApiListener::RotateLogFile(void)
+void ApiListener::RotateLogFile()
{
double ts = GetLogMessageTimestamp();
status->Set("api", stats.first);
}
-std::pair<Dictionary::Ptr, Dictionary::Ptr> ApiListener::GetStatus(void)
+std::pair<Dictionary::Ptr, Dictionary::Ptr> ApiListener::GetStatus()
{
Dictionary::Ptr status = new Dictionary();
Dictionary::Ptr perfdata = new Dictionary();
m_AnonymousClients.erase(aclient);
}
-std::set<JsonRpcConnection::Ptr> ApiListener::GetAnonymousClients(void) const
+std::set<JsonRpcConnection::Ptr> ApiListener::GetAnonymousClients() const
{
boost::mutex::scoped_lock lock(m_AnonymousClientsLock);
return m_AnonymousClients;
m_HttpClients.erase(aclient);
}
-std::set<HttpServerConnection::Ptr> ApiListener::GetHttpClients(void) const
+std::set<HttpServerConnection::Ptr> ApiListener::GetHttpClients() const
{
boost::mutex::scoped_lock lock(m_HttpClientsLock);
return m_HttpClients;
return Empty;
}
-Endpoint::Ptr ApiListener::GetLocalEndpoint(void) const
+Endpoint::Ptr ApiListener::GetLocalEndpoint() const
{
return m_LocalEndpoint;
}
}
}
-bool ApiListener::IsHACluster(void)
+bool ApiListener::IsHACluster()
{
Zone::Ptr zone = Zone::GetLocalZone();
static boost::signals2::signal<void(bool)> OnMasterChanged;
- ApiListener(void);
+ ApiListener();
- static String GetApiDir(void);
- static String GetCertsDir(void);
- static String GetCaDir(void);
- static String GetCertificateRequestsDir(void);
+ static String GetApiDir();
+ static String GetCertsDir();
+ static String GetCaDir();
+ static String GetCertificateRequestsDir();
- void UpdateSSLContext(void);
+ void UpdateSSLContext();
- static ApiListener::Ptr GetInstance(void);
+ static ApiListener::Ptr GetInstance();
- Endpoint::Ptr GetMaster(void) const;
- bool IsMaster(void) const;
+ Endpoint::Ptr GetMaster() const;
+ bool IsMaster() const;
- Endpoint::Ptr GetLocalEndpoint(void) const;
+ Endpoint::Ptr GetLocalEndpoint() const;
void SyncSendMessage(const Endpoint::Ptr& endpoint, const Dictionary::Ptr& message);
void RelayMessage(const MessageOrigin::Ptr& origin, const ConfigObject::Ptr& secobj, const Dictionary::Ptr& message, bool log);
static void StatsFunc(const Dictionary::Ptr& status, const Array::Ptr& perfdata);
- std::pair<Dictionary::Ptr, Dictionary::Ptr> GetStatus(void);
+ std::pair<Dictionary::Ptr, Dictionary::Ptr> GetStatus();
void AddAnonymousClient(const JsonRpcConnection::Ptr& aclient);
void RemoveAnonymousClient(const JsonRpcConnection::Ptr& aclient);
- std::set<JsonRpcConnection::Ptr> GetAnonymousClients(void) const;
+ std::set<JsonRpcConnection::Ptr> GetAnonymousClients() const;
void AddHttpClient(const HttpServerConnection::Ptr& aclient);
void RemoveHttpClient(const HttpServerConnection::Ptr& aclient);
- std::set<HttpServerConnection::Ptr> GetHttpClients(void) const;
+ std::set<HttpServerConnection::Ptr> GetHttpClients() const;
static double CalculateZoneLag(const Endpoint::Ptr& endpoint);
static Value HelloAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
- static void UpdateObjectAuthority(void);
+ static void UpdateObjectAuthority();
- static bool IsHACluster(void);
+ static bool IsHACluster();
static String GetFromZoneName(const Zone::Ptr& fromZone);
- static String GetDefaultCertPath(void);
- static String GetDefaultKeyPath(void);
- static String GetDefaultCaPath(void);
+ static String GetDefaultCertPath();
+ static String GetDefaultKeyPath();
+ static String GetDefaultCaPath();
protected:
- virtual void OnConfigLoaded(void) override;
- virtual void OnAllConfigLoaded(void) override;
+ virtual void OnConfigLoaded() override;
+ virtual void OnAllConfigLoaded() override;
virtual void Start(bool runtimeCreated) override;
virtual void Stop(bool runtimeDeleted) override;
static ApiListener::Ptr m_Instance;
- void ApiTimerHandler(void);
- void ApiReconnectTimerHandler(void);
- void CleanupCertificateRequestsTimerHandler(void);
+ void ApiTimerHandler();
+ void ApiReconnectTimerHandler();
+ void CleanupCertificateRequestsTimerHandler();
bool AddListener(const String& node, const String& service);
void AddConnection(const Endpoint::Ptr& endpoint);
void SyncRelayMessage(const MessageOrigin::Ptr& origin, const ConfigObject::Ptr& secobj, const Dictionary::Ptr& message, bool log);
void PersistMessage(const Dictionary::Ptr& message, const ConfigObject::Ptr& secobj);
- void OpenLogFile(void);
- void RotateLogFile(void);
- void CloseLogFile(void);
+ void OpenLogFile();
+ void RotateLogFile();
+ void CloseLogFile();
static void LogGlobHandler(std::vector<int>& files, const String& file);
void ReplayLog(const JsonRpcConnection::Ptr& client);
static Dictionary::Ptr MergeConfigUpdate(const ConfigDirInformation& config);
static bool UpdateConfigDir(const ConfigDirInformation& oldConfig, const ConfigDirInformation& newConfig, const String& configDir, bool authoritative);
- void SyncZoneDirs(void) const;
+ void SyncZoneDirs() const;
void SyncZoneDir(const Zone::Ptr& zone) const;
static void ConfigGlobHandler(ConfigDirInformation& config, const String& path, const String& file);
using namespace icinga;
-void ApiListener::UpdateObjectAuthority(void)
+void ApiListener::UpdateObjectAuthority()
{
Zone::Ptr my_zone = Zone::GetLocalZone();
using namespace icinga;
-String ConfigObjectUtility::GetConfigDir(void)
+String ConfigObjectUtility::GetConfigDir()
{
return ConfigPackageUtility::GetPackageDir() + "/_api/" +
ConfigPackageUtility::GetActiveStage("_api");
{
public:
- static String GetConfigDir(void);
+ static String GetConfigDir();
static String GetObjectConfigPath(const Type::Ptr& type, const String& fullName);
static String CreateObjectConfig(const Type::Ptr& type, const String& fullName,
using namespace icinga;
-String ConfigPackageUtility::GetPackageDir(void)
+String ConfigPackageUtility::GetPackageDir()
{
return Application::GetLocalStateDir() + "/lib/icinga2/api/packages";
}
Application::RequestRestart();
}
-std::vector<String> ConfigPackageUtility::GetPackages(void)
+std::vector<String> ConfigPackageUtility::GetPackages()
{
std::vector<String> packages;
Utility::Glob(GetPackageDir() + "/*", std::bind(&ConfigPackageUtility::CollectDirNames,
return (!boost::regex_search(name.GetData(), what, expr));
}
-boost::mutex& ConfigPackageUtility::GetStaticMutex(void)
+boost::mutex& ConfigPackageUtility::GetStaticMutex()
{
static boost::mutex mutex;
return mutex;
{
public:
- static String GetPackageDir(void);
+ static String GetPackageDir();
static void CreatePackage(const String& name);
static void DeletePackage(const String& name);
- static std::vector<String> GetPackages(void);
+ static std::vector<String> GetPackages();
static bool PackageExists(const String& name);
static String CreateStage(const String& packageName, const Dictionary::Ptr& files = nullptr);
static bool ContainsDotDot(const String& path);
static bool ValidateName(const String& name);
- static boost::mutex& GetStaticMutex(void);
+ static boost::mutex& GetStaticMutex();
private:
static void CollectDirNames(const String& path, std::vector<String>& dirs);
static Timer::Ptr l_FrameCleanupTimer;
static boost::mutex l_ApiScriptMutex;
-static void ScriptFrameCleanupHandler(void)
+static void ScriptFrameCleanupHandler()
{
boost::mutex::scoped_lock lock(l_ApiScriptMutex);
l_ApiScriptFrames.erase(key);
}
-static void EnsureFrameCleanupTimer(void)
+static void EnsureFrameCleanupTimer()
{
static boost::once_flag once = BOOST_ONCE_INIT;
std::map<String, String> Lines;
Dictionary::Ptr Locals;
- ApiScriptFrame(void)
+ ApiScriptFrame()
: Seen(0), NextLine(1)
{ }
};
boost::signals2::signal<void(const Endpoint::Ptr&, const JsonRpcConnection::Ptr&)> Endpoint::OnConnected;
boost::signals2::signal<void(const Endpoint::Ptr&, const JsonRpcConnection::Ptr&)> Endpoint::OnDisconnected;
-Endpoint::Endpoint(void)
+Endpoint::Endpoint()
: m_MessagesSent(60), m_MessagesReceived(60), m_BytesSent(60), m_BytesReceived(60)
{ }
-void Endpoint::OnAllConfigLoaded(void)
+void Endpoint::OnAllConfigLoaded()
{
ObjectImpl<Endpoint>::OnAllConfigLoaded();
OnDisconnected(this, client);
}
-std::set<JsonRpcConnection::Ptr> Endpoint::GetClients(void) const
+std::set<JsonRpcConnection::Ptr> Endpoint::GetClients() const
{
boost::mutex::scoped_lock lock(m_ClientsLock);
return m_Clients;
}
-Zone::Ptr Endpoint::GetZone(void) const
+Zone::Ptr Endpoint::GetZone() const
{
return m_Zone;
}
-bool Endpoint::GetConnected(void) const
+bool Endpoint::GetConnected() const
{
boost::mutex::scoped_lock lock(m_ClientsLock);
return !m_Clients.empty();
}
-Endpoint::Ptr Endpoint::GetLocalEndpoint(void)
+Endpoint::Ptr Endpoint::GetLocalEndpoint()
{
ApiListener::Ptr listener = ApiListener::GetInstance();
SetLastMessageReceived(time);
}
-double Endpoint::GetMessagesSentPerSecond(void) const
+double Endpoint::GetMessagesSentPerSecond() const
{
return m_MessagesSent.CalculateRate(Utility::GetTime(), 60);
}
-double Endpoint::GetMessagesReceivedPerSecond(void) const
+double Endpoint::GetMessagesReceivedPerSecond() const
{
return m_MessagesReceived.CalculateRate(Utility::GetTime(), 60);
}
-double Endpoint::GetBytesSentPerSecond(void) const
+double Endpoint::GetBytesSentPerSecond() const
{
return m_BytesSent.CalculateRate(Utility::GetTime(), 60);
}
-double Endpoint::GetBytesReceivedPerSecond(void) const
+double Endpoint::GetBytesReceivedPerSecond() const
{
return m_BytesReceived.CalculateRate(Utility::GetTime(), 60);
}
DECLARE_OBJECT(Endpoint);
DECLARE_OBJECTNAME(Endpoint);
- Endpoint(void);
+ Endpoint();
static boost::signals2::signal<void(const Endpoint::Ptr&, const intrusive_ptr<JsonRpcConnection>&)> OnConnected;
static boost::signals2::signal<void(const Endpoint::Ptr&, const intrusive_ptr<JsonRpcConnection>&)> OnDisconnected;
void AddClient(const intrusive_ptr<JsonRpcConnection>& client);
void RemoveClient(const intrusive_ptr<JsonRpcConnection>& client);
- std::set<intrusive_ptr<JsonRpcConnection> > GetClients(void) const;
+ std::set<intrusive_ptr<JsonRpcConnection> > GetClients() const;
- intrusive_ptr<Zone> GetZone(void) const;
+ intrusive_ptr<Zone> GetZone() const;
- virtual bool GetConnected(void) const override;
+ virtual bool GetConnected() const override;
- static Endpoint::Ptr GetLocalEndpoint(void);
+ static Endpoint::Ptr GetLocalEndpoint();
void SetCachedZone(const intrusive_ptr<Zone>& zone);
void AddMessageSent(int bytes);
void AddMessageReceived(int bytes);
- double GetMessagesSentPerSecond(void) const override;
- double GetMessagesReceivedPerSecond(void) const override;
+ double GetMessagesSentPerSecond() const override;
+ double GetMessagesReceivedPerSecond() const override;
- double GetBytesSentPerSecond(void) const override;
- double GetBytesReceivedPerSecond(void) const override;
+ double GetBytesSentPerSecond() const override;
+ double GetBytesReceivedPerSecond() const override;
protected:
- virtual void OnAllConfigLoaded(void) override;
+ virtual void OnAllConfigLoaded() override;
private:
mutable boost::mutex m_ClientsLock;
EventQueueRegistry::GetInstance()->Unregister(name);
}
-EventQueueRegistry *EventQueueRegistry::GetInstance(void)
+EventQueueRegistry *EventQueueRegistry::GetInstance()
{
return Singleton<EventQueueRegistry>::GetInstance();
}
class EventQueueRegistry : public Registry<EventQueueRegistry, EventQueue::Ptr>
{
public:
- static EventQueueRegistry *GetInstance(void);
+ static EventQueueRegistry *GetInstance();
};
}
: m_Host(host), m_Port(port), m_Tls(tls)
{ }
-void HttpClientConnection::Start(void)
+void HttpClientConnection::Start()
{
/* Nothing to do here atm. */
}
-void HttpClientConnection::Reconnect(void)
+void HttpClientConnection::Reconnect()
{
if (m_Stream)
m_Stream->Close();
DataAvailableHandler(m_Stream);
}
-Stream::Ptr HttpClientConnection::GetStream(void) const
+Stream::Ptr HttpClientConnection::GetStream() const
{
return m_Stream;
}
-String HttpClientConnection::GetHost(void) const
+String HttpClientConnection::GetHost() const
{
return m_Host;
}
-String HttpClientConnection::GetPort(void) const
+String HttpClientConnection::GetPort() const
{
return m_Port;
}
-bool HttpClientConnection::GetTls(void) const
+bool HttpClientConnection::GetTls() const
{
return m_Tls;
}
-void HttpClientConnection::Disconnect(void)
+void HttpClientConnection::Disconnect()
{
Log(LogDebug, "HttpClientConnection", "Http client disconnected");
m_Stream->Shutdown();
}
-bool HttpClientConnection::ProcessMessage(void)
+bool HttpClientConnection::ProcessMessage()
{
bool res;
m_Stream->Close();
}
-std::shared_ptr<HttpRequest> HttpClientConnection::NewRequest(void)
+std::shared_ptr<HttpRequest> HttpClientConnection::NewRequest()
{
Reconnect();
return std::make_shared<HttpRequest>(m_Stream);
HttpClientConnection(const String& host, const String& port, bool tls = true);
- void Start(void);
+ void Start();
- Stream::Ptr GetStream(void) const;
- String GetHost(void) const;
- String GetPort(void) const;
- bool GetTls(void) const;
+ Stream::Ptr GetStream() const;
+ String GetHost() const;
+ String GetPort() const;
+ bool GetTls() const;
- void Disconnect(void);
+ void Disconnect();
- std::shared_ptr<HttpRequest> NewRequest(void);
+ std::shared_ptr<HttpRequest> NewRequest();
typedef std::function<void(HttpRequest&, HttpResponse&)> HttpCompletionCallback;
void SubmitRequest(const std::shared_ptr<HttpRequest>& request, const HttpCompletionCallback& callback);
StreamReadContext m_Context;
- void Reconnect(void);
- bool ProcessMessage(void);
+ void Reconnect();
+ bool ProcessMessage();
void DataAvailableHandler(const Stream::Ptr& stream);
void ProcessMessageAsync(HttpRequest& request);
Headers->Set(key.ToLower(), value);
}
-void HttpRequest::FinishHeaders(void)
+void HttpRequest::FinishHeaders()
{
if (m_State == HttpRequestStart) {
String rqline = RequestMethod + " " + RequestUrl->Format(true) + " HTTP/1." + (ProtocolVersion == HttpVersion10 ? "0" : "1") + "\n";
}
}
-void HttpRequest::Finish(void)
+void HttpRequest::Finish()
{
ASSERT(m_State != HttpRequestEnd);
void AddHeader(const String& key, const String& value);
void WriteBody(const char *data, size_t count);
- void Finish(void);
+ void Finish();
private:
Stream::Ptr m_Stream;
HttpRequestState m_State;
FIFO::Ptr m_Body;
- void FinishHeaders(void);
+ void FinishHeaders();
};
}
m_Headers.emplace_back(key + ": " + value + "\r\n");
}
-void HttpResponse::FinishHeaders(void)
+void HttpResponse::FinishHeaders()
{
if (m_State == HttpResponseHeaders) {
if (m_Request.ProtocolVersion == HttpVersion11)
}
}
-void HttpResponse::Finish(void)
+void HttpResponse::Finish()
{
ASSERT(m_State != HttpResponseEnd);
return m_Body->Read(data, count, true);
}
-size_t HttpResponse::GetBodySize(void) const
+size_t HttpResponse::GetBodySize() const
{
if (!m_Body)
return 0;
return m_Body->GetAvailableBytes();
}
-bool HttpResponse::IsPeerConnected(void) const
+bool HttpResponse::IsPeerConnected() const
{
return !m_Stream->IsEof();
}
bool Parse(StreamReadContext& src, bool may_wait);
size_t ReadBody(char *data, size_t count);
- size_t GetBodySize(void) const;
+ size_t GetBodySize() const;
void SetStatus(int code, const String& message);
void AddHeader(const String& key, const String& value);
void WriteBody(const char *data, size_t count);
- void Finish(void);
+ void Finish();
- bool IsPeerConnected(void) const;
+ bool IsPeerConnected() const;
private:
HttpResponseState m_State;
FIFO::Ptr m_Body;
std::vector<String> m_Headers;
- void FinishHeaders(void);
+ void FinishHeaders();
};
}
m_ApiUser = ApiUser::GetByClientCN(identity);
}
-void HttpServerConnection::StaticInitialize(void)
+void HttpServerConnection::StaticInitialize()
{
l_HttpServerConnectionTimeoutTimer = new Timer();
l_HttpServerConnectionTimeoutTimer->OnTimerExpired.connect(std::bind(&HttpServerConnection::TimeoutTimerHandler));
l_HttpServerConnectionTimeoutTimer->Start();
}
-void HttpServerConnection::Start(void)
+void HttpServerConnection::Start()
{
/* the stream holds an owning reference to this object through the callback we're registering here */
m_Stream->RegisterDataHandler(std::bind(&HttpServerConnection::DataAvailableHandler, HttpServerConnection::Ptr(this)));
DataAvailableHandler();
}
-ApiUser::Ptr HttpServerConnection::GetApiUser(void) const
+ApiUser::Ptr HttpServerConnection::GetApiUser() const
{
return m_ApiUser;
}
-TlsStream::Ptr HttpServerConnection::GetStream(void) const
+TlsStream::Ptr HttpServerConnection::GetStream() const
{
return m_Stream;
}
-void HttpServerConnection::Disconnect(void)
+void HttpServerConnection::Disconnect()
{
Log(LogDebug, "HttpServerConnection", "Http client disconnected");
m_Stream->Close();
}
-bool HttpServerConnection::ProcessMessage(void)
+bool HttpServerConnection::ProcessMessage()
{
bool res;
m_PendingRequests--;
}
-void HttpServerConnection::DataAvailableHandler(void)
+void HttpServerConnection::DataAvailableHandler()
{
bool close = false;
Disconnect();
}
-void HttpServerConnection::CheckLiveness(void)
+void HttpServerConnection::CheckLiveness()
{
if (m_Seen < Utility::GetTime() - 10 && m_PendingRequests == 0) {
Log(LogInformation, "HttpServerConnection")
}
}
-void HttpServerConnection::TimeoutTimerHandler(void)
+void HttpServerConnection::TimeoutTimerHandler()
{
ApiListener::Ptr listener = ApiListener::GetInstance();
HttpServerConnection(const String& identity, bool authenticated, const TlsStream::Ptr& stream);
- void Start(void);
+ void Start();
- ApiUser::Ptr GetApiUser(void) const;
- bool IsAuthenticated(void) const;
- TlsStream::Ptr GetStream(void) const;
+ ApiUser::Ptr GetApiUser() const;
+ bool IsAuthenticated() const;
+ TlsStream::Ptr GetStream() const;
- void Disconnect(void);
+ void Disconnect();
private:
ApiUser::Ptr m_ApiUser;
StreamReadContext m_Context;
- bool ProcessMessage(void);
- void DataAvailableHandler(void);
+ bool ProcessMessage();
+ void DataAvailableHandler();
- static void StaticInitialize(void);
- static void TimeoutTimerHandler(void);
- void CheckLiveness(void);
+ static void StaticInitialize();
+ static void TimeoutTimerHandler();
+ void CheckLiveness();
void ProcessMessageAsync(HttpRequest& request);
};
using namespace icinga;
#ifdef I2_DEBUG
-static bool GetDebugJsonRpcCached(void)
+static bool GetDebugJsonRpcCached()
{
static int debugJsonRpc = -1;
static Dictionary::Ptr DecodeMessage(const String& message);
private:
- JsonRpc(void);
+ JsonRpc();
};
}
REGISTER_APIFUNCTION(Heartbeat, event, &JsonRpcConnection::HeartbeatAPIHandler);
-void JsonRpcConnection::HeartbeatTimerHandler(void)
+void JsonRpcConnection::HeartbeatTimerHandler()
{
for (const Endpoint::Ptr& endpoint : ConfigType::GetObjectsByType<Endpoint>()) {
for (const JsonRpcConnection::Ptr& client : endpoint->GetClients()) {
m_Endpoint = Endpoint::GetByName(identity);
}
-void JsonRpcConnection::StaticInitialize(void)
+void JsonRpcConnection::StaticInitialize()
{
l_JsonRpcConnectionTimeoutTimer = new Timer();
l_JsonRpcConnectionTimeoutTimer->OnTimerExpired.connect(std::bind(&JsonRpcConnection::TimeoutTimerHandler));
l_HeartbeatTimer->Start();
}
-void JsonRpcConnection::Start(void)
+void JsonRpcConnection::Start()
{
/* the stream holds an owning reference to this object through the callback we're registering here */
m_Stream->RegisterDataHandler(std::bind(&JsonRpcConnection::DataAvailableHandler, JsonRpcConnection::Ptr(this)));
DataAvailableHandler();
}
-double JsonRpcConnection::GetTimestamp(void) const
+double JsonRpcConnection::GetTimestamp() const
{
return m_Timestamp;
}
-String JsonRpcConnection::GetIdentity(void) const
+String JsonRpcConnection::GetIdentity() const
{
return m_Identity;
}
-bool JsonRpcConnection::IsAuthenticated(void) const
+bool JsonRpcConnection::IsAuthenticated() const
{
return m_Authenticated;
}
-Endpoint::Ptr JsonRpcConnection::GetEndpoint(void) const
+Endpoint::Ptr JsonRpcConnection::GetEndpoint() const
{
return m_Endpoint;
}
-TlsStream::Ptr JsonRpcConnection::GetStream(void) const
+TlsStream::Ptr JsonRpcConnection::GetStream() const
{
return m_Stream;
}
-ConnectionRole JsonRpcConnection::GetRole(void) const
+ConnectionRole JsonRpcConnection::GetRole() const
{
return m_Role;
}
}
}
-void JsonRpcConnection::Disconnect(void)
+void JsonRpcConnection::Disconnect()
{
Log(LogWarning, "JsonRpcConnection")
<< "API client disconnected for identity '" << m_Identity << "'";
}
}
-bool JsonRpcConnection::ProcessMessage(void)
+bool JsonRpcConnection::ProcessMessage()
{
String message;
return true;
}
-void JsonRpcConnection::DataAvailableHandler(void)
+void JsonRpcConnection::DataAvailableHandler()
{
bool close = false;
return Empty;
}
-void JsonRpcConnection::CheckLiveness(void)
+void JsonRpcConnection::CheckLiveness()
{
if (m_Seen < Utility::GetTime() - 60 && (!m_Endpoint || !m_Endpoint->GetSyncing())) {
Log(LogInformation, "JsonRpcConnection")
}
}
-void JsonRpcConnection::TimeoutTimerHandler(void)
+void JsonRpcConnection::TimeoutTimerHandler()
{
ApiListener::Ptr listener = ApiListener::GetInstance();
}
}
-size_t JsonRpcConnection::GetWorkQueueCount(void)
+size_t JsonRpcConnection::GetWorkQueueCount()
{
return l_JsonRpcConnectionWorkQueueCount;
}
-size_t JsonRpcConnection::GetWorkQueueLength(void)
+size_t JsonRpcConnection::GetWorkQueueLength()
{
size_t itemCount = 0;
return itemCount;
}
-double JsonRpcConnection::GetWorkQueueRate(void)
+double JsonRpcConnection::GetWorkQueueRate()
{
double rate = 0.0;
size_t count = GetWorkQueueCount();
JsonRpcConnection(const String& identity, bool authenticated, const TlsStream::Ptr& stream, ConnectionRole role);
- void Start(void);
+ void Start();
- double GetTimestamp(void) const;
- String GetIdentity(void) const;
- bool IsAuthenticated(void) const;
- Endpoint::Ptr GetEndpoint(void) const;
- TlsStream::Ptr GetStream(void) const;
- ConnectionRole GetRole(void) const;
+ double GetTimestamp() const;
+ String GetIdentity() const;
+ bool IsAuthenticated() const;
+ Endpoint::Ptr GetEndpoint() const;
+ TlsStream::Ptr GetStream() const;
+ ConnectionRole GetRole() const;
- void Disconnect(void);
+ void Disconnect();
void SendMessage(const Dictionary::Ptr& request);
- static void HeartbeatTimerHandler(void);
+ static void HeartbeatTimerHandler();
static Value HeartbeatAPIHandler(const intrusive_ptr<MessageOrigin>& origin, const Dictionary::Ptr& params);
- static size_t GetWorkQueueCount(void);
- static size_t GetWorkQueueLength(void);
- static double GetWorkQueueRate(void);
+ static size_t GetWorkQueueCount();
+ static size_t GetWorkQueueLength();
+ static double GetWorkQueueRate();
static void SendCertificateRequest(const JsonRpcConnection::Ptr& aclient, const intrusive_ptr<MessageOrigin>& origin, const String& path);
StreamReadContext m_Context;
- bool ProcessMessage(void);
+ bool ProcessMessage();
void MessageHandlerWrapper(const String& jsonString);
void MessageHandler(const String& jsonString);
- void DataAvailableHandler(void);
+ void DataAvailableHandler();
- static void StaticInitialize(void);
- static void TimeoutTimerHandler(void);
- void CheckLiveness(void);
+ static void StaticInitialize();
+ static void TimeoutTimerHandler();
+ void CheckLiveness();
void CertificateRequestResponseHandler(const Dictionary::Ptr& message);
};
using namespace icinga;
-bool MessageOrigin::IsLocal(void) const
+bool MessageOrigin::IsLocal() const
{
return !FromClient;
}
Zone::Ptr FromZone;
JsonRpcConnection::Ptr FromClient;
- bool IsLocal(void) const;
+ bool IsLocal() const;
};
}
using namespace icinga;
-int PkiUtility::NewCa(void)
+int PkiUtility::NewCa()
{
String caDir = ApiListener::GetCaDir();
String caCertFile = caDir + "/ca.crt";
requests->Set(fingerprint, result);
}
-Dictionary::Ptr PkiUtility::GetCertificateRequests(void)
+Dictionary::Ptr PkiUtility::GetCertificateRequests()
{
Dictionary::Ptr requests = new Dictionary();
class PkiUtility
{
public:
- static int NewCa(void);
+ static int NewCa();
static int NewCert(const String& cn, const String& keyfile, const String& csrfile, const String& certfile);
static int SignCsr(const String& csrfile, const String& certfile);
static std::shared_ptr<X509> FetchCert(const String& host, const String& port);
const String& certfile, const String& cafile, const std::shared_ptr<X509>& trustedcert,
const String& ticket = String());
static String GetCertificateInformation(const std::shared_ptr<X509>& certificate);
- static Dictionary::Ptr GetCertificateRequests(void);
+ static Dictionary::Ptr GetCertificateRequests();
private:
- PkiUtility(void);
+ PkiUtility();
};
}
}
-String Url::GetScheme(void) const
+String Url::GetScheme() const
{
return m_Scheme;
}
-String Url::GetAuthority(void) const
+String Url::GetAuthority() const
{
if (m_Host.IsEmpty())
return "";
return auth;
}
-String Url::GetUsername(void) const
+String Url::GetUsername() const
{
return m_Username;
}
-String Url::GetPassword(void) const
+String Url::GetPassword() const
{
return m_Password;
}
-String Url::GetHost(void) const
+String Url::GetHost() const
{
return m_Host;
}
-String Url::GetPort(void) const
+String Url::GetPort() const
{
return m_Port;
}
-const std::vector<String>& Url::GetPath(void) const
+const std::vector<String>& Url::GetPath() const
{
return m_Path;
}
-const std::map<String, std::vector<String> >& Url::GetQuery(void) const
+const std::map<String, std::vector<String> >& Url::GetQuery() const
{
return m_Query;
}
return it->second;
}
-String Url::GetFragment(void) const
+String Url::GetFragment() const
{
return m_Fragment;
}
String Format(bool onlyPathAndQuery = false, bool printCredentials = false) const;
- String GetScheme(void) const;
- String GetAuthority(void) const;
- String GetUsername(void) const;
- String GetPassword(void) const;
- String GetHost(void) const;
- String GetPort(void) const;
- const std::vector<String>& GetPath(void) const;
- const std::map<String, std::vector<String> >& GetQuery(void) const;
+ String GetScheme() const;
+ String GetAuthority() const;
+ String GetUsername() const;
+ String GetPassword() const;
+ String GetHost() const;
+ String GetPort() const;
+ const std::vector<String>& GetPath() const;
+ const std::map<String, std::vector<String> >& GetQuery() const;
String GetQueryElement(const String& name) const;
const std::vector<String>& GetQueryElements(const String& name) const;
- String GetFragment(void) const;
+ String GetFragment() const;
void SetScheme(const String& scheme);
void SetUsername(const String& username);
REGISTER_TYPE(Zone);
-void Zone::OnAllConfigLoaded(void)
+void Zone::OnAllConfigLoaded()
{
ObjectImpl<Zone>::OnAllConfigLoaded();
}
}
-Zone::Ptr Zone::GetParent(void) const
+Zone::Ptr Zone::GetParent() const
{
return m_Parent;
}
-std::set<Endpoint::Ptr> Zone::GetEndpoints(void) const
+std::set<Endpoint::Ptr> Zone::GetEndpoints() const
{
std::set<Endpoint::Ptr> result;
return result;
}
-std::vector<Zone::Ptr> Zone::GetAllParents(void) const
+std::vector<Zone::Ptr> Zone::GetAllParents() const
{
return m_AllParents;
}
return false;
}
-bool Zone::IsGlobal(void) const
+bool Zone::IsGlobal() const
{
return GetGlobal();
}
-bool Zone::IsSingleInstance(void) const
+bool Zone::IsSingleInstance() const
{
Array::Ptr endpoints = GetEndpointsRaw();
return !endpoints || endpoints->GetLength() < 2;
}
-Zone::Ptr Zone::GetLocalZone(void)
+Zone::Ptr Zone::GetLocalZone()
{
Endpoint::Ptr local = Endpoint::GetLocalEndpoint();
DECLARE_OBJECT(Zone);
DECLARE_OBJECTNAME(Zone);
- virtual void OnAllConfigLoaded(void) override;
+ virtual void OnAllConfigLoaded() override;
- Zone::Ptr GetParent(void) const;
- std::set<Endpoint::Ptr> GetEndpoints(void) const;
- std::vector<Zone::Ptr> GetAllParents(void) const;
+ Zone::Ptr GetParent() const;
+ std::set<Endpoint::Ptr> GetEndpoints() const;
+ std::vector<Zone::Ptr> GetAllParents() const;
bool CanAccessObject(const ConfigObject::Ptr& object);
bool IsChildOf(const Zone::Ptr& zone);
- bool IsGlobal(void) const;
- bool IsSingleInstance(void) const;
+ bool IsGlobal() const;
+ bool IsSingleInstance() const;
- static Zone::Ptr GetLocalZone(void);
+ static Zone::Ptr GetLocalZone();
protected:
virtual void ValidateEndpointsRaw(const Array::Ptr& value, const ValidationUtils& utils) override;
public:
DECLARE_PTR_TYPEDEFS(TestObject);
- TestObject::Ptr GetTestRef(void)
+ TestObject::Ptr GetTestRef()
{
return this;
}
struct IcingaCheckableFixture
{
- IcingaCheckableFixture(void)
+ IcingaCheckableFixture()
{
BOOST_TEST_MESSAGE("setup running Icinga 2 core");
Application::InitializeBase();
}
- ~IcingaCheckableFixture(void)
+ ~IcingaCheckableFixture()
{
BOOST_TEST_MESSAGE("cleanup Icinga 2 core");
Application::UninitializeBase();
{
char *tz;
- GlobalTimezoneFixture(void)
+ GlobalTimezoneFixture()
{
tz = getenv("TZ");
#ifdef _WIN32
tzset();
}
- ~GlobalTimezoneFixture(void)
+ ~GlobalTimezoneFixture()
{
#ifdef _WIN32
if (tz)
struct LivestatusFixture
{
- LivestatusFixture(void)
+ LivestatusFixture()
{
BOOST_TEST_MESSAGE("Preparing config objects...");
ConfigItem::RunWithActivationContext(new Function("CreateTestObjects", CreateTestObjects));
}
- static void CreateTestObjects(void)
+ static void CreateTestObjects()
{
String config = R"CONFIG(
object CheckCommand "dummy" {
using namespace icinga;
-static bool init_unit_test(void)
+static bool init_unit_test()
{
return true;
}
}
| T_LOAD_AFTER identifier ';'
{
- Field *field = new Field();
+ auto *field = new Field();
field->Attributes = FALoadDependency;
field->Name = $2;
std::free($2);
InitializeScanner();
}
-ClassCompiler::~ClassCompiler(void)
+ClassCompiler::~ClassCompiler()
{
DestroyScanner();
}
-std::string ClassCompiler::GetPath(void) const
+std::string ClassCompiler::GetPath() const
{
return m_Path;
}
-void *ClassCompiler::GetScanner(void)
+void *ClassCompiler::GetScanner()
{
return m_Scanner;
}
m_Header << "template<>" << std::endl
<< "struct TypeHelper<" << klass.Name << ", " << ((klass.Attributes & TAVarArgConstructor) ? "true" : "false") << ">" << std::endl
<< "{" << std::endl
- << "\t" << "static ObjectFactory GetFactory(void)" << std::endl
+ << "\t" << "static ObjectFactory GetFactory()" << std::endl
<< "\t" << "{" << std::endl
<< "\t\t" << "return nullptr;" << std::endl
<< "\t" << "}" << std::endl
<< "{" << std::endl
<< "public:" << std::endl
<< "\t" << "DECLARE_PTR_TYPEDEFS(TypeImpl<" << klass.Name << ">);" << std::endl << std::endl
- << "\t" << "TypeImpl(void);" << std::endl
- << "\t" << "~TypeImpl(void);" << std::endl << std::endl;
+ << "\t" << "TypeImpl();" << std::endl
+ << "\t" << "~TypeImpl();" << std::endl << std::endl;
- m_Impl << "TypeImpl<" << klass.Name << ">::TypeImpl(void)" << std::endl
+ m_Impl << "TypeImpl<" << klass.Name << ">::TypeImpl()" << std::endl
<< "{ }" << std::endl << std::endl
- << "TypeImpl<" << klass.Name << ">::~TypeImpl(void)" << std::endl
+ << "TypeImpl<" << klass.Name << ">::~TypeImpl()" << std::endl
<< "{ }" << std::endl << std::endl;
/* GetName */
- m_Header << "\t" << "virtual String GetName(void) const;" << std::endl;
+ m_Header << "\t" << "virtual String GetName() const;" << std::endl;
- m_Impl << "String TypeImpl<" << klass.Name << ">::GetName(void) const" << std::endl
+ m_Impl << "String TypeImpl<" << klass.Name << ">::GetName() const" << std::endl
<< "{" << std::endl
<< "\t" << "return \"" << klass.Name << "\";" << std::endl
<< "}" << std::endl << std::endl;
/* GetAttributes */
- m_Header << "\t" << "virtual int GetAttributes(void) const;" << std::endl;
+ m_Header << "\t" << "virtual int GetAttributes() const;" << std::endl;
- m_Impl << "int TypeImpl<" << klass.Name << ">::GetAttributes(void) const" << std::endl
+ m_Impl << "int TypeImpl<" << klass.Name << ">::GetAttributes() const" << std::endl
<< "{" << std::endl
<< "\t" << "return " << klass.Attributes << ";" << std::endl
<< "}" << std::endl << std::endl;
/* GetBaseType */
- m_Header << "\t" << "virtual Type::Ptr GetBaseType(void) const;" << std::endl;
+ m_Header << "\t" << "virtual Type::Ptr GetBaseType() const;" << std::endl;
- m_Impl << "Type::Ptr TypeImpl<" << klass.Name << ">::GetBaseType(void) const" << std::endl
+ m_Impl << "Type::Ptr TypeImpl<" << klass.Name << ">::GetBaseType() const" << std::endl
<< "{" << std::endl
<< "\t" << "return ";
m_Impl << "}" << std::endl << std::endl;
/* GetFieldCount */
- m_Header << "\t" << "virtual int GetFieldCount(void) const;" << std::endl;
+ m_Header << "\t" << "virtual int GetFieldCount() const;" << std::endl;
- m_Impl << "int TypeImpl<" << klass.Name << ">::GetFieldCount(void) const" << std::endl
+ m_Impl << "int TypeImpl<" << klass.Name << ">::GetFieldCount() const" << std::endl
<< "{" << std::endl
<< "\t" << "return " << klass.Fields.size();
<< "}" << std::endl << std::endl;
/* GetFactory */
- m_Header << "\t" << "virtual ObjectFactory GetFactory(void) const;" << std::endl;
+ m_Header << "\t" << "virtual ObjectFactory GetFactory() const;" << std::endl;
- m_Impl << "ObjectFactory TypeImpl<" << klass.Name << ">::GetFactory(void) const" << std::endl
+ m_Impl << "ObjectFactory TypeImpl<" << klass.Name << ">::GetFactory() const" << std::endl
<< "{" << std::endl
<< "\t" << "return TypeHelper<" << klass.Name << ", " << ((klass.Attributes & TAVarArgConstructor) ? "true" : "false") << ">::GetFactory();" << std::endl
<< "}" << std::endl << std::endl;
/* GetLoadDependencies */
- m_Header << "\t" << "virtual std::vector<String> GetLoadDependencies(void) const;" << std::endl;
+ m_Header << "\t" << "virtual std::vector<String> GetLoadDependencies() const;" << std::endl;
- m_Impl << "std::vector<String> TypeImpl<" << klass.Name << ">::GetLoadDependencies(void) const" << std::endl
+ m_Impl << "std::vector<String> TypeImpl<" << klass.Name << ">::GetLoadDependencies() const" << std::endl
<< "{" << std::endl
<< "\t" << "std::vector<String> deps;" << std::endl;
/* constructor */
m_Header << "public:" << std::endl
- << "\t" << "ObjectImpl<" << klass.Name << ">(void);" << std::endl;
+ << "\t" << "ObjectImpl<" << klass.Name << ">();" << std::endl;
- m_Impl << "ObjectImpl<" << klass.Name << ">::ObjectImpl(void)" << std::endl
+ m_Impl << "ObjectImpl<" << klass.Name << ">::ObjectImpl()" << std::endl
<< "{" << std::endl;
for (const Field& field : klass.Fields) {
/* destructor */
m_Header << "public:" << std::endl
- << "\t" << "~ObjectImpl<" << klass.Name << ">(void);" << std::endl;
+ << "\t" << "~ObjectImpl<" << klass.Name << ">();" << std::endl;
- m_Impl << "ObjectImpl<" << klass.Name << ">::~ObjectImpl(void)" << std::endl
+ m_Impl << "ObjectImpl<" << klass.Name << ">::~ObjectImpl()" << std::endl
<< "{ }" << std::endl << std::endl;
if (!klass.Fields.empty()) {
if (field.Attributes & FAGetVirtual || field.PureGetAccessor)
m_Header << "virtual ";
- m_Header << field.Type.GetRealType() << " Get" << field.GetFriendlyName() << "(void) const";
+ m_Header << field.Type.GetRealType() << " Get" << field.GetFriendlyName() << "() const";
if (field.PureGetAccessor) {
m_Header << " = 0;" << std::endl;
} else {
m_Header << ";" << std::endl;
- m_Impl << field.Type.GetRealType() << " ObjectImpl<" << klass.Name << ">::Get" << field.GetFriendlyName() << "(void) const" << std::endl
+ m_Impl << field.Type.GetRealType() << " ObjectImpl<" << klass.Name << ">::Get" << field.GetFriendlyName() << "() const" << std::endl
<< "{" << std::endl;
if (field.GetAccessor.empty() && !(field.Attributes & FANoStorage))
continue;
m_Header << "public:" << std::endl
- << "\t" << "Object::Ptr Navigate" << field.GetFriendlyName() << "(void) const";
+ << "\t" << "Object::Ptr Navigate" << field.GetFriendlyName() << "() const";
if (field.PureNavigateAccessor) {
m_Header << " = 0;" << std::endl;
} else {
m_Header << ";" << std::endl;
- m_Impl << "Object::Ptr ObjectImpl<" << klass.Name << ">::Navigate" << field.GetFriendlyName() << "(void) const" << std::endl
+ m_Impl << "Object::Ptr ObjectImpl<" << klass.Name << ">::Navigate" << field.GetFriendlyName() << "() const" << std::endl
<< "{" << std::endl;
if (field.NavigateAccessor.empty())
std::string realType = field.Type.GetRealType();
m_Header << "private:" << std::endl
- << "\t" << "inline " << realType << " GetDefault" << field.GetFriendlyName() << "(void) const;" << std::endl;
+ << "\t" << "inline " << realType << " GetDefault" << field.GetFriendlyName() << "() const;" << std::endl;
- m_Impl << realType << " ObjectImpl<" << klass.Name << ">::GetDefault" << field.GetFriendlyName() << "(void) const" << std::endl
+ m_Impl << realType << " ObjectImpl<" << klass.Name << ">::GetDefault" << field.GetFriendlyName() << "() const" << std::endl
<< "{" << std::endl;
if (field.DefaultAccessor.empty())
m_MissingValidators.clear();
}
-void ClassCompiler::HandleMissingValidators(void)
+void ClassCompiler::HandleMissingValidators()
{
for (const auto& it : m_MissingValidators) {
m_Impl << "void ObjectImpl<" << it.first.first << ">::Validate" << it.first.second << "(" << it.second.Type.GetArgumentType() << " value, const ValidationUtils& utils)" << std::endl
std::string TypeName;
int ArrayRank;
- FieldType(void)
+ FieldType()
: IsName(false), ArrayRank(0)
{ }
- inline std::string GetRealType(void) const
+ inline std::string GetRealType() const
{
if (ArrayRank > 0)
return "Array::Ptr";
return TypeName;
}
- inline std::string GetArgumentType(void) const
+ inline std::string GetArgumentType() const
{
std::string realType = GetRealType();
std::string NavigateAccessor;
bool PureNavigateAccessor;
- Field(void)
+ Field()
: Attributes(0), PureGetAccessor(false), PureSetAccessor(false), PureNavigateAccessor(false)
{ }
- inline std::string GetFriendlyName(void) const
+ inline std::string GetFriendlyName() const
{
if (!AlternativeName.empty())
return AlternativeName;
{
public:
ClassCompiler(const std::string& path, std::istream& input, std::ostream& oimpl, std::ostream& oheader);
- ~ClassCompiler(void);
+ ~ClassCompiler();
- void Compile(void);
+ void Compile();
- std::string GetPath(void) const;
+ std::string GetPath() const;
- void InitializeScanner(void);
- void DestroyScanner(void);
+ void InitializeScanner();
+ void DestroyScanner();
- void *GetScanner(void);
+ void *GetScanner();
size_t ReadInput(char *buffer, size_t max_size);
void HandleNamespaceEnd(const ClassDebugInfo& locp);
void HandleCode(const std::string& code, const ClassDebugInfo& locp);
void HandleLibrary(const std::string& library, const ClassDebugInfo& locp);
- void HandleMissingValidators(void);
+ void HandleMissingValidators();
void CodeGenValidator(const std::string& name, const std::string& klass, const std::vector<Rule>& rules, const std::string& field, const FieldType& fieldType, ValidatorType validatorType);
void CodeGenValidatorSubrules(const std::string& name, const std::string& klass, const std::vector<Rule>& rules);
projects / icinga2 / commitdiff