Status.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_STATUS_H_
#define _MIRA_STATUS_H_

#include <sstream>
#include <list>

#ifndef Q_MOC_RUN
#include <boost/optional.hpp>
#endif

#include <utils/Time.h>
#include <serialization/Serialization.h>
#include <serialization/adapters/std/map>

namespace mira {


class Status
{
public:
    enum StatusMode
    {
        OK,
        BOOTUP,
        RECOVER,
        WARNING,
        ERROR,
    };

public:

    Status() :
        mode(OK)
    {}

    Status(StatusMode iMode, const std::string& iCategory,
           const std::string& iTrText, const std::string& iMessage) :
        mode(iMode),
        category(iCategory),
        trText(iTrText),
        message(iMessage)
    {}

    bool operator==(const Status& other) const
    {
        return mode == other.mode &&
            category == other.category &&
            trText == other.trText &&
            message == other.message;
    }

    template <typename Reflector>
    void reflect(Reflector& r)
    {
        r.member("Mode", mode, "Status mode");
        r.member("Category", category, "Category");
        r.member("TranslatedText", trText, "Translated text");
        r.member("Message", message, "Message");
    }

public:

    StatusMode mode;

    std::string category;

    std::string trText;

    std::string message;
};


class DiagnosticsModule
{
public:

    typedef std::map<std::string, Status> StatusMap;

    DiagnosticsModule(const std::string& name="") :
        mHeartbeatInterval(Duration::seconds(1)),
        mName(name) {}

    virtual ~DiagnosticsModule() {}

    void setHeartbeatInterval(const Duration& interval)
    {
        mHeartbeatInterval = interval;
    }

    void setName(const std::string& name)
    {
        mName = name;
    }

    Duration getHeartbeatInterval() const
    {
        return mHeartbeatInterval;
    }

    void heartbeat()
    {
        mLastHeartbeat.reset(Time::now());
    }

    bool hasHeartbeatTimeout() const
    {
        return mLastHeartbeat && (Time::now()-*mLastHeartbeat) > mHeartbeatInterval;
    }

    void bootup(const std::string& message, const std::string& trText="");

    void bootupFinished();

    void recoverFinished();

    void recover(const std::string& message, const std::string& trText="");

    void ok(const std::string& category="");

    bool warning(const std::string& category, const std::string& message,
                 const std::string& trText="");

    bool error(const std::string& category, const std::string& message,
               const std::string& trText="");

    bool setStatus(Status::StatusMode mode, const std::string& category,
                   const std::string& message, const std::string& trText="");

    Status::StatusMode getStatus() const;

    StatusMap getStatusMap() const;

protected:

    boost::optional<Status> mBootUpStatus;
    boost::optional<Status> mRecoverStatus;
    Duration mHeartbeatInterval;
    boost::optional<Time> mLastHeartbeat;
    StatusMap mStatusMap;
    std::string mName;
};

typedef DiagnosticsModule* DiagnosticsModulePtr;


class StatusManager
{
public:

    typedef std::multimap<std::string, Status> StatusMap;

    static Status::StatusMode getOverallStatus(StatusMap::const_iterator start,
                                               StatusMap::const_iterator end)
    {
        Status::StatusMode mostSevereMode = Status::OK;
        for(auto i = start; i != end; ++i)
        {
            if (mostSevereMode < i->second.mode)
                mostSevereMode = i->second.mode;
        }
        return mostSevereMode;
    }

    void setID(const std::string& id)
    {
        mID = id;
    }

    Status::StatusMode getStatus() const;

    Status::StatusMode getStatus(const std::string& diagnosticModule) const;

    void registerDiagnostics(const std::string& name, DiagnosticsModulePtr ptr);

    void unregisterDiagnostics(const std::string& name);

    void unregisterDiagnostics(DiagnosticsModulePtr ptr);

    std::vector<std::string> getDiagnosticModules() const;

    StatusMap getStatusMap() const;

    DiagnosticsModule::StatusMap getStatusMap(const std::string& diagnosticModule) const;

    template <typename Reflector>
    void reflect(Reflector& r)
    {
    } // do nothing here

private:
    typedef std::map<std::string, DiagnosticsModulePtr> ModuleMap;
    // vector used for storing the order the modules were registered
    std::vector<std::string> mModuleOrder;
    mutable boost::mutex mModuleMutex;
    ModuleMap mModules;
    StatusMap mStatus;
    std::string mID;
};


}

#endif