使用libev监视文件夹下文件(夹)属性变动的方案和实现

编程入门 行业动态 更新时间:2024-10-26 21:30:48

使用libev监视文件夹下文件(夹)属性<a href=https://www.elefans.com/category/jswz/34/1751656.html style=变动的方案和实现"/>

使用libev监视文件夹下文件(夹)属性变动的方案和实现

        在《libev源码解析》系列中,我们分析了libev的基本原理。本文我们介绍一套使用libev封装的文件(夹)变动监视方案和实现。(转载请指明出于breaksoftware的csdn博客)

        我们先看个最简单方案,下面的代码会监视/home/work下文件(夹)的新增、删除等操作。

void call_back(ev::stat &w, int revents) {std::cout << "watch " << w.path << std::endl;
}int main() {ev::default_loop loop;ev::stat state;state.set(call_back);state.set(loop);state.start("/home/work/");loop.run();return 0;
}

        第6行,我们使用了默认的loop。除了default_loop,libev还提供了dynamic_loop。如果我们没有指定loop,则libev会使用默认的。

        第7行,我们声明了文件(夹)监视器state。

        第8行,将回调函数call_back和监视器关联。

        第9行,将loop和监视器关联。

        第10行,监视器开始监视目录/home/work。

        第11行,让loop运行起来以阻塞住进程。

        这样一旦目录下有文件(夹)变动,则会调用回调函数call_back。

        假如这种方式可以涵盖所有情况,那么也不会存在这篇博文了。因为上述方案存在如下缺陷:

  1. 堵塞主线程
  2. call_back的stat::path一直指向被监视的文件(夹)路径。这样在监控一个文件夹时,如果有子文件(夹)新增或者删除,我们都将无法从回调函数中得知变动的是谁。
  3. 子文件夹下有文件新增监控不到。
  4. 如果监视一个文件夹时发生子文件的复制覆盖行为,将监视不到。

        第1个问题并不严重,我们只要启动一个线程便可解决。第2个问题,我们可以通过对比变动前后的目录结构去解决,也不算太复杂。第3个问题,我们需要对每个子目录进行监控,并且在有新文件夹被创建时新增监控,在有文件夹被删除时删除监控。第4个问题则比较严重了。要解决第4个问题,我们需要对文件夹的监视精细到具体的文件级别,也就是说不是笼统的对某个目录进行监视,而是还要对目录下每个文件进行监视。

        于是对一个文件夹的监视,需要做到:

  1. 监视该文件夹,以获取新增文件(夹)信息。
  2. 监视该文件夹下所有子文件,以获取复制覆盖信息。
  3. 监视该文件夹下所有子文件夹,以监视子文件夹下文件的新增及其后续操作。
  4. 对于新增的文件(夹),需要新增监视。
  5. 对于删除的文件(夹),需要删除监视。
  6. 对于文件夹监视器和文件监视器重复上报的行为(删除文件)需要去重处理。

        由于loop会堵塞住线程,所以我们让一个loop占用一个线程。多个监视器可关联到一个loop。但是监视器和loop的关系存在如下情况:

  1. 如果有多个监视器关联到一个loop,则一个监视器停止后,loop仍会堵塞住线程。
  2. 如果只有一个监视器关联到loop,那这个监视器停止后,loop会从堵塞状态中跳出。

        我希望监视器可以关联到同一个loop,于是对loop做了如下封装

class LibevLoop {
public:LibevLoop();~LibevLoop();template<class T>friend void bind(T& a, LibevLoop* b);public:void run_loop();private:ev::dynamic_loop loop_;std::timed_mutex timed_mutex_;
};template<class T>
void bind(T& a, LibevLoop* b) {a.set(b->loop_);
}LibevLoop::~LibevLoop() {loop_.break_loop(ev::ALL);
}void LibevLoop::run_loop() {if (timed_mutex_.try_lock_for(std::chrono::milliseconds(1))) {std::thread t([this]{timed_mutex_.lock();loop_.run(); timed_mutex_.unlock();});t.detach();timed_mutex_.unlock();}
}

        由于ev::dynamic_loop是内部管理对象,我并不希望暴露出它,于是提供了一个友元函数bind供外部使用。其实这个地方使用模板函数并不是很合适,最好是针对具体类的方法。

        run_loop函数内部使用超时锁检测loop是否在运行,从而可以保证各个线程调用该函数时只有一个线程被运行。

        我们再封装了一个监视器类

class Watcher {
public:using callback = std::function<void(ev::stat&, int)>;Watcher() = delete;explicit Watcher(const std::string& path, callback c, LibevLoop* loop = nullptr);~Watcher();
private:void callback_(ev::stat &w, int revents);
private:callback cb_;ev::stat state_;
};Watcher::Watcher(const std::string& path, callback c, LibevLoop* loop) {if (!loop) {static LibevLoop loop_;loop = &loop_;}cb_.swap(c);state_.set<Watcher, &Watcher::callback_>(this);bind(state_, loop);state_.start(path.c_str());loop->run_loop();
}Watcher::~Watcher() {state_.stop();
}void Watcher::callback_(ev::stat &w, int revents) {cb_(w, revents);
}

        Watcher的构造函数执行的是文中最开始给出的libev的调用过程。区别是loop被替换为之前定义的LibevLoop,从而不会在该步堵塞线程。

        现在我们可以实现监视器中最基础的文件监视器。

class FileWatcher {
public:using callback = std::function<void(const std::string& path, FileWatcherAction action)>;FileWatcher() = delete;~FileWatcher();explicit FileWatcher(const std::string& path, callback cb, LibevLoop* loop = nullptr);
private:void watch_(ev::stat&, int);
private:callback cb_;std::string file_path_;std::time_t last_write_time_ = 0;std::shared_ptr<Watcher> watcher_;
};FileWatcher::~FileWatcher() {
}FileWatcher::FileWatcher(const std::string& path, callback cb, LibevLoop* loop) {file_path_ = absolute(path);cb_ = std::move(cb);if (boost::filesystem::is_directory(file_path_)) {return;}if (boost::filesystem::is_regular_file(file_path_)) {last_write_time_ = boost::filesystem::last_write_time(file_path_);}watcher_ = std::make_shared<Watcher>(file_path_, std::bind(&FileWatcher::watch_, this, std::placeholders::_1, std::placeholders::_2), loop);
}void FileWatcher::watch_(ev::stat &w, int revents) {if (!boost::filesystem::is_regular_file(file_path_)) {if (last_write_time_ != 0) {cb_(file_path_, FILE_DEL);}return;}std::time_t t = boost::filesystem::last_write_time(file_path_);if (last_write_time_ != t) {FileWatcherAction ac = (last_write_time_ == 0) ? FILE_NEW : FILE_MODIFY;cb_(file_path_, ac);}
}

        由于libev需要监视的路径是绝对路径,所以FileWatcher函数会先通过absolute函数修正路径。

std::string absolute(const std::string& path) {if (boost::filesystem::path(path).is_absolute()) {return path;}std::string absolute_path = boost::filesystem::system_complete(path).string();return absolute_path;
}

        然后获取该文件的最后修改时间。

        FileWatcher::watch_函数是回调函数,它一开始检测文件是否存在,如果不存在且之前存在(最后修改时间不为0),则发起通知。如果文件存在,则通过通过对比最后修改时间来确定发生的行为是“新增”还是“修改”。

        接下来就要接触到比较复杂的文件夹监视。之前我们提到过,需要对目录下所有文件进行监视,并且需要遍历整个目录以确定新增的是哪个文件。于是就设计了一个遍历目录的方法

using callback = std::function<void(const std::string&)>;void folder_scan(const std::string& path, callback file_cb, callback folder_cb) {if (!boost::filesystem::is_directory(path)) {return;}if (!boost::filesystem::exists(path)) {return;}boost::filesystem::directory_iterator it(path);boost::filesystem::directory_iterator end;for (; it != end; it++) {if (boost::filesystem::is_directory(*it)) {folder_cb(it->path().string());folder_scan(it->path().string(), file_cb, folder_cb);}else {file_cb(it->path().string());}}
}

        folder_scan方法提供了两个回调,一个是在扫描到文件时调用,一个是扫描到文件夹时调用。

        对比文件夹下文件(夹)新增的类将使用上述方法实现对比操作。

enum PathType {E_FILE = 0,E_FOLDER,
};struct PathInfo {std::string path;PathType type;bool operator < (const PathInfo & right) const {return pathpare(right.path) < 0;}
};using PathInfoSet = std::set<PathInfo>;class FolderDiff {
public:explicit FolderDiff(const std::string& path);void diff(PathInfoSet & add, PathInfoSet & remove);
private:void scan_(const std::string& path, PathType type, PathInfoSet& path_infos);
private:std::string folder_path_;PathInfoSet path_infos_;
};FolderDiff::FolderDiff(const std::string& path){folder_path_ = absolute(path);PathInfoSet path_infos;folder_scan(folder_path_, std::bind(&FolderDiff::scan_, this, std::placeholders::_1, E_FILE, std::ref(path_infos_)),std::bind(&FolderDiff::scan_, this, std::placeholders::_1, E_FOLDER, std::ref(path_infos_)));
}void FolderDiff::scan_(const std::string& path, PathType type, PathInfoSet& path_infos) {PathInfo pi{path, type};path_infos.insert(pi);
}void FolderDiff::diff(PathInfoSet & add, PathInfoSet & remove) {PathInfoSet path_infos;folder_scan(folder_path_, std::bind(&FolderDiff::scan_, this, std::placeholders::_1, E_FILE, std::ref(path_infos)),std::bind(&FolderDiff::scan_, this, std::placeholders::_1, E_FOLDER, std::ref(path_infos)));std::set_difference(path_infos.begin(), path_infos.end(),path_infos_.begin(), path_infos_.end(), std::inserter(add, add.begin()));std::set_difference(path_infos_.begin(), path_infos_.end(),path_infos.begin(), path_infos.end(), std::inserter(remove, remove.begin()));path_infos_ = path_infos;
}

        Folder::diff方法将计算出和之前目录状态的对比结果。

        FolderWatcher是最终实现文件夹监视的类。它的构造函数第8行构建了一个文件夹对比类;第10行遍历整个目录,对目录下文件夹和文件设置监视器。因为子文件夹也要监视,folder_watchers_保存了所有子文件夹的监视器。第14行启动了path路径文件夹监视器。

FolderWatcher::FolderWatcher(const std::string& path, callback c, LibevLoop* loop) {folder_path_ = absolute(path);if (boost::filesystem::is_regular_file(folder_path_)) {return;}cb_ = std::move(c);fdiff_ = std::make_shared<FolderDiff>(folder_path_);folder_scan(folder_path_, std::bind(&FolderWatcher::watch_file_, this, std::placeholders::_1),std::bind(&FolderWatcher::watch_folder_, this, std::placeholders::_1));watcher_ = std::make_shared<Watcher>(folder_path_, std::bind(&FolderWatcher::watch_, this, std::placeholders::_1, std::placeholders::_2), loop);
}void FolderWatcher::watch_folder_(const std::string& path) {std::unique_lock<std::mutex> lock(mutex_);folder_watchers_[path] = std::make_shared<Watcher>(path,std::bind(&FolderWatcher::watch_, this,std::placeholders::_1, std::placeholders::_2));
}

        对每个子文件的监视使用watch_file_回调,它在底层使用了之前定义的FileWatcher文件监视器类。

void FolderWatcher::watch_file_(const std::string& path){std::unique_lock<std::mutex> lock(mutex_);files_last_modify_time_[path] = boost::filesystem::last_write_time(path);file_watchers_[path] = std::make_shared<FileWatcher>(path, std::bind(&FolderWatcher::file_watcher_, this, std::placeholders::_1, std::placeholders::_2));
}void FolderWatcher::file_watcher_(const std::string& path, FileWatcherAction action) {PathInfo pi{path, E_FILE};WatcherAction ac = (WatcherAction)action; notify_filewatcher_change_(pi, ac);
}

        对主目录的监视使用watch_回调函数,它内部是通过之前定义的FolderDiff类实现的。

void FolderWatcher::watch_(ev::stat &w, int revents) {PathInfoSet add;PathInfoSet remove;fdiff_->diff(add, remove);for (auto& it : add) {notify_change_(it, true);}for (auto& it : remove) {notify_change_(it, false);}
}void FolderWatcher::notify_change_(const PathInfo& pi, bool add) {if (pi.type == E_FOLDER) {notify_folderwatcher_change_(pi, add ? NEW : DEL);}else {notify_filewatcher_change_(pi, add ? NEW : DEL);}
}

        如果变动的事文件夹,则使用notify_folderwatcher_change_方法处理;如果是文件,则使用notify_filewatcher_change方法处理。

        notify_folderwatcher_change_方法比较简单,它只是根据新增或者删除的行为维护folder_watchers_监视器映射表,并调用回调通知。

void FolderWatcher::notify_folderwatcher_change_(const PathInfo& pi, WatcherAction action) {bool notify = true;if (action == DEL) {std::unique_lock<std::mutex> lock(mutex_);auto it = folder_watchers_.find(pi.path);if (it == folder_watchers_.end()) {notify = false;}else {folder_watchers_.erase(it);}}else if (action == NEW || action == MODIFY) {std::unique_lock<std::mutex> lock(mutex_);auto it = folder_watchers_.find(pi.path);if (it == folder_watchers_.end()) {folder_watchers_[pi.path] = std::make_shared<Watcher>(pi.path,std::bind(&FolderWatcher::watch_, this,std::placeholders::_1, std::placeholders::_2));}}if (notify) {cb_(pi, action);}
}

        notify_filewatcher_change方法比较复杂,它底层调用的change_filewatchers_方法根据文件的新增和删除来管理文件监视器。

void FolderWatcher::change_filewatchers_(const std::string& path, WatcherAction action) {if (action == DEL) {std::unique_lock<std::mutex> lock(mutex_);auto it = file_watchers_.find(path);if (it != file_watchers_.end()) {file_watchers_.erase(it);}}else if (action == NEW) {std::unique_lock<std::mutex> lock(mutex_);auto it = file_watchers_.find(path);if (it != file_watchers_.end()) {file_watchers_.erase(it);}file_watchers_[path] = std::make_shared<FileWatcher>(path, std::bind(&FolderWatcher::file_watcher_, this, std::placeholders::_1, std::placeholders::_2));}
}

        由于对于文件的删除行为,文件监视器和文件夹监视器都会上报,所以需要对其进行去重。于是我们使用最后修改时间来做统一。

void FolderWatcher::notify_filewatcher_change_(const PathInfo& pi, WatcherAction action) {change_filewatchers_(pi.path, action);bool notify = true;if (action == DEL) {std::unique_lock<std::mutex> lock(mutex_);auto it = files_last_modify_time_.find(pi.path);if (it == files_last_modify_time_.end()) {notify = false;}else {files_last_modify_time_.erase(it);}}else if (action == NEW || action == MODIFY) {std::unique_lock<std::mutex> lock(mutex_);auto it = files_last_modify_time_.find(pi.path);if (it != files_last_modify_time_.end()) {if (boost::filesystem::last_write_time(pi.path) == it->second) {notify = false;}}else {files_last_modify_time_[pi.path] = boost::filesystem::last_write_time(pi.path);}}if (notify) {cb_(pi, action);}
}

        最后需要指出的是,这套代码,在不同的操作系统上有不一致的行为。比如在Centos上,如果我们监视一个不存在的文件路径,然后新建该文件,则会发起通知。而在Ubuntu上,该行为则监视不到。但是这个差异也可以理解。

        最后附上代码库,其中的单元测试基于Centos的。.git

更多推荐

使用libev监视文件夹下文件(夹)属性变动的方案和实现

本文发布于:2024-03-09 14:10:13,感谢您对本站的认可!
本文链接:https://www.elefans.com/category/jswz/34/1725193.html
版权声明:本站内容均来自互联网,仅供演示用,请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系,我们将在24小时内删除。
本文标签:变动   文件夹   属性   文件   方案

发布评论

评论列表 (有 0 条评论)
草根站长

>www.elefans.com

编程频道|电子爱好者 - 技术资讯及电子产品介绍!