ovsdb_sandesh.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015 Juniper Networks, Inc. All rights reserved.
 */

#ifndef SRC_VNSW_AGENT_OVS_TOR_AGENT_OVSDB_CLIENT_OVSDB_SANDESH_H_
#define SRC_VNSW_AGENT_OVS_TOR_AGENT_OVSDB_CLIENT_OVSDB_SANDESH_H_

#include <oper/agent_sandesh.h>

class AgentSandeshArguments;
namespace OVSDB {
class OvsdbSandeshTask : public Task {
public:
    enum TableType {
        PHYSICAL_SWITCH_TABLE = 1,
        PHYSICAL_PORT_TABLE,
        LOGICAL_SWITCH_TABLE,
        VLAN_PORT_TABLE,
        VRF_TABLE,
        UNICAST_REMOTE_TABLE,
        UNICAST_LOCAL_TABLE,
        MULTICAST_LOCAL_TABLE,
        HA_STALE_DEV_VN_TABLE,
        HA_STALE_L2_ROUTE_TABLE,
        TABLE_MAX,
    };

    enum FilterResp {
        FilterAllow = 1,
        FilterDeny
    };

    static const uint8_t kEntriesPerSandesh = 100;
    static const uint8_t kEntriesPerPage = 100;
    OvsdbSandeshTask(std::string resp_ctx, AgentSandeshArguments &args);
    OvsdbSandeshTask(std::string resp_ctx, const std::string &ip,
                     uint32_t port);

    virtual ~OvsdbSandeshTask();

    bool Run();
    std::string Description() const { return "OvsdbSandeshTask"; }

    std::string EncodeFirstPage();

protected:
    std::string ip_;
    uint32_t port_;

private:
    virtual void EncodeArgs(AgentSandeshArguments &args) {}
    virtual FilterResp Filter(KSyncEntry *entry) { return FilterAllow; }
    virtual void UpdateResp(KSyncEntry *entry, SandeshResponse *resp) = 0;
    virtual SandeshResponse *Alloc() = 0;
    virtual KSyncObject *GetObject(OvsdbClientSession *session) = 0;
    virtual TableType GetTableType() = 0;

    virtual bool NoSessionObject() { return false; }

    void EncodeSendPageReq(uint32_t display_count, uint32_t table_size);

    void SendResponse(bool more);

    SandeshResponse *resp_;
    std::string resp_data_;
    uint32_t first_;
    uint32_t last_;
    uint32_t total_count_;
    bool needs_next_;
    bool error_;
    std::string error_msg_;
    DISALLOW_COPY_AND_ASSIGN(OvsdbSandeshTask);
};

class PhysicalPortSandeshTask : public OvsdbSandeshTask {
public:
    PhysicalPortSandeshTask(std::string resp_ctx, AgentSandeshArguments &args);
    PhysicalPortSandeshTask(std::string resp_ctx, const std::string &ip,
                             uint32_t port, const std::string &name);

    virtual ~PhysicalPortSandeshTask();

private:
    void EncodeArgs(AgentSandeshArguments &args);
    FilterResp Filter(KSyncEntry *entry);
    void UpdateResp(KSyncEntry *kentry, SandeshResponse *resp);
    SandeshResponse *Alloc();
    KSyncObject *GetObject(OvsdbClientSession *session);
    TableType GetTableType() { return PHYSICAL_PORT_TABLE;}

    std::string name_;
    DISALLOW_COPY_AND_ASSIGN(PhysicalPortSandeshTask);
};

class LogicalSwitchSandeshTask : public OvsdbSandeshTask {
public:
    LogicalSwitchSandeshTask(std::string resp_ctx, AgentSandeshArguments &args);
    LogicalSwitchSandeshTask(std::string resp_ctx, const std::string &ip,
                             uint32_t port, const std::string &name,
                             uint32_t vxlan_id);

    virtual ~LogicalSwitchSandeshTask();

private:
    void EncodeArgs(AgentSandeshArguments &args);
    FilterResp Filter(KSyncEntry *entry);
    void UpdateResp(KSyncEntry *kentry, SandeshResponse *resp);
    SandeshResponse *Alloc();
    KSyncObject *GetObject(OvsdbClientSession *session);
    TableType GetTableType() { return LOGICAL_SWITCH_TABLE;}

    std::string name_;
    uint32_t vxlan_id_;
    DISALLOW_COPY_AND_ASSIGN(LogicalSwitchSandeshTask);
};

class VlanPortBindingSandeshTask : public OvsdbSandeshTask {
public:
    VlanPortBindingSandeshTask(std::string resp_ctx,
                               AgentSandeshArguments &args);
    VlanPortBindingSandeshTask(std::string resp_ctx, const std::string &ip,
                               uint32_t port, const std::string &physical_port);

    virtual ~VlanPortBindingSandeshTask();

private:
    void EncodeArgs(AgentSandeshArguments &args);
    FilterResp Filter(KSyncEntry *entry);
    void UpdateResp(KSyncEntry *kentry, SandeshResponse *resp);
    SandeshResponse *Alloc();
    KSyncObject *GetObject(OvsdbClientSession *session);
    TableType GetTableType() { return VLAN_PORT_TABLE;}

    std::string physical_port_;
    DISALLOW_COPY_AND_ASSIGN(VlanPortBindingSandeshTask);
};

class OvsdbVrfSandeshTask : public OvsdbSandeshTask {
public:
    OvsdbVrfSandeshTask(std::string resp_ctx, AgentSandeshArguments &args);
    OvsdbVrfSandeshTask(std::string resp_ctx, const std::string &ip,
                        uint32_t port, const std::string &logical_switch,
                        const std::string &mac);

    virtual ~OvsdbVrfSandeshTask();

private:
    void EncodeArgs(AgentSandeshArguments &args);
    FilterResp Filter(KSyncEntry *entry);
    void UpdateResp(KSyncEntry *kentry, SandeshResponse *resp);
    SandeshResponse *Alloc();
    KSyncObject *GetObject(OvsdbClientSession *session);
    TableType GetTableType() { return VRF_TABLE;}

    std::string logical_switch_;
    std::string mac_;
    DISALLOW_COPY_AND_ASSIGN(OvsdbVrfSandeshTask);
};

class UnicastMacRemoteSandeshTask : public OvsdbSandeshTask {
public:
    UnicastMacRemoteSandeshTask(std::string resp_ctx,
                                AgentSandeshArguments &args);
    UnicastMacRemoteSandeshTask(std::string resp_ctx, const std::string &ip,
                                uint32_t port, const std::string &ls,
                                const std::string &mac);

    virtual ~UnicastMacRemoteSandeshTask();

private:
    void EncodeArgs(AgentSandeshArguments &args);
    FilterResp Filter(KSyncEntry *entry);
    void UpdateResp(KSyncEntry *kentry, SandeshResponse *resp);
    SandeshResponse *Alloc();
    KSyncObject *GetObject(OvsdbClientSession *session);
    TableType GetTableType() { return UNICAST_REMOTE_TABLE;}

    std::string ls_name_;
    std::string mac_;
    DISALLOW_COPY_AND_ASSIGN(UnicastMacRemoteSandeshTask);
};

class UnicastMacLocalSandeshTask : public OvsdbSandeshTask {
public:
    UnicastMacLocalSandeshTask(std::string resp_ctx,
                               AgentSandeshArguments &args);
    UnicastMacLocalSandeshTask(std::string resp_ctx, const std::string &ip,
                               uint32_t port, const std::string &ls,
                               const std::string &mac);

    virtual ~UnicastMacLocalSandeshTask();

private:
    void EncodeArgs(AgentSandeshArguments &args);
    FilterResp Filter(KSyncEntry *entry);
    void UpdateResp(KSyncEntry *kentry, SandeshResponse *resp);
    SandeshResponse *Alloc();
    KSyncObject *GetObject(OvsdbClientSession *session);
    TableType GetTableType() { return UNICAST_LOCAL_TABLE;}

    std::string ls_name_;
    std::string mac_;
    DISALLOW_COPY_AND_ASSIGN(UnicastMacLocalSandeshTask);
};

class MulticastMacLocalSandeshTask : public OvsdbSandeshTask {
public:
    MulticastMacLocalSandeshTask(std::string resp_ctx,
                                 AgentSandeshArguments &args);
    MulticastMacLocalSandeshTask(std::string resp_ctx, const std::string &ip,
                                 uint32_t port, const std::string &ls);

    virtual ~MulticastMacLocalSandeshTask();

private:
    void EncodeArgs(AgentSandeshArguments &args);
    FilterResp Filter(KSyncEntry *entry);
    void UpdateResp(KSyncEntry *kentry, SandeshResponse *resp);
    SandeshResponse *Alloc();
    KSyncObject *GetObject(OvsdbClientSession *session);
    TableType GetTableType() { return MULTICAST_LOCAL_TABLE;}

    std::string ls_name_;
    DISALLOW_COPY_AND_ASSIGN(MulticastMacLocalSandeshTask);
};

class HaStaleDevVnSandeshTask : public OvsdbSandeshTask {
public:
    HaStaleDevVnSandeshTask(std::string resp_ctx,
                            AgentSandeshArguments &args);
    HaStaleDevVnSandeshTask(std::string resp_ctx, const std::string &dev_name,
                            const std::string &vn_uuid);

    virtual ~HaStaleDevVnSandeshTask();

    virtual bool NoSessionObject() { return true; }

private:
    void EncodeArgs(AgentSandeshArguments &args);
    FilterResp Filter(KSyncEntry *entry);
    void UpdateResp(KSyncEntry *kentry, SandeshResponse *resp);
    SandeshResponse *Alloc();
    KSyncObject *GetObject(OvsdbClientSession *session);
    TableType GetTableType() { return HA_STALE_DEV_VN_TABLE;}

    std::string dev_name_;
    std::string vn_uuid_;
    DISALLOW_COPY_AND_ASSIGN(HaStaleDevVnSandeshTask);
};

class HaStaleL2RouteSandeshTask : public OvsdbSandeshTask {
public:
    HaStaleL2RouteSandeshTask(std::string resp_ctx,
                              AgentSandeshArguments &args);
    HaStaleL2RouteSandeshTask(std::string resp_ctx, const std::string &dev_name,
                              const std::string &vn_uuid,
                              const std::string &mac);

    virtual ~HaStaleL2RouteSandeshTask();

    virtual bool NoSessionObject() { return true; }

private:
    void EncodeArgs(AgentSandeshArguments &args);
    FilterResp Filter(KSyncEntry *entry);
    void UpdateResp(KSyncEntry *kentry, SandeshResponse *resp);
    SandeshResponse *Alloc();
    KSyncObject *GetObject(OvsdbClientSession *session);
    TableType GetTableType() { return HA_STALE_L2_ROUTE_TABLE;}

    std::string dev_name_;
    std::string vn_uuid_;
    std::string mac_;
    DISALLOW_COPY_AND_ASSIGN(HaStaleL2RouteSandeshTask);
};

};

#endif  // SRC_VNSW_AGENT_OVS_TOR_AGENT_OVSDB_CLIENT_OVSDB_SANDESH_H_