ifmap_xmpp.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
 */
 
#ifndef __XMPP_IFMAP_INC__
#define __XMPP_IFMAP_INC__
 
#include <boost/function.hpp>
#include <boost/system/error_code.hpp>
#include <tbb/atomic.h>
 
#include <map>
#include <string>
 
#include "base/queue_task.h"
#include "ifmap/ifmap_client.h"
#include "ifmap/ifmap_server.h"
#include "xmpp/xmpp_channel.h"
 
class XmppChannel;
class XmppServer;
class IFMapChannelManager;
class IFMapXmppChannelMapEntry;
 
// Xmpp Channel Events
enum XCEvent {
    XCE_NOT_READY = 1,
    XCE_VR_SUBSCRIBE = 2,
    XCE_VM_SUBSCRIBE = 3,
    XCE_VM_UNSUBSCRIBE = 4,
};
 
struct ChannelEventInfo {
    XCEvent event;
    XmppChannel *channel;
    std::string name;
};
 
class IFMapXmppChannel {
public:
    static const std::string NoFqnSet;
    class IFMapSender;
    IFMapXmppChannel(XmppChannel *, IFMapServer *, IFMapChannelManager *);
    virtual ~IFMapXmppChannel();
 
    std::string ToString() const { return channel_->ToString(); } // hostname
    IFMapClient *Sender();
 
    virtual void ReceiveUpdate(const XmppStanza::XmppMessage *);
    XmppChannel *channel() { return channel_; }
 
    void ClearCounters();
    uint64_t msgs_sent() const;
    std::string VrSubscribeGetVrName(const std::string &iqnode,
                                     bool *valid_message);
    std::string VmSubscribeGetVmUuid(const std::string &iqnode,
                                     bool *valid_message);
    bool MustProcessChannelNotReady();
 
    void ProcessVrSubscribe(const std::string &identifier);
    void EnqueueVrSubscribe(const std::string &identifier);
 
    void ProcessVmSubscribe(const std::string &vm_uuid);
    void ProcessVmUnsubscribe(const std::string &vm_uuid);
    void EnqueueVmSubUnsub(bool subscribe, const std::string &vm_uuid);
    bool get_client_added() { return client_added_; }
    const std::string& channel_name() { return channel_name_; }
    const std::string& FQName() const;
 
private:
    friend class XmppIfmapTest;
    void WriteReadyCb(const boost::system::error_code &ec);
 
    xmps::PeerId peer_id_;
    XmppChannel *channel_;
    IFMapServer *ifmap_server_;
    IFMapChannelManager *ifmap_channel_manager_;
    IFMapSender *ifmap_client_;
    bool client_added_;  // true if ifmap_server has processed add-client
    std::string channel_name_;
};
 
class IFMapChannelManager {
public:
    IFMapChannelManager(XmppServer *, IFMapServer *);
    virtual ~IFMapChannelManager();
 
    IFMapXmppChannel *FindChannel(XmppChannel *);
    IFMapXmppChannel *FindChannel(std::string);
    void IFMapXmppChannelEventCb(XmppChannel *, xmps::PeerState);
    virtual IFMapXmppChannel *CreateIFMapXmppChannel(XmppChannel *);
    void EnqueueChannelUnregister(XmppChannel *channel);
    void ProcessChannelReady(XmppChannel *channel);
    void ProcessChannelNotReady(XmppChannel *channel);
 
    void incr_unknown_subscribe_messages() { ++unknown_subscribe_messages; }
    void incr_unknown_unsubscribe_messages() { ++unknown_unsubscribe_messages; }
    void incr_duplicate_channel_ready_messages() {
        ++duplicate_channel_ready_messages;
    }
    void incr_invalid_channel_not_ready_messages() {
        ++invalid_channel_not_ready_messages;
    }
    void incr_invalid_channel_state_messages() {
        ++invalid_channel_state_messages;
    }
    void incr_invalid_vm_subscribe_messages() {
        ++invalid_vm_subscribe_messages;
    }
    void incr_vmsub_novrsub_messages() {
        ++vmsub_novrsub_messages;
    }
    void incr_vmunsub_novrsub_messages() {
        ++vmunsub_novrsub_messages;
    }
    void incr_vmunsub_novmsub_messages() {
        ++vmunsub_novmsub_messages;
    }
    void incr_duplicate_vrsub_messages() {
        ++duplicate_vrsub_messages;
    }
    void incr_duplicate_vmsub_messages() {
        ++duplicate_vmsub_messages;
    }
 
    uint64_t get_unknown_subscribe_messages() {
        return unknown_subscribe_messages;
    }
    uint64_t get_unknown_unsubscribe_messages() {
        return unknown_unsubscribe_messages;
    }
    uint64_t get_duplicate_channel_ready_messages() {
        return duplicate_channel_ready_messages;
    }
    uint64_t get_invalid_channel_not_ready_messages() {
        return invalid_channel_not_ready_messages;
    }
    uint64_t get_invalid_channel_state_messages() {
        return invalid_channel_state_messages;
    }
    uint64_t get_invalid_vm_subscribe_messages() {
        return invalid_vm_subscribe_messages;
    }
    uint64_t get_vmsub_novrsub_messages() {
        return vmsub_novrsub_messages;
    }
    uint64_t get_vmunsub_novrsub_messages() {
        return vmunsub_novrsub_messages;
    }
    uint64_t get_vmunsub_novmsub_messages() {
        return vmunsub_novmsub_messages;
    }
    uint64_t get_duplicate_vrsub_messages() {
        return duplicate_vrsub_messages;
    }
    uint64_t get_duplicate_vmsub_messages() {
        return duplicate_vmsub_messages;
    }
    void FillChannelMap(std::vector<IFMapXmppChannelMapEntry> *out_map);
 
private:
    friend class IFMapChannelManagerTest;
    friend class XmppIfmapTest;
    typedef std::map<XmppChannel *, IFMapXmppChannel *> ChannelMap;
    struct ConfigTaskQueueEntry {
        XmppChannel *channel;
    };
 
    XmppServer *xmpp_server_;
    IFMapServer *ifmap_server_;
    ChannelMap channel_map_;
    tbb::mutex channel_map_mutex_; // serializes access to channel_map_
    WorkQueue<ConfigTaskQueueEntry> config_task_work_queue_;
 
    bool ProcessChannelUnregister(ConfigTaskQueueEntry entry);
 
    void DeleteIFMapXmppChannel(IFMapXmppChannel *ifmap_chnl);
    void EnqueueChannelEvent(XCEvent event, XmppChannel *channel);
 
    tbb::atomic<uint64_t> unknown_subscribe_messages;
    tbb::atomic<uint64_t> unknown_unsubscribe_messages;
    tbb::atomic<uint64_t> duplicate_channel_ready_messages;
    tbb::atomic<uint64_t> invalid_channel_not_ready_messages;
    tbb::atomic<uint64_t> invalid_channel_state_messages;
    tbb::atomic<uint64_t> invalid_vm_subscribe_messages;
    tbb::atomic<uint64_t> vmsub_novrsub_messages;
    tbb::atomic<uint64_t> vmunsub_novrsub_messages;
    tbb::atomic<uint64_t> vmunsub_novmsub_messages;
    tbb::atomic<uint64_t> duplicate_vrsub_messages;
    tbb::atomic<uint64_t> duplicate_vmsub_messages;
};
 
#endif // __XMPP_IFMAP_INC__