Changeset 2452


Ignore:
Timestamp:
Feb 18, 2009, 11:39:30 AM (16 years ago)
Author:
mies
Message:

implemented bootstrap info parser

Files:
9 edited

Legend:

Unmodified
Added
Removed

  • etc/pingpong/settings_initiator.cnf

    r2419 r2452  
    44ariba.tcp.port = 5002
    55#ariba.udp.port =
    6 #ariba.bootstrap.hints =
     6ariba.bootstrap.hints=pingpong{ip{127.0.0.1},tcp(ip,5002)}

  • etc/pingpong/settings_node1.cnf

    r2419 r2452  
    44ariba.tcp.port = 5003
    55#ariba.udp.port =
    6 ariba.bootstrap.hints = <spovnet>pingpong<ip>127.0.0.1<port>5002
     6ariba.bootstrap.hints=pingpong{ip{127.0.0.1},tcp(ip,5002)}

  • etc/pingpong/settings_node2.cnf

    r2419 r2452  
    44ariba.tcp.port = 5010
    55#ariba.udp.port =
    6 ariba.bootstrap.hints = <spovnet>pingpong<ip>127.0.0.1<port>5002
     6ariba.bootstrap.hints=pingpong{ip{127.0.0.1},tcp(ip,5002)}

  • source/ariba/AribaModule.cpp

    r2434 r2452  
    4545// ariba includes
    4646#include "ariba/utility/misc/Helper.h"
     47#include "ariba/utility/misc/StringFormat.h"
    4748
    4849// hack includes
    … …  
    5354using namespace ariba::utility::Helper;
    5455using ariba::interface::UnderlayAbstraction;
     56using ariba::communication::EndpointDescriptor;
    5557
    5658namespace ariba {
     59
     60AribaModule::BootstrapNode::~BootstrapNode() {
     61        if (desc!=NULL) delete desc;
     62}
    5763
    5864AribaModule::AribaModule() {
    … …  
    6975}
    7076
    71 
    7277string AribaModule::getBootstrapHints(const Name& spoVNetName) const {
    73 
     78        std::ostringstream o;
     79        BOOST_FOREACH( const BootstrapInfo& info, bootstrapNodes ) {
     80                o << info.spovnetName.toString() << "{";
     81                int i=0;
     82                BOOST_FOREACH( const BootstrapNode& node, info.nodes ) {
     83                        if (i!=0) o << ",";
     84                        if( node.desc != NULL ) o << node.desc->toString();
     85                        i++;
     86                }
     87        }
     88        return o.str();
    7489}
    7590
    7691void AribaModule::addBootstrapHints(string boot_info) {
    77         string str = boot_info;
    78         static ::boost::regex boot_expr("<([^>:]+)[:]?([0-9]+)?>([^<]+)(.*)");
    79         ::boost::smatch what;
    80         while (::boost::regex_match(str, what, boot_expr)) {
    81                 std::cout << what[1].str() << ":" << what[2].str() << "=" << what[3]
    82                                 << std::endl;
    83                 str = what[4].str();
    84         }
    85 }
    86 
    87 void AribaModule::addBootstrapNode(const Name& spovnet, const Name& node,
     92        using namespace boost::xpressive;
     93        using namespace ariba::utility::string_format;
     94        using namespace ariba::utility::Helper;
     95        using namespace std;
     96
     97        smatch match;
     98        if (regex_search(boot_info, match, robjects)) {
     99                regex_nav nav = match;
     100                for (int i = 0; i < nav.size(); i++) {
     101                        string type = nav[i][robject_id].str();
     102                        string data = nav[i][robject_data].str();
     103                        data = data.substr(1, data.size() - 2);
     104                        Name name = type;
     105                        EndpointDescriptor* desc = EndpointDescriptor::fromString(data);
     106                        addBootstrapNode(name, desc);
     107                }
     108        }
     109}
     110
     111void AribaModule::addBootstrapNode(const Name& spovnet,
    88112                communication::EndpointDescriptor* desc) {
    89113
     114        // set bootstrap node
     115        BootstrapNode node;
     116        node.timestamp = 0;
     117        node.desc = desc;
     118        bool added = false;
     119
     120        // add node to existing bootstrap list
     121        BOOST_FOREACH( BootstrapInfo& info, bootstrapNodes ){
     122                if (info.spovnetName == spovnet) {
     123                        info.nodes.push_back(node);
     124                        added = true;
     125                        break;
     126                }
     127        }
     128
     129        // create new entry
     130        if (!added) {
     131                BootstrapInfo info;
     132                info.spovnetName = spovnet;
     133                info.nodes.push_back(node);
     134                bootstrapNodes.push_back(info);
     135        }
     136
     137        std::cout << "added bootstrap info: " << getBootstrapHints() << std::endl;
    90138}
    91139
    92140const communication::EndpointDescriptor* AribaModule::getBootstrapNode(
    93                 const Name& spovnet) {
    94 
    95         BOOST_FOREACH( BootstrapInfo info, bootstrapNodes ){
    96                 if( info.spovnetName == spovnet ){
    97                         BOOST_FOREACH( BootstrapNode node, info.desc ){
     141                const Name& spovnet) const {
     142        BOOST_FOREACH( const BootstrapInfo& info, bootstrapNodes ) {
     143                if( info.spovnetName == spovnet ) {
     144                        BOOST_FOREACH( const BootstrapNode& node, info.nodes ) {
    98145                                if( node.desc != NULL ) return node.desc;
    99146                        }
    100147                }
    101148        }
    102 
    103149        return NULL;
    104150}
    … …  
    150196                *loc = communication::IPv4Locator::fromString(value);
    151197                ip_addr = loc;
    152         } else if (key == "tcp.port") tcp_port = stoi(value);
     198        }
     199        else if (key == "tcp.port") tcp_port = stoi(value);
    153200        else if (key == "udp.port") udp_port = stoi(value);
    154201        else if (key == "bootstrap.hints") addBootstrapHints(value);

  • source/ariba/AribaModule.h

    r2434 r2452  
    141141        class BootstrapNode {
    142142        public:
     143                inline BootstrapNode() : timestamp(0), desc(NULL) {
     144
     145                }
     146                inline BootstrapNode(uint32_t timestamp,
     147                                communication::EndpointDescriptor* desc) :
     148                        timestamp(timestamp), desc(desc) {
     149
     150                }
     151                ~BootstrapNode();
    143152                uint32_t timestamp;
    144153                communication::EndpointDescriptor* desc;
    … …  
    149158        public:
    150159                Name spovnetName;
    151                 vector<BootstrapNode> desc;
     160                vector<BootstrapNode> nodes;
    152161        };
    153162        vector<BootstrapInfo> bootstrapNodes;
    … …  
    155164protected:
    156165        // members
    157         string bootstrapFile;   //< file with bootstrap information
    158         bool started;                   //< flag, if module has been started
     166        string bootstrapFile; //< file with bootstrap information
     167        bool started; //< flag, if module has been started
    159168
    160169        // bootstrap node management
    161         void addBootstrapNode(const Name& spovnet, const Name& node,
     170        void addBootstrapNode(const Name& spovnet,
    162171                        communication::EndpointDescriptor* desc);
    163172        const communication::EndpointDescriptor* getBootstrapNode(
    164                         const Name& spovnet);
     173                        const Name& spovnet) const;
    165174
    166175        // TODO: merge with old interface

  • source/ariba/communication/EndpointDescriptor.cpp

    r2451 r2452  
    3838
    3939#include "EndpointDescriptor.h"
     40#include "ariba/utility/misc/StringFormat.h"
     41#include "ariba/utility/misc/Helper.h"
    4042
    4143namespace ariba {
    … …  
    6870string EndpointDescriptor::toString() const {
    6971        if( locator == NULL ) return "<undefined locator>";
    70         else                  return locator->toString();
     72        std::ostringstream o;
     73        o << "ip{" << locator->getIP() << "}";
     74        o << ",";
     75        o << "tcp(ip,{" << locator->getPort() << "})";
     76        return o.str();
    7177}
    7278
    7379EndpointDescriptor* EndpointDescriptor::fromString( string str ) {
    74         EndpointDescriptor* ep = new EndpointDescriptor();
    75         ep->locator->fromString(str);
    76         ep->isUnspec = false;
     80        using namespace boost::xpressive;
     81        using namespace ariba::utility::string_format;
     82        using namespace ariba::utility::Helper;
     83        using namespace std;
     84
     85        EndpointDescriptor* ep = NULL;
     86        smatch match;
     87        if (regex_search(str, match, robjects)) {
     88                regex_nav nav = match;
     89                for (int i=0; i<nav.size(); i++) {
     90                        string type = nav[i][robject_id].str();
     91                        if (type=="ip") {
     92                                string ip = nav[i][robject_data].str();
     93                                ip = ip.substr(1,ip.size()-2);
     94                                cout << "ep-ip = " <<ip << endl;
     95                                ep = new EndpointDescriptor();
     96                                ep->locator = new IPv4Locator();
     97                                ep->locator->setIP(ip);
     98                                ep->isUnspec = false;
     99                        } else
     100                        if (type=="tcp") {
     101                                string port = nav[i][robject_data][rfields][1].str();
     102                                port = port.substr(1,port.size()-2);
     103                                cout << "ep-tcp-port = " << port << endl;
     104                                ep->locator->setPort(stoi(port));
     105                        }
     106                }
     107        }
    77108        return ep;
    78109}

  • source/ariba/communication/modules/network/ip/IPv4Locator.h

    r2451 r2452  
    7777        virtual string toString() const;
    7878
     79        void setIP( string ip ) {
     80                ipv4Address = boost::asio::ip::address_v4::from_string( ip );
     81        }
     82
    7983        string getIP() const {
    8084                return ipv4Address.to_string();
    … …  
    9195        boost::asio::ip::address_v4 ipv4Address;
    9296        uint16_t port;
    93 
    9497};
    9598

  • source/ariba/utility/misc/StringFormat.cpp

    r2444 r2452  
    44#include "boost/xpressive/xpressive.hpp"
    55
     6namespace ariba {
     7namespace utility {
     8namespace string_format {
     9
    610using namespace boost::xpressive;
    711
    812// regex: string
    9 const sregex StringFormat::rstring = '"' >> keep(*~(boost::xpressive::set = '"'))
     13const sregex rstring = '"' >> keep(*~(boost::xpressive::set = '"'))
    1014                >> '"';
    1115
    1216// regex: base64 encoding
    13 const sregex StringFormat::rbase64 = '!' >> +(range('a', 'z') | range('A', 'Z')
     17const sregex rbase64 = '!' >> +(range('a', 'z') | range('A', 'Z')
    1418                | range('0', '9') | '/' | '+') >> *(boost::xpressive::set = '=');
    1519
    1620// regex: raw alphabet
    17 const sregex StringFormat::rchars = +(range('a', 'z') | range('A', 'Z'));
     21const sregex rchars = +(range('a', 'z') | range('A', 'Z'));
    1822
    1923// regex: integer
    20 const sregex StringFormat::rint = '0' | (range('1', '9') >> !(range('0', '9')));
     24const sregex rint = '0' | (range('1', '9') >> !(range('0', '9')));
    2125
    2226// regex: binary label
    23 const sregex StringFormat::rlabel = rchars | rstring | rbase64;
     27const sregex rlabel = rchars | rstring | rbase64;
    2428
    2529// regex: dot separated identifier
    26 const sregex StringFormat::rid = rlabel >> *('.' >> rlabel) >> *('.' >> rint);
     30const sregex rid = rlabel >> *('.' >> rlabel) >> *('.' >> rint);
    2731
    2832// regex: "leaf" data
    29 const sregex StringFormat::rdata = !(boost::xpressive::set = '!') >> '{'
     33const sregex rdata = !(boost::xpressive::set = '!') >> '{'
    3034                >> *(keep(+~(boost::xpressive::set = '{', '}')) | by_ref(rdata))
    3135                >> '}';
    3236
    3337// regex: fields
    34 const sregex StringFormat::rfield_label = rlabel >> '=';
    35 const sregex StringFormat::rfield = !rfield_label >> (rid | rdata);
    36 const sregex StringFormat::rfields = '(' >> rfield >> *(',' >> rfield) >> ')';
     38const sregex rfield_label = rlabel >> '=';
     39const sregex rfield = !rfield_label >> (rid | rdata);
     40const sregex rfields = '(' >> rfield >> *(',' >> rfield) >> ')';
    3741
    38 // regex: objects
    39 const sregex StringFormat::robject_data = (rdata | rfields);
    40 const sregex StringFormat::robject = rid >> robject_data;
    41 const sregex StringFormat::robjects = robject >> *(',' >> robject);
     42// regex objects
     43const sregex robject_data = (rdata | rfields);
     44const sregex robject_id = rid;
     45const sregex robject = robject_id >> robject_data;
     46const sregex robjects = robject >> *(',' >> robject);
     47
     48}}}

  • source/ariba/utility/misc/StringFormat.h

    r2444 r2452  
    55#include "boost/xpressive/xpressive.hpp"
    66
     7namespace ariba {
     8namespace utility {
     9namespace string_format {
     10
    711using boost::xpressive::sregex;
    812
    9 /**
    10  * This class defines some regular expressions ...
    11  *
    12  * @author Sebastian Mies
    13  */
    14 class StringFormat {
     13class regex_nav {
     14private:
     15        typedef boost::xpressive::smatch _match;
     16        typedef _match::nested_results_type nested_results;
     17        typedef nested_results::const_iterator nested_iterator;
     18        const _match& match;
     19
    1520public:
    16         // regex: string
    17         static const sregex rstring;
     21        regex_nav(const _match& match) :
     22                match(match) {
     23        }
    1824
    19         // regex: base64 encoding
    20         static const sregex rbase64;
     25        regex_nav() :
     26                match(*((const _match*) NULL)) {
     27        }
    2128
    22         // regex: raw alphabet
    23         static const sregex rchars;
     29        bool matched() const {
     30                return &match != NULL;
     31        }
    2432
    25         // regex: integer
    26         static const sregex rint;
     33        regex_nav operator[] (const sregex& type) const {
     34                const nested_results& nr = match.nested_results();
     35                for (nested_iterator i = nr.begin(); i != nr.end(); i++) {
     36                        if (i->regex_id() == type.regex_id()) return regex_nav(*i);
     37                }
     38                return regex_nav();
     39        }
    2740
    28         // regex: binary label
    29         static const sregex rlabel;
     41        regex_nav operator[](int index) const {
     42                const nested_results& nr = match.nested_results();
     43                for (nested_iterator i = nr.begin(); i != nr.end() && index >= 0; i++) {
     44                        if (index == 0) return regex_nav(*i);
     45                        index--;
     46                }
     47                return regex_nav();
     48        }
    3049
    31         // regex: dot separated identifier
    32         static const sregex rid;
     50        int size() const {
     51                return match.nested_results().size();
     52        }
    3353
    34         // regex: "leaf" data
    35         static const sregex rdata;
    36 
    37         // regex: fields
    38         static const sregex rfield_label;
    39         static const sregex rfield;
    40         static const sregex rfields;
    41 
    42         // regex: objects
    43         static const sregex robject_data;
    44         static const sregex robject;
    45         static const sregex robjects;
     54        std::string str() const {
     55                if (!matched()) return std::string("<no match>");
     56                return match[0].str();
     57        }
    4658};
    4759
     60// regex: string
     61extern const sregex rstring;
     62
     63// regex: base64 encoding
     64extern const sregex rbase64;
     65
     66// regex: raw alphabet
     67extern const sregex rchars;
     68
     69// regex: integer
     70extern const sregex rint;
     71
     72// regex: binary label
     73extern const sregex rlabel;
     74
     75// regex: dot separated identifier
     76extern const sregex rid;
     77
     78// regex: "leaf" data
     79extern const sregex rdata;
     80
     81// regex: fields
     82extern const sregex rfield_label;
     83extern const sregex rfield;
     84extern const sregex rfields;
     85
     86// regex: objects
     87extern const sregex robject_data;
     88extern const sregex robject_id;
     89extern const sregex robject;
     90extern const sregex robjects;
     91
     92}}}
     93
    4894#endif /* STRINGFORMAT_H_ */
Note: See TracChangeset for help on using the changeset viewer.