tyler.durden/icinga2
1
0
Fork 0
mirror of https://github.com/Icinga/icinga2.git synced 2025-07-25 14:44:32 +02:00
Code Issues Packages Projects Releases Wiki Activity

Removed obsolete files.

Browse Source
This commit is contained in:
Gunnar Beutner 2012-07-02 16:24:45 +02:00
parent 40350bfce8
commit fb98044dcf
8 changed files with 0 additions and 583 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

127
attic/condvar.cpp
View File

@ -1,127 +0,0 @@
/******************************************************************************
* Icinga 2 *
* Copyright (C) 2012 Icinga Development Team (http://www.icinga.org/) *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License *
* as published by the Free Software Foundation; either version 2 *
* of the License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the Free Software Foundation *
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
#include "i2-base.h"
using namespace icinga;
/**
* Constructor for the CondVar class.
*/
CondVar::CondVar(void)
{
#ifdef _WIN32
InitializeConditionVariable(&m_CondVar);
#else /* _WIN32 */
#endif /* _WIN32 */
}
/**
* Destructor for the CondVar class.
*/
CondVar::~CondVar(void)
{
#ifdef _WIN32
/* nothing to do here */
#else /* _WIN32 */
#endif /* _WIN32 */
}
/**
* Waits for the condition variable to be signaled. Releases the specified mutex
* before it begins to wait and re-acquires the mutex after waiting.
*
* @param mtx The mutex that should be released during waiting.
* @param timeoutMilliseconds The timeout in milliseconds. Use the special
* constant CondVar::TimeoutInfinite for an
* infinite timeout.
* @returns false if a timeout occured, true otherwise.
*/
bool CondVar::Wait(Mutex& mtx, WaitTimeout timeoutMilliseconds)
{
#ifdef _WIN32
return (SleepConditionVariableCS(&m_CondVar, mtx.Get(),
timeoutMilliseconds) != FALSE);
#else /* _WIN32 */
if (timeoutMilliseconds == TimeoutInfinite)
pthread_cond_wait(&m_CondVar, mtx.Get());
else {
timeval now;
timespec ts;
if (gettimeofday(&now, NULL) < 0)
throw PosixException("gettimeofday failed.", errno);
ts.tv_sec = now.tv_sec;
ts.tv_nsec = now.tv_usec * 1000;
ts.tv_nsec += timeoutMilliseconds * 1000;
int rc = pthread_cond_timedwait(&m_CondVar, mtx.Get(), &ts);
if (rc == 0)
return true;
if (errno != ETIMEDOUT)
throw PosixException("pthread_cond_timedwait failed",
errno);
return false;
}
#endif /* _WIN32 */
}
/**
* Wakes up at least one waiting thread.
*/
void CondVar::Signal(void)
{
#ifdef _WIN32
WakeConditionVariable(&m_CondVar);
#else /* _WIN32 */
pthread_cond_signal(&m_CondVar);
#endif /* _WIN32 */
}
/**
* Wakes up all waiting threads.
*/
void CondVar::Broadcast(void)
{
#ifdef _WIN32
WakeAllConditionVariable(&m_CondVar);
#else /* _WIN32 */
pthread_cond_broadcast(&m_CondVar);
#endif /* _WIN32 */
}
/**
* Retrieves the platform-specific condition variable handle.
*
* @returns The platform-specific condition variable handle.
*/
#ifdef _WIN32
CONDITION_VARIABLE *CondVar::Get(void)
#else /* _WIN32 */
pthread_cond_t *CondVar::Get(void)
#endif /* _WIN32 */
{
return &m_CondVar;
}

65
attic/condvar.h
View File

@ -1,65 +0,0 @@
/******************************************************************************
* Icinga 2 *
* Copyright (C) 2012 Icinga Development Team (http://www.icinga.org/) *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License *
* as published by the Free Software Foundation; either version 2 *
* of the License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the Free Software Foundation *
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
#ifndef CONDVAR_H
#define CONDVAR_H
namespace icinga
{
/**
* A wrapper around OS-specific condition variable functionality.
*
* @ingroup base
*/
class I2_BASE_API CondVar
{
private:
#ifdef _WIN32
CONDITION_VARIABLE m_CondVar;
#else /* _WIN32 */
pthread_cond_t m_CondVar;
#endif /* _WIN32 */
public:
#ifdef _WIN32
typedef DWORD WaitTimeout;
static const WaitTimeout TimeoutInfinite = INFINITE;
#else /* _WIN32 */
typedef int WaitTimeout;
static const WaitTimeout TimeoutInfinite = -1;
#endif /* _WIN32 */
CondVar(void);
~CondVar(void);
bool Wait(Mutex& mtx, WaitTimeout timeoutMilliseconds = TimeoutInfinite);
void Signal(void);
void Broadcast(void);
#ifdef _WIN32
CONDITION_VARIABLE *Get(void);
#else /* _WIN32 */
pthread_cond_t *Get(void);
#endif /* _WIN32 */
};
}
#endif /* CONDVAR_H */

40
attic/lock.cpp
View File

@ -1,40 +0,0 @@
/******************************************************************************
* Icinga 2 *
* Copyright (C) 2012 Icinga Development Team (http://www.icinga.org/) *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License *
* as published by the Free Software Foundation; either version 2 *
* of the License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the Free Software Foundation *
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
#include "i2-base.h"
using namespace icinga;
/**
* Constructor for the Lock class. Acquires a lock on the specified mutex.
*
* @param mutex The mutex that is to be locked.
*/
Lock::Lock(Mutex& mutex) : m_Mutex(mutex)
{
m_Mutex.Exit();
}
/**
* Destructor for the Lock class. Releases the lock.
*/
Lock::~Lock(void)
{
m_Mutex.Exit();
}

44
attic/lock.h
View File

@ -1,44 +0,0 @@
/******************************************************************************
* Icinga 2 *
* Copyright (C) 2012 Icinga Development Team (http://www.icinga.org/) *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License *
* as published by the Free Software Foundation; either version 2 *
* of the License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the Free Software Foundation *
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
#ifndef LOCK_H
#define LOCK_H
namespace icinga
{
/**
* A lock that is held on a mutex and automatically released when the Lock
* object is destroyed.
*
* @ingroup base
*/
class I2_BASE_API Lock
{
private:
Mutex& m_Mutex;
public:
Lock(Mutex& mutex);
~Lock(void);
};
}
#endif /* LOCK_H */

99
attic/mutex.cpp
View File

@ -1,99 +0,0 @@
/******************************************************************************
* Icinga 2 *
* Copyright (C) 2012 Icinga Development Team (http://www.icinga.org/) *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License *
* as published by the Free Software Foundation; either version 2 *
* of the License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the Free Software Foundation *
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
#include "i2-base.h"
using namespace icinga;
/**
* Constructor for the Mutex class.
*/
Mutex::Mutex(void)
{
#ifdef _WIN32
InitializeCriticalSection(&m_Mutex);
#else /* _WIN32 */
pthread_mutex_init(&m_Mutex, NULL);
#endif /* _WIN32 */
}
/**
* Destructor for the Mutex class.
*/
Mutex::~Mutex(void)
{
#ifdef _WIN32
DeleteCriticalSection(&m_Mutex);
#else /* _WIN32 */
pthread_mutex_destroy(&m_Mutex);
#endif /* _WIN32 */
}
/**
* Tries to lock the mutex. If the mutex cannot be immediatelly
* locked the operation fails.
*
* @returns true if the operation succeeded, false otherwise.
*/
bool Mutex::TryEnter(void)
{
#ifdef _WIN32
return (TryEnterCriticalSection(&m_Mutex) == TRUE);
#else /* _WIN32 */
return pthread_mutex_trylock(&m_Mutex);
#endif /* _WIN32 */
}
/**
* Locks the mutex.
*/
void Mutex::Enter(void)
{
#ifdef _WIN32
EnterCriticalSection(&m_Mutex);
#else /* _WIN32 */
pthread_mutex_lock(&m_Mutex);
#endif /* _WIN32 */
}
/**
* Unlocks the mutex.
*/
void Mutex::Exit(void)
{
#ifdef _WIN32
LeaveCriticalSection(&m_Mutex);
#else /* _WIN32 */
pthread_mutex_unlock(&m_Mutex);
#endif /* _WIN32 */
}
/**
* Retrieves the platform-specific mutex handle.
*
* @returns The platform-specific mutex handle.
*/
#ifdef _WIN32
CRITICAL_SECTION *Mutex::Get(void)
#else /* _WIN32 */
pthread_mutex_t *Mutex::Get(void)
#endif /* _WIN32 */
{
return &m_Mutex;
}

57
attic/mutex.h
View File

@ -1,57 +0,0 @@
/******************************************************************************
* Icinga 2 *
* Copyright (C) 2012 Icinga Development Team (http://www.icinga.org/) *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License *
* as published by the Free Software Foundation; either version 2 *
* of the License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the Free Software Foundation *
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
#ifndef MUTEX_H
#define MUTEX_H
namespace icinga
{
/**
* A wrapper around OS-specific mutex functionality.
*
* @ingroup base
*/
class I2_BASE_API Mutex
{
private:
#ifdef _WIN32
CRITICAL_SECTION m_Mutex;
#else /* _WIN32 */
pthread_mutex_t m_Mutex;
#endif /* _WIN32 */
public:
Mutex(void);
~Mutex(void);
bool TryEnter(void);
void Enter(void);
void Exit(void);
#ifdef _WIN32
CRITICAL_SECTION *Get(void);
#else /* _WIN32 */
pthread_mutex_t *Get(void);
#endif /* _WIN32 */
};
}
#endif /* MUTEX_H */

94
attic/thread.cpp
View File

@ -1,94 +0,0 @@
/******************************************************************************
* Icinga 2 *
* Copyright (C) 2012 Icinga Development Team (http://www.icinga.org/) *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License *
* as published by the Free Software Foundation; either version 2 *
* of the License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the Free Software Foundation *
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
#include "i2-base.h"
using namespace icinga;
/**
* Helper function that deals with OS-specific differences in the thread
* proc's function signature.
*/
#ifdef _WIN32
static DWORD WINAPI ThreadStartProc(LPVOID param)
{
ThreadParameters *tparam = (ThreadParameters *)param;
tparam->Callback(tparam->UserParams);
delete tparam;
return 0;
}
#else /* _WIN32 */
static void *ThreadStartProc(void *param)
{
ThreadParameters *tparam = (ThreadParameters *)param;
tparam->Callback(tparam->UserParams);
delete tparam;
return NULL;
}
#endif /* _WIN32 */
/**
* Constructor for the thread class. Creates a new thread that begins
* executing immediately.
*/
Thread::Thread(ThreadProc callback, void *param)
{
ThreadParameters *tparam = new ThreadParameters();
if (tparam == NULL)
throw OutOfMemoryException("Out of memory");
tparam->Callback = callback;
tparam->UserParams = param;
#ifdef _WIN32
m_Thread = CreateThread(NULL, 0, ThreadStartProc, tparam, CREATE_SUSPENDED, NULL);
if (m_Thread == NULL)
throw Win32Exception("CreateThread failed.", GetLastError());
#else /* _WIN32 */
if (pthread_create(&m_Thread, NULL, ThreadStartProc, &tparam) < 0)
throw PosixException("pthread_create failed.", errno);
#endif /* _WIN32 */
}
/**
* Destructor for the Thread class. Cleans up the resources associated
* with the thread.
*/
Thread::~Thread(void)
{
#ifdef _WIN32
CloseHandle(m_Thread);
#else /* _WIN32 */
/* nothing to do here */
#endif
}
/**
* Waits until the thread has finished executing.
*/
void Thread::Join(void)
{
#ifdef _WIN32
WaitForSingleObject(m_Thread, INFINITE);
#else /* _WIN32 */
pthread_join(m_Thread, NULL);
#endif
}

57
attic/thread.h
View File

@ -1,57 +0,0 @@
/******************************************************************************
* Icinga 2 *
* Copyright (C) 2012 Icinga Development Team (http://www.icinga.org/) *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License *
* as published by the Free Software Foundation; either version 2 *
* of the License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the Free Software Foundation *
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
#ifndef THREAD_H
#define THREAD_H
namespace icinga
{
typedef void (*ThreadProc)(void *);
struct ThreadParameters
{
ThreadProc Callback;
void *UserParams;
};
/**
* A wrapper around OS-specific thread functionality.
*
* @ingroup base
*/
class I2_BASE_API Thread
{
private:
#ifdef _WIN32
HANDLE m_Thread;
#else
pthread_t m_Thread;
#endif
public:
Thread(ThreadProc callback, void *param);
~Thread(void);
void Join(void);
};
}
#endif /* THREAD_H */