rt_tab_redist.hh

// -*- c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t -*-

// 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 General Public License, Version 2, June
// 1991 as published by the Free Software Foundation. Redistribution
// and/or modification of this program under the terms of any other
// version of the GNU 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 General Public License, Version 2, a copy of which can be
// found in the XORP LICENSE.gpl file.
// 
// XORP Inc, 2953 Bunker Hill Lane, Suite 204, Santa Clara, CA 95054, USA;
// http://xorp.net

// $XORP: xorp/rib/rt_tab_redist.hh,v 1.19 2008/10/02 21:58:13 bms Exp $

#ifndef __RIB_RT_TAB_REDIST_HH__
#define __RIB_RT_TAB_REDIST_HH__



#include "rt_tab_base.hh"

template <typename A>
class Redistributor;

template <typename A>
class RedistOutput;

template <typename A>
class RedistPolicy;

#ifndef XORP_USE_USTL

template <typename A>
struct RedistNetCmp {
    bool operator() (const IPNet<A>& l, const IPNet<A>& r) const;
};
#endif


template<class A>
class RedistTable : public RouteTable<A> {
public:
#ifdef XORP_USE_USTL
    typedef set<IPNet<A> > RouteIndex;
#else
    typedef set<IPNet<A>,RedistNetCmp<A> > RouteIndex;
#endif

public:
    RedistTable(const string&   tablename,
        RouteTable<A>*  from_table);

    ~RedistTable();

    void add_redistributor(Redistributor<A>* r);

    void remove_redistributor(Redistributor<A>* r);

    Redistributor<A>* redistributor(const string& name);

    //
    // Standard RouteTable methods
    //
    int add_route(const IPRouteEntry<A>& route, RouteTable<A>* caller);
    int delete_route(const IPRouteEntry<A>* route, RouteTable<A>* caller);
    const IPRouteEntry<A>* lookup_route(const IPNet<A>& net) const;
    const IPRouteEntry<A>* lookup_route(const A& addr) const;
    RouteRange<A>* lookup_route_range(const A& addr) const;
    TableType type() const { return REDIST_TABLE; }
    RouteTable<A>* parent() { return _parent; }
    void replumb(RouteTable<A>* old_parent, RouteTable<A>* new_parent);
    string str() const;

    const RouteIndex& route_index() const { return _rt_index; }

protected:
    RouteTable<A>*  _parent;    // Immediately upstream table.  May
                    // differ from _from_table if a
                    // Deletion table or another redist
                    // table has been plumbed in.
    RouteIndex      _rt_index;
    list<Redistributor<A>*> _outputs;
};



template <typename A>
class Redistributor :
    public NONCOPYABLE
{
public:
    class RedistEventInterface {
    // Methods only available to RedistTable.
    void did_add(const IPRouteEntry<A>& ipr);
    void will_delete(const IPRouteEntry<A>& ipr);
    void did_delete(const IPRouteEntry<A>& ipr);

    friend class RedistTable<A>;
    friend class Redistributor<A>;

    public:
    RedistEventInterface(Redistributor<A>* r) : _r(r) {}

    private:
    Redistributor<A>* _r;
    };

    class OutputEventInterface {
    // Methods only available to RedistOutput.  These are
    // events it can tell us about.
    void low_water();
    void high_water();
    void fatal_error();

    friend class RedistOutput<A>;
    friend class Redistributor<A>;

    public:
    OutputEventInterface(Redistributor<A>* r) : _r(r) {}

    private:
    Redistributor<A>* _r;
    };

public:
    Redistributor(EventLoop& e, const string& name);
    virtual ~Redistributor();

    const string& name() const;

    void set_redist_table(RedistTable<A>* rt);

    void set_output(RedistOutput<A>* output);

    void set_policy(RedistPolicy<A>* policy);

    bool policy_accepts(const IPRouteEntry<A>& ipr) const;

    RedistEventInterface& redist_event()        { return _rei; }

    OutputEventInterface& output_event()        { return _oei; }

    bool dumping() const                { return _dumping; }

private:
    void start_dump();
    void finish_dump();

    void schedule_dump_timer();
    void unschedule_dump_timer();
    void dump_a_route();

    const IPNet<A>& last_dumped_net() const { return _last_net; }
    RedistTable<A>* redist_table()      { return _table; }
    RedistOutput<A>* output()           { return _output; }

private:
    // These are nested classes and need to be friends to invoke methods in
    // enclosing class.
    friend class RedistEventInterface;
    friend class OutputEventInterface;

private:
    EventLoop&          _e;
    string          _name;
    RedistTable<A>*     _table;
    RedistOutput<A>*        _output;
    RedistPolicy<A>*        _policy;

    RedistEventInterface    _rei;
    OutputEventInterface    _oei;

    bool            _dumping;   // Announcing existing routes
    bool            _blocked;   // Output above high water
    IPNet<A>            _last_net;  // Last net announced
    XorpTimer           _dtimer;

    static const IPNet<A> NO_LAST_NET;      // Indicator for last net inval
};



template <typename A>
class RedistOutput :
    public NONCOPYABLE
{
public:
    RedistOutput(Redistributor<A>* r);
    virtual ~RedistOutput();

    virtual void add_route(const IPRouteEntry<A>& ipr)      = 0;
    virtual void delete_route(const IPRouteEntry<A>& ipr)   = 0;

    virtual void starting_route_dump()              = 0;

    virtual void finishing_route_dump()             = 0;

protected:
    void announce_low_water()       { _r->output_event().low_water(); }
    void announce_high_water()      { _r->output_event().high_water(); }
    void announce_fatal_error()     { _r->output_event().fatal_error(); }

private:
    Redistributor<A>* _r;
};


// ----------------------------------------------------------------------------
// Inline RedistTable methods

#ifndef XORP_USE_USTL
template <typename A>
inline bool
RedistNetCmp<A>::operator() (const IPNet<A>& l, const IPNet<A>& r) const
{
    if (l.prefix_len() != r.prefix_len())
    return l.prefix_len() < r.prefix_len();
    return l.masked_addr() < r.masked_addr();
}
#endif

#endif // __RIB_RT_TAB_REDIST_HH__