/Users/maurits/Documents/studie/afstuderen/biosphere/daemon/node.c

Go to the documentation of this file.

/*
 * Author: MA Hartman
 * Date: apr 13, 2007
 * 
 * Function:
 * Keeps track of other nodes in the network.
 * 
 * License information:
 * 
 * Copyright (c) 2006 Maurits Hartman
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 * 
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 * 
 */

#include "node.h"
#include "mutex.h"
#include <http_common.h>
#include <list.h>
#include <str.h>
#include <type.h>

#include <apr_network_io.h>
#include <apr_strings.h>
#include <stdio.h>
#include <assert.h>

extern apr_pool_t *global_mp;

static bs_list *nodes = NULL;


bs_status init_node(apr_pool_t *mp)
{
        nodes = new_list(mp);
        return BS_OK;
}


static bs_bool node_already_known(const char *address, bs_uint16 port)
{
        unsigned i;
        assert(nodes && address);
        
        lock_node_mux();
        for (i = 0; i < list_size(nodes); i++) {
                node_info *ni = list_index(nodes, i);
                node_address *na = ni->address;
                if (streq(na->address, address) && na->port == port) {
                        unlock_node_mux();
                        return TRUE;
                }
        }
        unlock_node_mux();
        return FALSE;
}


bs_status add_node(const char *address, bs_uint16 port)
{
        node_address *na;
        node_info *ni;
        unsigned i;
        bs_bool added = FALSE;
        bs_status rv;
        bs_definition *def;
        
        /* Check if node is not already known or is this node itself */
        if (node_already_known(address, port)) return BS_ERROR;
        
        /* Try to retrieve the definitions of this node: */
        lock_pool_mux();
        rv = connect_and_get(&def, address, port, global_mp);
        if (rv != BS_OK) return rv;
        
        /* Set up node info structure: */
        na = (node_address *) apr_palloc(global_mp, sizeof(node_address));
        na->address = apr_pstrdup(global_mp, address);
        na->port = port;
        ni = (node_info *) apr_pcalloc(global_mp, sizeof(node_info));
        ni->address = na;
        ni->services = def;
        ni->last_seen = apr_time_now();
        ni->ping = ping_node(address, port, global_mp);
        unlock_pool_mux();
        if (ni->ping == 0xffffffff) {
                fprintf(stderr, "Unable to contact node: %s:%d\n", address,
                                port);
                return BS_ERROR;
        }
        
        /* Add node to the list (sorted by ping) and return: */
        lock_node_mux();
        for (i = 0; i < list_size(nodes); i++) {
                node_info *tmp = (node_info *) list_index(nodes, i);
                if (tmp->ping > ni->ping) {
                        list_insert(nodes, i, ni);
                        added = TRUE;
                }
        }
        if (!added) list_append(nodes, ni);
        unlock_node_mux();
        return BS_OK;
}


bs_status remove_node(const char *address, bs_uint16 port)
{
        unsigned i;
        
        lock_node_mux();
        for (i = 0; i < list_size(nodes); i++) {
                node_info *ni = list_index(nodes, i);
                node_address *na = ni->address;
                if (streq(na->address, address) && na->port == port) {
                        list_remove(nodes, i);
                        break;  
                }       
        }
        unlock_node_mux();
        return BS_OK;
}


bs_uint32 ping_node(const char *address, bs_uint16 port,
                apr_pool_t *mp)
{
        apr_time_t start, end;
        apr_socket_t *sock;
        apr_status_t rv;
        apr_sockaddr_t *sa;
        
        rv = apr_sockaddr_info_get(&sa, address, APR_INET, port, 0, mp);
        if (rv != APR_SUCCESS) return 0xffffffff;
        rv = apr_socket_create(&sock, sa->family, SOCK_STREAM,
                        APR_PROTO_TCP, mp);
        if (rv != APR_SUCCESS) return 0xffffffff;
        
        start = apr_time_now();
        rv = apr_socket_connect(sock, sa);
        if (rv != APR_SUCCESS) return 0xffffffff;
        end = apr_time_now();
        
        apr_socket_close(sock);
        return (bs_uint32) (end - start);
}


node_info *get_servicing_node(const bs_service_request *req)
{
        unsigned i;
        
        /* Look for first node that can service the request: */
        lock_node_mux();
        for (i = 0; i < list_size(nodes); i++) {
                node_info *ni = (node_info *) list_index(nodes, i);
                if (request_corresponds_with_definition(req, ni->services)) {
                        /* Gotcha! */
                        unlock_node_mux();
                        return ni;
                }
        }       
        
        /* Nope, no node to be found: */
        unlock_node_mux();
        return NULL;
}

---