#include <efsw/FileWatcherWin32.hpp>
|
#include <efsw/FileSystem.hpp>
|
#include <efsw/System.hpp>
|
#include <efsw/String.hpp>
|
#include <efsw/Lock.hpp>
|
|
#if EFSW_PLATFORM == EFSW_PLATFORM_WIN32
|
|
namespace efsw
|
{
|
|
FileWatcherWin32::FileWatcherWin32( FileWatcher * parent ) :
|
FileWatcherImpl( parent ),
|
mLastWatchID(0),
|
mThread( NULL )
|
{
|
mIOCP = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 1);
|
if (mIOCP && mIOCP != INVALID_HANDLE_VALUE)
|
mInitOK = true;
|
}
|
|
FileWatcherWin32::~FileWatcherWin32()
|
{
|
mInitOK = false;
|
|
if (mIOCP && mIOCP != INVALID_HANDLE_VALUE)
|
{
|
PostQueuedCompletionStatus(mIOCP, 0, reinterpret_cast<ULONG_PTR>(this), NULL);
|
}
|
|
efSAFE_DELETE( mThread );
|
|
removeAllWatches();
|
|
CloseHandle(mIOCP);
|
}
|
|
WatchID FileWatcherWin32::addWatch(const std::string& directory, FileWatchListener* watcher, bool recursive)
|
{
|
std::string dir( directory );
|
|
FileInfo fi( dir );
|
|
if ( !fi.isDirectory() )
|
{
|
return Errors::Log::createLastError( Errors::FileNotFound, dir );
|
}
|
else if ( !fi.isReadable() )
|
{
|
return Errors::Log::createLastError( Errors::FileNotReadable, dir );
|
}
|
|
FileSystem::dirAddSlashAtEnd( dir );
|
|
Lock lock( mWatchesLock );
|
|
if ( pathInWatches( dir ) )
|
{
|
return Errors::Log::createLastError( Errors::FileRepeated, dir );
|
}
|
|
WatchID watchid = ++mLastWatchID;
|
|
WatcherStructWin32 * watch = CreateWatch( String::fromUtf8( dir ).toWideString().c_str(), recursive,
|
FILE_NOTIFY_CHANGE_CREATION |
|
FILE_NOTIFY_CHANGE_LAST_WRITE |
|
FILE_NOTIFY_CHANGE_FILE_NAME |
|
FILE_NOTIFY_CHANGE_DIR_NAME |
|
FILE_NOTIFY_CHANGE_SIZE,
|
mIOCP
|
);
|
|
if( NULL == watch )
|
{
|
return Errors::Log::createLastError( Errors::FileNotFound, dir );
|
}
|
|
// Add the handle to the handles vector
|
watch->Watch->ID = watchid;
|
watch->Watch->Watch = this;
|
watch->Watch->Listener = watcher;
|
watch->Watch->DirName = new char[dir.length()+1];
|
strcpy(watch->Watch->DirName, dir.c_str());
|
|
mWatches.insert( watch );
|
|
return watchid;
|
}
|
|
void FileWatcherWin32::removeWatch(const std::string& directory)
|
{
|
Lock lock( mWatchesLock );
|
|
Watches::iterator iter = mWatches.begin();
|
|
for(; iter != mWatches.end(); ++iter)
|
{
|
if(directory == (*iter)->Watch->DirName)
|
{
|
removeWatch(*iter);
|
break;
|
}
|
}
|
}
|
|
void FileWatcherWin32::removeWatch(WatchID watchid)
|
{
|
Lock lock( mWatchesLock );
|
|
Watches::iterator iter = mWatches.begin();
|
|
for(; iter != mWatches.end(); ++iter)
|
{
|
// Find the watch ID
|
if ( (*iter)->Watch->ID == watchid )
|
{
|
removeWatch(*iter);
|
return;
|
}
|
}
|
}
|
|
void FileWatcherWin32::removeWatch(WatcherStructWin32* watch)
|
{
|
Lock lock( mWatchesLock );
|
|
DestroyWatch(watch);
|
mWatches.erase(watch);
|
}
|
|
void FileWatcherWin32::watch()
|
{
|
if ( NULL == mThread )
|
{
|
mThread = new Thread( &FileWatcherWin32::run, this );
|
mThread->launch();
|
}
|
}
|
|
void FileWatcherWin32::removeAllWatches()
|
{
|
Lock lock( mWatchesLock );
|
|
Watches::iterator iter = mWatches.begin();
|
|
for( ; iter != mWatches.end(); ++iter )
|
{
|
DestroyWatch((*iter));
|
}
|
|
mWatches.clear();
|
}
|
|
void FileWatcherWin32::run()
|
{
|
do
|
{
|
if ( mInitOK && !mWatches.empty() )
|
{
|
DWORD numOfBytes = 0;
|
OVERLAPPED* ov = NULL;
|
ULONG_PTR compKey = 0;
|
BOOL res = FALSE;
|
|
while ( ( res = GetQueuedCompletionStatus( mIOCP, &numOfBytes, &compKey, &ov, INFINITE ) ) != FALSE )
|
{
|
if ( compKey != 0 && compKey == reinterpret_cast<ULONG_PTR>( this ) )
|
{
|
break;
|
}
|
else
|
{
|
Lock lock( mWatchesLock );
|
WatchCallback( numOfBytes, ov );
|
}
|
}
|
}
|
else
|
{
|
System::sleep( 10 );
|
}
|
} while ( mInitOK );
|
|
removeAllWatches();
|
}
|
|
void FileWatcherWin32::handleAction(Watcher* watch, const std::string& filename, unsigned long action, std::string /*oldFilename*/)
|
{
|
Action fwAction;
|
|
switch(action)
|
{
|
case FILE_ACTION_RENAMED_OLD_NAME:
|
watch->OldFileName = filename;
|
return;
|
case FILE_ACTION_ADDED:
|
fwAction = Actions::Add;
|
break;
|
case FILE_ACTION_RENAMED_NEW_NAME:
|
{
|
fwAction = Actions::Moved;
|
|
std::string fpath( watch->Directory + filename );
|
|
// Update the directory path
|
if ( watch->Recursive && FileSystem::isDirectory( fpath ) )
|
{
|
// Update the new directory path
|
std::string opath( watch->Directory + watch->OldFileName );
|
FileSystem::dirAddSlashAtEnd( opath );
|
FileSystem::dirAddSlashAtEnd( fpath );
|
|
for ( Watches::iterator it = mWatches.begin(); it != mWatches.end(); ++it )
|
{
|
if ( (*it)->Watch->Directory == opath )
|
{
|
(*it)->Watch->Directory = fpath;
|
|
break;
|
}
|
}
|
}
|
|
std::string folderPath( static_cast<WatcherWin32*>( watch )->DirName );
|
std::string realFilename = filename;
|
std::size_t sepPos = filename.find_last_of("/\\");
|
std::string oldFolderPath = static_cast<WatcherWin32*>( watch )->DirName + watch->OldFileName.substr( 0, watch->OldFileName.find_last_of( "/\\" ) );
|
|
if ( sepPos != std::string::npos )
|
{
|
folderPath += filename.substr( 0, sepPos );
|
realFilename = filename.substr( sepPos + 1 );
|
}
|
|
if ( folderPath == oldFolderPath )
|
{
|
watch->Listener->handleFileAction(watch->ID, folderPath, realFilename, fwAction, FileSystem::fileNameFromPath(watch->OldFileName));
|
}
|
else
|
{
|
watch->Listener->handleFileAction(watch->ID, static_cast<WatcherWin32*>( watch )->DirName, filename, fwAction, watch->OldFileName);
|
}
|
return;
|
}
|
case FILE_ACTION_REMOVED:
|
fwAction = Actions::Delete;
|
break;
|
case FILE_ACTION_MODIFIED:
|
fwAction = Actions::Modified;
|
break;
|
default:
|
return;
|
};
|
|
std::string folderPath( static_cast<WatcherWin32*>( watch )->DirName );
|
std::string realFilename = filename;
|
std::size_t sepPos = filename.find_last_of("/\\");
|
|
if ( sepPos != std::string::npos )
|
{
|
folderPath += filename.substr( 0, sepPos );
|
realFilename = filename.substr( sepPos + 1 );
|
}
|
|
watch->Listener->handleFileAction(watch->ID, folderPath, realFilename, fwAction);
|
}
|
|
std::list<std::string> FileWatcherWin32::directories()
|
{
|
std::list<std::string> dirs;
|
|
Lock lock( mWatchesLock );
|
|
for ( Watches::iterator it = mWatches.begin(); it != mWatches.end(); ++it )
|
{
|
dirs.push_back( std::string( (*it)->Watch->DirName ) );
|
}
|
|
return dirs;
|
}
|
|
bool FileWatcherWin32::pathInWatches( const std::string& path )
|
{
|
Lock lock( mWatchesLock );
|
|
for ( Watches::iterator it = mWatches.begin(); it != mWatches.end(); ++it )
|
{
|
if ( (*it)->Watch->DirName == path )
|
{
|
return true;
|
}
|
}
|
|
return false;
|
}
|
|
}
|
|
#endif
|
