一、借用标準庫模闆構造自己的模闆
通常，模闆設計是遵循當對象的類型不影響類中函數的行為時就使用模闆。這也就是為何标準庫提供大部分的模闆都是與容器、疊代器、擴充卡、通用算法等有關，因為這些主要是除了對象集合行為，如讀寫、增删、周遊、排序、比較等大多與對象類型無關的邏輯行為。
在實際項目中，本人建議大家在使用模闆時，采用的最好模闆設計方式是走擴充卡方法，就像标準庫基于vector、list、deque這些基準容器，通過适配封裝去實作stack、queue、priority queue這些容器擴充卡一樣。我們根據自己項目需要，采用标準庫提供的容器及算法，建立自己的類模闆應用到項目中。
二、基于标準庫模闆建立自定義類模闆案例
2.1 自定義容器擴充卡
在本文中，将設計一個日志消息隊列的容器擴充卡，基于雙端隊列(deque)容器和互斥鎖，通過适配，建立一個線程安全的消息隊列類模闆。該消息隊列類通過二次封裝，實作資料末端添加資料，頭部取出資料，隊列大小有限制的跨線程安全消息緩沖區。
首先建立一個queuedata.h和queuedata.cpp源檔案，在queuedata.h檔案實作消息隊列類模闆進行聲明，在queuedata.cpp源檔案進行定義，在queuedata.h檔案末通過#include "queuedata.cpp"引用定義内容。本文中，QueueData類模闆雖然說類似容器擴充卡，但是沒有提供配套的疊代器iterator，大家感興趣的可以自行實作一下（就是将deque容器的疊代器iterator做一下中轉即可）。
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#ifndef _QUEUE_DATA_H_
#define _QUEUE_DATA_H_
/***********************************************************************
*Copyright 2023-02-06, pyfree
*
*File Name : queuedata.h
*File Mark :
*Summary :
*資料隊列類模闆,線程安全，對std::deque進行适配，通過PYMutex鎖限制線程安全，提供資料增删等功能接口
*
*Current Version : 1.00
*Author : pyfree
*FinishDate :
*
*Replace Version :
*Author :
*FinishDate :
************************************************************************/
#include <deque>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <string>
#include "Mutex.h"
template <class T>
class QueueData
{
public:
QueueData(std::string desc = "thread_queue");
~QueueData();
//
/**
* 擷取隊列大小
* @return {int } 隊列大小
*/
int size();
/**
* 判定隊列是否為空
* @return {bool } 是否為空隊列
*/
bool isEmpty();
/**
* 擷取隊列頭元素
* @param it {T&} 頭元素
* @return {bool } 是否成功
*/
bool getFirst(T &it);
/**
* 删除元素
* @return {bool } 是否成功
*/
bool removeFirst();
/**
* 擷取隊列頭元素，并從隊列終删除
* @param it {T&} 頭元素
* @return {bool } 是否成功
*/
bool pop(T &it);
/**
* 從隊列頭開始逐漸擷取多個元素，并剔除
* @param its {queue<T>&} 擷取到的元素集
* @param sizel {int} 一次擷取多少個
* @return {bool } 至少擷取一個元素以上則成功
*/
bool getList(std::queue<T> &its,unsigned int sizel=5);
/**
* 從隊列尾部添加元素
* @param it {T} 被添加元素
* @return {void } 無傳回
*/
void add(T it);
/**
* 從隊列頭部添加元素
* @param it {T} 被添加元素
* @return {void } 無傳回
*/
void add_front(T it);
/**
* 清空元素
* @return {void }
*/
void clear();
private:
void init();
QueueData& operator=(const QueueData&) {return this;};
protected:
std::string queue_desc;
private:
/點集轉發
//協定解析結果緩存
std::deque<T> datacache_queue; //隊列容器
PYMutex m_Mutex; //線程鎖,或者如果更徹底采用acl庫,采用acl::thread_mutex替代
//
static unsigned int QSize; //隊列大小限制,超出是會從隊列頭剔除舊資料騰出空位在對末添加資料
//
int queue_overS; //隊列溢出次數計數
};
#include "queuedata.cpp"
#endif //_QUEUE_DATA_H_
2.2 非類型模闆參數的結構體模闆
傳入消息隊列類的資訊是一個非類型模闆參數的結構體模闆，可以根據實際項目需要選擇消息緩存區最大位元組數。建立LogDef.h源檔案，實作消息結構體模闆，并定義日志等級枚舉值。該結構體在定義對象時可以采用預設的方法MyLogStruct<> obj，也可以指定大小MyLogStruct<DATA_SIZE_MAX_LEVLE2> obj，或指定任意值作為緩存區域大小，MyLogStruct<100> obj。
#ifndef _LOG_DEF_H_
#define _LOG_DEF_H_
/***********************************************************************
*Copyright 2023-02-06, pyfree
*
*File Name : LogDef.h
*File Mark :
*Summary : Log線程類使用到的日志等級枚舉類型，日志資訊格式-用于日志緩沖區存放日志的結構體
*
*Current Version : 1.00
*Author : pyfree
*FinishDate :
*
*Replace Version :
*Author :
*FinishDate :
************************************************************************/
#ifdef __linux__
#include <string.h>
#endif
typedef enum eLogType
{
eLog_DEBUG = 1,
eLog_TRACE = 2,
eLog_NOTICE = 3,
eLog_WARNING = 4,
eLog_ERROR = 5
}LogLevel;
#define DATA_SIZE_MAX_LEVLE1 1024 //日志緩存資訊空間大小(1024位元組)
#define DATA_SIZE_MAX_LEVLE2 512 //日志緩存資訊空間大小(512位元組)
#define DATA_SIZE_MAX_LEVLE3 256 //日志緩存資訊空間大小(256位元組)
//日志緩存資訊結構體,采用結構體預設指派
template<int SIZE = DATA_SIZE_MAX_LEVLE3>
struct MyLogStruct
{
MyLogStruct():type(0)
{
memset(szBuffer, 0, SIZE);
};
int type;
char szBuffer[SIZE];
};
#endif //_LOG_DEF_H_
2.3 日志記錄類設計
下來就是日志記錄功能部分，創一個日志類，該類有一個QueueData<MyLogStruct<> > logs_cache對象用來緩存日志。該日志類還是一個單體模式設計，并繼承一個線程類。線程循環體内，日志對象會不斷去讀取緩存區内的日志資訊，如果讀取到資訊，就寫入到日志檔案内。另外，為了方式日志記錄過大造成磁盤存儲空間不足，将有一個DiskSpaceMgr類對象來定期巡檢磁盤剩餘空間，在存儲空間不足時，去删除舊的日志資訊。
建立Log.h和Log.cpp源檔案，Log.h源檔案如下：
#ifndef _CLOGGER_H_
#define _CLOGGER_H_
/***********************************************************************
*Copyright 2023-02-06, pyfree
*
*File Name : Log.h
*File Mark :
*Summary : Log寫入獨立線程類，提供添加日志資訊進入緩存接口，自身不斷從緩存讀取日志資訊寫入檔案
* 會啟動一個磁盤空間管理線程對象DiskSpaceMgr，在磁盤空間不足時，删除舊日志
*
*Current Version : 1.00
*Author : pyfree
*FinishDate :
*
*Replace Version :
*Author :
*FinishDate :
************************************************************************/
#include "myThread.h"
#include "LogDef.h"
#include "queuedata.h"
class DiskSpaceMgr;
class CLogger : public MyThread
{
public:
void Log(const eLogType type, const char* lpszFormat, ...);
static CLogger* createInstance( void );
private:
CLogger();
~CLogger();
int Run();
void WriteLog( const int iMsgType, const char * strMsg);
void WriteLogToFile( std::string strPath,std::string strTime,const char * strMsg);
std::string createFileName(std::string strTime_);
std::string strTime();
std::string createLogTimeAndTypeDesc(const unsigned int iMsgType, std::string strTime_);
private:
static CLogger* m_pLogInstance;
bool running;
FILE * fpLog;
std::string cur_log_path;
//for cache
QueueData<MyLogStruct<> > logs_cache;
//
DiskSpaceMgr *disk_space_mgr;
};
#endif //_CLOGGER_H_
2.4 磁盤剩餘空間管理類
對象DiskSpaceMgr *disk_space_mgr是由Logger類建立的，該磁盤空間管理類是繼承了類線程類的，線上程循環體内，不間斷地巡檢指定磁盤的剩餘空間是否小于限定空間大小，小于時，将按配置要求去删除舊的日志資訊。
建立spaceMgr.h和spaceMgr.cpp源檔案，spaceMgr.h内容如下：
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#ifndef _SPACE_MGR_H_
#define _SPACE_MGR_H_
/***********************************************************************
*Copyright 2023-02-06, pyfree
*
*File Name : spaceMgr.h
*File Mark :
*Summary : 磁盤空間巡檢線程類，根據預留白間要求删除app日志檔案
*
*Current Version : 1.00
*Author : pyfree
*FinishDate :
*
*Replace Version :
*Author :
*FinishDate :
************************************************************************/
#ifdef linux
#include <string>
#endif
#include <vector>
#include "myThread.h"
class DiskSpaceMgr : public MyThread
{
public:
/**
* 構造函數,如傳入參數D 2000 log log,則指明當D盤空閑空間不足2000M時,删除目前目錄/log下的log(字尾)檔案
* @param disk_ {char} 指定盤符
* @param fsl_ {int} 預留白間大小,機關MB
* @param dir_ {string} 指定目錄
* @param ext_ {string} 擴充名
* @return { }
*/
DiskSpaceMgr(char disk_, int fsl_,std::string dir_="log",std::string ext_="log");
virtual ~DiskSpaceMgr(void);
int Run();
void add(std::string dir_,std::string ext_);
private:
struct DelInfo
{
DelInfo(std::string dir_,std::string ext_)
: dir(dir_), ext(ext_)
{};
std::string dir;
std::string ext;
};
private:
//用于日志删除
std::vector<DelInfo> dirs; //存儲目錄
char DiskStr; //日志存儲磁盤
int freeSizeLimit; //磁盤預留白間要求
};
#endif
2.5 其他輔助類及函數設計
日志類及磁盤管理類都繼承了線程類MyThread，是通過myThread.h和myThread.cpp聲明定義的，myThread.h内容如下：
#ifndef _MYTHREAD_H
#define _MYTHREAD_H
/***********************************************************************
*Copyright 2023-02-06, pyfree
*
*File Name : myThread.h
*File Mark :
*Summary :
*支援windows和linux的線程類,提供基本的線程功能(循環、啟動、退出)
*
*Current Version : 1.00
*Author : pyfree
*FinishDate :
*
*Replace Version :
*Author :
*FinishDate :
************************************************************************/
#ifdef WIN32
#include <process.h>
#include <iostream>
typedef void* HANDLE_THREAD;
#else
#include <pthread.h>
#include <unistd.h>
typedef pthread_t HANDLE_THREAD;
#endif
class MyThread
{
public://func
MyThread(); // constructed function
~MyThread();
/**
* the entity for thread running
* @param null {void } 無參數
* @return {int} 運作傳回結果
*/
virtual int Run()=0;
/**
* start thread
* @param null {void } 無參數
* @return {bool} 是否啟動成功
*/
bool start();
/**
* get thread ID
* @param null {void } 無參數
* @return {HANDLE_THREAD} 線程句柄
*/
HANDLE_THREAD getThreadID();
#ifdef __linux__
//get thread status
int getState();
//wait for thread end
void join();
//wait for thread end in limit time
void join(unsigned long millisTime);
#endif
public://val
#ifdef __linux__
//threadStatus-new create
static const int THREAD_STATUS_NEW = 0;
//threadStatus-running
static const int THREAD_STATUS_RUNNING = 1;
//threadStatus-end
static const int THREAD_STATUS_EXIT = -1;
#endif
private://func
#ifdef WIN32
static void agent(void *p);
#else
//get manner pointer of execution
static void* run0(void* pVoid);
//manner of execution inside
void* run1();
#endif
private://val
HANDLE_THREAD hThread;
#ifdef __linux__
//thread status
int threadStatus;
#endif
};
#endif /* _MYTHREAD_H */
消息隊列類在隊列内容進行變更時，需要通過互斥鎖確定跨線程操作安全，互斥鎖是由Mutex.h和Mutex.cpp源檔案聲明定義的，Mutex.h内容如下：
#ifndef PYMUTEX_H
#define PYMUTEX_H
#ifdef WIN32
//#include <windows.h>
#else
#include <pthread.h>
#endif
typedef void *HANDLE;
class IMutex
{
public:
virtual ~IMutex() {}
virtual void Lock() const = 0;
virtual bool TryLock() const = 0;
virtual void Unlock() const = 0;
};
class PYMutex : public IMutex
{
public:
PYMutex();
~PYMutex();
virtual void Lock() const;
virtual bool TryLock() const;
virtual void Unlock() const;
private:
#ifdef _WIN32
HANDLE m_mutex;
#else
mutable pthread_mutex_t m_mutex;
#endif
};
#endif //PYMUTEX_H
磁盤管理類，在進行磁盤資訊讀取和檔案删除時，是借用了DiskSpace.h和DiskSpace.cpp源檔案聲明定義的磁盤空間統計和日志删除相關函數集來實作的，DiskSpace.h内容如下：
#ifndef DISK_SPACE_H
#define DISK_SPACE_H
/***********************************************************************
*Copyright 2023-02-06, pyfree
*
*File Name : DiskSpace.h
*File Mark :
*Summary :
*磁盤空間統計和日志删除相關函數集
*Current Version : 1.00
*Author : pyfree
*FinishDate :
*
*Replace Version :
*Author :
*FinishDate :
************************************************************************/
#include <string>
namespace pyfree
{
/**
* 根據指定磁盤擷取磁盤的總空間和剩餘空間
* @param _DiskStr {char} 磁盤目錄,一般win指定{C,D},linux指定{/}
* @param _totalSize {int} 傳回磁盤總空間
* @param _freeSize {int} 傳回磁盤剩餘空間
* @return {int} 預留的傳回值,暫指定是常量1
*/
int getDiskFreeSpace(char _DiskStr, int &_totalSize, int &_freeSize);
/**
* 根據指定目錄 擴充名 天數限制等删除目錄下的檔案,項目用于删除舊日志操作
* @param _dir {string}} 目錄
* @param extname {string} 擴充名,如txt/ini/log等
* @param dayForLimit_ {int} 指定天數，預設為0時會删除非當天的其他檔案
* @return {void} 無傳回
*/
void moveOldFile(std::string _dir, const std::string &extname, int dayForLimit_=0);
/**
* 擷取當天淩晨時刻的偏移時間,機關秒,與1970-01-01 00:00:00起
* @param deviation {int} 偏移秒數
* @return {int} 當天淩晨時刻的偏移時間.機關秒
*/
int getCurDayZeroClockTime(int deviation=0);
};
#endif
三、工程結構及程式設計測試
3.1 工程目錄結構
按上述源檔案設計，給出組織這些源檔案的工程目錄結構：
log_test
bin #測試程式輸出
build_win #win編譯中間檔案存儲
build_linux #Linux編譯中間檔案存儲
src
DiskSpace.h #磁盤通路、檔案删除等功能實作
DiskSpace.cpp
Log.h #日志類，單體模式，繼承線程類
Log.cpp
LogDef.h #日志資訊定義
Mutex.h #互斥鎖
Mutex.cpp
myThread.h #線程類
myThread.cpp
pysleep.h #線程睡眠等待統一宏轉換設計
queuedata.h #消息隊列類模闆
queuedata.cpp
spaceMgr.h #磁盤空間管理類，繼承線程類
spaceMgr.cpp
test
main.cpp #測試程式代碼
CMakeLists.txt #cmake工程
compile.txt #工程編譯指令
3.2 cmake工程配置
CMakeLists.txt，cmake工程配置檔案
# CMake 最低版本号要求
cmake_minimum_required (VERSION 2.8)
# 項目資訊
project (log_test)
#
if(WIN32)
message(STATUS "windows compiling...")
add_definitions(-D_PLATFORM_IS_WINDOWS_)
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
set(WIN_OS true)
else(WIN32)
message(STATUS "linux compiling...")
add_definitions( -D_PLATFORM_IS_LINUX_)
add_definitions("-Wno-invalid-source-encoding")
# add_definitions("-O2")
set(UNIX_OS true)
set(_DEBUG true)
endif(WIN32)
#
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
# 指定源檔案的目錄,并将名稱儲存到變量
SET(source_h
${PROJECT_SOURCE_DIR}/src/pysleep.h
${PROJECT_SOURCE_DIR}/src/Mutex.h
${PROJECT_SOURCE_DIR}/src/myThread.h
${PROJECT_SOURCE_DIR}/src/queuedata.h
${PROJECT_SOURCE_DIR}/src/LogDef.h
${PROJECT_SOURCE_DIR}/src/Log.h
${PROJECT_SOURCE_DIR}/src/DiskSpace.h
${PROJECT_SOURCE_DIR}/src/spaceMgr.h
)
SET(source_cpp
#
${PROJECT_SOURCE_DIR}/src/Mutex.cpp
${PROJECT_SOURCE_DIR}/src/myThread.cpp
${PROJECT_SOURCE_DIR}/src/Log.cpp
${PROJECT_SOURCE_DIR}/src/DiskSpace.cpp
${PROJECT_SOURCE_DIR}/src/spaceMgr.cpp
${PROJECT_SOURCE_DIR}/test/main.cpp
)
#頭檔案目錄
include_directories(${PROJECT_SOURCE_DIR}/src)
if (${UNIX_OS})
add_definitions(
"-W"
"-fPIC"
"-Wall"
# "-Wall -g"
"-Werror"
"-Wshadow"
"-Wformat"
"-Wpointer-arith"
"-D_REENTRANT"
"-D_USE_FAST_MACRO"
"-Wno-long-long"
"-Wuninitialized"
"-D_POSIX_PTHREAD_SEMANTICS"
"-DACL_PREPARE_COMPILE"
"-Wno-unused-parameter"
"-fexceptions"
)
set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -O0")
link_directories()
# 指定生成目标
add_executable(log_test ${source_h} ${source_cpp})
#link
target_link_libraries(log_test
-lpthread -pthread -lz -lrt -ldl
)
endif(${UNIX_OS})
if (${WIN_OS})
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4819")
add_definitions(
"-D_CRT_SECURE_NO_WARNINGS"
"-D_WINSOCK_DEPRECATED_NO_WARNINGS"
"-DNO_WARN_MBCS_MFC_DEPRECATION"
"-DWIN32_LEAN_AND_MEAN"
)
link_directories()
if (CMAKE_BUILD_TYPE STREQUAL "Debug")
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${PROJECT_SOURCE_DIR}/bin)
# 指定生成目标
add_executable(log_testd ${source_h} ${source_cpp})
else(CMAKE_BUILD_TYPE)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${PROJECT_SOURCE_DIR}/bin)
# 指定生成目标
add_executable(log_test ${source_h} ${source_cpp})
endif (CMAKE_BUILD_TYPE)
endif(${WIN_OS})
compile.txt，編譯指令訓示檔案
win:
cd log_test && mkdir build_win && cd build_win
cmake -G "Visual Studio 10 2010 Win64" -DCMAKE_BUILD_TYPE=Release ..
msbuild log_test.sln /p:Configuration="Release" /p:Platform="x64"
cmake -G "Visual Studio 10 2010 Win64" -DCMAKE_BUILD_TYPE=Debug ..
msbuild log_test.sln /p:Configuration="Debug" /p:Platform="x64"
Linux:
cd log_test
mkdir build_linux
cd build_linux
cmake ..
make
3.3 日志類調用，測試案例
測試工程檔案main.cpp：
#include <stdio.h>
#include <stdlib.h>
#include "pysleep.h"
#include "Log.h"
namespace GlobalVar {
extern char disk_DescStr; //磁盤名
extern unsigned int disk_space_limit; //剩餘空間限制為*MB
extern std::string logdir; //後期記錄日志目錄重配置檔案讀取
extern std::string logname; //可設定為服務名
extern std::string log_ext_flag; //日志擴充名
};
//log_test.exe D 2000 log log
//log_test.exe D
void arg_analysis(int argc, char *argv[]);
int main(int argc, char *argv[])
{
arg_analysis(argc,argv);
int i = 0;
while(i<100)
{
CLogger::createInstance()->Log(LogLevel(rand()%5),"log test for [%d]",i++);
pysleep(10);
}
//while(1){pysleep(10);}
return 0;
}
void arg_analysis(int argc, char *argv[])
{
for(int index=0; index<argc; index++)
{
switch(index)
{
case 0:
{
#ifdef WIN32
std::string appname = std::string(argv[0]);
GlobalVar::logname = appname.substr(0,appname.length()-4);
#else
GlobalVar::logname = std::string(argv[0]);
#endif
}
break;
case 1:
{
GlobalVar::disk_DescStr = argv[1][0];
}
break;
case 2:
{
GlobalVar::disk_space_limit = static_cast<unsigned int>(atoi(argv[2]));
}
break;
case 3:
{
GlobalVar::logdir = std::string(argv[3]);
}
break;
case 4:
{
GlobalVar::log_ext_flag = std::string(argv[4]);
}
break;
default:
break;
}
}
}
3.4 編譯及測試
win:
linux:
四、補充源碼
部分源碼前面已經給出（頭檔案），下面給出其他源碼檔案：
pysleep.h
#ifndef _PY_SLEEEP_H_
#define _PY_SLEEEP_H_
#ifdef WIN32
#include <windows.h>
#define pysleep(x) Sleep(x)
#else
#define pysleep(x) usleep(1000*x)
#endif
#endif //_PY_SLEEEP_H_
DiskSpace.cpp
#include "DiskSpace.h"
#include <time.h>
#include <list>
#include <vector>
#ifdef WIN32
#include <io.h>
#include <direct.h>
#include <Windows.h>
#else
#include <sys/statfs.h>
#include <dirent.h>
/*#include <sys/vfs.h> or <sys/statfs.h> */
#include <sys/vfs.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
#endif
#include "Log.h"
int pyfree::getDiskFreeSpace(char _DiskStr, int &_totalSize, int &_freeSize)
{
#ifdef WIN32
BOOL fResult;
unsigned _int64 i64FreeBytesToCaller;
unsigned _int64 i64TotalBytes;
unsigned _int64 i64FreeBytes;
char dir[4] = { _DiskStr, ':', '\\' };
fResult = GetDiskFreeSpaceEx(
dir,
(PULARGE_INTEGER)&i64FreeBytesToCaller,
(PULARGE_INTEGER)&i64TotalBytes,
(PULARGE_INTEGER)&i64FreeBytes);
//GetDiskFreeSpaceEx function,get the disk space status,return BOOL type
if (fResult)//jude the disk is in work status by the return value
{
_totalSize = static_cast<int>(static_cast<float>(i64TotalBytes) / 1024 / 1024);
_freeSize = static_cast<int>(static_cast<float>(i64FreeBytesToCaller) / 1024 / 1024);
//std::cout << " totalspace:" << _totalSize << " MB" << std::endl;//disk total size
//std::cout << " freespace:" << _freeSize << " MB" << std::endl;//disk free space sze
}
#endif // WIN32
#ifdef __linux__
//printf("DiskFlag(%c)\n", _DiskStr);
struct statfs diskInfo;
statfs("/", &diskInfo);
unsigned long long totalBlocks = diskInfo.f_bsize;
unsigned long long totalSize = totalBlocks * diskInfo.f_blocks;
_totalSize = static_cast<int>(totalSize >> 20);
//printf("TOTAL_SIZE == %d MB\n", _totalSize);
unsigned long long freeDisk = diskInfo.f_bfree*totalBlocks;
_freeSize = static_cast<int>(freeDisk >> 20);
//printf("DISK_FREE == %d MB\n", _freeSize);
#endif
return 1;
}
//delete old file which is older taday for the file modify time
void pyfree::moveOldFile(std::string _dir, const std::string &extname, int dayForLimit_)
{
try{
#ifdef WIN32
_finddata_t fileInfo;
intptr_t hFile;
std::string filter = _dir;
if (filter[filter.size() - 1] != '//' || filter[filter.size() - 1] != '\\') {
filter.push_back('\\');
}
filter += "*.";
filter += extname;
//time_t file_time_ = time(NULL);
time_t file_time_ = (time_t)getCurDayZeroClockTime(dayForLimit_*86400);
//get
hFile = _findfirst(filter.c_str(), &fileInfo);
if (hFile == -1) {
return;
}
std::string delOldFile = "";
//find the oldest file by modify time
do {
if (extname.empty())//no ext name, that is dir
{
if ((fileInfo.attrib & _A_SUBDIR)) {
if (0 == strcmp(fileInfo.name, ".") || 0 == strcmp(fileInfo.name, ".."))
{
continue;
}
}
}
//if(fileInfo.time_write<_time)//modify time
if (fileInfo.time_create<file_time_)//create time
{
file_time_ = fileInfo.time_create;
delOldFile = _dir + "//" + (std::string(fileInfo.name));
}
} while (_findnext(hFile, &fileInfo) == 0);
_findclose(hFile);
#endif
#ifdef linux
//printf("moveOldFile(*.%s) 1 from(%s) \n",extname.c_str(),_dir.c_str());
std::string curdir = _dir;
if (curdir[curdir.size() - 1] != '/') {
curdir.push_back('/');
}
DIR *dfd;
if ((dfd = opendir(curdir.c_str())) == NULL)
{
CLogger::createInstance()->Log(eLog_WARNING,"open %s error with msg is: %s\n", curdir.c_str(), strerror(errno));
return;
}
struct dirent *dp;
//time_t file_time_ = time(NULL);
time_t file_time_ = (time_t)getCurDayZeroClockTime(dayForLimit_ * 86400);
std::string delOldFile = "";
while ((dp = readdir(dfd)) != NULL)
{
if (extname.empty())//no ext name, that is dir
{
if (dp->d_type == DT_DIR) {
if (0 == strcmp(dp->d_name, ".") || 0 == strcmp(dp->d_name, ".."))
{
continue;
}
}
}
else {
if (NULL == strstr(dp->d_name, extname.c_str()))
{
continue;
}
}
std::string _path = _dir + "/";
_path += dp->d_name;
struct stat el;
stat(_path.c_str(), &el);
if (el.st_mtime<file_time_) {
file_time_ = el.st_mtime;
delOldFile = _path;
}
}
if (NULL != dp) {
delete dp;
dp = NULL;
}
if (NULL != dfd) {
closedir(dfd);
dfd = NULL;
}
#endif
if (!delOldFile.empty())
{
//printf("get old file: %s \n", delOldFile.c_str());
int ret = remove(delOldFile.c_str());
if (0 != ret) {
CLogger::createInstance()->Log(eLog_WARNING,"can't remove %s \n", delOldFile.c_str());
}else{
CLogger::createInstance()->Log(eLog_NOTICE,"success remove %s \n", delOldFile.c_str());
}
}
}catch(...){
CLogger::createInstance()->Log(eLog_ERROR,"moveOldFile(*.%s) from(%s) exception error\n"
,extname.c_str(),_dir.c_str());
}
}
int pyfree::getCurDayZeroClockTime(int deviation)
{
int ZeroClockTime_ = 0;
time_t cur_time_ = time(NULL);
struct tm _tt;
#ifdef WIN32
localtime_s(&_tt, &cur_time_);
#else
localtime_r(&cur_time_,&_tt);
#endif
//當日淩晨時刻
_tt.tm_hour = 0;
_tt.tm_min = 0;
_tt.tm_sec = 0;
ZeroClockTime_ = static_cast<int>(mktime(&_tt));
ZeroClockTime_ -= deviation;//偏移時間
return ZeroClockTime_;
}
Log.cpp
#include "Log.h"
#include <time.h>
#include <sys/timeb.h>
#include <stdio.h>
#include <stdarg.h>
#include <string>
#ifdef __linux__
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#ifndef sprintf_s
#define sprintf_s sprintf
#endif
#else //WIN32
#ifndef vsnprintf
#define vsnprintf vsnprintf_s
#endif
#endif
#include "pysleep.h"
#include "spaceMgr.h"
namespace GlobalVar
{
char disk_DescStr = 'D'; //磁盤名
unsigned int disk_space_limit = 2000; //剩餘空間限制為*MB,少于該值去删除日志釋放空間
std::string logdir = "log"; //後期記錄日志目錄重配置檔案讀取
std::string logname = "pyfree"; //可設定為服務名
std::string log_ext_flag = "log";//日志擴充名
};
CLogger* CLogger::m_pLogInstance = NULL;
CLogger::CLogger()
: running(true)
, fpLog(NULL)
, cur_log_path("log")
{
char buf[256] = {0};
sprintf_s(buf,"mkdir %s",GlobalVar::logdir.c_str());
system(buf);
this->start();
disk_space_mgr = new DiskSpaceMgr(GlobalVar::disk_DescStr
,GlobalVar::disk_space_limit,GlobalVar::logdir,GlobalVar::log_ext_flag);
disk_space_mgr->start();
};
CLogger::~CLogger()
{
delete disk_space_mgr;
disk_space_mgr = NULL;
running = false;
if (NULL != fpLog)
{
fclose(fpLog);
fpLog = NULL;
}
};
CLogger* CLogger::createInstance( void )
{
if (m_pLogInstance == NULL)
{
m_pLogInstance = new CLogger();
return m_pLogInstance;
}
else
return m_pLogInstance;
};
int CLogger::Run()
{
MyLogStruct<> log_item;
while (running)
{
if(logs_cache.pop(log_item))
{
WriteLog(log_item.type, log_item.szBuffer);
#ifdef _DEBUG
#ifndef WIN32
printf("Log::[%d]-->%s\n", getpid(), log_item.szBuffer);
#else
printf("Log::-->%s\n", log_item.szBuffer);
#endif //WIN32
#endif //_DEBUG
}
pysleep(1);
}
return 0;
};
void CLogger::Log(const eLogType type, const char* lpszFormat, ...)
{
va_list args;
MyLogStruct<> log_item;
log_item.type = static_cast<int>(type);
va_start(args, lpszFormat);
vsnprintf(log_item.szBuffer, sizeof(log_item.szBuffer), lpszFormat, args);
va_end(args);
logs_cache.add(log_item);
}
void CLogger::WriteLog( const int iMsgType, const char * strMsg)
{
try {
//system time to string
std::string strTime_ = strTime();
//file name
std::string strPath = createFileName(strTime_.substr(0,10));
// log time and type desc
std::string strTimeAndTypeDesc = createLogTimeAndTypeDesc(iMsgType, strTime_);
WriteLogToFile(strPath,strTimeAndTypeDesc,strMsg);
}
catch (...) {
printf("write log[%d]{%s}error\n", iMsgType, strMsg);
}
}
void CLogger::WriteLogToFile( std::string strPath,std::string strTime_,const char * strMsg)
{
if(cur_log_path!=strPath||NULL == fpLog)
{
if (NULL != fpLog)
{
fclose(fpLog);
fpLog = NULL;
}
//open
#ifdef WIN32
fopen_s(&fpLog, strPath.c_str(), "a+");
#else
fpLog = fopen(strPath.c_str(), "a+");
#endif
}
if (NULL != fpLog)
{
fseek(fpLog, 0, SEEK_END);
fwrite(strTime_.c_str(), strTime_.length(), 1, fpLog);
fwrite(strMsg, strlen(strMsg), 1, fpLog);
fwrite("\n", 1, 1, fpLog);
}
}
std::string CLogger::createFileName(std::string strTime_)
{
//file name
std::string strPath = GlobalVar::logdir;
#ifdef WIN32
strPath += "\\";
#else
strPath += "/";
#endif
strPath += strTime_;
strPath += "_";
strPath += GlobalVar::logname;
strPath += ".log";
return strPath;
}
std::string CLogger::strTime()
{
time_t tt;
struct timeb tm0;
struct tm tm1;
char buf[64];
ftime(&tm0);
tt = tm0.time;
#ifdef WIN32
localtime_s(&tm1, &tt);
#else
localtime_r(&tt, &tm1);
#endif
sprintf_s(buf, "%04d-%02d-%02d %02d:%02d:%02d.%03d "
, tm1.tm_year + 1900, tm1.tm_mon + 1, tm1.tm_mday
, tm1.tm_hour, tm1.tm_min, tm1.tm_sec, tm0.millitm);
std::string strTime_ = buf;
buf[10] = '\0';
return strTime_;
}
//日志等級枚舉值的字元串描述
std::string eLogTypeDesc[6] = {
"[UNKNOWN] ",
"[eLog_DEBUG] ",
"[eLog_TRACE] ",
"[eLog_NOTICE] ",
"[eLog_WARNING] ",
"[eLog_ERROR] "};
std::string CLogger::createLogTimeAndTypeDesc(const unsigned int iMsgType, std::string strTime_)
{
std::string strTimeAndTypeDesc = strTime_;
unsigned int msg_type = iMsgType;
if(msg_type>6) msg_type = 0; //非枚舉值外的均為未知
strTimeAndTypeDesc += eLogTypeDesc[msg_type];
return strTimeAndTypeDesc;
};
/*以下是LogFunction*/
/*
*在queuedata.cpp中應用,該函數主要用來解決QueueData類嵌套調用CLogger的異常問題：
*“嵌套名指定中使用了不完全的類型”
*/
void reportLogCacheOver(const char *queue_desc,int size)
{
//每溢出10次，報告一次
CLogger::createInstance()->Log(eLog_WARNING,
"add item to queue %s, but the size of QueueData is up to limmit size: %d.\n"
, queue_desc, size);
}
Mutex.cpp
#include "Mutex.h"
#ifdef WIN32
#include <windows.h>
#endif
//#include <iostream>
#include <stdio.h>
PYMutex::PYMutex()
{
#ifdef _WIN32
m_mutex = ::CreateMutex(NULL, FALSE, NULL);
#else
pthread_mutex_init(&m_mutex, NULL);
#endif
}
PYMutex::~PYMutex()
{
#ifdef _WIN32
::CloseHandle(m_mutex);
#else
pthread_mutex_destroy(&m_mutex);
#endif
}
void PYMutex::Lock() const
{
#ifdef _WIN32
//DWORD d = WaitForSingleObject(m_mutex, INFINITE);
WaitForSingleObject(m_mutex, INFINITE);
/// \todo check 'd' for result
#else
pthread_mutex_lock(&m_mutex);
#endif
}
bool PYMutex::TryLock() const
{
#ifdef _WIN32
DWORD dwWaitResult = WaitForSingleObject(m_mutex, 0);
if (dwWaitResult != WAIT_OBJECT_0 && dwWaitResult != WAIT_TIMEOUT) {
printf("thread WARNING: bad result from try-locking mutex\n");
}
return (dwWaitResult == WAIT_OBJECT_0) ? true : false;
#else
return (0==pthread_mutex_trylock(&m_mutex))?true:false;
#endif
};
void PYMutex::Unlock() const
{
#ifdef _WIN32
::ReleaseMutex(m_mutex);
#else
pthread_mutex_unlock(&m_mutex);
#endif
}
myThread.cpp
#include "myThread.h"
#ifdef WIN32
#include <windows.h>
#else
#include <stdio.h>
#endif
MyThread::MyThread()
{
#ifdef __linux__
hThread = 0;
threadStatus = THREAD_STATUS_NEW;
#endif
}
MyThread::~MyThread()
{
#ifdef WIN32
WaitForSingleObject(hThread, INFINITE);
#else
join(10);
#endif
}
int MyThread::Run()
{
#ifdef WIN32
printf("Base Thread\n");
#else
while(true){
printf("thread is running!\n");
sleep(100);
}
#endif
return 0;
}
bool MyThread::start()
{
#ifdef WIN32
return NULL!=(hThread =(HANDLE_THREAD)_beginthread(agent, 0, (void *)this));
#else
return pthread_create(&hThread, NULL, run0, this) == 0;
#endif
}
HANDLE_THREAD MyThread::getThreadID()
{
return hThread;
}
#ifdef WIN32
void MyThread::agent(void *p)
{
MyThread *agt = (MyThread *)p;
agt->Run();
}
#else
void* MyThread::run0(void* pVoid)
{
MyThread* p = (MyThread*) pVoid;
p->run1();
return p;
}
void* MyThread::run1()
{
threadStatus = THREAD_STATUS_RUNNING;
hThread = pthread_self();
Run();
threadStatus = THREAD_STATUS_EXIT;
hThread = 0;
pthread_exit(NULL);
}
int MyThread::getState()
{
return threadStatus;
}
void MyThread::join()
{
if (hThread > 0)
{
pthread_join(hThread, NULL);
}
}
void MyThread::join(unsigned long millisTime)
{
if (hThread == 0)
{
return;
}
if (millisTime == 0)
{
join();
}else
{
unsigned long k = 0;
while (threadStatus != THREAD_STATUS_EXIT && k <= millisTime)
{
usleep(100);
k++;
}
}
}
#endif
queuedata.cpp
#include "queuedata.h"
#include "LogDef.h"
#include "Log.h"
extern void reportLogCacheOver(const char*,int);
template <class T>
unsigned int QueueData<T>::QSize = 100;
template <class T>
QueueData<T>::QueueData(std::string desc)
: queue_desc(desc)
{
init();
};
template <class T>
void QueueData<T>::init()
{
queue_overS = 0;
};
template <class T>
QueueData<T>::~QueueData()
{
}
//
template <class T>
int QueueData<T>::size()
{
int ret = 0;
m_Mutex.Lock();
ret = static_cast<int>(datacache_queue.size());
m_Mutex.Unlock();
return ret;
}
template <class T>
bool QueueData<T>::isEmpty()
{
bool ret = false;
m_Mutex.Lock();
ret = datacache_queue.empty();
m_Mutex.Unlock();
return ret;
}
template <class T>
bool QueueData<T>::getFirst(T &it)
{
bool ret = false;
m_Mutex.Lock();
if (!datacache_queue.empty())
{
it = datacache_queue.front();
ret = true;
}
m_Mutex.Unlock();
return ret;
}
template <class T>
bool QueueData<T>::removeFirst()
{
bool ret = false;
m_Mutex.Lock();
if (!datacache_queue.empty())
{
datacache_queue.pop_front();
ret = true;
}
m_Mutex.Unlock();
return ret;
}
template <class T>
bool QueueData<T>::pop(T &it)
{
bool ret = false;
m_Mutex.Lock();
if (!datacache_queue.empty())
{
it = datacache_queue.front();
datacache_queue.pop_front();
ret = true;
}
m_Mutex.Unlock();
return ret;
};
template <class T>
bool QueueData<T>::getList(std::queue<T> &its,unsigned int sizel)
{
m_Mutex.Lock();
while (!datacache_queue.empty())
{
its.push(datacache_queue.front());
datacache_queue.pop_front();
if (its.size() >= sizel)
{
break;
}
}
m_Mutex.Unlock();
return !its.empty();
};
template <class T>
void QueueData<T>::add(T it)
{
m_Mutex.Lock();
if (datacache_queue.size() > QSize)
{
queue_overS++;
datacache_queue.pop_front();
}
datacache_queue.push_back(it);
m_Mutex.Unlock();
if (queue_overS >= 10)
{
//每溢出10次，報告一次
reportLogCacheOver(queue_desc.c_str(),QSize);
queue_overS = 0;
}
}
template <class T>
void QueueData<T>::add_front(T it)
{
m_Mutex.Lock();
if (datacache_queue.size() > QSize)
{
queue_overS++;
datacache_queue.pop_front();
}
datacache_queue.push_front(it);
m_Mutex.Unlock();
if (queue_overS >= 10)
{
reportLogCacheOver(queue_desc.c_str(),QSize);
queue_overS = 0;
}
}
template <class T>
void QueueData<T>::clear()
{
m_Mutex.Lock();
datacache_queue.clear();
m_Mutex.Unlock();
queue_overS = 0;
}
spaceMgr.cpp
#include "spaceMgr.h"
#include "pysleep.h"
#include "DiskSpace.h"
DiskSpaceMgr::DiskSpaceMgr(char disk_, int fsl_
, std::string dir_/*="log"*/, std::string ext_/*="log"*/)
: DiskStr(disk_),freeSizeLimit(fsl_)
{
DelInfo del_(dir_,ext_);
dirs.push_back(del_);
}
DiskSpaceMgr::~DiskSpaceMgr(void)
{
}
int DiskSpaceMgr::Run()
{
int i_totalSize = 0;
int i_freeSize = 0;
while (true)
{
if (pyfree::getDiskFreeSpace(DiskStr, i_totalSize, i_freeSize) > 0)
{
if (freeSizeLimit > i_freeSize)
{
for(unsigned int i=0; i<dirs.size(); ++i)
{
std::string ext = dirs.at(i).ext;
pyfree::moveOldFile(dirs.at(i).dir, ext);
}
}
}
pysleep(10);
}
return 0;
}
void DiskSpaceMgr::add(std::string dir_,std::string ext_)
{
DelInfo del_(dir_,ext_);
dirs.push_back(del_);
}