124 lines
4.2 KiB
C++
124 lines
4.2 KiB
C++
#include "watchdog.h"
|
|
|
|
namespace fs = std::filesystem; //makes it easier to read
|
|
void WatchDog::start()
|
|
{
|
|
//checks if file exist
|
|
if(!fs::exists(path))
|
|
{
|
|
//returns and sets parameters to false if file doesnt exist
|
|
watching = false;
|
|
hasInitialTime = false;
|
|
std::cout << "WatchDog: File does not exists: " << path << std::endl;
|
|
return;
|
|
}
|
|
//grabs intial write time
|
|
lastWriteTime = fs::last_write_time(path);
|
|
watching = true;
|
|
hasInitialTime = true;
|
|
std::cout << "WatchDog: Started" << std::endl;
|
|
}
|
|
void WatchDog::stop(){
|
|
watching = false;
|
|
}
|
|
bool WatchDog::checkFile(){
|
|
//If not watching returns false
|
|
if (!watching) return false;
|
|
|
|
//Checking if file was deleted
|
|
if(!fs::exists(path))
|
|
{
|
|
if (hasInitialTime) {
|
|
std::cout << "WatchDog: File was delete: " << path << std::endl;
|
|
hasInitialTime = false;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//Built in function with file system to check last write tim
|
|
fs::file_time_type currentWriteTime = fs::last_write_time(path);
|
|
|
|
//File was just created
|
|
if(!hasInitialTime)
|
|
{
|
|
lastWriteTime = currentWriteTime;
|
|
hasInitialTime = true;
|
|
std::cout << "WatchDog: File created: " << path << std::endl;
|
|
return true;
|
|
}
|
|
|
|
//File modified
|
|
if (currentWriteTime != lastWriteTime)
|
|
{
|
|
lastWriteTime = currentWriteTime;
|
|
std::cout << "WatchDog: File modifed at "
|
|
<< timePointToString(lastWriteTime) << std::endl;
|
|
return true;
|
|
}
|
|
|
|
} catch (const fs::filesystem_error& e) {
|
|
// File deleted, inaccessible, or path invalid
|
|
if (hasInitialTime) {
|
|
std::cout << "WatchDog: File deleted or inaccessible: " << path << std::endl;
|
|
hasInitialTime = false;
|
|
return true;
|
|
}
|
|
return false;
|
|
|
|
} catch (const std::exception& e) {
|
|
std::cerr << "WatchDog: Unexpected error checking file: " << e.what() << std::endl;
|
|
return false;
|
|
}
|
|
|
|
// No change
|
|
return false;
|
|
}
|
|
|
|
std::string Watchdog::TimePointToString(const fs::file_time_type& timePoint){
|
|
/**
|
|
* Step 1: timePoint
|
|
* - This is the last write time of the file, returned by std::filesystem.
|
|
* - Its clock is platform-dependent (filesystem clock).
|
|
*
|
|
* Step 2: fs::file_time_type::clock::now()
|
|
* - Current time according to the filesystem clock.
|
|
*
|
|
* Step 3: std::chrono::system_clock::now()
|
|
* - Current time according to the system clock (standard C++ clock).
|
|
*
|
|
* Conversion formula:
|
|
* timePoint - fs::file_time_type::clock::now() + std::chrono::system_clock::now()
|
|
*
|
|
* Explanation:
|
|
* a) timePoint - fs::file_time_type::clock::now()
|
|
* - Calculates the duration between the file's last write time and "now"
|
|
* according to the filesystem clock.
|
|
* b) + std::chrono::system_clock::now()
|
|
* - Shifts that duration to align with the system clock timeline.
|
|
* c) std::chrono::time_point_cast<std::chrono::system_clock::duration>(...)
|
|
* - Ensures the resulting time_point uses the correct duration type
|
|
* for std::chrono::system_clock.
|
|
*
|
|
* Result:
|
|
* - systemTime is a std::chrono::system_clock::time_point representing
|
|
* the same instant as timePoint, but compatible with system_clock.
|
|
*/
|
|
std::chrono::system_clock::time_point systemTimePoint =
|
|
std::chrono::time_point_cast<std::chrono::system_clock::duration>(
|
|
timePoint - fs::file_time_type::clock::now() + std::chrono::system_clock::now()
|
|
);
|
|
|
|
//Converts to seconds
|
|
std::time_t timeInSeconds = std::chrono::system_clock::to_time_t(systemTimePoint);
|
|
|
|
//Converts to local time, built in function
|
|
std::tm localTime = *std::localtime(&timeInSeconds);
|
|
|
|
// Format the time into a string using strftime
|
|
char buffer[20];
|
|
std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &localTime);
|
|
|
|
return std::string(buffer);
|
|
}
|