linux下c++实现文件监控

最新推荐文章于 2024-07-24 10:10:28 发布
最新推荐文章于 2024-07-24 10:10:28 发布
阅读量5.4k 收藏 15
点赞数 1
分类专栏： C/C++ 文章标签： 文件监控
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/onejune2013/article/details/77388696
版权

HotSwitchDict.h

#ifndef _HOTSWITCH_DICT_H_
#define _HOTSWITCH_DICT_H_
#include <string>
#include <pthread.h>
#include <unistd.h>
#include <fstream>
#include <sys/stat.h>
#include <iostream>
#include <time.h>
#include <stdint.h>

using std::string;
using std::cerr;
using std::endl;
using std::cout;

namespace hsd {

/**
 * @brief 获取当前时间
 */
inline string _getCurrentTime()
{
    time_t t = time(NULL);
    /*本地时间：日期，时间 年月日，星期，时分秒*/
    struct tm* c_t = localtime(&t);
    char buf[20];
    sprintf(buf, "%d-%d-%d %d:%d:%d", c_t->tm_year+1900, c_t->tm_mon, 
                    c_t->tm_mday, c_t->tm_hour, c_t->tm_min, c_t->tm_sec);
    return string(buf);
}

template <class DictType> class HotSwitchDict;

template <class DictType> 
void* monitorThread(void *arg)
{
    HotSwitchDict<DictType> * pHotDict = (HotSwitchDict<DictType>*)arg;
    bool needSleep = false;
    uint32_t curSleepTime = 0;    

    // 检测是否需要停止检测
    while( !pHotDict->m_stopMonitor )
    {
        if( needSleep ) {
            if( curSleepTime++ < pHotDict->m_sleepTime ) {
                sleep(1);
                continue;
            }
            else {
                needSleep = false;
                curSleepTime = 0;
            }
        }
        // 检测pHotDict->m_pSwitchDict是否不为空 2012-08-12
        // 不为空，判断是否到底备用词典的延迟生命周期
        if( pHotDict->m_pSwitchDict != NULL ) {
            delete pHotDict->m_pSwitchDict;
            pHotDict->m_pSwitchDict = NULL;
        }
        // 检测新文件是否到来
        if(pHotDict->isNewDictArrived())
        {
            // 构造新的DictType类型指针
            pHotDict->m_pSwitchDict = 
                    pHotDict->newDictFunc(pHotDict->getNewDictFileName());
            // 判断词典是否加载成功
            if(pHotDict->m_pSwitchDict == NULL) {
                cerr << "[WARNING] [" << _getCurrentTime() << 
                            "] Error when load new Dictionary!" << endl;
            }
            else {
                // 加读锁后，交换m_pCurDict和m_pSwitchDict指针
                DictType * pDictTemp = pHotDict->m_pCurDict;
                pthread_rwlock_wrlock(&pHotDict->m_rwLock);
                pHotDict->m_pCurDict = pHotDict->m_pSwitchDict;
                // 不在删除，直接将m_pSwitchDict指向原来的内存空间
                // 保证指针不删除原来m_pCurDict的指针
                pHotDict->m_pSwitchDict = pDictTemp;
                pthread_rwlock_unlock(&pHotDict->m_rwLock);
                //  delete pDictTemp;
                // 修改当前内存中的词典名字
                pHotDict->switchFileName();
                cout << "[INFO] [" << _getCurrentTime() 
                         << "] New Dictionary Switched!" << endl;
            }
            needSleep = true;
        }
        else { // 继续监控
            needSleep = true;
        }
    }
  return NULL;
}

// 默认的词典构建对象函数
template <class DictType>
inline DictType * DefaultNewDictFunc(const string & fileName)
{
    DictType * tmpDict;
    try {
        tmpDict = new DictType(fileName.c_str());
    }
    catch (int e) {
        return NULL;
    }
    return tmpDict;
}

template <class DictType>
class HotSwitchDict
{
    public:
        typedef DictType* (*NewDictFunc)(const string & fileName);
        // 友元函数，需要操作HotSwitchDict的private变量
        friend void * monitorThread<DictType>(void * arg);
        /**
         * @brief HotSwitchDict 构造函数
         * @param fileName 词典的文件名
         * @param flagFile 词典的监控文件，保存新词典的名字和md5码
         * @param sleepTime 每次词典监控的扫描时间间隔
         */
        HotSwitchDict(const string & fileName, const string & flagFile, 
                                    uint32_t sleepTime = 1)
        : m_pCurDict(NULL), m_pSwitchDict(NULL), m_fileName(fileName),
            m_newFileName(""), m_flagFile(flagFile), m_sleepTime(sleepTime), 
            m_stopMonitor(false)
        {
            pthread_rwlock_init(&m_rwLock, NULL);
            m_lastUpdateTime = 0;
            if( sleepTime < 10 || sleepTime > 3600 ) {
                m_sleepTime = 3600;
            }
        }
        /**
         * @brief 初始化函数，用来初始化词典文件以及监控线程
         * @ndf 初始化词典的函数指针
         * @return 如果初始化不成功，返回false 
         */
        bool init(NewDictFunc ndf)
        {
            this->setNewDictFunc(ndf);
            m_pCurDict = newDictFunc(m_fileName);
            if( m_pCurDict == NULL ) {
                return false;
            }
            int err = pthread_create(&m_monitorThread, NULL, 
                                                monitorThread<DictType>, (void*)this);
            if( err != 0 ) return false;
            return true;
        }
        /**
         * @brief 销毁对象，等待监控xiancheng结束，销毁dict指针和读写锁
         * todo 屏蔽继承
         */
        ~HotSwitchDict() 
        {
            if( m_pCurDict != NULL )
            {
                m_stopMonitor = true;
                // 取消线程，避免出现sleep时间过长，导致join需要大量时间
                //pthread_cancel(m_monitorThread);
                // 等待监控线程结束
                pthread_join(m_monitorThread, NULL);
                // 销毁对象
                delete m_pCurDict;
            }
            m_pCurDict = NULL;
            if( m_pSwitchDict != NULL ) {
                delete m_pSwitchDict;
                m_pSwitchDict = NULL;
            }
            // 销毁锁
            pthread_rwlock_destroy(&m_rwLock);
        }
        /**
         * @brief 获取当前dict的指针
         */
        DictType * getCurDict()
        {
            return m_pCurDict;
        }
        /**
         * @brief 加读锁
         */
        int32_t rwlock_read_lock()
        {
            return pthread_rwlock_rdlock(&m_rwLock);
        }
        /**
         * @brief 加写锁
         */
        int32_t rwlock_write_lock()
        {
            return pthread_rwlock_wrlock(&m_rwLock);
        }
        /**
         * @brief 解开锁 
         */
        int32_t rwlock_unlock()
        {
            return pthread_rwlock_unlock(&m_rwLock);
        }
    private:
        HotSwitchDict() {}
        /**
         * @brief 根据词典文件创建新的dict指针
         */
        DictType * newDictFunc(const string & fileName)
        {
            return m_newDictFunc(fileName.c_str());
        }
        /**
         * @brief 判断新词典文件是否存在
         */
        bool isNewDictArrived()
        {
            // 读取finish文件，得到新词典对应的文件名
            if( access(m_flagFile.c_str(), F_OK|R_OK) < 0 )
            {
                cerr << "[WARNING] [" << _getCurrentTime() << "] flagFile " 
                         << m_flagFile << " not exist or not readable" << endl;
                return false;
            }
            // 如果文件修改时间比m_lastUpdateTime大，则读取文件
            struct stat buf;
            if( stat(m_flagFile.c_str(), &buf) < 0 ) {
                return false;
            }
            time_t flagFileTime = buf.st_ctime;
            if( flagFileTime <= m_lastUpdateTime )
            {
#ifdef DEBUG
                cout << "[DEBUG] flagFileTime is smaller than m_lastUpdateTime" << endl;
#endif
                return false;
            }
            std::ifstream in(m_flagFile.c_str());
            if( !in.is_open() ) {
                cerr << "[ERROR] [" << _getCurrentTime() << "] flagFile " 
                         << m_flagFile << " opened failed" << endl;
                return false;
            }
            string newfileName;
            in >> newfileName;
            in.close();
            // 判定新文件名是否发生变化
            if( newfileName == m_fileName ) {
#ifdef DEBUG
                cout << "[DEBUG] newfileName == m_fileName" << endl;
#endif
                return false;
            }
            // 判断新文件是否存在，使用绝对路径
            if( access(newfileName.c_str(), F_OK|R_OK) < 0 )
            {
                cerr << "[WARN] [" << _getCurrentTime() << "] newfileName " 
                         << newfileName << " not exist or not readable" << endl;
                return false;
            }
            // 保存md5码，并进行验证
            m_newFileName = newfileName;
            m_lastUpdateTime = flagFileTime;
#ifdef DEBUG
            cout << "[DEBUG] [" << _getCurrentTime() << 
                     "] change m_newFileName to " << m_newFileName << endl;
#endif
            return true;
        }
        string getNewDictFileName()
        {
            return m_newFileName;
        }
        /**
         * @brief 当前词典的文件名修改
         */
        void switchFileName()
        {
            m_fileName = m_newFileName;
            m_newFileName = "";
        }
        /**
         * @brief 设置从一个文件初始化DictType*类型的函数
         */
        void setNewDictFunc(NewDictFunc ndf)
        {
            m_newDictFunc = ndf;
        }
    private:    
        DictType * m_pCurDict;
        DictType * m_pSwitchDict;
        string m_fileName;
        string m_newFileName;
        string m_flagFile;
        uint32_t m_sleepTime;
        pthread_rwlock_t m_rwLock;
        pthread_t m_monitorThread;
        bool m_stopMonitor;
        NewDictFunc m_newDictFunc;
        time_t m_lastUpdateTime;
};
}
#endif // _HOTSWITCH_DICT_H_

main.cpp

#include "HotSwitchDict.h"
#include<iostream>
#include<string>
#include<fstream>
#include<map>

using namespace std;
using namespace hsd;

map<string, float>* process_file(const string &file_name)
{
    char s[1000];
    map<string, float> *fea_map;
    fea_map = new map<string, float>;
    fstream f(file_name.c_str());
    f.getline(s, 1000);
    cout<<s<<endl;
    f.close();
    return fea_map;
}


int main()
{
    string f_name, flag_file;
    f_name = "./data/dict.dat";
    flag_file = "./data/dict.dat.md5";

    map<string, float>* (*fun)(const string & fileName);
    HotSwitchDict< map<string, float> > hs(f_name, flag_file, 3);

    fun = process_file;
    hs.init(fun);

    int i = 0;
    while(1);                                                                                           

    return 1;
}

使用方法：
1. 将需要监控的文件路径包括文件名写入flag_file,f_name是实际需要读取的文件。
2. 更新f_name之后，同时更新flag_file中的内容。
3. process_file是监控模块的回调函数，自定义文件处理。

然鸟
关注
专栏目录
Linux/C/C++ 文件监控和网络监控的简单实现(利用hook技术)
weixin_45646368的博客
12-19 2740
file_filter.c #include <stdio.h> #include <string.h> #include <stdlib.h> #include <sys/stat.h> #include <unistd.h> #include <dlfcn.h> #define STRMAXLEN 301 const char path[] = "/home/changun/test"; // 受监控的目录 const cha
Linux下目录新增文件监控
qq_39334247的博客
08-05 870
Linux下目录新增文件监控
2024-07-24 Linux C語言使用inotify进行文件变化检测
最新发布
海月汐辰
07-24 431
inotify。
linuxmon:C++ 中的 Linux 监视器（文件、进程、网络连接...）
07-06
linuxmon C++ 中的 Linux 系统监视器（文件、进程、网络连接...）
用什么方式可以监听到linux目录增加文件了具体怎样监听
qq_33192454的博客
07-11 929
使用 SSH 和 inotify-tools是一种简单而有效的方法，可以快速实现对远程目录的监听。使用 Python 的 Paramiko 和 Watchdog 库提供了更多的灵活性和可扩展性，可以根据需要自定义更多的逻辑。根据具体需求选择合适的方法，确保在部署前进行充分测试。怎样监听远程linux的对应的目录下的文件是否存在，如果有想要的文件就把文件移动到当前linux的data目录中用java实现。
【C++】Linux inotify 文件监控机制介绍及使用
unonoi的博客
07-12 7769
使用 Linux 进行文件监控。Linux 提供的 是一种异步文件监控机制，可以用来监控文件系统的事件，包括访问、读写、权限、删除、移动等事件。 既可以监控单个文件，也可以监控整个目录，当监控的对象是一个目录的时候，目录本身和目录下的文件/文件夹都是被监控的对象。但是不能递归监控子目录，如果想要监控子目录下的文件，需要自己通过递归的方法将所有子目录都添加到监控中。此种机制出现的目的是当内核空间发生某种事件之后，可以立即通知到用户空间，方便用户对此做出相应的操作。 是一个内核用于通知用户空间程序文件系统变
Linux 监视文件、文件夹改动
weixin_34356310的博客
04-26 604
/******************************************************************** * Linux 监视文件、文件夹改动 * 说明： * 主要是为了解决当配置文件被修改时，需要重新对配置文件解析，并应用 * 配置文件，这样可以解决修改了配置文件，需要重启系统或者重启软件的需求。...
C++编写文件目录监视程序！源代码奉上！
05-28 713
C++写的一款目录监视程序，功能还挺多，在程序选择项中可以选择监视的内容：添加了内容、删除了内空、修改了文件属性、重命名了文件以及其它的修改，选择你要监视的磁盘及目录，点击“开始”就运行了本程序。另外程序还具有几个实用小功能：开机启动、窗体在前、自动监视等。 实现效果展示： 源代码展示： 这不仅可以节省繁琐的管理任务所花费的时间，还可以提高管理员在小问题变得更加...
linux 文件监控,linux下c++实现文件监控
weixin_39926613的博客
05-09 379
#ifndef _HOTSWITCH_DICT_H_#define _HOTSWITCH_DICT_H_#include #include #include #include #include #include #include #include using std::string;using std::cerr;using std::endl;using std::cout;namespace ...
linux-linux下C++轻量级WebServer服务器实现.zip
02-26
在Linux环境下，使用C++开发轻量级Web服务器是一个典型的系统编程任务，涉及到网络编程、多线程、I/O模型等多个重要知识点。本项目旨在通过C++实现一个基础的HTTP服务器，以处理简单的HTTP请求，如GET和POST，提供...
监听文件是否改变
12-12
设计程序monitor，实现如下功能： 1、程序运行形态为控制台窗口。 2、从屏幕获取第一次用户输入，该输入为一个目录路径。 3、调用ensure_exist函数，确保该路径存在。若ensure_exist调用失败，则提示用户:“路径不合法，重新输入”。 4、若路径存在或者路径创建成功，则提示用户：“开始监视目录:(路径)...” 5、程序开始监视该目录本身以及该目录下所有子目录和文件，若有任何变动（包括文件/文件夹重命名、移动、复制、删除、修改、新建等），则在屏幕打印“目录被改动！[时间:(输出变动时间)]” 6、监视过程中，若用户输入“Q”或者“q”，退出监视，程序结束。 7、能处理各种异常输入，程序能正常到达终点。 c语言编写
inotify 文件监视
12-16
linux 文件监视事件 inotify， inotify 是一个 Linux 内核特性，它监控文件系统，并且及时向专门的应用程序发出相关的事件警告，比如删除、读、写和卸载操作等。
Linux平台C++监控子进程程序
Lvnux的专栏
04-07 3067
1、问题描述有时候服务端程序会偶现异常停止，这个时候除了要查找程序的bug外，还有拉起程序以继续提供服务。目前为了方便，我们直接用shell脚本去监控服务进程，这种方法比较简单，不再赘述。这里描述另一种方法：服务进程分离为主监控进程和子工作进程，主进程只负责监控子进程（停止、拉起子进程等），子进程负责对外提供服务。监控子进程的程序，个人认为重点如下： 子进程收到终止信号后，完成自身善后工作，然后直接
linux c 监控文件内容改变,如何让程序监视C ++中的文件修改？
weixin_32452127的博客
05-12 539
WinCE的一个工作例子voidFileInfoHelper::WatchFileChanges(TCHAR*ptcFileBaseDir,TCHAR*ptcFileName){staticintiCount=0;DWORDdwWaitStatus;HANDLEdwChangeHandles;if(!ptcFileBaseDir||!ptcFileName)...
linux c 监视目录文件,linux c监控文件事件
weixin_39787089的博客
04-29 450
linux c监控文件事件某些应用程序需要对文件或目录进行监控，来侦测其发生特定事件。例如当文件加入或移出一目录，图形化文件管理器应能判定此目录是否在其当前显示之列，而守护进程可能也要监控自己的配置文件是否修改。创建新的inotify实例。#include int inotify_init(void);//成功返回文件描述符，错误-1追加新的监控项#include int inotify_add_...
C++实现检测某目录下一个或多个文件的变化
misaler的博客
08-25 1362
void file_changed(const std::string dir_path){ if (dir_path.empty()){ LGE("path is null"); return; } #ifdef WIN32 HANDLE h_dir = INVALID_HANDLE_VALUE; BYTE lp_buffer[1024]; ZeroMemory(lp_buffer, 1024); DWORD byte
c++文件读写，fstream追加，fstream覆盖，getline，写入流
热门推荐
小小酥的博客
04-13 1万+
c++文件读写，追加，覆盖，fstream的使用 【参考文献】：c++primer(5版)第八章IO库 #include <iostream> #include <string> #include<fstream> using namespace std; int main() { //注意“/” string fin="D:/cpp/tempvscode...
LinuxC/C++文件监控
03-31
在Linux C/C中，可以使用inotify API来监控文件系统的事件。inotify API提供了一种异步的、高效的文件系统事件监控机制，可以监控文件或目录的创建、删除、修改、移动等操作。 使用inotify API需要先创建一个inotify实例，并使用inotify_add_watch函数添加要监控的文件或目录。当文件系统中发生对应的事件时，inotify会通知应用程序。 下面是一个简单的例子，演示如何使用inotify API监控文件变化： ```c #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/inotify.h> #define EVENT_SIZE ( sizeof (struct inotify_event) ) #define BUF_LEN ( 1024 * ( EVENT_SIZE + 16 ) ) int main( int argc, char **argv ) { int length, i = 0; int fd; int wd; char buffer[BUF_LEN]; fd = inotify_init(); if ( fd < 0 ) { perror( "inotify_init" ); } wd = inotify_add_watch( fd, "/tmp", IN_MODIFY | IN_CREATE | IN_DELETE ); while ( 1 ) { i = 0; length = read( fd, buffer, BUF_LEN ); if ( length < 0 ) { perror( "read" ); } while ( i < length ) { struct inotify_event *event = ( struct inotify_event * ) &buffer[ i ]; if ( event->len ) { if ( event->mask & IN_CREATE ) { if ( event->mask & IN_ISDIR ) { printf( "The directory %s was created.\n", event->name ); } else { printf( "The file %s was created.\n", event->name ); } } else if ( event->mask & IN_DELETE ) { if ( event->mask & IN_ISDIR ) { printf( "The directory %s was deleted.\n", event->name ); } else { printf( "The file %s was deleted.\n", event->name ); } } else if ( event->mask & IN_MODIFY ) { if ( event->mask & IN_ISDIR ) { printf( "The directory %s was modified.\n", event->name ); } else { printf( "The file %s was modified.\n", event->name ); } } } i += EVENT_SIZE + event->len; } } ( void ) inotify_rm_watch( fd, wd ); ( void ) close( fd ); exit( 0 ); } ``` 上面的代码中，先使用inotify_init函数创建一个inotify实例，然后使用inotify_add_watch函数添加要监控的目录。在while循环中，使用read函数读取inotify实例中的事件，然后根据事件类型进行相应的处理。最后使用inotify_rm_watch函数移除监控项，关闭inotify实例。 需要注意的是，inotify API只能用于Linux系统，其他操作系统需要使用不同的机制来监控文件系统事件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值