文件监控

w1146869587

2021-11-05 cbf39419a8299e7d119618e5e8e1b1eb35f72f45

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
#include <efsw/efsw.hpp>
#include <efsw/System.hpp>
#include <efsw/FileSystem.hpp>
#include <signal.h>
#include <iostream>
 
bool STOP = false;
 
void sigend(int signal)
{
    std::cout << std::endl << "Bye bye" << std::endl;
    STOP = true;
}
 
/// Processes a file action
class UpdateListener : public efsw::FileWatchListener
{
    public:
        UpdateListener() {}
 
        std::string getActionName( efsw::Action action )
        {
            switch ( action )
            {
                case efsw::Actions::Add:        return "Add";
                case efsw::Actions::Modified:    return "Modified";
                case efsw::Actions::Delete:        return "Delete";
                case efsw::Actions::Moved:        return "Moved";
                default:                        return "Bad Action";
            }
        }
 
        void handleFileAction( efsw::WatchID watchid, const std::string& dir, const std::string& filename, efsw::Action action, std::string oldFilename = ""  )
        {
            std::cout << "DIR (" << dir + ") FILE (" + ( oldFilename.empty() ? "" : "from file " + oldFilename + " to " ) + filename + ") has event " << getActionName( action ) << std::endl;
        }
};
 
efsw::WatchID handleWatchID( efsw::WatchID watchid )
{
    switch ( watchid )
    {
        case efsw::Errors::FileNotFound:
        case efsw::Errors::FileRepeated:
        case efsw::Errors::FileOutOfScope:
        case efsw::Errors::FileRemote:
        case efsw::Errors::Unspecified:
        {
            std::cout << efsw::Errors::Log::getLastErrorLog().c_str() << std::endl;
            break;
        }
        default:
        {
            std::cout << "Added WatchID: " << watchid << std::endl;
        }
    }
 
    return watchid;
}
 
int main(int argc, char **argv)
{
    signal( SIGABRT    ,    sigend );
    signal( SIGINT    ,    sigend );
    signal( SIGTERM    ,    sigend );
 
    std::cout << "Press ^C to exit demo" << std::endl;
 
    bool commonTest = true;
    bool useGeneric = false;
    std::string path;
 
    if ( argc >= 2 )
    {
        path = std::string( argv[1] );
 
        if ( efsw::FileSystem::isDirectory( path ) )
        {
            commonTest    = false;
        }
 
        if ( argc >= 3 )
        {
            if ( std::string( argv[2] ) == "true" )
            {
                useGeneric = true;
            }
        }
    }
 
    UpdateListener * ul = new UpdateListener();
 
    /// create the file watcher object
    efsw::FileWatcher fileWatcher( useGeneric );
 
    fileWatcher.followSymlinks( false );
    fileWatcher.allowOutOfScopeLinks( false );
 
    if ( commonTest )
    {
        std::string CurPath( efsw::System::getProcessPath() );
 
        std::cout << "CurPath: " << CurPath.c_str() << std::endl;
 
        /// add a watch to the system
        handleWatchID( fileWatcher.addWatch( CurPath + "test", ul, true ) );
 
        /// starts watching
        fileWatcher.watch();
 
        /// adds another watch after started watching...
        efsw::System::sleep( 100 );
 
        efsw::WatchID watchID = handleWatchID( fileWatcher.addWatch( CurPath + "test2", ul, true ) );
 
        /// delete the watch
        if ( watchID > 0 )
        {
            efsw::System::sleep( 1000 );
            fileWatcher.removeWatch( watchID );
        }
    }
    else
    {
        efsw::WatchID err;
 
        if ( ( err = fileWatcher.addWatch( path, ul, true ) ) > 0 )
        {
            fileWatcher.watch();
 
            std::cout << "Watching directory: " << path.c_str() << std::endl;
 
            if ( useGeneric )
            {
                std::cout << "Using generic backend watcher" << std::endl;
            }
        }
        else
        {
            std::cout << "Error trying to watch directory: " << path.c_str() << std::endl;
            std::cout << efsw::Errors::Log::getLastErrorLog().c_str() << std::endl;
        }
    }
 
    while( !STOP )
    {
        efsw::System::sleep( 100 );
    }
 
    return 0;
}