633 lines
17 KiB
C++
633 lines
17 KiB
C++
#include "ConfigParser.h"
|
||
|
||
#include <fstream>
|
||
#include <iostream>
|
||
#include <algorithm>
|
||
#include <cctype>
|
||
|
||
#include <utility>
|
||
#include <sys/stat.h>
|
||
#include <ctime>
|
||
#include <sstream>
|
||
#include <memory>
|
||
#include <mutex>
|
||
|
||
#ifdef __linux__
|
||
|
||
#include <cstring>
|
||
|
||
#endif
|
||
|
||
using namespace std;
|
||
|
||
/** 清理字符串前后空格 */
|
||
void trim(std::string &s) {
|
||
auto wsfront = std::find_if_not(s.begin(), s.end(), [](int c) {
|
||
return std::isspace(c);
|
||
});
|
||
auto wsback = std::find_if_not(s.rbegin(), s.rend(), [](int c) {
|
||
return std::isspace(c);
|
||
}).base();
|
||
s = (wsback <= wsfront) ? std::string() : std::string(wsfront, wsback);
|
||
}
|
||
|
||
CPStatus configFromIni(const std::string &path, std::unordered_map<std::string, std::string> &config) {
|
||
CPStatus result = CPSUCCESS;
|
||
//打开文件
|
||
ifstream file(path);
|
||
if (!file.is_open()) {
|
||
result = CPFILE;
|
||
return result;
|
||
}
|
||
// 一次性读取整个文件（减少I/O操作）
|
||
file.seekg(0, std::ios::end);
|
||
size_t size = file.tellg();
|
||
file.seekg(0, std::ios::beg);
|
||
string m_buffer;
|
||
m_buffer.resize(size);
|
||
file.read(&m_buffer[0], static_cast<long long>(size));
|
||
//处理全部数据
|
||
config.clear();
|
||
std::string line;
|
||
line.reserve(256); // 预分配行缓存
|
||
for (auto it = m_buffer.cbegin(); it != m_buffer.cend();) {
|
||
// 快速跳过空白行
|
||
while (it != m_buffer.cend() && (*it == '\r' || *it == '\n')) ++it;
|
||
if (it == m_buffer.cend()) break;
|
||
|
||
// 获取行内容
|
||
line.clear();
|
||
while (it != m_buffer.cend() && *it != '\r' && *it != '\n' && *it != '\0') {
|
||
line += *it++;
|
||
}
|
||
//处理行内容
|
||
// 跳过空行和注释
|
||
if (line.empty() || line[0] == ';' || line[0] == '#') {
|
||
++it;
|
||
continue;
|
||
}
|
||
|
||
// 分割键值对
|
||
size_t eq_pos = line.find('=');
|
||
if (eq_pos != std::string::npos) {
|
||
std::string key = line.substr(0, eq_pos);
|
||
std::string value = line.substr(eq_pos + 1);
|
||
trim(key);
|
||
trim(value);
|
||
if (!key.empty()) {
|
||
config[key] = value; // 移动语义自动优化
|
||
}
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
void UDPSocketBase::create_socket() {
|
||
while (true) {
|
||
sockfd_ = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
|
||
#if defined(_WIN32)
|
||
if (sockfd_ != INVALID_SOCKET_VALUE){
|
||
break;
|
||
}
|
||
#else
|
||
if (sockfd_ >= 0) {
|
||
break;
|
||
}
|
||
#endif
|
||
}
|
||
}
|
||
|
||
void UDPSocketBase::create_socket(socket_t socket) {
|
||
sockfd_ = socket;
|
||
}
|
||
|
||
void UDPSocketBase::set_nonblock(bool enable) {
|
||
u_long ctl = enable ? 1 : 0;
|
||
#if defined(_WIN32)
|
||
ioctlsocket(sockfd_, FIONBIO, &ctl) == 0;
|
||
#else
|
||
ioctl(sockfd_, FIONBIO, &ctl) == 0;
|
||
#endif
|
||
is_nonblock_ = enable;
|
||
}
|
||
|
||
void UDPSocketBase::bind_socket(const sockaddr_in &addr) const {
|
||
if (bind(sockfd_, (struct sockaddr *) &addr, sizeof(addr)) != 0) {
|
||
throw std::runtime_error("Bind failed");
|
||
}
|
||
}
|
||
|
||
UDPSocketBase::~UDPSocketBase() {
|
||
#if defined(_WIN32)
|
||
int ret = closesocket(sockfd_);
|
||
#else
|
||
int ret = close(sockfd_);
|
||
#endif
|
||
sockfd_ = (~0);
|
||
}
|
||
|
||
UDPSender::UDPSender(socket_t socket, bool nonblock) {
|
||
if (socket != INVALID_SOCKET_VALUE) {
|
||
create_socket(socket);
|
||
}
|
||
else {
|
||
create_socket();
|
||
}
|
||
set_nonblock(nonblock);
|
||
}
|
||
|
||
void UDPSender::set_destination(const std::string &ip, uint16_t port) {
|
||
dstIp = ip;
|
||
dstPort = port;
|
||
dest_addr_.sin_family = AF_INET;
|
||
dest_addr_.sin_port = htons(port);
|
||
#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x600
|
||
dest_addr_.sin_addr.S_un.S_addr = inet_addr(ip.c_str());
|
||
#else
|
||
inet_pton(AF_INET, ip.c_str(), &dest_addr_.sin_addr);
|
||
#endif
|
||
}
|
||
|
||
void UDPSender::set_source(const std::string &ip, uint16_t port) {
|
||
sockaddr_in addr{};
|
||
addr.sin_family = AF_INET;
|
||
addr.sin_port = htons(port);
|
||
#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x600
|
||
addr.sin_addr.S_un.S_addr = inet_addr(ip.c_str());
|
||
#else
|
||
inet_pton(AF_INET, ip.c_str(), &addr.sin_addr);
|
||
#endif
|
||
bind_socket(addr);
|
||
}
|
||
|
||
size_t UDPSender::send(const std::vector<uint8_t> &data) {
|
||
auto sent = sendto(sockfd_,
|
||
reinterpret_cast<const char *>(data.data()),
|
||
static_cast<int>(data.size()),
|
||
0,
|
||
(struct sockaddr *) &dest_addr_,
|
||
sizeof(dest_addr_));
|
||
|
||
if (sent == SOCKET_ERROR) {
|
||
// throw std::runtime_error("Send failed");
|
||
printf("Send failed\n");
|
||
}
|
||
return static_cast<size_t>(sent);
|
||
}
|
||
|
||
size_t UDPSender::send(const std::string &data) {
|
||
auto sent = sendto(sockfd_,
|
||
reinterpret_cast<const char *>(data.data()),
|
||
static_cast<int>(data.size()),
|
||
0,
|
||
(struct sockaddr *) &dest_addr_,
|
||
sizeof(dest_addr_));
|
||
|
||
if (sent == SOCKET_ERROR) {
|
||
// throw std::runtime_error("Send failed");
|
||
printf("Send failed\n");
|
||
|
||
}
|
||
return static_cast<size_t>(sent);
|
||
}
|
||
|
||
size_t UDPSender::send(uint8_t *data, size_t size) {
|
||
int nleft, nwritten;
|
||
const char *ptr;
|
||
|
||
ptr = (char *) data; /* can't do pointer arithmetic on void* */
|
||
nleft = size;
|
||
while (nleft > 0) {
|
||
#if defined(_WIN32)
|
||
if ((nwritten = sendto(sockfd_, ptr, nleft, 0, (const struct sockaddr*)&dest_addr_, sizeof(dest_addr_))) <= 0)
|
||
#else
|
||
if ((nwritten = sendto(sockfd_, ptr, nleft, MSG_NOSIGNAL, (const struct sockaddr *) &dest_addr_,
|
||
sizeof(struct sockaddr))) <= 0)
|
||
#endif
|
||
{
|
||
if (!(errno == EWOULDBLOCK || errno == EAGAIN || errno == EINTR))
|
||
return -1; /* error */
|
||
else
|
||
continue;
|
||
}
|
||
|
||
nleft -= nwritten;
|
||
ptr += nwritten;
|
||
}
|
||
|
||
return (size);
|
||
}
|
||
|
||
|
||
UDPReceiver::UDPReceiver(uint16_t port, bool nonblock, size_t buffer_size)
|
||
: buffer_(buffer_size), running_(false), srcPort(port) {
|
||
create_socket();
|
||
|
||
sockaddr_in addr{};
|
||
addr.sin_family = AF_INET;
|
||
addr.sin_port = htons(port);
|
||
addr.sin_addr.s_addr = INADDR_ANY;
|
||
|
||
bind_socket(addr);
|
||
set_nonblock(nonblock);
|
||
this->isOnline.store(false);
|
||
}
|
||
|
||
void UDPReceiver::start_receiving(const UDPReceiver::ReceiveCallback &callback) {
|
||
running_ = true;
|
||
receiver_thread_ = std::thread([this, callback]() {
|
||
while (running_.load(std::memory_order_relaxed)) {
|
||
try {
|
||
auto result = receive();
|
||
ssize_t size = result.first;
|
||
auto &from = result.second;
|
||
if (size > 0) {
|
||
lastTime_ = std::chrono::steady_clock::now();
|
||
std::vector<uint8_t> data(buffer_.begin(),
|
||
buffer_.begin() + size);
|
||
callback(data, from.first, from.second);
|
||
}
|
||
}
|
||
catch (const std::runtime_error &e) {
|
||
if (is_nonblock_) continue;
|
||
// cerr << e.what() << endl;
|
||
}
|
||
}
|
||
});
|
||
online_thread_ = std::thread([this]() {
|
||
while (running_.load(std::memory_order_relaxed)) {
|
||
this_thread::sleep_for(std::chrono::seconds(1));
|
||
if (!isOnline.load()) {
|
||
continue;
|
||
}
|
||
auto time = std::chrono::steady_clock::now() - lastTime_;
|
||
if (std::chrono::duration_cast<std::chrono::seconds>(time).count() > 5) {
|
||
isOnline.store(false);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
void UDPReceiver::stop_receiving() {
|
||
running_.store(false);
|
||
if (receiver_thread_.joinable()) {
|
||
receiver_thread_.join();
|
||
}
|
||
if (online_thread_.joinable()) {
|
||
online_thread_.join();
|
||
}
|
||
}
|
||
|
||
std::pair<ssize_t, std::pair<sockaddr_in, socklen_t>> UDPReceiver::receive() {
|
||
sockaddr_in from_addr{};
|
||
socklen_t from_len = sizeof(from_addr);
|
||
#ifdef _WIN32
|
||
DWORD timeout = UDPTimeout*1000; // 3秒(单位：毫秒)
|
||
setsockopt(sockfd_, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeout, sizeof(timeout));
|
||
#else
|
||
struct timeval tv;
|
||
tv.tv_sec = UDPTimeout; // 秒
|
||
tv.tv_usec = 0; // 微秒
|
||
setsockopt(sockfd_, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
|
||
#endif
|
||
auto size = recvfrom(sockfd_,
|
||
reinterpret_cast<char *>(buffer_.data()),
|
||
static_cast<int>(buffer_.size()),
|
||
0,
|
||
(struct sockaddr *) &from_addr,
|
||
&from_len);
|
||
|
||
if (size == SOCKET_ERROR) {
|
||
throw std::runtime_error("Receive Timeout");
|
||
}
|
||
|
||
return {size, {from_addr, from_len}};
|
||
}
|
||
|
||
UDPReceiver::~UDPReceiver() {
|
||
stop_receiving();
|
||
}
|
||
|
||
LogL::LogL(LogType logType, bool isSync, LogLevel level, std::string logPath) : m_isSync(isSync), m_logType(logType),
|
||
m_logPath(std::move(logPath)),
|
||
m_file(nullptr),
|
||
m_thread(nullptr), m_sender(nullptr),
|
||
m_logLevel(level) {
|
||
|
||
switch (m_logType) {
|
||
case LTStd: {
|
||
break;
|
||
}
|
||
case LTTxt: {
|
||
//创建文件
|
||
myDateTime now;
|
||
std::string dirName;
|
||
if (m_logPath.empty()) {
|
||
dirName = "log";
|
||
}
|
||
else {
|
||
dirName = m_logPath;
|
||
}
|
||
myMkdir(dirName.c_str());
|
||
std::string fileName = dirName + "/" + now.toDate() + ".txt";
|
||
m_file = new std::ofstream(fileName, std::ios::app);
|
||
m_today = now.day;
|
||
break;
|
||
}
|
||
case LTUdp: {
|
||
m_sender.reset(new UDPSender);
|
||
std::vector<std::string> parts;
|
||
std::stringstream ss(m_logPath);
|
||
std::string part;
|
||
// 按逗号分割字符串
|
||
while (std::getline(ss, part, ':')) {
|
||
parts.push_back(part);
|
||
}
|
||
if (parts.size() == 3) {
|
||
m_sender->set_destination(parts[0], stoi(parts[1]));
|
||
m_sender->set_source(parts[0], stoi(parts[2]));
|
||
}
|
||
else if (parts.size() == 2) {
|
||
m_sender->set_destination(parts[0], stoi(parts[1]));
|
||
}
|
||
else {
|
||
throw std::runtime_error("UDP Path Error");
|
||
}
|
||
break;
|
||
}
|
||
case LTTcp: {
|
||
|
||
break;
|
||
}
|
||
}
|
||
if (!m_isSync) {
|
||
//运行日志线程
|
||
m_thread_run = true;
|
||
m_thread = new std::thread(&LogL::logThread, this);
|
||
}
|
||
}
|
||
|
||
LogL::~LogL() {
|
||
//停止线程
|
||
while (m_thread) {
|
||
if (m_log_queue.empty()) {
|
||
cout << "已清空日志队列" << endl;
|
||
break;
|
||
}
|
||
cout << "正在写入剩余日志:" << m_log_queue.size() << endl;
|
||
this_thread::sleep_for(chrono::milliseconds(300));
|
||
}
|
||
if (m_thread) {
|
||
//设置结束并等待线程结束
|
||
m_thread_run = false;
|
||
m_cond_empty.notify_all();
|
||
if (m_thread->joinable()) {
|
||
m_thread->join();
|
||
}
|
||
delete m_thread;
|
||
m_thread = nullptr;
|
||
}
|
||
//关闭文件
|
||
m_mtx.lock();
|
||
if (m_file) {
|
||
m_file->flush();
|
||
m_file->close();
|
||
delete m_file;
|
||
m_file = nullptr;
|
||
}
|
||
m_mtx.unlock();
|
||
cout << "日志析构函数完成" << endl;
|
||
}
|
||
|
||
void LogL::logThread() {
|
||
std::string str;
|
||
while (m_thread_run) {
|
||
//如果队列为空,等待
|
||
if (m_log_queue.empty()) {
|
||
std::unique_lock<std::mutex> lock(m_mtx);
|
||
m_cond_empty.wait(lock);
|
||
continue;
|
||
}
|
||
//取出队列头并出栈
|
||
str = m_log_queue.front();
|
||
m_log_queue.pop();
|
||
m_cond_full.notify_one();
|
||
switch (m_logType) {
|
||
case LTStd:
|
||
cout << str << endl;
|
||
break;
|
||
case LTTxt: {
|
||
if (m_file == nullptr) {
|
||
std::cerr << "logThread():日志文件打开失败" << endl;
|
||
break;
|
||
}
|
||
*m_file << str << endl;
|
||
break;
|
||
}
|
||
case LTUdp:
|
||
try {
|
||
m_sender->send(str);
|
||
}
|
||
catch (const std::runtime_error &e) {
|
||
std::cerr << e.what() << endl;
|
||
}
|
||
break;
|
||
case LTTcp:
|
||
break;
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
void LogL::debug(const std::string &str) {
|
||
log(str, LLDebug);
|
||
}
|
||
|
||
void LogL::info(const std::string &str) {
|
||
log(str, LLInfo);
|
||
}
|
||
|
||
void LogL::warn(const std::string &str) {
|
||
log(str, LLWarn);
|
||
}
|
||
|
||
void LogL::error(const std::string &str) {
|
||
log(str, LLError);
|
||
}
|
||
|
||
void LogL::log(const std::string &str, LogLevel level) {
|
||
if (level < m_logLevel) {
|
||
return;
|
||
}
|
||
string tmpLever;
|
||
switch (level) {
|
||
case LLDebug:
|
||
tmpLever = " [debug]:";
|
||
break;
|
||
case LLInfo:
|
||
tmpLever = " [info]:";
|
||
break;
|
||
case LLWarn:
|
||
tmpLever = " [warn]:";
|
||
break;
|
||
case LLError:
|
||
tmpLever = " [error]:";
|
||
break;
|
||
}
|
||
myDateTime now;
|
||
if (m_logType == LTTxt) {
|
||
//逾期更新日志文件
|
||
m_mtx.lock();
|
||
if (now.day != m_today) {
|
||
if (m_file) {
|
||
m_file->flush();
|
||
m_file->close();
|
||
delete m_file;
|
||
m_file = nullptr;
|
||
}
|
||
std::string dirName;
|
||
if (m_logPath.empty()) {
|
||
dirName = "log";
|
||
}
|
||
else {
|
||
dirName = m_logPath;
|
||
}
|
||
myMkdir(dirName.c_str());
|
||
std::string fileName =
|
||
dirName + "/" + now.toDate() + ".txt";
|
||
m_file = new std::ofstream(fileName, std::ios::app);
|
||
}
|
||
m_mtx.unlock();
|
||
}
|
||
std::string logInfo = now.toDateTime() + tmpLever + str;
|
||
if (m_isSync) {
|
||
switch (m_logType) {
|
||
case LTStd:
|
||
cout << logInfo << endl;
|
||
break;
|
||
case LTTxt: {
|
||
if (m_file == nullptr) {
|
||
std::cerr << "日志文件打开失败" << endl;
|
||
break;
|
||
}
|
||
*m_file << logInfo << endl;
|
||
break;
|
||
}
|
||
case LTUdp:
|
||
try {
|
||
m_sender->send(logInfo);
|
||
}
|
||
catch (const std::runtime_error &e) {
|
||
std::cerr << e.what() << endl;
|
||
}
|
||
break;
|
||
case LTTcp:
|
||
break;
|
||
}
|
||
}
|
||
else {
|
||
if (m_log_queue.size() >= 4096) {
|
||
std::unique_lock<std::mutex> lock(m_mtx);
|
||
m_cond_full.wait(lock);
|
||
}
|
||
m_mtx.lock();
|
||
m_log_queue.push(logInfo);
|
||
m_mtx.unlock();
|
||
m_cond_empty.notify_all();
|
||
}
|
||
}
|
||
|
||
|
||
bool createPath(const char *path) {
|
||
struct stat st = {0};
|
||
if (stat(path, &st) == -1) {
|
||
#if WIN32
|
||
if (mkdir(path) == 0) {
|
||
#else
|
||
if (mkdir(path, 0777) == 0) {
|
||
#endif
|
||
return true;
|
||
}
|
||
else {
|
||
std::cerr << "Failed to create directory: " << path << std::endl;
|
||
return false;
|
||
}
|
||
}
|
||
return true; // Directory already exists
|
||
}
|
||
|
||
bool myMkdir(const char *path) {
|
||
char buffer[1024];
|
||
char *p = buffer;
|
||
const char *sep = "/";
|
||
|
||
strcpy(buffer, path);
|
||
while ((p = strchr(p, *sep)) != nullptr) {
|
||
*p = '\0';
|
||
if (!createPath(buffer)) {
|
||
return false;
|
||
}
|
||
*p = *sep;
|
||
p++;
|
||
}
|
||
createPath(buffer);
|
||
return true;
|
||
}
|
||
|
||
myDateTime::myDateTime() {
|
||
auto now = std::chrono::system_clock::now();
|
||
std::time_t time1 = std::chrono::system_clock::to_time_t(now);
|
||
std::tm *tm1 = std::localtime(&time1);
|
||
year = tm1->tm_year + 1900;
|
||
month = tm1->tm_mon + 1;
|
||
day = tm1->tm_mday;
|
||
hour = tm1->tm_hour;
|
||
minute = tm1->tm_min;
|
||
second = tm1->tm_sec;
|
||
}
|
||
|
||
std::string myDateTime::toDate() const {
|
||
string date = to_string(year) + "-";
|
||
if (month < 10) {
|
||
date += "0" + to_string(month) + "-";
|
||
}
|
||
else {
|
||
date += to_string(month) + "-";
|
||
}
|
||
if (day < 10) {
|
||
date += "0" + to_string(day);
|
||
}
|
||
else {
|
||
date += to_string(day);
|
||
}
|
||
return date;
|
||
}
|
||
|
||
std::string myDateTime::toTime() const {
|
||
string time;
|
||
if (hour < 10) {
|
||
time += "0" + to_string(hour) + ":";
|
||
}
|
||
else {
|
||
time += to_string(hour) + ":";
|
||
}
|
||
if (minute < 10) {
|
||
time += "0" + to_string(minute) + ":";
|
||
}
|
||
else {
|
||
time += to_string(minute) + ":";
|
||
}
|
||
if (second < 10) {
|
||
time += "0" + to_string(second);
|
||
}
|
||
else {
|
||
time += to_string(second);
|
||
}
|
||
return time;
|
||
}
|
||
|
||
std::string myDateTime::toDateTime() const {
|
||
string dateTime = toDate() + " " + toTime();
|
||
return dateTime;
|
||
}
|