SensorHandler.h

Go to the documentation of this file.

// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 4; tab-width: 4; -*-
// vim: set shiftwidth=4 softtabstop=4 expandtab:
/*
 ********************************************************************
 ** NIDAS: NCAR In-situ Data Acquistion Software
 **
 ** 2004, Copyright University Corporation for Atmospheric Research
 **
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU General Public License as published by
 ** the Free Software Foundation; either version 2 of the License, or
 ** (at your option) any later version.
 **
 ** This program is distributed in the hope that it will be useful,
 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ** GNU General Public License for more details.
 **
 ** The LICENSE.txt file accompanying this software contains
 ** a copy of the GNU General Public License. If it is not found,
 ** write to the Free Software Foundation, Inc.,
 ** 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 **
 ********************************************************************
*/

#ifndef NIDAS_CORE_PORTSELECTOR_H
#define NIDAS_CORE_PORTSELECTOR_H

#include <nidas/Config.h>

#include "DSMSensor.h"
#include "Polled.h"
#include "SensorOpener.h"
#include "RemoteSerialListener.h"
#include <nidas/util/Thread.h>
#include <nidas/util/ThreadSupport.h>
#include <nidas/util/IOException.h>

#include <sys/time.h>

#include <vector>
#include <set>

#if (((POLLING_METHOD == POLL_EPOLL_ET || POLLING_METHOD == POLL_EPOLL_LT) && !defined(HAVE_EPOLL_PWAIT)) || (POLLING_METHOD == POLL_POLL && !defined(HAVE_PPOLL)))
#define USE_NOTIFY_PIPE
#endif

namespace nidas { namespace core {

class SensorHandler:public nidas::util::Thread
{
public:

    friend class RemoteSerialConnection;
    friend class RemoteSerialListener;

    SensorHandler(unsigned short rserialPort = 0);

    ~SensorHandler();

    void signalHandler(int sig, siginfo_t*);

    void addSensor(DSMSensor * sensor);

    void closeSensor(DSMSensor * sensor);

    void sensorIsOpen(DSMSensor * sensor) throw();

    void checkSensors(dsm_time_t);

    void setSensorStatsInterval(int val)
    {
        _sensorStatsInterval = val * USECS_PER_MSEC;
    }
    int getSensorStatsInterval() const
    {
        return _sensorStatsInterval / USECS_PER_MSEC;
    }

    void handleRemoteSerial(int fd, DSMSensor * sensor)
     throw(nidas::util::IOException);

    int run() throw(nidas::util::Exception);

    std::list<DSMSensor*> getAllSensors() const;

    std::list<DSMSensor*> getOpenedSensors() const;

    void interrupt();

    int join() throw(nidas::util::Exception);

#if POLLING_METHOD == POLL_EPOLL_ET || POLLING_METHOD == POLL_EPOLL_LT
    int getEpollFd() const { return _epollfd; }
#endif

    void incrementFullBufferReads(const DSMSensor* sensor);


    void updateTimeouts()
    {
        _pollingChanged = true;
    }

private:

    class PolledDSMSensor : public Polled
    {
    public:
        PolledDSMSensor(DSMSensor* sensor,SensorHandler* handler)
            throw(nidas::util::IOException);

        ~PolledDSMSensor() {}

        bool handlePollEvents(uint32_t events) throw();

        DSMSensor* getDSMSensor() { return _sensor; }

        int getFd() const { return _sensor->getReadFd(); }

        const std::string getName() const { return _sensor->getName(); }

        int getTimeoutMsecs() const { return _sensor->getTimeoutMsecs(); }

        void setupTimeouts(int checkIntervalMsecs);

        bool checkTimeout();

        void close() throw(nidas::util::IOException);

    private:
        DSMSensor* _sensor;

        SensorHandler* _handler;

        int _nTimeoutChecks;

        int _nTimeoutChecksMax;

        int _lastCheckInterval;

        // no copying
        PolledDSMSensor(const PolledDSMSensor&);

        // no assignment
        PolledDSMSensor& operator = (const PolledDSMSensor&);

    };

#ifdef USE_NOTIFY_PIPE
    class NotifyPipe: public Polled
    {
    public:
        NotifyPipe(SensorHandler* handler) throw(nidas::util::IOException);

        ~NotifyPipe();

        bool handlePollEvents(uint32_t events) throw();

        void close() throw(nidas::util::IOException);

        void notify() throw();

        int getFd() const { return _fds[0]; }

    private:
        int _fds[2];
        SensorHandler* _handler;

        // no copying
        NotifyPipe(const NotifyPipe&);

        // no assignment
        NotifyPipe& operator = (const NotifyPipe&);
    };
#endif

    void add(DSMSensor* sensor) throw();

    void remove(PolledDSMSensor* sensor) throw();

    void scheduleClose(PolledDSMSensor*) throw();

    void scheduleReopen(PolledDSMSensor*) throw();

    void add(RemoteSerialConnection *) throw();

    void remove(RemoteSerialConnection *) throw();

    void scheduleAdd(RemoteSerialConnection*) throw();

    void scheduleClose(RemoteSerialConnection*) throw();

    void handlePollingChange();

    void calcStatistics(dsm_time_t);

    void setupTimeouts(int sensorCheckIntervalMsecs);

    void checkTimeouts(dsm_time_t);

    std::list<DSMSensor*> _allSensors;

    mutable nidas::util::Mutex _pollingMutex;

    bool _pollingChanged;

    std::list<DSMSensor*> _openedSensors;

    std::list<PolledDSMSensor*> _polledSensors;

    std::list<DSMSensor*> _newOpenedSensors;

    std::set<PolledDSMSensor*> _pendingSensorClosures;

    std::set<PolledDSMSensor*> _pendingSensorReopens;

    unsigned short _remoteSerialSocketPort;

    RemoteSerialListener *_rserial;

    std::list<RemoteSerialConnection*> _newRserials;

    std::set<RemoteSerialConnection*> _pendingRserialClosures;

    std::list<RemoteSerialConnection*> _activeRserialConns;

#if POLLING_METHOD == POLL_EPOLL_ET || POLLING_METHOD == POLL_EPOLL_LT

    int _epollfd;

    struct epoll_event* _events;

    int _nevents;

#elif POLLING_METHOD == POLL_PSELECT

    fd_set _rfdset;

    fd_set _efdset;

    int _nselect;

    int* _fds;

#elif POLLING_METHOD == POLL_POLL

    struct pollfd* _fds;

#endif

#if POLLING_METHOD == POLL_PSELECT || POLLING_METHOD == POLL_POLL

    Polled** _polled;

#if POLLING_METHOD == POLL_POLL
    nfds_t _nfds;
#else
    unsigned int _nfds;
#endif

    unsigned int _nAllocFds;

    struct timespec _timeout;

#endif

#ifdef USE_NOTIFY_PIPE
    NotifyPipe* _notifyPipe;
#endif

    dsm_time_t _sensorCheckTime;

    dsm_time_t _sensorStatsTime;

    int _sensorCheckIntervalMsecs;

    unsigned int _sensorCheckIntervalUsecs;

    unsigned int _sensorStatsInterval;

    SensorOpener _opener;

    std::map<const DSMSensor*,unsigned int> _fullBufferReads;

    bool _acceptingOpens;

    SensorHandler(const SensorHandler&);

    SensorHandler& operator=(const SensorHandler&);
};

}}                              // namespace nidas namespace core

#endif