ifmgr_cmd_queue.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 __IFMGR_CMD_QUEUE_HH__
#define __IFMGR_CMD_QUEUE_HH__


#include "libxorp/ref_ptr.hh"

class IfMgrCommandBase;

class IfMgrIfTree;
class IfMgrIfAtom;
class IfMgrVifAtom;
class IfMgrIPv4Atom;
#ifdef HAVE_IPV6
class IfMgrIPv6Atom;
#endif

class IfMgrCommandSinkBase {
public:
    typedef ref_ptr<IfMgrCommandBase> Cmd;
public:
    virtual void push(const Cmd& cmd) = 0;
    virtual ~IfMgrCommandSinkBase();
};

class IfMgrCommandTee : public IfMgrCommandSinkBase {
public:
    typedef IfMgrCommandSinkBase::Cmd Cmd;

public:
    IfMgrCommandTee(IfMgrCommandSinkBase& o1, IfMgrCommandSinkBase& o2);
    void push(const Cmd& cmd);

protected:
    IfMgrCommandSinkBase& _o1;
    IfMgrCommandSinkBase& _o2;
};


template <typename SinkType = IfMgrCommandSinkBase>
class IfMgrNWayCommandTee : public IfMgrCommandSinkBase {
public:
    typedef IfMgrCommandSinkBase::Cmd Cmd;
    typedef list<SinkType*> SinkList;

public:
    void push(const Cmd& cmd);

    bool add_sink(SinkType* sink);

    bool remove_sink(SinkType* sink);

protected:
    SinkList _sinks;
};

template <typename SinkType>
void
IfMgrNWayCommandTee<SinkType>::push(const Cmd& cmd)
{
    typename SinkList::iterator i;
    for (i = _sinks.begin(); i != _sinks.end(); ++i) {
    (*i)->push(cmd);
    }
}

template <typename SinkType>
bool
IfMgrNWayCommandTee<SinkType>::add_sink(SinkType* o)
{
    if (find(_sinks.begin(), _sinks.end(), o) != _sinks.end())
    return false;
    _sinks.push_back(o);
    return true;
}

template <typename SinkType>
bool
IfMgrNWayCommandTee<SinkType>::remove_sink(SinkType* o)
{
    typename SinkList::iterator i = find(_sinks.begin(), _sinks.end(), o);
    if (i == _sinks.end())
    return false;
    _sinks.erase(i);
    return true;
}


class IfMgrCommandDispatcher : public IfMgrCommandSinkBase {
public:
    typedef IfMgrCommandSinkBase::Cmd Cmd;

public:
    IfMgrCommandDispatcher(IfMgrIfTree& tree);

    void push(const Cmd& cmd);

    virtual bool execute();

protected:
    Cmd      _cmd;
    IfMgrIfTree& _iftree;
};

class IfMgrCommandQueueBase : public IfMgrCommandSinkBase {
public:
    typedef IfMgrCommandSinkBase::Cmd Cmd;
public:
    virtual void push(const Cmd& cmd) = 0;

    virtual bool empty() const = 0;

    virtual Cmd& front() = 0;

    virtual const Cmd& front() const = 0;

    virtual void pop_front() = 0;
};

class IfMgrCommandFifoQueue : public IfMgrCommandQueueBase {
public:
    typedef IfMgrCommandQueueBase::Cmd Cmd;

public:
    void    push(const Cmd& cmd);
    bool    empty() const;
    Cmd&    front();
    const Cmd&  front() const;
    void    pop_front();

protected:
    list<Cmd> _fifo;
};

class IfMgrCommandIfClusteringQueue : public IfMgrCommandQueueBase {
public:
    typedef IfMgrCommandQueueBase::Cmd Cmd;
    typedef list<Cmd> CmdList;

public:
    IfMgrCommandIfClusteringQueue();

    void    push(const Cmd& cmd);
    bool    empty() const;
    Cmd&    front();
    const Cmd&  front() const;
    void    pop_front();

protected:
    void    change_active_interface();

protected:
    string      _current_ifname;    // ifname of commands current
                            // commands queue
                            // last command output
    CmdList     _future_cmds;       // commands with ifname not
                        // matching _current_ifname
    CmdList     _current_cmds;
};


class IfMgrIfTreeToCommands {
public:
    IfMgrIfTreeToCommands(const IfMgrIfTree& tree)
    : _tree(tree)
    {}

    void convert(IfMgrCommandSinkBase& sink) const;

protected:
    const IfMgrIfTree& _tree;
};

class IfMgrIfAtomToCommands {
public:
    IfMgrIfAtomToCommands(const IfMgrIfAtom& interface)
    : _i(interface)
    {}

    void convert(IfMgrCommandSinkBase& sink) const;

protected:
    const IfMgrIfAtom& _i;
};

class IfMgrVifAtomToCommands {
public:
    IfMgrVifAtomToCommands(const string& ifn, const IfMgrVifAtom& vif)
    : _ifn(ifn), _v(vif)
    {}

    void convert(IfMgrCommandSinkBase& sink) const;

protected:
    const string&   _ifn;       // Interface name
    const IfMgrVifAtom& _v;
};

class IfMgrIPv4AtomToCommands {
public:
    IfMgrIPv4AtomToCommands(const string& ifn,
                const string& vifn,
                const IfMgrIPv4Atom& a)
    : _ifn(ifn), _vifn(vifn), _a(a)
    {}

    void convert(IfMgrCommandSinkBase& sink) const;

protected:
    const string& _ifn;
    const string& _vifn;
    const IfMgrIPv4Atom& _a;
};

#ifdef HAVE_IPV6

class IfMgrIPv6AtomToCommands {
public:
    IfMgrIPv6AtomToCommands(const string& ifn,
                const string& vifn,
                const IfMgrIPv6Atom& a)
    : _ifn(ifn), _vifn(vifn), _a(a)
    {}

    void convert(IfMgrCommandSinkBase& sink) const;

protected:
    const string&    _ifn;
    const string&    _vifn;
    const IfMgrIPv6Atom& _a;
};
#endif //ipv6

#endif // __IFMGR_CMD_QUEUE_HH__