SCRUG-NA/2025
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[seiscomp, scanloc] Install, add .gitignore

Browse Source
This commit is contained in:
Dirk Rössler
2025-10-09 15:07:02 +02:00
commit 20f5301bb1
2848 changed files with 1315858 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

442
include/seiscomp/broker/utils/utils.h Normal file
View File

@ -0,0 +1,442 @@
/***************************************************************************
* Copyright (C) gempa GmbH *
* All rights reserved. *
* Contact: gempa GmbH (seiscomp-dev@gempa.de) *
* *
* Author: Jan Becker *
* Email: jabe@gempa.de *
* *
* GNU Affero General Public License Usage *
* This file may be used under the terms of the GNU Affero *
* Public License version 3.0 as published by the Free Software Foundation *
* and appearing in the file LICENSE included in the packaging of this *
* file. Please review the following information to ensure the GNU Affero *
* Public License version 3.0 requirements will be met: *
* https://www.gnu.org/licenses/agpl-3.0.html. *
* *
* Other Usage *
* Alternatively, this file may be used in accordance with the terms and *
* conditions contained in a signed written agreement between you and *
* gempa GmbH. *
***************************************************************************/
#ifndef GEMPA_MESSAGESERVER_UTILS_H__
#define GEMPA_MESSAGESERVER_UTILS_H__
#include <seiscomp/core/exceptions.h>
#include <seiscomp/broker/api.h>
#include <vector>
#include <cstdio>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <type_traits>
#include <boost/noncopyable.hpp>
namespace Seiscomp {
namespace Utils {
/**
* @brief The Randomizer class generated random data of arbitrary length.
*
* This class utilized /dev/urandom under Unix. Other operating systems are
* not yet supported. Randomizer is implemented as a singleton. The usage
* is as simple as:
*
* \code
* if ( !Randomizer::Instance().fillData(data, len) )
* cerr << "Failed to generate random data" << endl;
* \endcode
*
* A helper template method Randomizer::fill is provided which takes an
* argument of arbitrary type and fills it with random data.
*
* \code
* int id;
* if ( !Randomizer::Instance().fill(id) )
* cerr << "Failed to generate id" << endl;
* \endcode
*/
class SC_BROKER_API Randomizer {
// ----------------------------------------------------------------------
// Destruction
// ----------------------------------------------------------------------
public:
//! D'tor
~Randomizer();
// ----------------------------------------------------------------------
// Public interface
// ----------------------------------------------------------------------
public:
/**
* @brief Returns the singleton instance.
* @return The singleton instance
*/
static Randomizer &Instance() { return _instance; }
/**
* @brief Fills a value with random data.
* @param target The value to be filled.
* @return true on success, false otherwise
*/
template <typename T>
bool fill(T &target);
/**
* @brief Fills a block of data with random data
* @param data The pointer to the memory block
* @param len The length in bytes of the memory block
* @return true on success, false otherwise
*/
bool fillData(void *data, size_t len);
// ----------------------------------------------------------------------
// Private interface
// ----------------------------------------------------------------------
private:
//! Private constructor
Randomizer();
// ----------------------------------------------------------------------
// Private members
// ----------------------------------------------------------------------
private:
static Randomizer _instance;
FILE *_randomFd;
};
template <typename T>
bool Randomizer::fill(T &target) {
return fillData(&target, sizeof(target));
}
template <typename T>
class BlockingDequeue : private boost::noncopyable {
// ----------------------------------------------------------------------
// Public types
// ----------------------------------------------------------------------
public:
typedef std::unique_lock<std::mutex> lock;
// ----------------------------------------------------------------------
// X'truction
// ----------------------------------------------------------------------
public:
BlockingDequeue();
BlockingDequeue(int n);
~BlockingDequeue();
// ----------------------------------------------------------------------
// Blocking interface
// ----------------------------------------------------------------------
public:
void resize(int n);
bool canPush() const;
bool push(T v);
bool canPop() const;
T pop();
bool pop(T &);
void close();
void reopen();
size_t size() const;
void lockBuffer();
void unlockBuffer();
//! Requires lockBuffer to be called
size_t buffered() const;
//! Requires lockBuffer to be called
T &operator[](size_t idx);
// ----------------------------------------------------------------------
// Private members
// ----------------------------------------------------------------------
private:
volatile int _begin, _end;
volatile size_t _buffered;
volatile bool _closed;
std::vector<T> _buffer;
std::condition_variable _notFull, _notEmpty;
mutable std::mutex _monitor;
};
template <typename T, int IsPtr>
struct BlockingDequeueHelper {};
template <typename T>
struct BlockingDequeueHelper<T,0> {
static void clean(const std::vector<T> &) {}
static T defaultValue() { return T(); }
};
template <typename T>
struct BlockingDequeueHelper<T,1> {
static void clean(const std::vector<T> &b) {
for ( size_t i = 0; i < b.size(); ++i ) {
if ( b[i] ) delete b[i];
}
}
static T defaultValue() { return NULL; }
};
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
BlockingDequeue<T>::BlockingDequeue() :
_begin(0), _end(0),
_buffered(0), _closed(false), _buffer(0)
{}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
BlockingDequeue<T>::BlockingDequeue(int n) :
_begin(0), _end(0),
_buffered(0), _closed(false), _buffer(n)
{}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
BlockingDequeue<T>::~BlockingDequeue() {
close();
BlockingDequeueHelper<T, std::is_pointer<T>::value>::clean(_buffer);
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
void BlockingDequeue<T>::resize(int n) {
lock lk(_monitor);
_buffer.resize(n);
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
bool BlockingDequeue<T>::canPush() const {
lock lk(_monitor);
if ( _closed )
throw Core::GeneralException("Queue has been closed");
return _buffered < _buffer.size();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
bool BlockingDequeue<T>::push(T v) {
lock lk(_monitor);
while (_buffered == _buffer.size() && !_closed)
_notFull.wait(lk);
if ( _closed ) {
_notEmpty.notify_all();
return false;
}
_buffer[_end] = v;
_end = (_end+1) % _buffer.size();
++_buffered;
_notEmpty.notify_all();
return true;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
bool BlockingDequeue<T>::canPop() const {
lock lk(_monitor);
if ( _closed )
throw Core::GeneralException("Queue has been closed");
return _buffered > 0;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
T BlockingDequeue<T>::pop() {
lock lk(_monitor);
while (_buffered == 0 && !_closed) {
_notEmpty.wait(lk);
}
if ( _closed )
throw Core::GeneralException("Queue has been closed");
T v = _buffer[_begin];
_buffer[_begin] = BlockingDequeueHelper<T, std::is_pointer<T>::value>::defaultValue();
_begin = (_begin+1) % _buffer.size();
--_buffered;
_notFull.notify_all();
return v;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
bool BlockingDequeue<T>::pop(T &v) {
lock lk(_monitor);
if ( _closed )
throw Core::GeneralException("Queue has been closed");
if ( _buffered > 0 ) {
v = _buffer[_begin];
_buffer[_begin] = BlockingDequeueHelper<T, std::is_pointer<T>::value>::defaultValue();
_begin = (_begin+1) % _buffer.size();
--_buffered;
_notFull.notify_all();
return true;
}
else
return false;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
void BlockingDequeue<T>::close() {
lock lk(_monitor);
if ( _closed ) return;
_closed = true;
_notFull.notify_all();
_notEmpty.notify_all();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
void BlockingDequeue<T>::reopen() {
lock lk(_monitor);
_closed = false;
if ( !_buffered )
_notFull.notify_all();
else
_notEmpty.notify_all();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
size_t BlockingDequeue<T>::size() const {
lock lk(_monitor);
return _buffered;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
void BlockingDequeue<T>::lockBuffer() {
_monitor.lock();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
void BlockingDequeue<T>::unlockBuffer() {
_monitor.unlock();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
size_t BlockingDequeue<T>::buffered() const {
return _buffered;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
T &BlockingDequeue<T>::operator[](size_t idx) {
idx += _begin;
if ( idx >= _buffer.size() )
idx -= _buffer.size();
return _buffer[idx];
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
}
}
#endif