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);
 
    int run();
 
    std::list<DSMSensor*> getAllSensors() const;
 
    std::list<DSMSensor*> getOpenedSensors() const;
 
    void interrupt();
 
    int join();
 
#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);
 
        ~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();
 
    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);
 
        ~NotifyPipe();
 
        bool handlePollEvents(uint32_t events);
 
        void close();
 
        void notify();
 
        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;
 
    bool getPollingChanged();
 
    void setPollingChanged();
 
    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