FileMonitor Class Reference

#include <FileHelpers.hpp>

Public Member Functions
	FileMonitor (std::filesystem::path filePath, uint32_t notifyEvents=IN_MODIFY)
	FileMonitor (const FileMonitor &)=delete
	Copy constructor.
	FileMonitor (FileMonitor &&)=delete
	Move constructor.
FileMonitor &	operator= (FileMonitor)=delete
	Copy assignment operator.
FileMonitor &	operator= (FileMonitor &&)=delete
	Move assignment operator.
FNotifyCallback	notifyCallback () const
void	notifyCallback (FNotifyCallback func)
void	userPtr (const void *ptr)
	~FileMonitor ()

Private Member Functions
void	threadFunc (const std::stop_token &stopToken) const noexcept

Private Attributes
int	_fDescriptor {-1}
	File descriptor.
int	_wDescriptor {-1}
	Watch descriptor.
std::filesystem::path	_filePath
	File path.
FNotifyCallback	_notifyCallback
	Callback function.
uint32_t	_notifyEvents
	Notify types.
const void *	_userPtr = nullptr
	User pointer.
std::unique_ptr< std::jthread >	_thread
	Thread.

Detailed Description

Invokes functions for a file for given notify events

Definition at line 65 of file FileHelpers.hpp.

Constructor & Destructor Documentation

FileMonitor() [1/3]

FileMonitor::FileMonitor ( std::filesystem::path filePath, uint32_t notifyEvents = IN_MODIFY )

explicit

Constructor

Parameters

[in]	filePath	Path to the file
[in]	notifyEvents	Events to notify

Definition at line 58 of file FileHelpers.cpp.

    : _fDescriptor(inotify_init()), _filePath(std::move(filePath)), _notifyEvents(notifyEvents)
{
    if (_fDescriptor < 0)
    {
        throw std::ios_base::failure("Failed to initialize inotify");
    }
 
    _wDescriptor = inotify_add_watch(_fDescriptor, _filePath.c_str(), notifyEvents);
    if (_wDescriptor < 0)
    {
        close(_fDescriptor);
        throw std::ios_base::failure("Failed to add watch descriptor");
    }
 
    if (const int flags = fcntl(_fDescriptor, F_GETFL);
        flags < 0 || fcntl(_fDescriptor, F_SETFL, flags | O_NONBLOCK) < 0)
    {
        close(_fDescriptor);
        throw std::ios_base::failure("Failed to set file descriptor to non-blocking mode");
    }
 
    _thread = std::make_unique<std::jthread>([this](const std::stop_token &sToken) { threadFunc(sToken); });
}

Here is the call graph for this function:

Here is the caller graph for this function:

FileMonitor() [2/3]

FileMonitor::FileMonitor ( const FileMonitor & )

delete

Copy constructor.

Here is the call graph for this function:

FileMonitor() [3/3]

FileMonitor::FileMonitor ( FileMonitor && )

delete

Move constructor.

Here is the call graph for this function:

~FileMonitor()

FileMonitor::~FileMonitor

(

)

Destructor

Definition at line 83 of file FileHelpers.cpp.

{
    if (_thread)
    {
        _thread.reset();
    }
 
    // Remove watch descriptor first
    if (_wDescriptor >= 0)
    {
        if (inotify_rm_watch(_fDescriptor, _wDescriptor) < 0)
        {
            try
            {
                spdlog::error("Failed to remove watch descriptor: {}", getErrnoString(errno));
            }
            catch (const std::exception &e)
            {
                const auto errStr = getErrnoString(errno);
                (void)std::fprintf(stderr,
                                   "Failed to remove watch descriptor and also logger thrown an exception: %s %s\n",
                                   errStr.c_str(), e.what());
            }
        }
        _wDescriptor = -1;
    }
 
    // Then close the file descriptor
    if (_fDescriptor >= 0)
    {
        if (close(_fDescriptor) < 0)
        {
            try
            {
                spdlog::error("Failed to close file descriptor: {}", getErrnoString(errno));
            }
            catch (const std::exception &e)
            {
                const auto errStr = getErrnoString(errno);
                (void)std::fprintf(stderr,
                                   "Failed to close file descriptor and also logger thrown an exception: %s %s\n",
                                   errStr.c_str(), e.what());
            }
        }
        _fDescriptor = -1;
    }
}

Here is the call graph for this function:

Member Function Documentation

notifyCallback() [1/2]

FNotifyCallback FileMonitor::notifyCallback ( ) const

inlinenodiscard

Definition at line 105 of file FileHelpers.hpp.

{ return _notifyCallback; }

notifyCallback() [2/2]

void FileMonitor::notifyCallback ( FNotifyCallback func )

inline

Definition at line 106 of file FileHelpers.hpp.

{ _notifyCallback = std::move(func); }

operator=() [1/2]

FileMonitor & FileMonitor::operator= ( FileMonitor && )

delete

Move assignment operator.

Here is the call graph for this function:

operator=() [2/2]

FileMonitor & FileMonitor::operator= ( FileMonitor )

delete

Copy assignment operator.

Here is the call graph for this function:

threadFunc()

void FileMonitor::threadFunc ( const std::stop_token & stopToken ) const

privatenoexcept

Definition at line 17 of file FileHelpers.cpp.

{
    while (!stopToken.stop_requested())
    {
        // Buffer for reading events
        unsigned int nBytes = 0;
        if (ioctl(_fDescriptor, FIONREAD, &nBytes) < 0)
        {
            spdlog::error("Failed to get available events for file monitoring: {}", getErrnoString(errno));
        }
 
        auto buffer = std::vector<char>(nBytes + 1, '\0');
        auto nRead = read(_fDescriptor, buffer.data(), nBytes);
        if (nRead < 0 && errno != EAGAIN)
        {
            spdlog::error("Failed to read events for file monitoring: {}", getErrnoString(errno));
        }
        else if (nRead == 0)
        {
            spdlog::debug("No events read for file monitoring");
        }
 
        ssize_t idx = 0;
        while (_notifyCallback && idx < nRead)
        {
            const auto *event = std::bit_cast<inotify_event *>(&buffer[static_cast<size_t>(idx)]);
 
            // Check if file notify type matches
            if ((event->mask & _notifyEvents) != 0)
            {
                _notifyCallback(_userPtr);
                break;
            }
 
            idx += static_cast<ssize_t>(sizeof(inotify_event) + event->len);
        }
 
        std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_INTERVAL_MS));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

userPtr()

void FileMonitor::userPtr ( const void * ptr )

inline

Sets user pointer

Parameters

[in]

ptr

User pointer

Definition at line 112 of file FileHelpers.hpp.

{ _userPtr = ptr; }

Member Data Documentation

_fDescriptor

int FileMonitor::_fDescriptor {-1}

private

File descriptor.

Definition at line 68 of file FileHelpers.hpp.

{-1};

_filePath

std::filesystem::path FileMonitor::_filePath

private

File path.

Definition at line 72 of file FileHelpers.hpp.

_notifyCallback

FNotifyCallback FileMonitor::_notifyCallback

private

Callback function.

Definition at line 74 of file FileHelpers.hpp.

_notifyEvents

uint32_t FileMonitor::_notifyEvents

private

Notify types.

Definition at line 76 of file FileHelpers.hpp.

_thread

std::unique_ptr<std::jthread> FileMonitor::_thread

private

Thread.

Definition at line 81 of file FileHelpers.hpp.

_userPtr

const void* FileMonitor::_userPtr = nullptr

private

User pointer.

Definition at line 78 of file FileHelpers.hpp.

_wDescriptor

int FileMonitor::_wDescriptor {-1}

private

Watch descriptor.

Definition at line 70 of file FileHelpers.hpp.

{-1};

---

The documentation for this class was generated from the following files:

• /__w/Repo-Init/Repo-Init/include/utils/FileHelpers.hpp
• /__w/Repo-Init/Repo-Init/src/utils/FileHelpers.cpp