// NodeMonitor.cpp

#include <new>

#include <errno.h>
#include <sys/resource.h>

#include <AutoLocker.h>
#include <Message.h>
#include <Node.h>
#include <NodeMonitor.h>

#include "DebugSupport.h"
#include "NodeMonitor.h"
#include "NodeMonitoringEvent.h"

// node monitor constants
static const int32 kDefaultNodeMonitorLimit = 4096;
static const int32 kNodeMonitorLimitIncrement = 512;

// constructor
NodeMonitor::NodeMonitor(NodeMonitorListener* listener)
        : BLooper("node monitor", B_DISPLAY_PRIORITY, 1000),
          fListener(listener),
          fCurrentNodeMonitorLimit(kDefaultNodeMonitorLimit)
{
        // set the initial limit -- just to be sure
        struct rlimit rl;
        rl.rlim_cur = fCurrentNodeMonitorLimit;
        rl.rlim_max = RLIM_SAVED_MAX;
        setrlimit(RLIMIT_NOVMON, &rl);

        // start volume watching
        watch_node(NULL, B_WATCH_MOUNT, this);
}

// destructor
NodeMonitor::~NodeMonitor()
{
        // stop volume watching
        stop_watching(this);
}

// MessageReceived
void
NodeMonitor::MessageReceived(BMessage* message)
{
        switch (message->what) {
                case B_NODE_MONITOR:
                {
                        NodeMonitoringEvent* event = NULL;
                        int32 opcode;
                        if (message->FindInt32("opcode", &opcode) == B_OK) {
                                switch (opcode) {
                                        case B_ENTRY_CREATED:
                                                event = new(std::nothrow) EntryCreatedEvent;
                                                break;
                                        case B_ENTRY_REMOVED:
                                                event = new(std::nothrow) EntryRemovedEvent;
                                                break;
                                        case B_ENTRY_MOVED:
                                                event = new(std::nothrow) EntryMovedEvent;
                                                break;
                                        case B_STAT_CHANGED:
                                                event = new(std::nothrow) StatChangedEvent;
                                                break;
                                        case B_ATTR_CHANGED:
                                                event = new(std::nothrow) AttributeChangedEvent;
                                                break;
                                        case B_DEVICE_MOUNTED:
                                                event = new(std::nothrow) VolumeMountedEvent;
                                                break;
                                        case B_DEVICE_UNMOUNTED:
                                                event = new(std::nothrow) VolumeUnmountedEvent;
                                                break;
                                }
                        }
                        if (event) {
                                if (event->Init(message) == B_OK)
                                        fListener->ProcessNodeMonitoringEvent(event);
                                else
                                        delete event;
                        }
                        break;
                }
                default:
                        BLooper::MessageReceived(message);
        }
}

// StartWatching
status_t
NodeMonitor::StartWatching(const node_ref& ref)
{
        uint32 flags = B_WATCH_ALL;
        status_t error = watch_node(&ref, flags, this);
        // If starting to watch the node fail, we allocate more node
        // monitoring slots and try again.
        if (error != B_OK) {
                error = _IncreaseLimit();
                if (error == B_OK)
                        error = watch_node(&ref, flags, this);
        }
        if (error == B_OK) {
                PRINT("NodeMonitor: started watching node: "
                        "(%" B_PRIdDEV ", %" B_PRIdINO ")\n", ref.device, ref.node);
        }
        return error;
}

// StopWatching
status_t
NodeMonitor::StopWatching(const node_ref& ref)
{
        PRINT("NodeMonitor: stopped watching node: "
                "(%" B_PRIdDEV ", %" B_PRIdINO ")\n", ref.device, ref.node);
        return watch_node(&ref, B_STOP_WATCHING, this);
}

// _IncreaseLimit
status_t
NodeMonitor::_IncreaseLimit()
{
        AutoLocker<BLooper> _(this);

        int32 newLimit = fCurrentNodeMonitorLimit + kNodeMonitorLimitIncrement;
        struct rlimit rl;
        rl.rlim_cur = newLimit;
        rl.rlim_max = RLIM_SAVED_MAX;
        if (setrlimit(RLIMIT_NOVMON, &rl) < 0)
                return errno;

        fCurrentNodeMonitorLimit = newLimit;

        return B_OK;
}


// #pragma mark -

// constructor
NodeMonitorListener::NodeMonitorListener()
{
}

// destructor
NodeMonitorListener::~NodeMonitorListener()
{
}