sandesh_connection.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
 */
 
//
// sandesh_connection.h
//
// Sandesh connection class
//
 
#ifndef __SANDESH_CONNECTION_H__
#define __SANDESH_CONNECTION_H__
 
#include <boost/asio/ip/tcp.hpp>
 
#include <base/util.h>
#include <base/lifetime.h>
#include "sandesh_state_machine.h"
 
class Sandesh;
class SandeshSession;
class TcpSession;
class TcpServer;
class SandeshUVE;
class SandeshHeader;
class SandeshMessage;
 
class SandeshConnection {
public:
    typedef boost::asio::ip::tcp::endpoint Endpoint;
    SandeshConnection(const char *prefix, TcpServer *server, Endpoint endpoint,
                      int task_instance, int task_id);
    virtual ~SandeshConnection();
 
    // Invoked from server when a session is accepted.
    void AcceptSession(SandeshSession *session);
    virtual bool ReceiveMsg(const std::string &msg, SandeshSession *session);
 
    TcpServer *server() { return server_; }
 
    Endpoint endpoint() { return endpoint_; }
    bool SendSandesh(Sandesh *snh);
 
    void set_session(SandeshSession *session);
 
    SandeshSession *session() const;
    SandeshStateMachine *state_machine() const;
 
    std::string StateName() const { return state_machine_->StateName(); }
 
    int GetTaskInstance() const {
        // Parallelism between connections
        return task_instance_;
    }
 
    int GetTaskId() const {
        return task_id_;
    }
 
    void Initialize() {
        state_machine_->Initialize();
    }
 
    void Shutdown();
    bool MayDelete() const;
 
    void SetAdminState(bool down);
 
    virtual bool ProcessResourceUpdate(bool res) { return true; }
    virtual bool ProcessSandeshMessage(const SandeshMessage *msg,
            bool resource) = 0;
    virtual bool ProcessSandeshCtrlMessage(const std::string &msg,
            const SandeshHeader &header, const std::string sandesh_name,
            const uint32_t header_offset) = 0;
    virtual void ProcessDisconnect(SandeshSession * sess) = 0;
 
    virtual void ManagedDelete() = 0;
    virtual LifetimeActor *deleter() = 0;
    virtual LifetimeManager *lifetime_manager() = 0;
    virtual void Destroy() = 0;
 
protected:
    bool is_deleted_;
 
private:
    friend class SandeshServerStateMachineTest;
 
    TcpServer *server_;
    Endpoint endpoint_;
    bool admin_down_;
    SandeshSession *session_;
    int task_instance_;
    int task_id_;
    boost::scoped_ptr<SandeshStateMachine> state_machine_;
 
    DISALLOW_COPY_AND_ASSIGN(SandeshConnection);
};
 
class SandeshServerConnection : public SandeshConnection {
public:
    SandeshServerConnection(TcpServer *server, Endpoint endpoint,
        int task_instance, int task_id);
    virtual ~SandeshServerConnection();
 
    virtual bool ProcessResourceUpdate(bool res);
    virtual bool ProcessSandeshMessage(const SandeshMessage *msg,
            bool resource);
    virtual bool ProcessSandeshCtrlMessage(const std::string &msg,
            const SandeshHeader &header, const std::string sandesh_name,
            const uint32_t header_offset);
    virtual void ProcessDisconnect(SandeshSession *session);
 
    virtual void ManagedDelete();
    virtual LifetimeActor *deleter();
    virtual LifetimeManager *lifetime_manager();
    virtual void Destroy();
 
private:
    class DeleteActor;
    boost::scoped_ptr<DeleteActor> deleter_;
    LifetimeRef<SandeshServerConnection> server_delete_ref_;
 
    DISALLOW_COPY_AND_ASSIGN(SandeshServerConnection);
};
 
#endif // __SANDESH_CONNECTION_H__