Changeset 6786


Ignore:
Timestamp:
Nov 2, 2009, 1:31:19 AM (14 years ago)
Author:
mies
Message:

Changed Data to Message conversion constructor in Message to explicit
Fixed some general bugs in Data: operator<<
Fixed bug in DHTMessage: allow unspecified key/values
Added local DHT message delivery
Adapted sources to work with gcc 4.4.1

Files:
8 added
10 edited

Legend:

Unmodified
Added
Removed

  • sample/testdht/DHTTest.cpp

    r6760 r6786  
    6969        // bind communication and node listener
    7070        node->bind( this );                              /*NodeListener*/
    71         //node->bind( this, DHTTest::DHTTEST_SERVICEID); /*CommunicationListener*/
     71        node->bind( this, DHTTest::DHTTEST_SERVICEID); /*CommunicationListener*/
    7272
    7373        // start node module

  • source/ariba/overlay/BaseOverlay.cpp

    r6760 r6786  
    727727        sideport(&SideportListener::DEFAULT), started(false), counter(0) {
    728728        dht = new DHT();
     729        localDHT = new DHT();
    729730}
    730731
    … …  
    19131914        if (msg->getType()==OverlayMsg::typeDHTData) {
    19141915                const ServiceID& service = msg->getService();
    1915                 logging_debug( "Received DHT data for service " << service.toString() );
     1916                logging_info( "Received DHT data for service " << service.toString() );
    19161917
    19171918                // delegate data message
    … …  
    19401941
    19411942        case OverlayMsg::typeDHTGet: {
     1943                logging_info("DHT-Get: key=" << dhtMsg->getKey() );
    19421944                vector<Data> vect = dht->get(dhtMsg->getKey());
     1945                BOOST_FOREACH(const Data& d, vect)
     1946                        logging_info("DHT-Get: value=" << d);
    19431947                OverlayMsg omsg(*msg);
    19441948                omsg.swapRoles();
    … …  
    19461950                DHTMessage dhtmsg(dhtMsg->getKey(), vect);
    19471951                omsg.encapsulate(&dhtmsg);
    1948                 this->send(&omsg, omsg.getDestinationNode());
     1952                dhtSend(&omsg, omsg.getDestinationNode());
    19491953                break;
    19501954        }
    … …  
    19691973/// put a value to the DHT with a ttl given in seconds
    19701974void BaseOverlay::dhtPut( const Data& key, const Data& value, int ttl ) {
     1975
     1976        logging_info("DHT: putting key=" <<  key
     1977                        << " value=" << value
     1978                        << " ttl=" << ttl
     1979        );
     1980
     1981        // put into local data store (for refreshes)
     1982        localDHT->put(key,value,ttl);
     1983
    19711984        // calculate hash
    19721985        NodeID dest = NodeID::sha1(key.getBuffer(), key.getLength() / 8);
    1973         OverlayMsg msg(OverlayMsg::typeDHTPut);
    19741986        DHTMessage dhtmsg(key,value);
    19751987        dhtmsg.setTTL(ttl);
    1976         msg.setDestinationNode(dest);
     1988
     1989        OverlayMsg msg(OverlayMsg::typeDHTPut);
    19771990        msg.encapsulate( &dhtmsg );
    1978         send(&msg, dest);
     1991        dhtSend(&msg, dest);
    19791992}
    19801993
    19811994/// removes a key value pair from the DHT
    19821995void BaseOverlay::dhtRemove( const Data& key, const Data& value ) {
     1996        // remove from local data store
     1997        localDHT->remove(key,value);
     1998
    19831999        // calculate hash
    19842000        NodeID dest = NodeID::sha1(key.getBuffer(), key.getLength() / 8);
     2001        DHTMessage dhtmsg(key,value);
     2002
     2003        // send message
    19852004        OverlayMsg msg(OverlayMsg::typeDHTRemove);
    1986         DHTMessage dhtmsg(key,value);
    1987         msg.setDestinationNode(dest);
    19882005        msg.encapsulate( &dhtmsg );
    1989         send(&msg, dest);
     2006        dhtSend(&msg, dest);
    19902007}
    19912008
    … …  
    19942011        // calculate hash
    19952012        NodeID dest = NodeID::sha1(key.getBuffer(), key.getLength() / 8);
     2013        DHTMessage dhtmsg(key);
     2014
     2015        // send message
    19962016        OverlayMsg msg(OverlayMsg::typeDHTRemove);
    1997         DHTMessage dhtmsg(key);
    1998         msg.setDestinationNode(dest);
    19992017        msg.encapsulate( &dhtmsg );
    2000         send(&msg, dest);
     2018        dhtSend(&msg, dest);
    20012019}
    20022020
    20032021/// requests data stored using key
    20042022void BaseOverlay::dhtGet( const Data& key, const ServiceID& service ) {
     2023        logging_info("DHT: trying to resolve key=" <<
     2024                        key << " for service=" << service.toString() );
     2025
    20052026        // calculate hash
    20062027        NodeID dest = NodeID::sha1(key.getBuffer(), key.getLength() / 8);
     2028        DHTMessage dhtmsg(key);
     2029
     2030        // send message
    20072031        OverlayMsg msg(OverlayMsg::typeDHTGet);
    2008         DHTMessage dhtmsg(key);
    2009         msg.setDestinationNode(dest);
    20102032        msg.setService(service);
    20112033        msg.encapsulate( &dhtmsg );
    2012         send(&msg, dest);
    2013 }
     2034        dhtSend(&msg, dest);
     2035}
     2036
     2037void BaseOverlay::dhtSend( OverlayMsg* msg, const NodeID& dest ) {
     2038        logging_info("DHT: sending message with key=" << dest.toString() );
     2039        msg->setSourceNode(this->nodeId);
     2040        msg->setDestinationNode(dest);
     2041
     2042        // local storage? yes-> put into DHT directly
     2043        if (overlayInterface->isClosestNodeTo(msg->getDestinationNode())) {
     2044                Data d = data_serialize(msg);
     2045                Message* m2 = new Message(d);
     2046                OverlayMsg* m3 = m2->decapsulate<OverlayMsg>();
     2047                handleDHTMessage(m3);
     2048                delete m2;
     2049                return;
     2050        }
     2051
     2052        // send message "normally"
     2053        send(msg, dest);
     2054}
     2055
    20142056
    20152057}} // namespace ariba, overlay

  • source/ariba/overlay/BaseOverlay.h

    r6266 r6786  
    506506
    507507        DHT* dht;
     508        DHT* localDHT;
    508509
    509510        void stabilizeDHT();
     511        void dhtSend( OverlayMsg* msg, const NodeID& dest );
    510512
    511513        // misc --------------------------------------------------------------------

  • source/ariba/overlay/messages/DHTMessage.h

    r6266 r6786  
    6262        X && ttl;
    6363
     64//      std::cout << "1" << std::endl;
     65
    6466        // key serialization
    65         uint16_t key_length = key.getLength();
     67        uint16_t key_length = key.isUnspecified() ? 0 : key.getLength();
    6668        X && key_length;
    6769        if (X.isDeserializer()) key.setLength( key_length );
    68         X && key;
     70
     71//      std::cout << "2 - " << key_length << std::endl;
     72        X && this->key;
     73//      std::cout << "2b" << std::endl;
    6974
    7075        // store number of values
    … …  
    7277        X && num_values;
    7378
     79//      std::cout << "3" << std::endl;
     80
    7481        // value serialization
    7582        for (size_t i=0; i<num_values; i++) {
    76                 Data value = values[i];
    77                 uint16_t value_length = value.getLength();
     83//              std::cout << "4" << std::endl;
     84                Data value;
     85                if (X.isSerializer()) value = values[i];
     86                uint16_t value_length = value.isUnspecified() ? 0 : value.getLength();
    7887                X && value_length;
     88//              std::cout << "5" << std::endl;
    7989                if (X.isDeserializer()) value.setLength( value_length );
    8090                X && value;
     91//              std::cout << "6" << std::endl;
    8192                if (X.isDeserializer()) values.push_back(value);
    8293        }

  • source/ariba/utility/addressing/facades/address_v.hpp

    r5284 r6786  
    22#define ADDRESS_V_H_
    33
     4#include <stdint.h>
    45#include <string>
    56#include <iostream>

  • source/ariba/utility/addressing/facades/to_bytes_v.hpp

    r5284 r6786  
    55
    66#include <memory>
     7#include <stdint.h>
    78#include "vfacade.hpp"
    89

  • source/ariba/utility/addressing/port_address.hpp

    r5284 r6786  
    55
    66#include<string>
     7#include<cstdio>
     8
    79#include<boost/tr1/functional.hpp>
    810

  • source/ariba/utility/messages/Message.h

    r5484 r6786  
    105105         * data.
    106106         */
    107         inline Message( const Data& data ) :
     107        explicit inline Message( const Data& data ) :
    108108                srcAddr(NULL),destAddr(NULL), releasePayload(true) {
    109109                this->payload = data.clone();

  • source/ariba/utility/serialization/Data.hpp

    r5870 r6786  
    4949template<typename T = uint8_t, typename DataModel = DefaultDataModel<uint8_t> > class DataTpl;
    5050typedef DataTpl<> Data;
    51 template<typename T, typename DataModel> std::ostream& operator<<(std::ostream& stream, DataTpl<T, DataModel>& data);
     51template<typename T, typename DataModel> std::ostream& operator<<(std::ostream& stream, const DataTpl<T, DataModel>& data);
    5252
    5353//== internal includes ==
    … …  
    324324};
    325325
    326 /* default human readable text output */
    327 template<typename T, typename DataModel>
    328 std::ostream& operator<<(std::ostream& stream, DataTpl<T, DataModel>& data) {
    329         stream << "[" << bitstr(data.getBuffer(), data.getLength(), 4)
    330                         << "|'";
    331         char* buffer = (char*) data.getBuffer();
    332         for (size_t i = 0; i < data.getLength() / 8; i++) {
    333                 char c = buffer[i] < 32 ? '.' : buffer[i];
    334                 stream << c;
    335         }
    336         stream << "']";
    337         return stream;
    338 }
    339 
    340326/* unspecified type */
    341327template<typename T, typename DataModel>
    … …  
    397383
    398384        finline int32_t length() const {
    399                 return bufferLen;
     385                return (bufferLen == -1) ? 0 : bufferLen;
    400386        }
    401387
    … …  
    442428}sznEnd();
    443429
     430/* default human readable text output */
     431template<typename T, typename DataModel>
     432std::ostream& operator<<(std::ostream& stream, const DataTpl<T, DataModel>& data) {
     433        stream << "[" << bitstr(data.getBuffer(), data.getLength(), 4)
     434                        << "|'";
     435        const char* buffer = (const char*) data.getBuffer();
     436        for (size_t i = 0; i < data.getLength() / 8; i++) {
     437                char c = buffer[i] < 32 ? '.' : buffer[i];
     438                stream << c;
     439        }
     440        stream << "']";
     441        return stream;
     442}
    444443#endif /* DATA_HPP_ */

  • source/ariba/utility/transport/tcpip/protlib/address.cpp

    r5876 r6786  
    534534        char ipstr[INET6_ADDRSTRLEN] = {0};
    535535        // look for /
    536         i = strchr(str,'/');
     536        i = strchr((char*)str,'/');
    537537        if (i) {
    538538                iplen = i-str;
Note: See TracChangeset for help on using the changeset viewer.