metadata_proxy.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
 */
 
#ifndef vnsw_agent_metadata_proxy_h_
#define vnsw_agent_metadata_proxy_h_
 
#include <map>
#include <mutex>
 
#include "http/client/http_client.h"
#include "http/http_session.h"
#include "oper/vm_interface.h"
 
class MetadataServer;
class MetadataClient;
 
class MetadataProxy {
public:
    struct SessionData {
        SessionData(HttpConnection *c, bool conn_close)
            : conn(c), content_len(0), data_sent(0),
              close_req(conn_close), header_end(false) {}
 
        HttpConnection *conn;
        uint32_t content_len;
        uint32_t data_sent;
        bool close_req;
        bool header_end;
    };
 
    struct MetadataStats {
        MetadataStats() { Reset(); }
        void Reset() { requests = responses = proxy_sessions = internal_errors = 0; }
 
        uint32_t requests;
        uint32_t responses;
        uint32_t proxy_sessions;
        uint32_t internal_errors;
    };
 
    typedef std::map<HttpSession *, SessionData> SessionMap;
    typedef std::pair<HttpSession *, SessionData> SessionPair;
    typedef std::map<HttpConnection *, HttpSession *> ConnectionSessionMap;
    typedef std::pair<HttpConnection *, HttpSession *> ConnectionSessionPair;
    typedef boost::intrusive_ptr<HttpSession> HttpSessionPtr;
 
    MetadataProxy(ServicesModule *module, const std::string &secret);
    virtual ~MetadataProxy();
    void CloseSessions();
    void Shutdown();
 
    void HandleMetadataRequest(HttpSession *session, const HttpRequest *request);
    void HandleMetadataResponse(HttpConnection *conn, HttpSessionPtr session,
                                std::string &msg, boost::system::error_code &ec);
 
    void OnServerSessionEvent(HttpSession *session, TcpSession::Event event);
    void OnClientSessionEvent(HttpClientSession *session, TcpSession::Event event);
 
    const MetadataStats &metadatastats() const { return metadata_stats_; }
    void ClearStats() { metadata_stats_.Reset(); }
 
    int VhostIndex(const std::string& vhost_name);
 
    bool NetlinkGetVhostIp(Ip6Address& vhost_ll_ip);
 
    void NetlinkAddVhostNb(const IpAddress& nb_ip, const MacAddress& via_mac);
 
    void NetlinkAddInterfaceRoute(const IpAddress& intf_addr);
 
    void AdvertiseMetaDataLinkLocalRoutes(const VmInterface* vm,
        const Ip6Address& ll_ip, const VrfEntry* intf_vrf);
    
    void DeleteMetaDataLinkLocalRoute(const VmInterface* vm_intf);
    
    const Ip6Address& Ipv6ServiceAddress() const;
 
    void InitializeHttp6Server(const VmInterface *vhost0);
 
    void AdvertiseVhostRoute();
 
 
    void DeleteVhostRoute();
 
    void OnAVrfChange(DBTablePartBase *part, DBEntryBase *e);
 
    void OnAFabricRouteChange(DBTablePartBase *part, DBEntryBase *e);
 
    void OnAnInterfaceChange(DBTablePartBase *part, DBEntryBase *e);
 
    void RegisterListeners();
 
    void UnregisterListeners();
 
private:
    HttpConnection *GetProxyConnection(HttpSession *session,
        bool conn_close,
        std::string *nova_hostname);
    void CloseServerSession(HttpSession *session);
    void CloseClientSession(HttpConnection *conn);
    void ErrorClose(HttpSession *sesion, uint16_t error);
 
    ServicesModule *services_;
    std::string shared_secret_;
 
    MetadataServer *http_server_;
 
    MetadataServer *http_server6_;
 
    MetadataClient *http_client_;
    SessionMap metadata_sessions_;
    ConnectionSessionMap metadata_proxy_sessions_;
    MetadataStats metadata_stats_;
 
    Ip6Address ipv6_service_address_;
 
    DBTableBase::ListenerId vrf_table_notify_id_;
 
    DBTableBase::ListenerId fabric_notify_id_;
 
    DBTableBase::ListenerId intf_table_notify_id_;
 
    std::map<std::string, Ip6Address> ll_ipv6_addresses_;
 
    std::mutex ll_ipv6_addr_mutex_;
 
    DISALLOW_COPY_AND_ASSIGN(MetadataProxy);
};
 
#endif // vnsw_agent_metadata_proxy_h_