equilibrium-data_config.c

Go to the documentation of this file.

/*
 * $Id: equilibrium-data_config.c 346460 2009-11-14 05:06:47Z ssiano $
 *
 * This code is provided as is by Juniper Networks SDK Developer Support.
 * It is provided with no warranties or guarantees, and Juniper Networks
 * will not provide support or maintenance of this code in any fashion.
 * The code is provided only to help a developer better understand how
 * the SDK can be used.
 * 
 * Copyright (c) 2008, Juniper Networks, Inc.
 * All rights reserved.
 */

#include "equilibrium-data_main.h"
#include "equilibrium-data_config.h"
#include "equilibrium-data_monitor.h"


/*** Constants ***/


/*** Data structures ***/

typedef struct eq_server_s {
    in_addr_t                  server_addr; 
    TAILQ_ENTRY(eq_server_s)   entries;     
} eq_server_t;


typedef TAILQ_HEAD(server_list_s, eq_server_s) server_list_t;


typedef struct eq_app_s {
    patnode     node;              
    char        application_name[MAX_APP_NAME]; 
    in_addr_t   application_addr;  
    uint16_t    application_port;  
    uint16_t    session_timeout;   
    eq_smon_t * server_mon_params; 
    server_list_t * servers;       
    uint32_t    session_count;     
} eq_app_t;


typedef struct eq_serviceset_s {
    patnode    node;              
    uint16_t   svc_set_id;        
    patroot *  applications;      
} eq_serviceset_t;

static patroot services_conf; 

static atomic_uint_t current_time;


/*** STATIC/INTERNAL Functions ***/


PATNODE_TO_STRUCT(service_entry, eq_serviceset_t, node)



PATNODE_TO_STRUCT(app_entry, eq_app_t, node)


static void
update_time(evContext ctx __unused,
            void * uap  __unused,
            struct timespec due __unused,
            struct timespec inter __unused)
{
    atomic_add_uint(1, &current_time);
}


/*** GLOBAL/EXTERNAL Functions ***/


status_t
init_config(evContext ctx)
{
    patricia_root_init(&services_conf, FALSE, sizeof(uint16_t), 0);
                   // root, is key ptr, key size, key offset

    current_time = (atomic_uint_t)(time(NULL) - 1);
    
    // cached system time
    if(evSetTimer(ctx, update_time, NULL,
        evNowTime(), evConsTime(1, 0), NULL)) {

        LOG(LOG_EMERG, "%s: Failed to initialize an eventlib timer to generate "
            "the cached time", __func__);
        return EFAIL;
    }
    
    return SUCCESS;
}

void
clear_config(void)
{
    reset_configuration();
}


time_t
get_current_time(void)
{
    return (time_t)current_time;
}


void
reset_configuration(void)
{
    eq_serviceset_t * ss;    
   
    while((ss= service_entry(patricia_find_next(&services_conf, NULL)))!= NULL){
        delete_service_set(ss->svc_set_id);      
    }
}


void
delete_service_set(uint16_t svc_set_id)
{
    eq_app_t * app;
    eq_serviceset_t * ss;
    eq_server_t * server;
    
    // get this service-set
    ss = service_entry(
            patricia_get(&services_conf, sizeof(svc_set_id), &svc_set_id));
    
    if(ss == NULL) {
        LOG(LOG_WARNING, "%s: unknown service set", __func__);
        return;
    }
    
    // Remove ss from patricia tree of the service sets
    if (!patricia_delete(&services_conf, &ss->node)) {
        LOG(LOG_ERR, "%s: Removing service set from the configuration",
                __func__);
        return;
    }
    
    if(ss->applications == NULL) {
        free(ss);
        return;
    }
    
    monitor_remove_all_servers_in_service_set(svc_set_id);
    
    while((app= app_entry(patricia_find_next(ss->applications, NULL))) != NULL){
        
        if(app->servers != NULL) {
            while((server = TAILQ_FIRST(app->servers)) != NULL) {
                TAILQ_REMOVE(app->servers, server, entries);
                free(server);
            }
        }
        
        if(app->server_mon_params != NULL) {
            free(app->server_mon_params);
        }
        
        // Remove app from patricia tree of the service set
        if (!patricia_delete(ss->applications, &app->node)) {
            LOG(LOG_ERR, "%s: Removing application from the service set failed",
                    __func__);
        }
        free(app);        
    }
    
    patricia_root_delete(ss->applications);
    free(ss);
}


void
delete_application(uint16_t svc_set_id,
                   char * app_name)
{
    eq_app_t * app;
    eq_serviceset_t * ss;
    eq_server_t * server;
    
    // get this service-set
    ss = service_entry(
            patricia_get(&services_conf, sizeof(svc_set_id), &svc_set_id));
    
    if(ss == NULL) {
        LOG(LOG_WARNING, "%s: unknown service set", __func__);
        return;
    }
    
    if(ss->applications == NULL) {
        return;
    }
    
    app = app_entry(
            patricia_get(ss->applications, strlen(app_name) + 1, app_name));
    
    if(app == NULL) {
        return;
    }
    
    monitor_remove_all_servers_in_app(
            svc_set_id, app->application_addr, app->application_port);
    
    while((server = TAILQ_FIRST(app->servers)) != NULL) {
        TAILQ_REMOVE(app->servers, server, entries);
        free(server);
    }
    
    if(app->server_mon_params != NULL) {
        free(app->server_mon_params);
    }
    
    // Remove app from patricia tree of the service set
    if (!patricia_delete(ss->applications, &app->node)) {
        LOG(LOG_ERR, "%s: Removing application from the service set failed",
                __func__);
        return;
    }
    free(app);
}


void
delete_all_servers(uint16_t svc_set_id,
                   char * app_name)
{
    eq_app_t * app;
    eq_serviceset_t * ss;
    eq_server_t * server;
    
    // get this service-set
    ss = service_entry(
            patricia_get(&services_conf, sizeof(svc_set_id), &svc_set_id));
    
    if(ss == NULL) {
        LOG(LOG_WARNING, "%s: unknown service set", __func__);
        return;
    }
    
    // check if any applications config exists
    if(ss->applications == NULL) {
        LOG(LOG_WARNING, "%s: unknown application", __func__);
        return;
    }
    
    app = app_entry(
            patricia_get(ss->applications, strlen(app_name) + 1, app_name));
    
    if(app == NULL) {
        LOG(LOG_WARNING, "%s: unknown application", __func__);
        return;
    }
    
    monitor_remove_all_servers_in_app(
            svc_set_id, app->application_addr, app->application_port);
    
    while((server = TAILQ_FIRST(app->servers)) != NULL) {
        TAILQ_REMOVE(app->servers, server, entries);
        free(server);
    }
}


void
delete_server(uint16_t svc_set_id,
              char * app_name,
              in_addr_t server_addr)
{
    eq_app_t * app;
    eq_serviceset_t * ss;
    eq_server_t * server;
    
    // get this service-set
    ss = service_entry(
            patricia_get(&services_conf, sizeof(svc_set_id), &svc_set_id));
    
    if(ss == NULL) {
        LOG(LOG_WARNING, "%s: server in unknown service set", __func__);
        return;
    }
    
    // check if any applications config exists
    if(ss->applications == NULL) {
        LOG(LOG_WARNING, "%s: server in unknown application", __func__);
        return;
    }
    
    app = app_entry(
            patricia_get(ss->applications, strlen(app_name) + 1, app_name));
    
    if(app == NULL) {
        LOG(LOG_WARNING, "%s: server in unknown application", __func__);
        return;
    }
    
    server = TAILQ_FIRST(app->servers);
    while(server != NULL) {
        if(server->server_addr == server_addr) {
            TAILQ_REMOVE(app->servers, server, entries); // got it
            
            // tell the monitor about this server being removed
            monitor_remove_server(svc_set_id, app->application_addr,
                    app->application_port, server->server_addr);
            
            free(server);
            return;
        }
        server = TAILQ_NEXT(server, entries);
    }
    LOG(LOG_WARNING, "%s: server is already not configured", __func__);
}


void
update_application(uint16_t svc_set_id,
                   char * app_name,
                   in_addr_t app_addr,
                   uint16_t app_port,
                   uint16_t session_timeout,
                   uint16_t connection_interval,
                   uint16_t connection_timeout,
                   uint8_t timeouts_allowed,
                   uint16_t down_retry_interval)
{
    eq_app_t * app;
    eq_serviceset_t * ss;
    eq_smon_t * smon = NULL;
    eq_server_t * server = NULL;
    
    // check if we know about this service-set
    ss = service_entry(
            patricia_get(&services_conf, sizeof(svc_set_id), &svc_set_id));
    
    if(ss == NULL) {
        ss = calloc(1, sizeof(eq_serviceset_t));
        INSIST_ERR(ss != NULL);
        ss->svc_set_id = svc_set_id;

        // Add to patricia tree (without node length init) since it is fixed
        if(!patricia_add(&services_conf, &ss->node)) {
            LOG(LOG_ERR, "%s: Failed to add service set %d to configuration",
                    __func__, svc_set_id);
            return;
        }
    }
    
    // check if any applications config exists
    if(ss->applications == NULL) {
        // if not, init it
        ss->applications = patricia_root_init(NULL, FALSE, MAX_APP_NAME, 0);
        INSIST_ERR(ss->applications != NULL);
    }
    
    app = app_entry(
            patricia_get(ss->applications, strlen(app_name) + 1, app_name));
    
    if(connection_interval != 0) {
        smon = calloc(1, sizeof(eq_smon_t));
        INSIST_ERR(smon != NULL);
        smon->connection_interval = connection_interval;
        smon->connection_timeout = connection_timeout;
        smon->timeouts_allowed = timeouts_allowed;
        smon->down_retry_interval = down_retry_interval;
    }
    
    if(app == NULL) {
        app = calloc(1, sizeof(eq_app_t));
        INSIST_ERR(app != NULL);
        strncpy(app->application_name, app_name, MAX_APP_NAME);

        // Add to patricia tree
        patricia_node_init_length(&app->node, strlen(app_name) + 1);

        if(!patricia_add(ss->applications, &app->node)) {
            LOG(LOG_ERR, "%s: Failed to add application %s to "
                    "configuration", __func__, app_name);
            return;
        }
        
        app->servers = malloc(sizeof(server_list_t));
        INSIST_ERR(app->servers != NULL);
        TAILQ_INIT(app->servers);
        
        app->server_mon_params = smon;
        app->application_port = app_port;
        app->application_addr = app_addr;
        app->session_timeout = session_timeout;
        
        LOG(LOG_INFO, "%s: Added new application <%d,%s> to configuration",
                __func__, svc_set_id, app_name);
        
        return;
    }
    
    // it is now new, so we need to check for changes
    
    app->session_timeout = session_timeout;
    
    if(app->application_port != app_port || app->application_addr != app_addr) {
        
        // delete server and re-add them
        monitor_remove_all_servers_in_app(
                svc_set_id, app->application_addr, app->application_port);
        
        app->application_port = app_port;
        app->application_addr = app_addr;
        
        server = TAILQ_FIRST(app->servers);
        while(server != NULL) {

            monitor_add_server(svc_set_id, app->application_addr,
                    app->application_port, server->server_addr,
                    app->server_mon_params);
            
            server = TAILQ_NEXT(server, entries);
        }
    }
    
    if(app->server_mon_params == NULL) {
        if(smon != NULL) { // added
            change_monitoring_config(svc_set_id, app_addr, app_port, smon);
            app->server_mon_params = smon;
        }
    } else { // existing monitor, look for a change
        if(smon == NULL) { // removed
            change_monitoring_config(svc_set_id, app_addr, app_port, smon);
            free(app->server_mon_params);
            app->server_mon_params = NULL;
        } else {
            if(memcmp(smon, app->server_mon_params, sizeof(eq_smon_t)) != 0) {
                change_monitoring_config(svc_set_id, app_addr, app_port, smon);
                free(app->server_mon_params);
                app->server_mon_params = smon;
            } else {
                free(smon); // no change to existing monitor parameters
            }
        }
    }
}


void
add_server(uint16_t svc_set_id,
           char * app_name,
           in_addr_t server_addr)
{
    eq_app_t * app;
    eq_serviceset_t * ss;
    eq_server_t * server = NULL;
    
    // get this service-set
    ss = service_entry(
            patricia_get(&services_conf, sizeof(svc_set_id), &svc_set_id));
    
    if(ss == NULL) {
        LOG(LOG_ERR, "%s: server in unknown service set %d", __func__,
                svc_set_id);
        return;
    }
    
    // check if any applications config exists
    if(ss->applications == NULL) {
        LOG(LOG_ERR, "%s: server in unknown application", __func__);
        return;
    }
    
    app = app_entry(
            patricia_get(ss->applications, strlen(app_name) + 1, app_name));
    
    if(app == NULL) {
        LOG(LOG_ERR, "%s: server in unknown application", __func__);
        return;
    }
    
    server = TAILQ_FIRST(app->servers);
    while(server != NULL) {
        if(server->server_addr == server_addr) {
            return; // already know about this server
        }
        server = TAILQ_NEXT(server, entries);            
    }
    
    server = malloc(sizeof(eq_server_t));
    INSIST_ERR(server != NULL);
    server->server_addr = server_addr;
    TAILQ_INSERT_TAIL(app->servers, server, entries);
    
    // tell the monitor about this new server
    monitor_add_server(svc_set_id, app->application_addr, app->application_port,
            server_addr, app->server_mon_params);
}


char *
get_app_name(uint16_t svc_set_id, in_addr_t addr, uint16_t port)
{
    eq_app_t * app;
    eq_serviceset_t * ss;
    
    // get this service-set
    ss = service_entry(
            patricia_get(&services_conf, sizeof(svc_set_id), &svc_set_id));
    
    if(ss == NULL || ss->applications == NULL) {
        return NULL;
    }
    
    // get first application
    app = app_entry(patricia_find_next(ss->applications, NULL));
    
    while(app != NULL) {
        
        if(app->application_addr == addr && app->application_port == port) {
            return app->application_name;
        }
        
        app = app_entry(patricia_find_next(ss->applications, &app->node));       
    }
    
    return NULL;
}


uint16_t
get_app_session_timeout(uint16_t svc_set_id, in_addr_t addr, uint16_t port)
{
    eq_app_t * app;
    eq_serviceset_t * ss;
    
    // get this service-set
    ss = service_entry(
            patricia_get(&services_conf, sizeof(svc_set_id), &svc_set_id));
    
    if(ss == NULL || ss->applications == NULL) {
        return 0;
    }
    
    // get first application
    app = app_entry(patricia_find_next(ss->applications, NULL));
    
    while(app != NULL) {
        
        if(app->application_addr == addr && app->application_port == port) {
            return app->session_timeout;
        }
        
        app = app_entry(patricia_find_next(ss->applications, &app->node));       
    }
    
    return 0;
}

---