ovsdb_client.cc

Go to the documentation of this file.

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

#include <ovsdb_object.h>
#include <oper/agent_sandesh.h>
#include <ovsdb_types.h>
#include <ovsdb_client.h>
#include <ovsdb_client_ssl.h>
#include <ovsdb_client_tcp.h>
#include <ovsdb_client_connection_state.h>
#include <ovs_tor_agent/tor_agent_init.h>
#include <ovs_tor_agent/tor_agent_param.h>

using OVSDB::OvsdbClient;
using OVSDB::ConnectionStateTable;

OvsdbClient::OvsdbClient(OvsPeerManager *manager, int keepalive_interval,
                         int ha_stale_route_interval) :
    peer_manager_(manager), ksync_obj_manager_(KSyncObjectManager::Init()),
    keepalive_interval_(keepalive_interval),
    ha_stale_route_interval_(ha_stale_route_interval) {
}

OvsdbClient::~OvsdbClient() {
}

void OvsdbClient::set_connect_complete_cb(SessionEventCb cb) {
    connect_complete_cb_ = cb;
}

void OvsdbClient::set_pre_connect_complete_cb(SessionEventCb cb) {
    pre_connect_complete_cb_ = cb;
}

void OvsdbClient::RegisterConnectionTable(Agent *agent) {
    connection_table_.reset(new ConnectionStateTable(agent, peer_manager_));
}

ConnectionStateTable *OvsdbClient::connection_table() {
    return connection_table_.get();
}

KSyncObjectManager *OvsdbClient::ksync_obj_manager() {
    return ksync_obj_manager_;
}

int OvsdbClient::keepalive_interval() const {
    if (keepalive_interval_ < 0) {
        // unconfigured return default
        return OVSDBKeepAliveTimer;
    }

    if (keepalive_interval_ != 0 &&
        keepalive_interval_ < OVSDBMinKeepAliveTimer) {
        return OVSDBMinKeepAliveTimer;
    }

    return keepalive_interval_;
}

int OvsdbClient::ha_stale_route_interval() const {
    if (ha_stale_route_interval_ < 0) {
        // unconfigured return default
        return OVSDBHaStaleRouteTimer;
    }

    if (ha_stale_route_interval_ < OVSDBMinHaStaleRouteTimer) {
        return OVSDBMinHaStaleRouteTimer;
    }

    return ha_stale_route_interval_;
}

void OvsdbClient::Init() {
}

OvsdbClient *OvsdbClient::Allocate(Agent *agent, TorAgentParam *params,
        OvsPeerManager *manager) {
    KSyncObjectManager::Init();
    if (params->tor_protocol() == "tcp") {
        return (new OvsdbClientTcp(agent, IpAddress(params->tor_ip()),
                                   params->tor_port(), params->tsn_ip(),
                                   params->keepalive_interval(),
                                   params->ha_stale_route_interval(), manager));
    } else if (params->tor_protocol() == "pssl") {
        return (new OvsdbClientSsl(agent, IpAddress(params->tor_ip()),
                                   params->tor_port(), params->tsn_ip(),
                                   params->keepalive_interval(),
                                   params->ha_stale_route_interval(),
                                   params->ssl_cert(), params->ssl_privkey(),
                                   params->ssl_cacert(), manager));
    }
    return NULL;
}

// Sandesh routines
class OvsdbClientSandesTask : public Task {
public:
    OvsdbClientSandesTask(std::string resp_ctx) :
        Task((TaskScheduler::GetInstance()->GetTaskId("Agent::KSync")), 0),
        resp_(new OvsdbClientResp()), resp_data_(resp_ctx) {
    }

    virtual ~OvsdbClientSandesTask() {}

    virtual bool Run() {
        SandeshOvsdbClient client_data;
        OvsdbClient *client = Agent::GetInstance()->ovsdb_client();
        client_data.set_protocol(client->protocol());
        client_data.set_server(client->server());
        client_data.set_port(client->port());
        client_data.set_tor_service_node(client->tsn_ip().to_string());
        client_data.set_keepalive_interval(client->keepalive_interval());
        client_data.set_ha_stale_route_interval(client->ha_stale_route_interval());
        client->AddSessionInfo(client_data);
        resp_->set_client(client_data);
        SendResponse();
        return true;
    }
    std::string Description() const { return "OvsdbClientSandesTask"; }

private:
    void SendResponse() {
        resp_->set_context(resp_data_);
        resp_->set_more(false);
        resp_->Response();
    }

    OvsdbClientResp *resp_;
    std::string resp_data_;
    DISALLOW_COPY_AND_ASSIGN(OvsdbClientSandesTask);
};

void OvsdbClientReq::HandleRequest() const {
    OvsdbClientSandesTask *task = new OvsdbClientSandesTask(context());
    TaskScheduler *scheduler = TaskScheduler::GetInstance();
    scheduler->Enqueue(task);
}