xrl_router.hh

// -*- c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t -*-
// vim:set sts=4 ts=8:

// Copyright (c) 2001-2011 XORP, Inc and Others
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License, Version
// 2.1, June 1999 as published by the Free Software Foundation.
// Redistribution and/or modification of this program under the terms of
// any other version of the GNU Lesser General Public License is not
// permitted.
// 
// 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. For more details,
// see the GNU Lesser General Public License, Version 2.1, a copy of
// which can be found in the XORP LICENSE.lgpl file.
// 
// XORP, Inc, 2953 Bunker Hill Lane, Suite 204, Santa Clara, CA 95054, USA;
// http://xorp.net

#ifndef __LIBXIPC_XRL_ROUTER_HH__
#define __LIBXIPC_XRL_ROUTER_HH__

#include "libxorp/xorp.h"
#include "libxorp/callback.hh"

#include "xrl.hh"
#include "xrl_sender.hh"
#include "xrl_dispatcher.hh"
#include "xrl_pf.hh"
#include "finder_constants.hh"
#include "finder_client_observer.hh"

class DispatchState;

class FinderClient;
class FinderClientXrlTarget;
class FinderTcpAutoConnector;
class FinderDBEntry;
class XrlRouterDispatchState;

class XrlRouter :
    public XrlDispatcher,
    public XrlSender,
    public FinderClientObserver
{
public:
    typedef XrlSender::Callback XrlCallback;
    typedef XrlRouterDispatchState DispatchState;

public:
    XrlRouter(EventLoop&    e,
          const char*   class_name,
          const char*   finder_address,
          uint16_t      finder_port)
    throw (InvalidAddress);

    XrlRouter(EventLoop&    e,
          const char*   class_name,
          IPv4      finder_address,
          uint16_t      finder_port)
    throw (InvalidAddress);

    virtual ~XrlRouter();

    bool add_listener(XrlPFListener* listener);

    void finalize();

    bool finalized() const      { return _finalized; }

    bool connected() const;

    bool connect_failed() const;

    bool ready() const;

    bool failed() const;

    virtual string toString() const;

    bool send(const Xrl& xrl, const XrlCallback& cb);

    bool pending() const;

    bool add_handler_internal(const string& cmd,
                  const XrlRecvAsyncCallback& rcb);

    EventLoop& eventloop()      { return _e; }

    const string& instance_name() const { return _instance_name; }

    const string& class_name() const    { return XrlCmdMap::name(); }

    IPv4     finder_address() const;

    uint16_t finder_port() const;

    XI* lookup_xrl(const string& name) const;

#if 0
    void batch_start(const string& target);
    void batch_stop(const string& target);
#endif

protected:
    virtual void finder_connect_event();

    virtual void finder_disconnect_event();

    virtual void finder_ready_event(const string& tgt_name);

    void dispatch_xrl(const string&     method_name,
              const XrlArgs&        inputs,
              XrlDispatcherCallback outputs) const;

    void resolve_callback(const XrlError&     e,
              const FinderDBEntry*    dbe,
              XrlRouterDispatchState* ds);

    void send_callback(const XrlError&  e,
               XrlArgs*     reply,
               XrlPFSender* sender, // un-used, should be ref-ptr if we ever actually use this.
               XrlCallback  user_callback);

    bool send_resolved(const Xrl&       xrl,
               const FinderDBEntry* dbe,
               const XrlCallback&   dispatch_cb,
               bool  direct_call);

    void initialize(const char* class_name,
            IPv4    finder_addr,
            uint16_t    finder_port);

private:
    ref_ptr<XrlPFSender> lookup_sender(const Xrl& xrl, FinderDBEntry *dbe);

protected:
    EventLoop&          _e;
    FinderClient*       _fc;
    FinderClientXrlTarget*  _fxt;
    FinderTcpAutoConnector* _fac;
    string          _instance_name;
    bool            _finalized;

    list<XrlPFListener*>    _listeners;     // listeners
    list<XrlRouterDispatchState*> _dsl;         // dispatch state
    list< ref_ptr<XrlPFSender> > _senders;      // active senders

    static uint32_t     _icnt;          // instance count

private:
    typedef map<string, XI*>        XIM;

    mutable XIM         _xi_cache;
};

void wait_until_xrl_router_is_ready(EventLoop& e, XrlRouter& xr);

#endif // __LIBXIPC_XRL_ROUTER_HH__