physical_device.h

Go to the documentation of this file.

/*
 * Copyright (c) 2014 Juniper Networks, Inc. All rights reserved.
 * Copyright Contributors to the OpenSDN project
 */
#ifndef SRC_VNSW_AGENT_OPER_PHYSICAL_DEVICE_H_
#define SRC_VNSW_AGENT_OPER_PHYSICAL_DEVICE_H_
 
#include <cmn/agent_cmn.h>
#include <cmn/agent.h>
#include <nexthop.h>
#include <agent_types.h>
#include <oper_db.h>
#include <string>
 
class IFMapDependencyManager;
class PhysicalDevice;
class PhysicalDeviceTable;
 
struct PhysicalDeviceKey : public AgentOperDBKey {
    PhysicalDeviceKey(const boost::uuids::uuid &id) :
        AgentOperDBKey(), uuid_(id) { }
    PhysicalDeviceKey(const boost::uuids::uuid &id, DBSubOperation sub_op) :
        AgentOperDBKey(sub_op), uuid_(id) { }
    virtual ~PhysicalDeviceKey() { }
 
    boost::uuids::uuid uuid_;
};
 
struct PhysicalDeviceDataBase : public AgentOperDBData {
    PhysicalDeviceDataBase(Agent *agent, IFMapNode *ifmap_node) :
        AgentOperDBData(agent, ifmap_node) {
    }
    virtual ~PhysicalDeviceDataBase() { }
};
 
struct PhysicalDeviceData : public PhysicalDeviceDataBase {
    PhysicalDeviceData(Agent *agent, const std::string &fq_name,
                       const std::string &name, const std::string &vendor,
                       const IpAddress &ip, const IpAddress &mgmt_ip,
                       const std::string &protocol, IFMapNode *ifmap_node) :
        PhysicalDeviceDataBase(agent, ifmap_node), fq_name_(fq_name),
        name_(name), vendor_(vendor), ip_(ip), management_ip_(mgmt_ip),
        protocol_(protocol) {
    }
    virtual ~PhysicalDeviceData() { }
 
    std::string fq_name_;
    std::string name_;
    std::string vendor_;
    IpAddress ip_;
    IpAddress management_ip_;
    std::string protocol_;
};
 
struct PhysicalDeviceTsnManagedData : public PhysicalDeviceDataBase {
    PhysicalDeviceTsnManagedData(Agent *agent, bool master) :
        PhysicalDeviceDataBase(agent, NULL), master_(master) {
    }
    virtual ~PhysicalDeviceTsnManagedData() { }
 
    bool master_;
};
 
class PhysicalDevice : AgentRefCount<PhysicalDevice>, public AgentOperDBEntry {
 public:
    typedef enum {
        INVALID,
        OVS
    } ManagementProtocol;
 
    explicit PhysicalDevice(const boost::uuids::uuid &id) :
        AgentOperDBEntry(), uuid_(id), name_(""), vendor_(""), ip_(),
        protocol_(INVALID), master_(false) { }
    virtual ~PhysicalDevice() { }
 
    virtual bool IsLess(const DBEntry &rhs) const;
    virtual KeyPtr GetDBRequestKey() const;
    virtual void SetKey(const DBRequestKey *key);
    virtual std::string ToString() const;
    uint32_t GetRefCount() const {
        return AgentRefCount<PhysicalDevice>::GetRefCount();
    }
 
    bool Copy(PhysicalDeviceTable *table, const PhysicalDeviceData *data);
    const boost::uuids::uuid &uuid() const { return uuid_; }
    const std::string &fq_name() const { return fq_name_; }
    const std::string &name() const { return name_; }
    const std::string &vendor() const { return vendor_; }
    const IpAddress &ip() const { return ip_; }
    const IpAddress &management_ip() const { return management_ip_; }
    ManagementProtocol protocol() const { return protocol_; }
    bool master() const { return master_; }
    void set_master(bool value) { master_ = value; }
 
    void SendObjectLog(AgentLogEvent::type event) const;
    bool DBEntrySandesh(Sandesh *resp, std::string &name) const;
 
 private:
    friend class PhysicalDeviceTable;
    boost::uuids::uuid uuid_;
    std::string fq_name_;
    std::string name_;
    std::string vendor_;
    IpAddress ip_;
    IpAddress management_ip_;
    ManagementProtocol protocol_;
    bool master_;
    DISALLOW_COPY_AND_ASSIGN(PhysicalDevice);
};
 
class PhysicalDeviceTable : public AgentOperDBTable {
 public:
    typedef std::set<boost::uuids::uuid> PhysicalDeviceSet;
    typedef std::map<const std::string, PhysicalDeviceSet> VrfDevicesMap;
    typedef std::pair<const std::string, PhysicalDeviceSet> VrfDevicesPair;
    typedef std::set<std::string> VrfSet;
    typedef std::map<const boost::uuids::uuid, VrfSet> DeviceVrfMap;
    typedef std::pair<const boost::uuids::uuid, VrfSet> DeviceVrfPair;
    typedef std::map<IpAddress, PhysicalDevice *> IpToDeviceMap;
    typedef std::pair<IpAddress, PhysicalDevice *> IpToDevicePair;
 
    PhysicalDeviceTable(DB *db, const std::string &name) :
        AgentOperDBTable(db, name), ip_tree_(), managed_pd_set_(),
        vrf2devices_map_(), device2vrf_map_() { }
    virtual ~PhysicalDeviceTable() { }
 
    virtual std::unique_ptr<DBEntry> AllocEntry(const DBRequestKey *k) const;
    virtual size_t Hash(const DBEntry *entry) const {return 0;}
    virtual size_t Hash(const DBRequestKey *key) const {return 0;}
 
    virtual DBEntry *OperDBAdd(const DBRequest *req);
    virtual bool OperDBOnChange(DBEntry *entry, const DBRequest *req);
    virtual bool OperDBDelete(DBEntry *entry, const DBRequest *req);
    virtual bool OperDBResync(DBEntry *entry, const DBRequest *req);
    virtual bool IFNodeToReq(IFMapNode *node, DBRequest &req,
            const boost::uuids::uuid &u);
    bool ProcessConfig(IFMapNode *node, DBRequest &req,
            const boost::uuids::uuid &u);
    virtual bool IFNodeToUuid(IFMapNode *node, boost::uuids::uuid &u);
    virtual AgentSandeshPtr GetAgentSandesh(const AgentSandeshArguments *args,
                                            const std::string &context);
 
    PhysicalDevice *Find(const boost::uuids::uuid &u);
 
    void RegisterDBClients(IFMapDependencyManager *dep);
    static DBTableBase *CreateTable(DB *db, const std::string &name);
    void UpdateIpToDevMap(IpAddress old, IpAddress new_ip, PhysicalDevice *p);
    void DeleteIpToDevEntry(IpAddress ip);
    PhysicalDevice *IpToPhysicalDevice(IpAddress ip);
    const PhysicalDeviceSet &managed_pd_set() const { return managed_pd_set_; }
    void EnqueueDeviceChange(const boost::uuids::uuid &u, bool master);
    void UpdateDeviceMastership(const std::string &vrf, ComponentNHList clist,
                                bool del);
 
 private:
    void ResetDeviceMastership(const boost::uuids::uuid &u,
                               const std::string &vrf);
    void AddDeviceToVrfEntry(const boost::uuids::uuid &u,
                             const std::string &vrf);
    bool RemoveDeviceToVrfEntry(const boost::uuids::uuid &u,
                                const std::string &vrf);
    IpToDeviceMap ip_tree_;
    PhysicalDeviceSet managed_pd_set_;
    VrfDevicesMap vrf2devices_map_;
    DeviceVrfMap device2vrf_map_;
    DISALLOW_COPY_AND_ASSIGN(PhysicalDeviceTable);
};
 
#endif  // SRC_VNSW_AGENT_OPER_PHYSICAL_DEVICE_H_