yatengine.h

#ifndef __YATENGINE_H
#define __YATENGINE_H

#ifndef __cplusplus
#error C++ is required
#endif

#include <yateclass.h>

namespace TelEngine {

class YATE_API Configuration : public String
{
    YNOCOPY(Configuration); // no automatic copies please
public:
    Configuration();

    explicit Configuration(const char* filename, bool warn = true);

    inline Configuration& operator=(const String& value)
        { String::operator=(value); return *this; }

    inline unsigned int sections() const
        { return m_sections.length(); }

    inline unsigned int count() const
        { return m_sections.count(); }

    NamedList* getSection(unsigned int index) const;

    NamedList* getSection(const String& sect) const;

    NamedString* getKey(const String& sect, const String& key) const;

    const char* getValue(const String& sect, const String& key, const char* defvalue = 0) const;

    int getIntValue(const String& sect, const String& key, int defvalue = 0,
        int minvalue = INT_MIN, int maxvalue = INT_MAX, bool clamp = true) const;

    int getIntValue(const String& sect, const String& key, const TokenDict* tokens, int defvalue = 0) const;

    int64_t getInt64Value(const String& sect, const String& key, int64_t defvalue = 0,
        int64_t minvalue = LLONG_MIN, int64_t maxvalue = LLONG_MAX, bool clamp = true) const;

    double getDoubleValue(const String& sect, const String& key, double defvalue = 0.0) const;

    bool getBoolValue(const String& sect, const String& key, bool defvalue = false) const;

    void clearSection(const char* sect = 0);

    NamedList* createSection(const String& sect);

    void clearKey(const String& sect, const String& key);

    void addValue(const String& sect, const char* key, const char* value = 0);

    void setValue(const String& sect, const char* key, const char* value = 0);

    void setValue(const String& sect, const char* key, int value);

    void setValue(const String& sect, const char* key, bool value);

    bool load(bool warn = true);

    bool save() const;

private:
    ObjList *getSectHolder(const String& sect) const;
    ObjList *makeSectHolder(const String& sect);
    bool loadFile(const char* file, String sect, unsigned int depth, bool warn);
    ObjList m_sections;
};

class YATE_API SharedVars : public Mutex
{
public:
    inline SharedVars()
        : Mutex(false,"SharedVars"), m_vars("")
        { }

    void get(const String& name, String& rval);

    void set(const String& name, const char* val);

    bool create(const String& name, const char* val = 0);

    void clear(const String& name);

    bool exists(const String& name);

    unsigned int inc(const String& name, unsigned int wrap = 0);

    unsigned int dec(const String& name, unsigned int wrap = 0);

private:
    NamedList m_vars;
};

class MessageDispatcher;
class MessageRelay;
class Engine;

class YATE_API Message : public NamedList
{
    friend class MessageDispatcher;
public:
    explicit Message(const char* name, const char* retval = 0, bool broadcast = false);

    Message(const Message& original);

    Message(const Message& original, bool broadcast);

    ~Message();

    virtual void* getObject(const String& name) const;

    inline String& retValue()
        { return m_return; }

    inline const String& retValue() const
        { return m_return; }

    inline RefObject* userData() const
        { return m_data; }

    void userData(RefObject* data);

    inline void* userObject(const String& name) const
        { return m_data ? m_data->getObject(name) : 0; }


    inline void setNotify(bool notify = true)
        { m_notify = notify; }

    inline bool broadcast() const
        { return m_broadcast; }

    inline Time& msgTime()
        { return m_time; }

    inline const Time& msgTime() const
        { return m_time; }

    inline Message& operator=(const char* value)
        { String::operator=(value); return *this; }

    String encode(const char* id) const;

    String encode(bool received, const char* id) const;

    int decode(const char* str, String& id);

    int decode(const char* str, bool& received, const char* id);

protected:
    virtual void dispatched(bool accepted);

private:
    Message(); // no default constructor please
    Message& operator=(const Message& value); // no assignment please
    String m_return;
    Time m_time;
    RefObject* m_data;
    bool m_notify;
    bool m_broadcast;
    void commonEncode(String& str) const;
    int commonDecode(const char* str, int offs);
};

class YATE_API MessageHandler : public String
{
    friend class MessageDispatcher;
    YNOCOPY(MessageHandler); // no automatic copies please
public:
    explicit MessageHandler(const char* name, unsigned priority = 100,
        const char* trackName = 0, bool addPriority = true);

    virtual ~MessageHandler();

    virtual void destruct();

    virtual bool received(Message& msg) = 0;

    inline unsigned priority() const
        { return m_priority; }

    inline const String& trackName() const
        { return m_trackName; }

    inline void trackName(const char* name)
        { if (!m_dispatcher) m_trackName = name; }

    inline NamedCounter* objectsCounter() const
        { return m_counter; }

    inline const NamedString* filter() const
        { return m_filter; }

    void setFilter(NamedString* filter);

    inline void setFilter(const char* name, const char* value)
        { setFilter(new NamedString(name,value)); }

    void clearFilter();

protected:
    void cleanup();

    virtual bool receivedInternal(Message& msg);

    void safeNowInternal();

private:
    String m_trackName;
    unsigned m_priority;
    int m_unsafe;
    MessageDispatcher* m_dispatcher;
    NamedString* m_filter;
    NamedCounter* m_counter;
};

class YATE_API MessageReceiver : public GenObject
{
public:
    virtual bool received(Message& msg, int id) = 0;
};

class YATE_API MessageRelay : public MessageHandler
{
    YNOCOPY(MessageRelay); // no automatic copies please
public:
    inline MessageRelay(const char* name, MessageReceiver* receiver, int id,
        int priority = 100, const char* trackName = 0, bool addPriority = true)
        : MessageHandler(name,priority,trackName,addPriority),
          m_receiver(receiver), m_id(id)
        { }

    virtual bool received(Message& msg)
        { return m_receiver && m_receiver->received(msg,m_id); }

    inline int id() const
        { return m_id; }

    virtual bool receivedInternal(Message& msg);

private:
    MessageReceiver* m_receiver;
    int m_id;
};

class YATE_API MessageNotifier
{
public:
    virtual ~MessageNotifier();

    virtual void dispatched(const Message& msg, bool handled) = 0;
};

class YATE_API MessagePostHook : public RefObject, public MessageNotifier
{
};

class YATE_API MessageDispatcher : public GenObject, public Mutex
{
    friend class Engine;
    YNOCOPY(MessageDispatcher); // no automatic copies please
public:
    MessageDispatcher(const char* trackParam = 0);

    ~MessageDispatcher();

    inline const String& trackParam() const
        { return m_trackParam; }

    bool install(MessageHandler* handler);

    bool uninstall(MessageHandler* handler);

    bool dispatch(Message& msg);

    bool enqueue(Message* msg);

    void dequeue();

    bool dequeueOne();

    inline void warnTime(u_int64_t usec)
        { m_warnTime = usec; }

    inline void clear()
        { m_handlers.clear(); m_hookAppend = &m_hooks; m_hooks.clear(); }

    unsigned int messageCount();

    unsigned int handlerCount();

    unsigned int postHookCount();

    u_int64_t enqueueCount() const
        { return m_enqueueCount; }

    u_int64_t dequeueCount() const
        { return m_dequeueCount; }

    u_int64_t dispatchCount() const
        { return m_dispatchCount; }

    u_int64_t queuedMax() const
        { return m_queuedMax; }

    u_int64_t messageAge(bool usec = false) const
        { return usec ? m_msgAvgAge : ((m_msgAvgAge + 500) / 1000); }

    void getStats(u_int64_t& enqueued, u_int64_t& dequeued, u_int64_t& dispatched, u_int64_t& queueMax);

    void setHook(MessagePostHook* hook, bool remove = false);

protected:
    inline void trackParam(const char* paramName)
        { m_trackParam = paramName; }

private:
    ObjList m_handlers;
    ObjList m_messages;
    ObjList m_hooks;
    Mutex m_hookMutex;
    ObjList* m_msgAppend;
    ObjList* m_hookAppend;
    String m_trackParam;
    unsigned int m_changes;
    u_int64_t m_warnTime;
    u_int64_t m_enqueueCount;
    u_int64_t m_dequeueCount;
    u_int64_t m_dispatchCount;
    u_int64_t m_queuedMax;
    u_int64_t m_msgAvgAge;
    int m_hookCount;
    bool m_hookHole;
};

class YATE_API MessageHook : public RefObject
{
public:
    virtual bool enqueue(Message* msg) = 0;

    virtual void clear() = 0;

    virtual bool matchesFilter(const Message& msg) = 0;
};


class YATE_API MessageQueue : public MessageHook, public Mutex
{
    friend class Engine;
public:
    MessageQueue(const char* hookName, int numWorkers = 0);

    ~MessageQueue();

    virtual bool enqueue(Message* msg);

    bool dequeue();

    void addFilter(const char* name, const char* value);

    void removeFilter(const String& name);

    virtual void clear();

    void removeThread(Thread* thread);

    inline unsigned int count() const
        { return m_count; }

    inline const NamedList& getFilters() const
        { return m_filters; }

    virtual bool matchesFilter(const Message& msg);
protected:

    virtual void received(Message& msg);

private:
    NamedList m_filters;
    ObjList m_messages;
    ObjList m_workers;
    ObjList* m_append;
    unsigned int m_count;
};


class YATE_API Plugin : public GenObject, public DebugEnabler
{
public:
    explicit Plugin(const char* name, bool earlyInit = false);

    virtual ~Plugin();

    virtual const String& toString() const
        { return m_name; }

    virtual void* getObject(const String& name) const;

    virtual void initialize() = 0;

    virtual bool isBusy() const
        { return false; }

    inline const String& name() const
        { return m_name; }

    inline NamedCounter* objectsCounter() const
        { return m_counter; }

    bool earlyInit() const
        { return m_early; }

private:
    Plugin(); // no default constructor please
    String m_name;
    NamedCounter* m_counter;
    bool m_early;
};

#if 0 /* for documentation generator */

void INIT_PLUGIN(class pclass);

bool UNLOAD_PLUGIN(bool unloadNow);
#endif

#define INIT_PLUGIN(pclass) static pclass __plugin
#ifdef DISABLE_UNLOAD
#define UNLOAD_PLUGIN(arg) static bool _unused_unload(bool arg)
#else
#ifdef _WINDOWS
#define UNLOAD_PLUGIN(arg) extern "C" __declspec(dllexport) bool _unload(bool arg)
#else
#define UNLOAD_PLUGIN(arg) extern "C" bool _unload(bool arg)
#endif
#endif

class YATE_API EngineCheck
{
public:
    virtual ~EngineCheck()
        { }

    virtual bool check(const ObjList* cmds) = 0;

    static void setChecker(EngineCheck* ptr = 0);
};

typedef int (*EngineLoop)();

class YATE_API Engine
{
    friend class EnginePrivate;
    friend class EngineCommand;
    YNOCOPY(Engine); // no automatic copies please
public:
    enum RunMode {
        Stopped = 0,
        Console = 1,
        Server = 2,
        Client = 3,
        ClientProxy = 4,
    };

    enum CallAccept {
        Accept = 0,
        Partial = 1,
        Congestion = 2,
        Reject = 3,
    };

    enum PluginMode {
        LoadFail = 0,
        LoadLate,
        LoadEarly
    };

    static int main(int argc, const char** argv, const char** env,
        RunMode mode = Console, EngineLoop loop = 0, bool fail = false);

    static void help(bool client, bool errout = false);

    int engineInit();

    int engineCleanup();

    int run();

    static Engine* self();

    static RunMode mode()
        { return s_mode; }

    inline static CallAccept accept() {
        return (s_congestion && (s_accept < Congestion)) ? Congestion : s_accept;
    }

    inline static void setAccept(CallAccept ca) {
        s_accept = ca;
    }

    inline static const TokenDict* getCallAcceptStates() {
        return s_callAccept;
    }

    static void setCongestion(const char* reason = 0);

    static unsigned int getCongestion()
        { return s_congestion; }

    inline static bool clientMode()
        { return (s_mode == Client) || (s_mode == ClientProxy); }

    static bool Register(const Plugin* plugin, bool reg = true);

    inline static const String& nodeName()
        { return s_node; }

    inline static const String& sharedPath()
        { return s_shrpath; }

    static String configFile(const char* name, bool user = false);

    static const String& configPath(bool user = false);

    inline static const String& configSuffix()
        { return s_cfgsuffix; }

    inline static const String& modulePath()
        { return s_modpath; }

    static void extraPath(const String& path);

    static void userPath(const String& path);

    inline static const String& moduleSuffix()
        { return s_modsuffix; }

    static const char* pathSeparator();

    static const Configuration& config();

    static unsigned int runId();

    inline static const NamedList& runParams()
        { return s_params; }

    static void init();

    static bool init(const String& name);

    static void halt(unsigned int code);

    static bool restart(unsigned int code, bool gracefull = false);

    static bool started()
        { return s_started; }

    static bool exiting()
        { return (s_haltcode != -1); }

    static bool install(MessageHandler* handler);

    static bool uninstall(MessageHandler* handler);

    static bool enqueue(Message* msg, bool skipHooks = false);

    inline static bool enqueue(const char* name, bool broadcast = false)
        { return name && *name && enqueue(new Message(name,0,broadcast)); }

    static bool dispatch(Message* msg);

    static bool dispatch(Message& msg);

    static bool dispatch(const char* name, bool broadcast = false);

    inline void setHook(MessagePostHook* hook, bool remove = false)
        { m_dispatcher.setHook(hook,remove); }

    inline static const String& trackParam()
        { return s_self ? s_self->m_dispatcher.trackParam() : String::empty(); }

    static bool installHook(MessageHook* hook);

    static void uninstallHook(MessageHook* hook);

    int usedPlugins();

    inline unsigned int messageCount()
        { return m_dispatcher.messageCount(); }

    inline unsigned int handlerCount()
        { return m_dispatcher.handlerCount(); }

    inline unsigned int postHookCount()
        { return m_dispatcher.postHookCount(); }

    inline unsigned int messageRate() const
        { return m_messageRate; }

    inline unsigned int messageMaxRate() const
        { return m_maxMsgRate; }

    unsigned int messageAge(bool usec = false) const
        { return (unsigned int)m_dispatcher.messageAge(usec); }

    inline void getStats(u_int64_t& enqueued, u_int64_t& dequeued, u_int64_t& dispatched, u_int64_t& queueMax)
        { m_dispatcher.getStats(enqueued,dequeued,dispatched,queueMax); }

    bool loadPluginDir(const String& relPath);

    static void pluginMode(PluginMode mode);

    static const ObjList* events(const String& type);

    static void clearEvents(const String& type);

    static SharedVars& sharedVars();

    static void buildCmdLine(String& line);

    static void initLibrary(const String& line, String* output = 0);

    static int cleanupLibrary();

protected:
    ~Engine();

    bool loadPlugin(const char* file, bool local = false, bool nounload = false);

    void loadPlugins();

    void initPlugins();

private:
    Engine();
    void internalStatisticsStart();
    void tryPluginFile(const String& name, const String& path, bool defload);
    ObjList m_libs;
    MessageDispatcher m_dispatcher;
    uint64_t m_dispatchedLast;
    unsigned int m_messageRate;
    unsigned int m_maxMsgRate;
    bool m_rateCongested;
    bool m_queueCongested;
    bool m_ageCongested;
    static Engine* s_self;
    static String s_node;
    static String s_shrpath;
    static String s_cfgsuffix;
    static String s_modpath;
    static String s_modsuffix;
    static ObjList s_extramod;
    static NamedList s_params;
    static int s_haltcode;
    static RunMode s_mode;
    static bool s_started;
    static unsigned int s_congestion;
    static CallAccept s_accept;
    static const TokenDict s_callAccept[];
};

}; // namespace TelEngine

#endif /* __YATENGINE_H */

/* vi: set ts=8 sw=4 sts=4 noet: */