Borealis: rpc_Lookup.h Source File

00001 /***** 00002 * 00003 * ../catalog/central/rpc_Lookup.h 00004 * 00005 * Include this file to gain access to the following classes: 00006 * 00007 * - Remote<Lookup> 00008 * 00009 * This file is automatically generated by nmstl-rpcgen. 00010 * Do not modify it! 00011 * 00012 *****/ 00013 00014 #ifndef ___CATALOG_CENTRAL_RPC_LOOKUP_H 00015 #define ___CATALOG_CENTRAL_RPC_LOOKUP_H 00016 00017 #include <NMSTL/rpc> 00018 00019 00020 namespace Borealis { class Lookup; }; 00021 00022 00023 NMSTL_NAMESPACE_BEGIN; 00024 00025 #ifdef DOXYGEN_SKIP 00026 00027 00028 00029 00030 /***** 00031 * 00032 * Following are the public interfaces to RPC objects. 00033 * 00034 *****/ 00035 00036 template<typename T> class Remote; 00037 class Remote<Borealis::Lookup> { 00038 public: 00041 void register_object(const Callback<void, RPC< void > >& completion, 00042 ptr<Object> object); 00043 00045 RPC< void > register_object(ptr<Object> object); 00046 00049 void register_object_set(const Callback<void, RPC< void > >& completion, 00050 ptr<Object> object); 00051 00053 RPC< void > register_object_set(ptr<Object> object); 00054 00057 void register_objects(const Callback<void, RPC< void > >& completion, 00058 vector< ptr<Object> > object); 00059 00061 RPC< void > register_objects(vector< ptr<Object> > object); 00062 00065 void register_object_sets(const Callback<void, RPC< void > >& completion, 00066 vector< ptr<Object> > object); 00067 00069 RPC< void > register_object_sets(vector< ptr<Object> > object); 00070 00073 void lookup_object(const Callback<void, RPC< ptr<Object> > >& completion, 00074 Name name); 00075 00077 RPC< ptr<Object> > lookup_object(Name name); 00078 00081 void lookup_object_set(const Callback<void, RPC< vector< ptr<Object> > > >& completion, 00082 Name name); 00083 00085 RPC< vector< ptr<Object> > > lookup_object_set(Name name); 00086 00089 void lookup_objects(const Callback<void, RPC< vector< ptr<Object> > > >& completion, 00090 vector<Name> names); 00091 00093 RPC< vector< ptr<Object> > > lookup_objects(vector<Name> names); 00094 00097 void lookup_object_sets(const Callback<void, RPC< vector< vector< ptr<Object> > > > >& completion, 00098 vector<Name> names); 00099 00101 RPC< vector< vector< ptr<Object> > > > lookup_object_sets(vector<Name> names); 00102 00105 void register_node(const Callback<void, RPC< void > >& completion, 00106 MedusaID node, InetAddress address); 00107 00109 RPC< void > register_node(MedusaID node, InetAddress address); 00110 00113 void lookup_node(const Callback<void, RPC< InetAddress > >& completion, 00114 MedusaID node); 00115 00117 RPC< InetAddress > lookup_node(MedusaID node); 00118 00121 void set_backup_pair(const Callback<void, RPC< void > >& completion, 00122 MedusaID primary, MedusaID secondary); 00123 00125 RPC< void > set_backup_pair(MedusaID primary, MedusaID secondary); 00126 00129 void get_backup(const Callback<void, RPC< MedusaID > >& completion, 00130 MedusaID primary); 00131 00133 RPC< MedusaID > get_backup(MedusaID primary); 00134 00137 void add_responsability(const Callback<void, RPC< void > >& completion, 00138 MedusaID node, ptr<Object> object, bool standalone); 00139 00141 RPC< void > add_responsability(MedusaID node, ptr<Object> object, bool standalone); 00142 00145 void add_responsabilities(const Callback<void, RPC< void > >& completion, 00146 MedusaID node, vector< pair< ptr<Object>,bool > > objects); 00147 00149 RPC< void > add_responsabilities(MedusaID node, vector< pair< ptr<Object>,bool > > objects); 00150 00153 void remove_responsability(const Callback<void, RPC< void > >& completion, 00154 MedusaID node, Name name); 00155 00157 RPC< void > remove_responsability(MedusaID node, Name name); 00158 00161 void remove_responsabilities(const Callback<void, RPC< void > >& completion, 00162 MedusaID node, vector<Name> names); 00163 00165 RPC< void > remove_responsabilities(MedusaID node, vector<Name> names); 00166 00169 void get_responsabilities(const Callback<void, RPC< vector< ptr<Object> > > >& completion, 00170 MedusaID node); 00171 00173 RPC< vector< ptr<Object> > > get_responsabilities(MedusaID node); 00174 00175 }; 00176 00177 00178 /***** 00179 * 00180 * You can safely ignore everything after here. 00181 * 00182 *****/ 00183 00184 00185 00186 00187 00188 #else // !defined(DOXYGEN_SKIP) 00189 00190 namespace __nmstl_tmp_rpc_defs { 00191 template<typename X> struct RPCDefs; 00192 template<typename X> struct Remote; 00193 using namespace Borealis; 00194 template<> 00195 struct RPCDefs<Borealis::Lookup> { 00196 static const int register_object_METHOD_ID = 20000; 00197 struct register_object_IN : public rpc_request_1< void > { 00198 ptr<Object> object; 00199 register_object_IN() {} 00200 register_object_IN(ptr<Object> object) : object(object) {} 00201 rpc_message *clone() const { return new register_object_IN(*this); } 00202 string as_string() const { 00203 string out; 00204 out << "register_object_IN{" << "object=" << object << "}"; 00205 return out; 00206 } 00207 NMSTL_SIMPLY_SERIALIZABLE(register_object_IN, << Serial::tag("param") << object ); 00208 NMSTL_SERIAL_TAG(register_object_IN, "params"); 00209 }; 00210 class register_object_OUT { 00211 RPCStatus m_stat; 00212 public: 00213 operator const void * () const { return m_stat; } 00214 const RPCStatus& stat() const { return m_stat; } 00215 bool get() const { return true; } 00216 }; 00217 static const int register_object_set_METHOD_ID = 20001; 00218 struct register_object_set_IN : public rpc_request_1< void > { 00219 ptr<Object> object; 00220 register_object_set_IN() {} 00221 register_object_set_IN(ptr<Object> object) : object(object) {} 00222 rpc_message *clone() const { return new register_object_set_IN(*this); } 00223 string as_string() const { 00224 string out; 00225 out << "register_object_set_IN{" << "object=" << object << "}"; 00226 return out; 00227 } 00228 NMSTL_SIMPLY_SERIALIZABLE(register_object_set_IN, << Serial::tag("param") << object ); 00229 NMSTL_SERIAL_TAG(register_object_set_IN, "params"); 00230 }; 00231 class register_object_set_OUT { 00232 RPCStatus m_stat; 00233 public: 00234 operator const void * () const { return m_stat; } 00235 const RPCStatus& stat() const { return m_stat; } 00236 bool get() const { return true; } 00237 }; 00238 static const int register_objects_METHOD_ID = 20002; 00239 struct register_objects_IN : public rpc_request_1< void > { 00240 vector< ptr<Object> > object; 00241 register_objects_IN() {} 00242 register_objects_IN(vector< ptr<Object> > object) : object(object) {} 00243 rpc_message *clone() const { return new register_objects_IN(*this); } 00244 string as_string() const { 00245 string out; 00246 out << "register_objects_IN{" << "object=" << object << "}"; 00247 return out; 00248 } 00249 NMSTL_SIMPLY_SERIALIZABLE(register_objects_IN, << Serial::tag("param") << object ); 00250 NMSTL_SERIAL_TAG(register_objects_IN, "params"); 00251 }; 00252 class register_objects_OUT { 00253 RPCStatus m_stat; 00254 public: 00255 operator const void * () const { return m_stat; } 00256 const RPCStatus& stat() const { return m_stat; } 00257 bool get() const { return true; } 00258 }; 00259 static const int register_object_sets_METHOD_ID = 20003; 00260 struct register_object_sets_IN : public rpc_request_1< void > { 00261 vector< ptr<Object> > object; 00262 register_object_sets_IN() {} 00263 register_object_sets_IN(vector< ptr<Object> > object) : object(object) {} 00264 rpc_message *clone() const { return new register_object_sets_IN(*this); } 00265 string as_string() const { 00266 string out; 00267 out << "register_object_sets_IN{" << "object=" << object << "}"; 00268 return out; 00269 } 00270 NMSTL_SIMPLY_SERIALIZABLE(register_object_sets_IN, << Serial::tag("param") << object ); 00271 NMSTL_SERIAL_TAG(register_object_sets_IN, "params"); 00272 }; 00273 class register_object_sets_OUT { 00274 RPCStatus m_stat; 00275 public: 00276 operator const void * () const { return m_stat; } 00277 const RPCStatus& stat() const { return m_stat; } 00278 bool get() const { return true; } 00279 }; 00280 static const int lookup_object_METHOD_ID = 20004; 00281 struct lookup_object_IN : public rpc_request_1< ptr<Object> > { 00282 Name name; 00283 lookup_object_IN() {} 00284 lookup_object_IN(Name name) : name(name) {} 00285 rpc_message *clone() const { return new lookup_object_IN(*this); } 00286 string as_string() const { 00287 string out; 00288 out << "lookup_object_IN{" << "name=" << name << "}"; 00289 return out; 00290 } 00291 NMSTL_SIMPLY_SERIALIZABLE(lookup_object_IN, << Serial::tag("param") << name ); 00292 NMSTL_SERIAL_TAG(lookup_object_IN, "params"); 00293 }; 00294 class lookup_object_OUT { 00295 RPCStatus m_stat; 00296 ptr<Object> m_val; 00297 public: 00298 operator const void * () const { return m_stat; } 00299 const RPCStatus& stat() const { return m_stat; } 00300 ptr<Object> get() const { return m_val; } 00301 }; 00302 static const int lookup_object_set_METHOD_ID = 20005; 00303 struct lookup_object_set_IN : public rpc_request_1< vector< ptr<Object> > > { 00304 Name name; 00305 lookup_object_set_IN() {} 00306 lookup_object_set_IN(Name name) : name(name) {} 00307 rpc_message *clone() const { return new lookup_object_set_IN(*this); } 00308 string as_string() const { 00309 string out; 00310 out << "lookup_object_set_IN{" << "name=" << name << "}"; 00311 return out; 00312 } 00313 NMSTL_SIMPLY_SERIALIZABLE(lookup_object_set_IN, << Serial::tag("param") << name ); 00314 NMSTL_SERIAL_TAG(lookup_object_set_IN, "params"); 00315 }; 00316 class lookup_object_set_OUT { 00317 RPCStatus m_stat; 00318 vector< ptr<Object> > m_val; 00319 public: 00320 operator const void * () const { return m_stat; } 00321 const RPCStatus& stat() const { return m_stat; } 00322 vector< ptr<Object> > get() const { return m_val; } 00323 }; 00324 static const int lookup_objects_METHOD_ID = 20006; 00325 struct lookup_objects_IN : public rpc_request_1< vector< ptr<Object> > > { 00326 vector<Name> names; 00327 lookup_objects_IN() {} 00328 lookup_objects_IN(vector<Name> names) : names(names) {} 00329 rpc_message *clone() const { return new lookup_objects_IN(*this); } 00330 string as_string() const { 00331 string out; 00332 out << "lookup_objects_IN{" << "names=" << names << "}"; 00333 return out; 00334 } 00335 NMSTL_SIMPLY_SERIALIZABLE(lookup_objects_IN, << Serial::tag("param") << names ); 00336 NMSTL_SERIAL_TAG(lookup_objects_IN, "params"); 00337 }; 00338 class lookup_objects_OUT { 00339 RPCStatus m_stat; 00340 vector< ptr<Object> > m_val; 00341 public: 00342 operator const void * () const { return m_stat; } 00343 const RPCStatus& stat() const { return m_stat; } 00344 vector< ptr<Object> > get() const { return m_val; } 00345 }; 00346 static const int lookup_object_sets_METHOD_ID = 20007; 00347 struct lookup_object_sets_IN : public rpc_request_1< vector< vector< ptr<Object> > > > { 00348 vector<Name> names; 00349 lookup_object_sets_IN() {} 00350 lookup_object_sets_IN(vector<Name> names) : names(names) {} 00351 rpc_message *clone() const { return new lookup_object_sets_IN(*this); } 00352 string as_string() const { 00353 string out; 00354 out << "lookup_object_sets_IN{" << "names=" << names << "}"; 00355 return out; 00356 } 00357 NMSTL_SIMPLY_SERIALIZABLE(lookup_object_sets_IN, << Serial::tag("param") << names ); 00358 NMSTL_SERIAL_TAG(lookup_object_sets_IN, "params"); 00359 }; 00360 class lookup_object_sets_OUT { 00361 RPCStatus m_stat; 00362 vector< vector< ptr<Object> > > m_val; 00363 public: 00364 operator const void * () const { return m_stat; } 00365 const RPCStatus& stat() const { return m_stat; } 00366 vector< vector< ptr<Object> > > get() const { return m_val; } 00367 }; 00368 static const int register_node_METHOD_ID = 20008; 00369 struct register_node_IN : public rpc_request_1< void > { 00370 MedusaID node; InetAddress address; 00371 register_node_IN() {} 00372 register_node_IN(MedusaID node, InetAddress address) : node(node), address(address) {} 00373 rpc_message *clone() const { return new register_node_IN(*this); } 00374 string as_string() const { 00375 string out; 00376 out << "register_node_IN{" << "node=" << node << ", address=" << address << "}"; 00377 return out; 00378 } 00379 NMSTL_SIMPLY_SERIALIZABLE(register_node_IN, << Serial::tag("param") << node << address ); 00380 NMSTL_SERIAL_TAG(register_node_IN, "params"); 00381 }; 00382 class register_node_OUT { 00383 RPCStatus m_stat; 00384 public: 00385 operator const void * () const { return m_stat; } 00386 const RPCStatus& stat() const { return m_stat; } 00387 bool get() const { return true; } 00388 }; 00389 static const int lookup_node_METHOD_ID = 20009; 00390 struct lookup_node_IN : public rpc_request_1< InetAddress > { 00391 MedusaID node; 00392 lookup_node_IN() {} 00393 lookup_node_IN(MedusaID node) : node(node) {} 00394 rpc_message *clone() const { return new lookup_node_IN(*this); } 00395 string as_string() const { 00396 string out; 00397 out << "lookup_node_IN{" << "node=" << node << "}"; 00398 return out; 00399 } 00400 NMSTL_SIMPLY_SERIALIZABLE(lookup_node_IN, << Serial::tag("param") << node ); 00401 NMSTL_SERIAL_TAG(lookup_node_IN, "params"); 00402 }; 00403 class lookup_node_OUT { 00404 RPCStatus m_stat; 00405 InetAddress m_val; 00406 public: 00407 operator const void * () const { return m_stat; } 00408 const RPCStatus& stat() const { return m_stat; } 00409 InetAddress get() const { return m_val; } 00410 }; 00411 static const int set_backup_pair_METHOD_ID = 20010; 00412 struct set_backup_pair_IN : public rpc_request_1< void > { 00413 MedusaID primary; MedusaID secondary; 00414 set_backup_pair_IN() {} 00415 set_backup_pair_IN(MedusaID primary, MedusaID secondary) : primary(primary), secondary(secondary) {} 00416 rpc_message *clone() const { return new set_backup_pair_IN(*this); } 00417 string as_string() const { 00418 string out; 00419 out << "set_backup_pair_IN{" << "primary=" << primary << ", secondary=" << secondary << "}"; 00420 return out; 00421 } 00422 NMSTL_SIMPLY_SERIALIZABLE(set_backup_pair_IN, << Serial::tag("param") << primary << secondary ); 00423 NMSTL_SERIAL_TAG(set_backup_pair_IN, "params"); 00424 }; 00425 class set_backup_pair_OUT { 00426 RPCStatus m_stat; 00427 public: 00428 operator const void * () const { return m_stat; } 00429 const RPCStatus& stat() const { return m_stat; } 00430 bool get() const { return true; } 00431 }; 00432 static const int get_backup_METHOD_ID = 20011; 00433 struct get_backup_IN : public rpc_request_1< MedusaID > { 00434 MedusaID primary; 00435 get_backup_IN() {} 00436 get_backup_IN(MedusaID primary) : primary(primary) {} 00437 rpc_message *clone() const { return new get_backup_IN(*this); } 00438 string as_string() const { 00439 string out; 00440 out << "get_backup_IN{" << "primary=" << primary << "}"; 00441 return out; 00442 } 00443 NMSTL_SIMPLY_SERIALIZABLE(get_backup_IN, << Serial::tag("param") << primary ); 00444 NMSTL_SERIAL_TAG(get_backup_IN, "params"); 00445 }; 00446 class get_backup_OUT { 00447 RPCStatus m_stat; 00448 MedusaID m_val; 00449 public: 00450 operator const void * () const { return m_stat; } 00451 const RPCStatus& stat() const { return m_stat; } 00452 MedusaID get() const { return m_val; } 00453 }; 00454 static const int add_responsability_METHOD_ID = 20012; 00455 struct add_responsability_IN : public rpc_request_1< void > { 00456 MedusaID node; ptr<Object> object; bool standalone; 00457 add_responsability_IN() {} 00458 add_responsability_IN(MedusaID node, ptr<Object> object, bool standalone) : node(node), object(object), standalone(standalone) {} 00459 rpc_message *clone() const { return new add_responsability_IN(*this); } 00460 string as_string() const { 00461 string out; 00462 out << "add_responsability_IN{" << "node=" << node << ", object=" << object << ", standalone=" << standalone << "}"; 00463 return out; 00464 } 00465 NMSTL_SIMPLY_SERIALIZABLE(add_responsability_IN, << Serial::tag("param") << node << object << standalone ); 00466 NMSTL_SERIAL_TAG(add_responsability_IN, "params"); 00467 }; 00468 class add_responsability_OUT { 00469 RPCStatus m_stat; 00470 public: 00471 operator const void * () const { return m_stat; } 00472 const RPCStatus& stat() const { return m_stat; } 00473 bool get() const { return true; } 00474 }; 00475 static const int add_responsabilities_METHOD_ID = 20013; 00476 struct add_responsabilities_IN : public rpc_request_1< void > { 00477 MedusaID node; vector< pair< ptr<Object>,bool > > objects; 00478 add_responsabilities_IN() {} 00479 add_responsabilities_IN(MedusaID node, vector< pair< ptr<Object>,bool > > objects) : node(node), objects(objects) {} 00480 rpc_message *clone() const { return new add_responsabilities_IN(*this); } 00481 string as_string() const { 00482 string out; 00483 out << "add_responsabilities_IN{" << "node=" << node << ", objects=" << objects << "}"; 00484 return out; 00485 } 00486 NMSTL_SIMPLY_SERIALIZABLE(add_responsabilities_IN, << Serial::tag("param") << node << objects ); 00487 NMSTL_SERIAL_TAG(add_responsabilities_IN, "params"); 00488 }; 00489 class add_responsabilities_OUT { 00490 RPCStatus m_stat; 00491 public: 00492 operator const void * () const { return m_stat; } 00493 const RPCStatus& stat() const { return m_stat; } 00494 bool get() const { return true; } 00495 }; 00496 static const int remove_responsability_METHOD_ID = 20014; 00497 struct remove_responsability_IN : public rpc_request_1< void > { 00498 MedusaID node; Name name; 00499 remove_responsability_IN() {} 00500 remove_responsability_IN(MedusaID node, Name name) : node(node), name(name) {} 00501 rpc_message *clone() const { return new remove_responsability_IN(*this); } 00502 string as_string() const { 00503 string out; 00504 out << "remove_responsability_IN{" << "node=" << node << ", name=" << name << "}"; 00505 return out; 00506 } 00507 NMSTL_SIMPLY_SERIALIZABLE(remove_responsability_IN, << Serial::tag("param") << node << name ); 00508 NMSTL_SERIAL_TAG(remove_responsability_IN, "params"); 00509 }; 00510 class remove_responsability_OUT { 00511 RPCStatus m_stat; 00512 public: 00513 operator const void * () const { return m_stat; } 00514 const RPCStatus& stat() const { return m_stat; } 00515 bool get() const { return true; } 00516 }; 00517 static const int remove_responsabilities_METHOD_ID = 20015; 00518 struct remove_responsabilities_IN : public rpc_request_1< void > { 00519 MedusaID node; vector<Name> names; 00520 remove_responsabilities_IN() {} 00521 remove_responsabilities_IN(MedusaID node, vector<Name> names) : node(node), names(names) {} 00522 rpc_message *clone() const { return new remove_responsabilities_IN(*this); } 00523 string as_string() const { 00524 string out; 00525 out << "remove_responsabilities_IN{" << "node=" << node << ", names=" << names << "}"; 00526 return out; 00527 } 00528 NMSTL_SIMPLY_SERIALIZABLE(remove_responsabilities_IN, << Serial::tag("param") << node << names ); 00529 NMSTL_SERIAL_TAG(remove_responsabilities_IN, "params"); 00530 }; 00531 class remove_responsabilities_OUT { 00532 RPCStatus m_stat; 00533 public: 00534 operator const void * () const { return m_stat; } 00535 const RPCStatus& stat() const { return m_stat; } 00536 bool get() const { return true; } 00537 }; 00538 static const int get_responsabilities_METHOD_ID = 20016; 00539 struct get_responsabilities_IN : public rpc_request_1< vector< ptr<Object> > > { 00540 MedusaID node; 00541 get_responsabilities_IN() {} 00542 get_responsabilities_IN(MedusaID node) : node(node) {} 00543 rpc_message *clone() const { return new get_responsabilities_IN(*this); } 00544 string as_string() const { 00545 string out; 00546 out << "get_responsabilities_IN{" << "node=" << node << "}"; 00547 return out; 00548 } 00549 NMSTL_SIMPLY_SERIALIZABLE(get_responsabilities_IN, << Serial::tag("param") << node ); 00550 NMSTL_SERIAL_TAG(get_responsabilities_IN, "params"); 00551 }; 00552 class get_responsabilities_OUT { 00553 RPCStatus m_stat; 00554 vector< ptr<Object> > m_val; 00555 public: 00556 operator const void * () const { return m_stat; } 00557 const RPCStatus& stat() const { return m_stat; } 00558 vector< ptr<Object> > get() const { return m_val; } 00559 }; 00560 static const vector<pair<string, int> >& method_list() { 00561 static const pair<string, int> methods[] = { 00562 pair<string, int>("register_object", 20000), 00563 pair<string, int>("register_object_set", 20001), 00564 pair<string, int>("register_objects", 20002), 00565 pair<string, int>("register_object_sets", 20003), 00566 pair<string, int>("lookup_object", 20004), 00567 pair<string, int>("lookup_object_set", 20005), 00568 pair<string, int>("lookup_objects", 20006), 00569 pair<string, int>("lookup_object_sets", 20007), 00570 pair<string, int>("register_node", 20008), 00571 pair<string, int>("lookup_node", 20009), 00572 pair<string, int>("set_backup_pair", 20010), 00573 pair<string, int>("get_backup", 20011), 00574 pair<string, int>("add_responsability", 20012), 00575 pair<string, int>("add_responsabilities", 20013), 00576 pair<string, int>("remove_responsability", 20014), 00577 pair<string, int>("remove_responsabilities", 20015), 00578 pair<string, int>("get_responsabilities", 20016) 00579 }; 00580 static const vector<pair<string, int> > ret(methods, methods + sizeof methods / sizeof methods[0]); 00581 return ret; 00582 }; 00583 static const map<string, int>& method_id_by_name() { 00584 static const map<string, int> ret(method_list().begin(), method_list().end()); 00585 return ret; 00586 } 00587 static const map<int, string>& method_name_by_id() { 00588 static const map<int, string> ret = RPCObject::reverse_map(method_id_by_name()); 00589 return ret; 00590 } 00591 }; 00592 template<> 00593 class Remote<Borealis::Lookup> : public RemoteObject { 00594 friend class RPCClient; 00595 protected: 00596 Remote<Borealis::Lookup>(RPCClient& cli, rpc_object_id object_id) : 00597 RemoteObject(cli, object_id) {} 00598 00599 public: 00600 Remote<Borealis::Lookup>() {} 00601 void register_object(const Callback<void, RPC< void > >& completion, ptr<Object> object) const { 00602 RPCDefs<Borealis::Lookup>::register_object_IN *req = 00603 new RPCDefs<Borealis::Lookup>::register_object_IN(object); 00604 req->object_id = object_id(); 00605 req->method_id = RPCDefs<Borealis::Lookup>::register_object_METHOD_ID; 00606 req->method_name = "register_object"; 00607 req->cb = completion; 00608 client().send_request(ptr<rpc_request>(req)); 00609 } 00610 RPC< void > register_object(ptr<Object> object) const { 00611 RPCDefs<Borealis::Lookup>::register_object_IN *req = 00612 new RPCDefs<Borealis::Lookup>::register_object_IN(object); 00613 ptr<rpc_request> preq(req); 00614 req->object_id = object_id(); 00615 req->method_id = RPCDefs<Borealis::Lookup>::register_object_METHOD_ID; 00616 req->method_name = "register_object"; 00617 bool done = false; RPC< void > ret; 00618 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00619 client().send_request(preq); 00620 while (!done && client().block()) ; 00621 req->cb = Callback<void, RPC< void > >(); 00622 return ret; 00623 } 00624 typedef const RPCDefs<Borealis::Lookup>::register_object_OUT &register_object_result; 00625 void register_object_set(const Callback<void, RPC< void > >& completion, ptr<Object> object) const { 00626 RPCDefs<Borealis::Lookup>::register_object_set_IN *req = 00627 new RPCDefs<Borealis::Lookup>::register_object_set_IN(object); 00628 req->object_id = object_id(); 00629 req->method_id = RPCDefs<Borealis::Lookup>::register_object_set_METHOD_ID; 00630 req->method_name = "register_object_set"; 00631 req->cb = completion; 00632 client().send_request(ptr<rpc_request>(req)); 00633 } 00634 RPC< void > register_object_set(ptr<Object> object) const { 00635 RPCDefs<Borealis::Lookup>::register_object_set_IN *req = 00636 new RPCDefs<Borealis::Lookup>::register_object_set_IN(object); 00637 ptr<rpc_request> preq(req); 00638 req->object_id = object_id(); 00639 req->method_id = RPCDefs<Borealis::Lookup>::register_object_set_METHOD_ID; 00640 req->method_name = "register_object_set"; 00641 bool done = false; RPC< void > ret; 00642 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00643 client().send_request(preq); 00644 while (!done && client().block()) ; 00645 req->cb = Callback<void, RPC< void > >(); 00646 return ret; 00647 } 00648 typedef const RPCDefs<Borealis::Lookup>::register_object_set_OUT &register_object_set_result; 00649 void register_objects(const Callback<void, RPC< void > >& completion, vector< ptr<Object> > object) const { 00650 RPCDefs<Borealis::Lookup>::register_objects_IN *req = 00651 new RPCDefs<Borealis::Lookup>::register_objects_IN(object); 00652 req->object_id = object_id(); 00653 req->method_id = RPCDefs<Borealis::Lookup>::register_objects_METHOD_ID; 00654 req->method_name = "register_objects"; 00655 req->cb = completion; 00656 client().send_request(ptr<rpc_request>(req)); 00657 } 00658 RPC< void > register_objects(vector< ptr<Object> > object) const { 00659 RPCDefs<Borealis::Lookup>::register_objects_IN *req = 00660 new RPCDefs<Borealis::Lookup>::register_objects_IN(object); 00661 ptr<rpc_request> preq(req); 00662 req->object_id = object_id(); 00663 req->method_id = RPCDefs<Borealis::Lookup>::register_objects_METHOD_ID; 00664 req->method_name = "register_objects"; 00665 bool done = false; RPC< void > ret; 00666 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00667 client().send_request(preq); 00668 while (!done && client().block()) ; 00669 req->cb = Callback<void, RPC< void > >(); 00670 return ret; 00671 } 00672 typedef const RPCDefs<Borealis::Lookup>::register_objects_OUT &register_objects_result; 00673 void register_object_sets(const Callback<void, RPC< void > >& completion, vector< ptr<Object> > object) const { 00674 RPCDefs<Borealis::Lookup>::register_object_sets_IN *req = 00675 new RPCDefs<Borealis::Lookup>::register_object_sets_IN(object); 00676 req->object_id = object_id(); 00677 req->method_id = RPCDefs<Borealis::Lookup>::register_object_sets_METHOD_ID; 00678 req->method_name = "register_object_sets"; 00679 req->cb = completion; 00680 client().send_request(ptr<rpc_request>(req)); 00681 } 00682 RPC< void > register_object_sets(vector< ptr<Object> > object) const { 00683 RPCDefs<Borealis::Lookup>::register_object_sets_IN *req = 00684 new RPCDefs<Borealis::Lookup>::register_object_sets_IN(object); 00685 ptr<rpc_request> preq(req); 00686 req->object_id = object_id(); 00687 req->method_id = RPCDefs<Borealis::Lookup>::register_object_sets_METHOD_ID; 00688 req->method_name = "register_object_sets"; 00689 bool done = false; RPC< void > ret; 00690 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00691 client().send_request(preq); 00692 while (!done && client().block()) ; 00693 req->cb = Callback<void, RPC< void > >(); 00694 return ret; 00695 } 00696 typedef const RPCDefs<Borealis::Lookup>::register_object_sets_OUT &register_object_sets_result; 00697 void lookup_object(const Callback<void, RPC< ptr<Object> > >& completion, Name name) const { 00698 RPCDefs<Borealis::Lookup>::lookup_object_IN *req = 00699 new RPCDefs<Borealis::Lookup>::lookup_object_IN(name); 00700 req->object_id = object_id(); 00701 req->method_id = RPCDefs<Borealis::Lookup>::lookup_object_METHOD_ID; 00702 req->method_name = "lookup_object"; 00703 req->cb = completion; 00704 client().send_request(ptr<rpc_request>(req)); 00705 } 00706 RPC< ptr<Object> > lookup_object(Name name) const { 00707 RPCDefs<Borealis::Lookup>::lookup_object_IN *req = 00708 new RPCDefs<Borealis::Lookup>::lookup_object_IN(name); 00709 ptr<rpc_request> preq(req); 00710 req->object_id = object_id(); 00711 req->method_id = RPCDefs<Borealis::Lookup>::lookup_object_METHOD_ID; 00712 req->method_name = "lookup_object"; 00713 bool done = false; RPC< ptr<Object> > ret; 00714 req->cb = wrap(&rpc_sync_completion< ptr<Object> >, &done, &ret); 00715 client().send_request(preq); 00716 while (!done && client().block()) ; 00717 req->cb = Callback<void, RPC< ptr<Object> > >(); 00718 return ret; 00719 } 00720 typedef const RPCDefs<Borealis::Lookup>::lookup_object_OUT &lookup_object_result; 00721 void lookup_object_set(const Callback<void, RPC< vector< ptr<Object> > > >& completion, Name name) const { 00722 RPCDefs<Borealis::Lookup>::lookup_object_set_IN *req = 00723 new RPCDefs<Borealis::Lookup>::lookup_object_set_IN(name); 00724 req->object_id = object_id(); 00725 req->method_id = RPCDefs<Borealis::Lookup>::lookup_object_set_METHOD_ID; 00726 req->method_name = "lookup_object_set"; 00727 req->cb = completion; 00728 client().send_request(ptr<rpc_request>(req)); 00729 } 00730 RPC< vector< ptr<Object> > > lookup_object_set(Name name) const { 00731 RPCDefs<Borealis::Lookup>::lookup_object_set_IN *req = 00732 new RPCDefs<Borealis::Lookup>::lookup_object_set_IN(name); 00733 ptr<rpc_request> preq(req); 00734 req->object_id = object_id(); 00735 req->method_id = RPCDefs<Borealis::Lookup>::lookup_object_set_METHOD_ID; 00736 req->method_name = "lookup_object_set"; 00737 bool done = false; RPC< vector< ptr<Object> > > ret; 00738 req->cb = wrap(&rpc_sync_completion< vector< ptr<Object> > >, &done, &ret); 00739 client().send_request(preq); 00740 while (!done && client().block()) ; 00741 req->cb = Callback<void, RPC< vector< ptr<Object> > > >(); 00742 return ret; 00743 } 00744 typedef const RPCDefs<Borealis::Lookup>::lookup_object_set_OUT &lookup_object_set_result; 00745 void lookup_objects(const Callback<void, RPC< vector< ptr<Object> > > >& completion, vector<Name> names) const { 00746 RPCDefs<Borealis::Lookup>::lookup_objects_IN *req = 00747 new RPCDefs<Borealis::Lookup>::lookup_objects_IN(names); 00748 req->object_id = object_id(); 00749 req->method_id = RPCDefs<Borealis::Lookup>::lookup_objects_METHOD_ID; 00750 req->method_name = "lookup_objects"; 00751 req->cb = completion; 00752 client().send_request(ptr<rpc_request>(req)); 00753 } 00754 RPC< vector< ptr<Object> > > lookup_objects(vector<Name> names) const { 00755 RPCDefs<Borealis::Lookup>::lookup_objects_IN *req = 00756 new RPCDefs<Borealis::Lookup>::lookup_objects_IN(names); 00757 ptr<rpc_request> preq(req); 00758 req->object_id = object_id(); 00759 req->method_id = RPCDefs<Borealis::Lookup>::lookup_objects_METHOD_ID; 00760 req->method_name = "lookup_objects"; 00761 bool done = false; RPC< vector< ptr<Object> > > ret; 00762 req->cb = wrap(&rpc_sync_completion< vector< ptr<Object> > >, &done, &ret); 00763 client().send_request(preq); 00764 while (!done && client().block()) ; 00765 req->cb = Callback<void, RPC< vector< ptr<Object> > > >(); 00766 return ret; 00767 } 00768 typedef const RPCDefs<Borealis::Lookup>::lookup_objects_OUT &lookup_objects_result; 00769 void lookup_object_sets(const Callback<void, RPC< vector< vector< ptr<Object> > > > >& completion, vector<Name> names) const { 00770 RPCDefs<Borealis::Lookup>::lookup_object_sets_IN *req = 00771 new RPCDefs<Borealis::Lookup>::lookup_object_sets_IN(names); 00772 req->object_id = object_id(); 00773 req->method_id = RPCDefs<Borealis::Lookup>::lookup_object_sets_METHOD_ID; 00774 req->method_name = "lookup_object_sets"; 00775 req->cb = completion; 00776 client().send_request(ptr<rpc_request>(req)); 00777 } 00778 RPC< vector< vector< ptr<Object> > > > lookup_object_sets(vector<Name> names) const { 00779 RPCDefs<Borealis::Lookup>::lookup_object_sets_IN *req = 00780 new RPCDefs<Borealis::Lookup>::lookup_object_sets_IN(names); 00781 ptr<rpc_request> preq(req); 00782 req->object_id = object_id(); 00783 req->method_id = RPCDefs<Borealis::Lookup>::lookup_object_sets_METHOD_ID; 00784 req->method_name = "lookup_object_sets"; 00785 bool done = false; RPC< vector< vector< ptr<Object> > > > ret; 00786 req->cb = wrap(&rpc_sync_completion< vector< vector< ptr<Object> > > >, &done, &ret); 00787 client().send_request(preq); 00788 while (!done && client().block()) ; 00789 req->cb = Callback<void, RPC< vector< vector< ptr<Object> > > > >(); 00790 return ret; 00791 } 00792 typedef const RPCDefs<Borealis::Lookup>::lookup_object_sets_OUT &lookup_object_sets_result; 00793 void register_node(const Callback<void, RPC< void > >& completion, MedusaID node, InetAddress address) const { 00794 RPCDefs<Borealis::Lookup>::register_node_IN *req = 00795 new RPCDefs<Borealis::Lookup>::register_node_IN(node, address); 00796 req->object_id = object_id(); 00797 req->method_id = RPCDefs<Borealis::Lookup>::register_node_METHOD_ID; 00798 req->method_name = "register_node"; 00799 req->cb = completion; 00800 client().send_request(ptr<rpc_request>(req)); 00801 } 00802 RPC< void > register_node(MedusaID node, InetAddress address) const { 00803 RPCDefs<Borealis::Lookup>::register_node_IN *req = 00804 new RPCDefs<Borealis::Lookup>::register_node_IN(node, address); 00805 ptr<rpc_request> preq(req); 00806 req->object_id = object_id(); 00807 req->method_id = RPCDefs<Borealis::Lookup>::register_node_METHOD_ID; 00808 req->method_name = "register_node"; 00809 bool done = false; RPC< void > ret; 00810 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00811 client().send_request(preq); 00812 while (!done && client().block()) ; 00813 req->cb = Callback<void, RPC< void > >(); 00814 return ret; 00815 } 00816 typedef const RPCDefs<Borealis::Lookup>::register_node_OUT &register_node_result; 00817 void lookup_node(const Callback<void, RPC< InetAddress > >& completion, MedusaID node) const { 00818 RPCDefs<Borealis::Lookup>::lookup_node_IN *req = 00819 new RPCDefs<Borealis::Lookup>::lookup_node_IN(node); 00820 req->object_id = object_id(); 00821 req->method_id = RPCDefs<Borealis::Lookup>::lookup_node_METHOD_ID; 00822 req->method_name = "lookup_node"; 00823 req->cb = completion; 00824 client().send_request(ptr<rpc_request>(req)); 00825 } 00826 RPC< InetAddress > lookup_node(MedusaID node) const { 00827 RPCDefs<Borealis::Lookup>::lookup_node_IN *req = 00828 new RPCDefs<Borealis::Lookup>::lookup_node_IN(node); 00829 ptr<rpc_request> preq(req); 00830 req->object_id = object_id(); 00831 req->method_id = RPCDefs<Borealis::Lookup>::lookup_node_METHOD_ID; 00832 req->method_name = "lookup_node"; 00833 bool done = false; RPC< InetAddress > ret; 00834 req->cb = wrap(&rpc_sync_completion< InetAddress >, &done, &ret); 00835 client().send_request(preq); 00836 while (!done && client().block()) ; 00837 req->cb = Callback<void, RPC< InetAddress > >(); 00838 return ret; 00839 } 00840 typedef const RPCDefs<Borealis::Lookup>::lookup_node_OUT &lookup_node_result; 00841 void set_backup_pair(const Callback<void, RPC< void > >& completion, MedusaID primary, MedusaID secondary) const { 00842 RPCDefs<Borealis::Lookup>::set_backup_pair_IN *req = 00843 new RPCDefs<Borealis::Lookup>::set_backup_pair_IN(primary, secondary); 00844 req->object_id = object_id(); 00845 req->method_id = RPCDefs<Borealis::Lookup>::set_backup_pair_METHOD_ID; 00846 req->method_name = "set_backup_pair"; 00847 req->cb = completion; 00848 client().send_request(ptr<rpc_request>(req)); 00849 } 00850 RPC< void > set_backup_pair(MedusaID primary, MedusaID secondary) const { 00851 RPCDefs<Borealis::Lookup>::set_backup_pair_IN *req = 00852 new RPCDefs<Borealis::Lookup>::set_backup_pair_IN(primary, secondary); 00853 ptr<rpc_request> preq(req); 00854 req->object_id = object_id(); 00855 req->method_id = RPCDefs<Borealis::Lookup>::set_backup_pair_METHOD_ID; 00856 req->method_name = "set_backup_pair"; 00857 bool done = false; RPC< void > ret; 00858 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00859 client().send_request(preq); 00860 while (!done && client().block()) ; 00861 req->cb = Callback<void, RPC< void > >(); 00862 return ret; 00863 } 00864 typedef const RPCDefs<Borealis::Lookup>::set_backup_pair_OUT &set_backup_pair_result; 00865 void get_backup(const Callback<void, RPC< MedusaID > >& completion, MedusaID primary) const { 00866 RPCDefs<Borealis::Lookup>::get_backup_IN *req = 00867 new RPCDefs<Borealis::Lookup>::get_backup_IN(primary); 00868 req->object_id = object_id(); 00869 req->method_id = RPCDefs<Borealis::Lookup>::get_backup_METHOD_ID; 00870 req->method_name = "get_backup"; 00871 req->cb = completion; 00872 client().send_request(ptr<rpc_request>(req)); 00873 } 00874 RPC< MedusaID > get_backup(MedusaID primary) const { 00875 RPCDefs<Borealis::Lookup>::get_backup_IN *req = 00876 new RPCDefs<Borealis::Lookup>::get_backup_IN(primary); 00877 ptr<rpc_request> preq(req); 00878 req->object_id = object_id(); 00879 req->method_id = RPCDefs<Borealis::Lookup>::get_backup_METHOD_ID; 00880 req->method_name = "get_backup"; 00881 bool done = false; RPC< MedusaID > ret; 00882 req->cb = wrap(&rpc_sync_completion< MedusaID >, &done, &ret); 00883 client().send_request(preq); 00884 while (!done && client().block()) ; 00885 req->cb = Callback<void, RPC< MedusaID > >(); 00886 return ret; 00887 } 00888 typedef const RPCDefs<Borealis::Lookup>::get_backup_OUT &get_backup_result; 00889 void add_responsability(const Callback<void, RPC< void > >& completion, MedusaID node, ptr<Object> object, bool standalone) const { 00890 RPCDefs<Borealis::Lookup>::add_responsability_IN *req = 00891 new RPCDefs<Borealis::Lookup>::add_responsability_IN(node, object, standalone); 00892 req->object_id = object_id(); 00893 req->method_id = RPCDefs<Borealis::Lookup>::add_responsability_METHOD_ID; 00894 req->method_name = "add_responsability"; 00895 req->cb = completion; 00896 client().send_request(ptr<rpc_request>(req)); 00897 } 00898 RPC< void > add_responsability(MedusaID node, ptr<Object> object, bool standalone) const { 00899 RPCDefs<Borealis::Lookup>::add_responsability_IN *req = 00900 new RPCDefs<Borealis::Lookup>::add_responsability_IN(node, object, standalone); 00901 ptr<rpc_request> preq(req); 00902 req->object_id = object_id(); 00903 req->method_id = RPCDefs<Borealis::Lookup>::add_responsability_METHOD_ID; 00904 req->method_name = "add_responsability"; 00905 bool done = false; RPC< void > ret; 00906 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00907 client().send_request(preq); 00908 while (!done && client().block()) ; 00909 req->cb = Callback<void, RPC< void > >(); 00910 return ret; 00911 } 00912 typedef const RPCDefs<Borealis::Lookup>::add_responsability_OUT &add_responsability_result; 00913 void add_responsabilities(const Callback<void, RPC< void > >& completion, MedusaID node, vector< pair< ptr<Object>,bool > > objects) const { 00914 RPCDefs<Borealis::Lookup>::add_responsabilities_IN *req = 00915 new RPCDefs<Borealis::Lookup>::add_responsabilities_IN(node, objects); 00916 req->object_id = object_id(); 00917 req->method_id = RPCDefs<Borealis::Lookup>::add_responsabilities_METHOD_ID; 00918 req->method_name = "add_responsabilities"; 00919 req->cb = completion; 00920 client().send_request(ptr<rpc_request>(req)); 00921 } 00922 RPC< void > add_responsabilities(MedusaID node, vector< pair< ptr<Object>,bool > > objects) const { 00923 RPCDefs<Borealis::Lookup>::add_responsabilities_IN *req = 00924 new RPCDefs<Borealis::Lookup>::add_responsabilities_IN(node, objects); 00925 ptr<rpc_request> preq(req); 00926 req->object_id = object_id(); 00927 req->method_id = RPCDefs<Borealis::Lookup>::add_responsabilities_METHOD_ID; 00928 req->method_name = "add_responsabilities"; 00929 bool done = false; RPC< void > ret; 00930 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00931 client().send_request(preq); 00932 while (!done && client().block()) ; 00933 req->cb = Callback<void, RPC< void > >(); 00934 return ret; 00935 } 00936 typedef const RPCDefs<Borealis::Lookup>::add_responsabilities_OUT &add_responsabilities_result; 00937 void remove_responsability(const Callback<void, RPC< void > >& completion, MedusaID node, Name name) const { 00938 RPCDefs<Borealis::Lookup>::remove_responsability_IN *req = 00939 new RPCDefs<Borealis::Lookup>::remove_responsability_IN(node, name); 00940 req->object_id = object_id(); 00941 req->method_id = RPCDefs<Borealis::Lookup>::remove_responsability_METHOD_ID; 00942 req->method_name = "remove_responsability"; 00943 req->cb = completion; 00944 client().send_request(ptr<rpc_request>(req)); 00945 } 00946 RPC< void > remove_responsability(MedusaID node, Name name) const { 00947 RPCDefs<Borealis::Lookup>::remove_responsability_IN *req = 00948 new RPCDefs<Borealis::Lookup>::remove_responsability_IN(node, name); 00949 ptr<rpc_request> preq(req); 00950 req->object_id = object_id(); 00951 req->method_id = RPCDefs<Borealis::Lookup>::remove_responsability_METHOD_ID; 00952 req->method_name = "remove_responsability"; 00953 bool done = false; RPC< void > ret; 00954 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00955 client().send_request(preq); 00956 while (!done && client().block()) ; 00957 req->cb = Callback<void, RPC< void > >(); 00958 return ret; 00959 } 00960 typedef const RPCDefs<Borealis::Lookup>::remove_responsability_OUT &remove_responsability_result; 00961 void remove_responsabilities(const Callback<void, RPC< void > >& completion, MedusaID node, vector<Name> names) const { 00962 RPCDefs<Borealis::Lookup>::remove_responsabilities_IN *req = 00963 new RPCDefs<Borealis::Lookup>::remove_responsabilities_IN(node, names); 00964 req->object_id = object_id(); 00965 req->method_id = RPCDefs<Borealis::Lookup>::remove_responsabilities_METHOD_ID; 00966 req->method_name = "remove_responsabilities"; 00967 req->cb = completion; 00968 client().send_request(ptr<rpc_request>(req)); 00969 } 00970 RPC< void > remove_responsabilities(MedusaID node, vector<Name> names) const { 00971 RPCDefs<Borealis::Lookup>::remove_responsabilities_IN *req = 00972 new RPCDefs<Borealis::Lookup>::remove_responsabilities_IN(node, names); 00973 ptr<rpc_request> preq(req); 00974 req->object_id = object_id(); 00975 req->method_id = RPCDefs<Borealis::Lookup>::remove_responsabilities_METHOD_ID; 00976 req->method_name = "remove_responsabilities"; 00977 bool done = false; RPC< void > ret; 00978 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00979 client().send_request(preq); 00980 while (!done && client().block()) ; 00981 req->cb = Callback<void, RPC< void > >(); 00982 return ret; 00983 } 00984 typedef const RPCDefs<Borealis::Lookup>::remove_responsabilities_OUT &remove_responsabilities_result; 00985 void get_responsabilities(const Callback<void, RPC< vector< ptr<Object> > > >& completion, MedusaID node) const { 00986 RPCDefs<Borealis::Lookup>::get_responsabilities_IN *req = 00987 new RPCDefs<Borealis::Lookup>::get_responsabilities_IN(node); 00988 req->object_id = object_id(); 00989 req->method_id = RPCDefs<Borealis::Lookup>::get_responsabilities_METHOD_ID; 00990 req->method_name = "get_responsabilities"; 00991 req->cb = completion; 00992 client().send_request(ptr<rpc_request>(req)); 00993 } 00994 RPC< vector< ptr<Object> > > get_responsabilities(MedusaID node) const { 00995 RPCDefs<Borealis::Lookup>::get_responsabilities_IN *req = 00996 new RPCDefs<Borealis::Lookup>::get_responsabilities_IN(node); 00997 ptr<rpc_request> preq(req); 00998 req->object_id = object_id(); 00999 req->method_id = RPCDefs<Borealis::Lookup>::get_responsabilities_METHOD_ID; 01000 req->method_name = "get_responsabilities"; 01001 bool done = false; RPC< vector< ptr<Object> > > ret; 01002 req->cb = wrap(&rpc_sync_completion< vector< ptr<Object> > >, &done, &ret); 01003 client().send_request(preq); 01004 while (!done && client().block()) ; 01005 req->cb = Callback<void, RPC< vector< ptr<Object> > > >(); 01006 return ret; 01007 } 01008 typedef const RPCDefs<Borealis::Lookup>::get_responsabilities_OUT &get_responsabilities_result; 01009 }; 01010 }; 01011 template<> struct RPCDefs<Borealis::Lookup> : __nmstl_tmp_rpc_defs::RPCDefs<Borealis::Lookup> {}; 01012 template<> struct Remote<Borealis::Lookup> : __nmstl_tmp_rpc_defs::Remote<Borealis::Lookup> { 01013 Remote<Borealis::Lookup>() {} 01014 Remote<Borealis::Lookup>(RPCClient& cli, rpc_object_id object_id) : 01015 __nmstl_tmp_rpc_defs::Remote<Borealis::Lookup>(cli, object_id) {} 01016 01017 Remote<Borealis::Lookup>(const __nmstl_tmp_rpc_defs::Remote<Borealis::Lookup>& x) : 01018 __nmstl_tmp_rpc_defs::Remote<Borealis::Lookup>(x) {} 01019 }; 01020 01021 01022 #endif // !defined(DOXYGEN_SKIP) 01023 01024 NMSTL_NAMESPACE_END; 01025 01026 #endif // !defined(___CATALOG_CENTRAL_RPC_LOOKUP_H) 01027 01028 01029 01030 01031 01032 #ifdef NMSTL_RPC_DEFINE 01033 01034 #include <string> 01035 #include <map> 01036 #include <NMSTL/rpc> 01037 01038 void Borealis::Lookup::handle_request(const NMSTL::RPCObject::response_cb& cb, const NMSTL::ptr<NMSTL::rpc_request>& req) { 01039 switch(req->method_id) { 01040 case NMSTL::RPCDefs<Borealis::Lookup>::register_object_METHOD_ID: 01041 { 01042 const NMSTL::RPCDefs<Borealis::Lookup>::register_object_IN* inp = 01043 dynamic_cast<const NMSTL::RPCDefs<Borealis::Lookup>::register_object_IN*>(req.get()); 01044 01045 if (!inp) { 01046 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01047 " to Borealis::Lookup::register_object; expected " + 01048 typeid(NMSTL::RPCDefs<Borealis::Lookup>::register_object_IN); 01049 WARN << err; 01050 cb(err, 0, true); 01051 return; 01052 } 01053 01054 const NMSTL::RPCDefs<Borealis::Lookup>::register_object_IN& in = *inp; 01055 NMSTL::AsyncRPC< void > pending = register_object(in.object); 01056 pending.set_response_handler(cb); 01057 break; 01058 } 01059 case NMSTL::RPCDefs<Borealis::Lookup>::register_object_set_METHOD_ID: 01060 { 01061 const NMSTL::RPCDefs<Borealis::Lookup>::register_object_set_IN* inp = 01062 dynamic_cast<const NMSTL::RPCDefs<Borealis::Lookup>::register_object_set_IN*>(req.get()); 01063 01064 if (!inp) { 01065 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01066 " to Borealis::Lookup::register_object_set; expected " + 01067 typeid(NMSTL::RPCDefs<Borealis::Lookup>::register_object_set_IN); 01068 WARN << err; 01069 cb(err, 0, true); 01070 return; 01071 } 01072 01073 const NMSTL::RPCDefs<Borealis::Lookup>::register_object_set_IN& in = *inp; 01074 NMSTL::AsyncRPC< void > pending = register_object_set(in.object); 01075 pending.set_response_handler(cb); 01076 break; 01077 } 01078 case NMSTL::RPCDefs<Borealis::Lookup>::register_objects_METHOD_ID: 01079 { 01080 const NMSTL::RPCDefs<Borealis::Lookup>::register_objects_IN* inp = 01081 dynamic_cast<const NMSTL::RPCDefs<Borealis::Lookup>::register_objects_IN*>(req.get()); 01082 01083 if (!inp) { 01084 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01085 " to Borealis::Lookup::register_objects; expected " + 01086 typeid(NMSTL::RPCDefs<Borealis::Lookup>::register_objects_IN); 01087 WARN << err; 01088 cb(err, 0, true); 01089 return; 01090 } 01091 01092 const NMSTL::RPCDefs<Borealis::Lookup>::register_objects_IN& in = *inp; 01093 NMSTL::AsyncRPC< void > pending = register_objects(in.object); 01094 pending.set_response_handler(cb); 01095 break; 01096 } 01097 case NMSTL::RPCDefs<Borealis::Lookup>::register_object_sets_METHOD_ID: 01098 { 01099 const NMSTL::RPCDefs<Borealis::Lookup>::register_object_sets_IN* inp = 01100 dynamic_cast<const NMSTL::RPCDefs<Borealis::Lookup>::register_object_sets_IN*>(req.get()); 01101 01102 if (!inp) { 01103 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01104 " to Borealis::Lookup::register_object_sets; expected " + 01105 typeid(NMSTL::RPCDefs<Borealis::Lookup>::register_object_sets_IN); 01106 WARN << err; 01107 cb(err, 0, true); 01108 return; 01109 } 01110 01111 const NMSTL::RPCDefs<Borealis::Lookup>::register_object_sets_IN& in = *inp; 01112 NMSTL::AsyncRPC< void > pending = register_object_sets(in.object); 01113 pending.set_response_handler(cb); 01114 break; 01115 } 01116 case NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_METHOD_ID: 01117 { 01118 const NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_IN* inp = 01119 dynamic_cast<const NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_IN*>(req.get()); 01120 01121 if (!inp) { 01122 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01123 " to Borealis::Lookup::lookup_object; expected " + 01124 typeid(NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_IN); 01125 WARN << err; 01126 cb(err, 0, true); 01127 return; 01128 } 01129 01130 const NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_IN& in = *inp; 01131 NMSTL::AsyncRPC< ptr<Object> > pending = lookup_object(in.name); 01132 pending.set_response_handler(cb); 01133 break; 01134 } 01135 case NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_set_METHOD_ID: 01136 { 01137 const NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_set_IN* inp = 01138 dynamic_cast<const NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_set_IN*>(req.get()); 01139 01140 if (!inp) { 01141 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01142 " to Borealis::Lookup::lookup_object_set; expected " + 01143 typeid(NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_set_IN); 01144 WARN << err; 01145 cb(err, 0, true); 01146 return; 01147 } 01148 01149 const NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_set_IN& in = *inp; 01150 NMSTL::AsyncRPC< vector< ptr<Object> > > pending = lookup_object_set(in.name); 01151 pending.set_response_handler(cb); 01152 break; 01153 } 01154 case NMSTL::RPCDefs<Borealis::Lookup>::lookup_objects_METHOD_ID: 01155 { 01156 const NMSTL::RPCDefs<Borealis::Lookup>::lookup_objects_IN* inp = 01157 dynamic_cast<const NMSTL::RPCDefs<Borealis::Lookup>::lookup_objects_IN*>(req.get()); 01158 01159 if (!inp) { 01160 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01161 " to Borealis::Lookup::lookup_objects; expected " + 01162 typeid(NMSTL::RPCDefs<Borealis::Lookup>::lookup_objects_IN); 01163 WARN << err; 01164 cb(err, 0, true); 01165 return; 01166 } 01167 01168 const NMSTL::RPCDefs<Borealis::Lookup>::lookup_objects_IN& in = *inp; 01169 NMSTL::AsyncRPC< vector< ptr<Object> > > pending = lookup_objects(in.names); 01170 pending.set_response_handler(cb); 01171 break; 01172 } 01173 case NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_sets_METHOD_ID: 01174 { 01175 const NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_sets_IN* inp = 01176 dynamic_cast<const NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_sets_IN*>(req.get()); 01177 01178 if (!inp) { 01179 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01180 " to Borealis::Lookup::lookup_object_sets; expected " + 01181 typeid(NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_sets_IN); 01182 WARN << err; 01183 cb(err, 0, true); 01184 return; 01185 } 01186 01187 const NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_sets_IN& in = *inp; 01188 NMSTL::AsyncRPC< vector< vector< ptr<Object> > > > pending = lookup_object_sets(in.names); 01189 pending.set_response_handler(cb); 01190 break; 01191 } 01192 case NMSTL::RPCDefs<Borealis::Lookup>::register_node_METHOD_ID: 01193 { 01194 const NMSTL::RPCDefs<Borealis::Lookup>::register_node_IN* inp = 01195 dynamic_cast<const NMSTL::RPCDefs<Borealis::Lookup>::register_node_IN*>(req.get()); 01196 01197 if (!inp) { 01198 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01199 " to Borealis::Lookup::register_node; expected " + 01200 typeid(NMSTL::RPCDefs<Borealis::Lookup>::register_node_IN); 01201 WARN << err; 01202 cb(err, 0, true); 01203 return; 01204 } 01205 01206 const NMSTL::RPCDefs<Borealis::Lookup>::register_node_IN& in = *inp; 01207 NMSTL::AsyncRPC< void > pending = register_node(in.node, in.address); 01208 pending.set_response_handler(cb); 01209 break; 01210 } 01211 case NMSTL::RPCDefs<Borealis::Lookup>::lookup_node_METHOD_ID: 01212 { 01213 const NMSTL::RPCDefs<Borealis::Lookup>::lookup_node_IN* inp = 01214 dynamic_cast<const NMSTL::RPCDefs<Borealis::Lookup>::lookup_node_IN*>(req.get()); 01215 01216 if (!inp) { 01217 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01218 " to Borealis::Lookup::lookup_node; expected " + 01219 typeid(NMSTL::RPCDefs<Borealis::Lookup>::lookup_node_IN); 01220 WARN << err; 01221 cb(err, 0, true); 01222 return; 01223 } 01224 01225 const NMSTL::RPCDefs<Borealis::Lookup>::lookup_node_IN& in = *inp; 01226 NMSTL::AsyncRPC< InetAddress > pending = lookup_node(in.node); 01227 pending.set_response_handler(cb); 01228 break; 01229 } 01230 case NMSTL::RPCDefs<Borealis::Lookup>::set_backup_pair_METHOD_ID: 01231 { 01232 const NMSTL::RPCDefs<Borealis::Lookup>::set_backup_pair_IN* inp = 01233 dynamic_cast<const NMSTL::RPCDefs<Borealis::Lookup>::set_backup_pair_IN*>(req.get()); 01234 01235 if (!inp) { 01236 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01237 " to Borealis::Lookup::set_backup_pair; expected " + 01238 typeid(NMSTL::RPCDefs<Borealis::Lookup>::set_backup_pair_IN); 01239 WARN << err; 01240 cb(err, 0, true); 01241 return; 01242 } 01243 01244 const NMSTL::RPCDefs<Borealis::Lookup>::set_backup_pair_IN& in = *inp; 01245 NMSTL::AsyncRPC< void > pending = set_backup_pair(in.primary, in.secondary); 01246 pending.set_response_handler(cb); 01247 break; 01248 } 01249 case NMSTL::RPCDefs<Borealis::Lookup>::get_backup_METHOD_ID: 01250 { 01251 const NMSTL::RPCDefs<Borealis::Lookup>::get_backup_IN* inp = 01252 dynamic_cast<const NMSTL::RPCDefs<Borealis::Lookup>::get_backup_IN*>(req.get()); 01253 01254 if (!inp) { 01255 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01256 " to Borealis::Lookup::get_backup; expected " + 01257 typeid(NMSTL::RPCDefs<Borealis::Lookup>::get_backup_IN); 01258 WARN << err; 01259 cb(err, 0, true); 01260 return; 01261 } 01262 01263 const NMSTL::RPCDefs<Borealis::Lookup>::get_backup_IN& in = *inp; 01264 NMSTL::AsyncRPC< MedusaID > pending = get_backup(in.primary); 01265 pending.set_response_handler(cb); 01266 break; 01267 } 01268 case NMSTL::RPCDefs<Borealis::Lookup>::add_responsability_METHOD_ID: 01269 { 01270 const NMSTL::RPCDefs<Borealis::Lookup>::add_responsability_IN* inp = 01271 dynamic_cast<const NMSTL::RPCDefs<Borealis::Lookup>::add_responsability_IN*>(req.get()); 01272 01273 if (!inp) { 01274 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01275 " to Borealis::Lookup::add_responsability; expected " + 01276 typeid(NMSTL::RPCDefs<Borealis::Lookup>::add_responsability_IN); 01277 WARN << err; 01278 cb(err, 0, true); 01279 return; 01280 } 01281 01282 const NMSTL::RPCDefs<Borealis::Lookup>::add_responsability_IN& in = *inp; 01283 NMSTL::AsyncRPC< void > pending = add_responsability(in.node, in.object, in.standalone); 01284 pending.set_response_handler(cb); 01285 break; 01286 } 01287 case NMSTL::RPCDefs<Borealis::Lookup>::add_responsabilities_METHOD_ID: 01288 { 01289 const NMSTL::RPCDefs<Borealis::Lookup>::add_responsabilities_IN* inp = 01290 dynamic_cast<const NMSTL::RPCDefs<Borealis::Lookup>::add_responsabilities_IN*>(req.get()); 01291 01292 if (!inp) { 01293 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01294 " to Borealis::Lookup::add_responsabilities; expected " + 01295 typeid(NMSTL::RPCDefs<Borealis::Lookup>::add_responsabilities_IN); 01296 WARN << err; 01297 cb(err, 0, true); 01298 return; 01299 } 01300 01301 const NMSTL::RPCDefs<Borealis::Lookup>::add_responsabilities_IN& in = *inp; 01302 NMSTL::AsyncRPC< void > pending = add_responsabilities(in.node, in.objects); 01303 pending.set_response_handler(cb); 01304 break; 01305 } 01306 case NMSTL::RPCDefs<Borealis::Lookup>::remove_responsability_METHOD_ID: 01307 { 01308 const NMSTL::RPCDefs<Borealis::Lookup>::remove_responsability_IN* inp = 01309 dynamic_cast<const NMSTL::RPCDefs<Borealis::Lookup>::remove_responsability_IN*>(req.get()); 01310 01311 if (!inp) { 01312 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01313 " to Borealis::Lookup::remove_responsability; expected " + 01314 typeid(NMSTL::RPCDefs<Borealis::Lookup>::remove_responsability_IN); 01315 WARN << err; 01316 cb(err, 0, true); 01317 return; 01318 } 01319 01320 const NMSTL::RPCDefs<Borealis::Lookup>::remove_responsability_IN& in = *inp; 01321 NMSTL::AsyncRPC< void > pending = remove_responsability(in.node, in.name); 01322 pending.set_response_handler(cb); 01323 break; 01324 } 01325 case NMSTL::RPCDefs<Borealis::Lookup>::remove_responsabilities_METHOD_ID: 01326 { 01327 const NMSTL::RPCDefs<Borealis::Lookup>::remove_responsabilities_IN* inp = 01328 dynamic_cast<const NMSTL::RPCDefs<Borealis::Lookup>::remove_responsabilities_IN*>(req.get()); 01329 01330 if (!inp) { 01331 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01332 " to Borealis::Lookup::remove_responsabilities; expected " + 01333 typeid(NMSTL::RPCDefs<Borealis::Lookup>::remove_responsabilities_IN); 01334 WARN << err; 01335 cb(err, 0, true); 01336 return; 01337 } 01338 01339 const NMSTL::RPCDefs<Borealis::Lookup>::remove_responsabilities_IN& in = *inp; 01340 NMSTL::AsyncRPC< void > pending = remove_responsabilities(in.node, in.names); 01341 pending.set_response_handler(cb); 01342 break; 01343 } 01344 case NMSTL::RPCDefs<Borealis::Lookup>::get_responsabilities_METHOD_ID: 01345 { 01346 const NMSTL::RPCDefs<Borealis::Lookup>::get_responsabilities_IN* inp = 01347 dynamic_cast<const NMSTL::RPCDefs<Borealis::Lookup>::get_responsabilities_IN*>(req.get()); 01348 01349 if (!inp) { 01350 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01351 " to Borealis::Lookup::get_responsabilities; expected " + 01352 typeid(NMSTL::RPCDefs<Borealis::Lookup>::get_responsabilities_IN); 01353 WARN << err; 01354 cb(err, 0, true); 01355 return; 01356 } 01357 01358 const NMSTL::RPCDefs<Borealis::Lookup>::get_responsabilities_IN& in = *inp; 01359 NMSTL::AsyncRPC< vector< ptr<Object> > > pending = get_responsabilities(in.node); 01360 pending.set_response_handler(cb); 01361 break; 01362 } 01363 default: 01364 string err = string("Unknown method_id ") + req->method_id + " in Borealis::Lookup::handle_request"; 01365 WARN << err; 01366 cb(err, 0, true); 01367 } 01368 } 01369 void Borealis::Lookup::handle_request(const response_cb& cb, rpc_id method_id, ISerial& is) { 01370 switch(method_id) { 01371 case RPCDefs<Borealis::Lookup>::register_object_METHOD_ID: 01372 { 01373 RPCDefs<Borealis::Lookup>::register_object_IN in; 01374 is >> in; 01375 if (!is) { 01376 WARN << "Invalid RPC request to Borealis::Lookup::register_object: " << is.stat(); 01377 cb(is.stat(), 0, true); 01378 return; 01379 } 01380 DEBUG << "Handling register_object"; 01381 AsyncRPC< void > pending = register_object(in.object); 01382 pending.set_response_handler(cb); 01383 break; 01384 } 01385 case RPCDefs<Borealis::Lookup>::register_object_set_METHOD_ID: 01386 { 01387 RPCDefs<Borealis::Lookup>::register_object_set_IN in; 01388 is >> in; 01389 if (!is) { 01390 WARN << "Invalid RPC request to Borealis::Lookup::register_object_set: " << is.stat(); 01391 cb(is.stat(), 0, true); 01392 return; 01393 } 01394 DEBUG << "Handling register_object_set"; 01395 AsyncRPC< void > pending = register_object_set(in.object); 01396 pending.set_response_handler(cb); 01397 break; 01398 } 01399 case RPCDefs<Borealis::Lookup>::register_objects_METHOD_ID: 01400 { 01401 RPCDefs<Borealis::Lookup>::register_objects_IN in; 01402 is >> in; 01403 if (!is) { 01404 WARN << "Invalid RPC request to Borealis::Lookup::register_objects: " << is.stat(); 01405 cb(is.stat(), 0, true); 01406 return; 01407 } 01408 DEBUG << "Handling register_objects"; 01409 AsyncRPC< void > pending = register_objects(in.object); 01410 pending.set_response_handler(cb); 01411 break; 01412 } 01413 case RPCDefs<Borealis::Lookup>::register_object_sets_METHOD_ID: 01414 { 01415 RPCDefs<Borealis::Lookup>::register_object_sets_IN in; 01416 is >> in; 01417 if (!is) { 01418 WARN << "Invalid RPC request to Borealis::Lookup::register_object_sets: " << is.stat(); 01419 cb(is.stat(), 0, true); 01420 return; 01421 } 01422 DEBUG << "Handling register_object_sets"; 01423 AsyncRPC< void > pending = register_object_sets(in.object); 01424 pending.set_response_handler(cb); 01425 break; 01426 } 01427 case RPCDefs<Borealis::Lookup>::lookup_object_METHOD_ID: 01428 { 01429 RPCDefs<Borealis::Lookup>::lookup_object_IN in; 01430 is >> in; 01431 if (!is) { 01432 WARN << "Invalid RPC request to Borealis::Lookup::lookup_object: " << is.stat(); 01433 cb(is.stat(), 0, true); 01434 return; 01435 } 01436 DEBUG << "Handling lookup_object"; 01437 AsyncRPC< ptr<Object> > pending = lookup_object(in.name); 01438 pending.set_response_handler(cb); 01439 break; 01440 } 01441 case RPCDefs<Borealis::Lookup>::lookup_object_set_METHOD_ID: 01442 { 01443 RPCDefs<Borealis::Lookup>::lookup_object_set_IN in; 01444 is >> in; 01445 if (!is) { 01446 WARN << "Invalid RPC request to Borealis::Lookup::lookup_object_set: " << is.stat(); 01447 cb(is.stat(), 0, true); 01448 return; 01449 } 01450 DEBUG << "Handling lookup_object_set"; 01451 AsyncRPC< vector< ptr<Object> > > pending = lookup_object_set(in.name); 01452 pending.set_response_handler(cb); 01453 break; 01454 } 01455 case RPCDefs<Borealis::Lookup>::lookup_objects_METHOD_ID: 01456 { 01457 RPCDefs<Borealis::Lookup>::lookup_objects_IN in; 01458 is >> in; 01459 if (!is) { 01460 WARN << "Invalid RPC request to Borealis::Lookup::lookup_objects: " << is.stat(); 01461 cb(is.stat(), 0, true); 01462 return; 01463 } 01464 DEBUG << "Handling lookup_objects"; 01465 AsyncRPC< vector< ptr<Object> > > pending = lookup_objects(in.names); 01466 pending.set_response_handler(cb); 01467 break; 01468 } 01469 case RPCDefs<Borealis::Lookup>::lookup_object_sets_METHOD_ID: 01470 { 01471 RPCDefs<Borealis::Lookup>::lookup_object_sets_IN in; 01472 is >> in; 01473 if (!is) { 01474 WARN << "Invalid RPC request to Borealis::Lookup::lookup_object_sets: " << is.stat(); 01475 cb(is.stat(), 0, true); 01476 return; 01477 } 01478 DEBUG << "Handling lookup_object_sets"; 01479 AsyncRPC< vector< vector< ptr<Object> > > > pending = lookup_object_sets(in.names); 01480 pending.set_response_handler(cb); 01481 break; 01482 } 01483 case RPCDefs<Borealis::Lookup>::register_node_METHOD_ID: 01484 { 01485 RPCDefs<Borealis::Lookup>::register_node_IN in; 01486 is >> in; 01487 if (!is) { 01488 WARN << "Invalid RPC request to Borealis::Lookup::register_node: " << is.stat(); 01489 cb(is.stat(), 0, true); 01490 return; 01491 } 01492 DEBUG << "Handling register_node"; 01493 AsyncRPC< void > pending = register_node(in.node, in.address); 01494 pending.set_response_handler(cb); 01495 break; 01496 } 01497 case RPCDefs<Borealis::Lookup>::lookup_node_METHOD_ID: 01498 { 01499 RPCDefs<Borealis::Lookup>::lookup_node_IN in; 01500 is >> in; 01501 if (!is) { 01502 WARN << "Invalid RPC request to Borealis::Lookup::lookup_node: " << is.stat(); 01503 cb(is.stat(), 0, true); 01504 return; 01505 } 01506 DEBUG << "Handling lookup_node"; 01507 AsyncRPC< InetAddress > pending = lookup_node(in.node); 01508 pending.set_response_handler(cb); 01509 break; 01510 } 01511 case RPCDefs<Borealis::Lookup>::set_backup_pair_METHOD_ID: 01512 { 01513 RPCDefs<Borealis::Lookup>::set_backup_pair_IN in; 01514 is >> in; 01515 if (!is) { 01516 WARN << "Invalid RPC request to Borealis::Lookup::set_backup_pair: " << is.stat(); 01517 cb(is.stat(), 0, true); 01518 return; 01519 } 01520 DEBUG << "Handling set_backup_pair"; 01521 AsyncRPC< void > pending = set_backup_pair(in.primary, in.secondary); 01522 pending.set_response_handler(cb); 01523 break; 01524 } 01525 case RPCDefs<Borealis::Lookup>::get_backup_METHOD_ID: 01526 { 01527 RPCDefs<Borealis::Lookup>::get_backup_IN in; 01528 is >> in; 01529 if (!is) { 01530 WARN << "Invalid RPC request to Borealis::Lookup::get_backup: " << is.stat(); 01531 cb(is.stat(), 0, true); 01532 return; 01533 } 01534 DEBUG << "Handling get_backup"; 01535 AsyncRPC< MedusaID > pending = get_backup(in.primary); 01536 pending.set_response_handler(cb); 01537 break; 01538 } 01539 case RPCDefs<Borealis::Lookup>::add_responsability_METHOD_ID: 01540 { 01541 RPCDefs<Borealis::Lookup>::add_responsability_IN in; 01542 is >> in; 01543 if (!is) { 01544 WARN << "Invalid RPC request to Borealis::Lookup::add_responsability: " << is.stat(); 01545 cb(is.stat(), 0, true); 01546 return; 01547 } 01548 DEBUG << "Handling add_responsability"; 01549 AsyncRPC< void > pending = add_responsability(in.node, in.object, in.standalone); 01550 pending.set_response_handler(cb); 01551 break; 01552 } 01553 case RPCDefs<Borealis::Lookup>::add_responsabilities_METHOD_ID: 01554 { 01555 RPCDefs<Borealis::Lookup>::add_responsabilities_IN in; 01556 is >> in; 01557 if (!is) { 01558 WARN << "Invalid RPC request to Borealis::Lookup::add_responsabilities: " << is.stat(); 01559 cb(is.stat(), 0, true); 01560 return; 01561 } 01562 DEBUG << "Handling add_responsabilities"; 01563 AsyncRPC< void > pending = add_responsabilities(in.node, in.objects); 01564 pending.set_response_handler(cb); 01565 break; 01566 } 01567 case RPCDefs<Borealis::Lookup>::remove_responsability_METHOD_ID: 01568 { 01569 RPCDefs<Borealis::Lookup>::remove_responsability_IN in; 01570 is >> in; 01571 if (!is) { 01572 WARN << "Invalid RPC request to Borealis::Lookup::remove_responsability: " << is.stat(); 01573 cb(is.stat(), 0, true); 01574 return; 01575 } 01576 DEBUG << "Handling remove_responsability"; 01577 AsyncRPC< void > pending = remove_responsability(in.node, in.name); 01578 pending.set_response_handler(cb); 01579 break; 01580 } 01581 case RPCDefs<Borealis::Lookup>::remove_responsabilities_METHOD_ID: 01582 { 01583 RPCDefs<Borealis::Lookup>::remove_responsabilities_IN in; 01584 is >> in; 01585 if (!is) { 01586 WARN << "Invalid RPC request to Borealis::Lookup::remove_responsabilities: " << is.stat(); 01587 cb(is.stat(), 0, true); 01588 return; 01589 } 01590 DEBUG << "Handling remove_responsabilities"; 01591 AsyncRPC< void > pending = remove_responsabilities(in.node, in.names); 01592 pending.set_response_handler(cb); 01593 break; 01594 } 01595 case RPCDefs<Borealis::Lookup>::get_responsabilities_METHOD_ID: 01596 { 01597 RPCDefs<Borealis::Lookup>::get_responsabilities_IN in; 01598 is >> in; 01599 if (!is) { 01600 WARN << "Invalid RPC request to Borealis::Lookup::get_responsabilities: " << is.stat(); 01601 cb(is.stat(), 0, true); 01602 return; 01603 } 01604 DEBUG << "Handling get_responsabilities"; 01605 AsyncRPC< vector< ptr<Object> > > pending = get_responsabilities(in.node); 01606 pending.set_response_handler(cb); 01607 break; 01608 } 01609 default: 01610 string err = string("Unknown method_id ") + method_id + " in Borealis::Lookup::handle_request"; 01611 WARN << err; 01612 cb(err, 0, true); 01613 } 01614 } 01615 NMSTL::rpc_id Borealis::Lookup::method_id_for_name(string method_name) { 01616 map<string, int>::const_iterator i = RPCDefs<Borealis::Lookup>::method_id_by_name().find(method_name); 01617 return (i == RPCDefs<Borealis::Lookup>::method_id_by_name().end()) ? rpc_id() : i->second; 01618 } 01619 string Borealis::Lookup::method_name_for_id(NMSTL::rpc_id method_id) { 01620 map<int, string>::const_iterator i = RPCDefs<Borealis::Lookup>::method_name_by_id().find(method_id); 01621 return (i == RPCDefs<Borealis::Lookup>::method_name_by_id().end()) ? string() : i->second; 01622 } 01623 NMSTL::ptr<NMSTL::rpc_request> Borealis::Lookup::make_request(NMSTL::rpc_id method_id, NMSTL::ISerial& is) { 01624 switch(method_id) { 01625 case NMSTL::RPCDefs<Borealis::Lookup>::register_object_METHOD_ID: 01626 { 01627 NMSTL::RPCDefs<Borealis::Lookup>::register_object_IN *in = new NMSTL::RPCDefs<Borealis::Lookup>::register_object_IN; 01628 NMSTL::ptr<NMSTL::rpc_request> req(in); 01629 if (is >> *in) return req; 01630 } 01631 case NMSTL::RPCDefs<Borealis::Lookup>::register_object_set_METHOD_ID: 01632 { 01633 NMSTL::RPCDefs<Borealis::Lookup>::register_object_set_IN *in = new NMSTL::RPCDefs<Borealis::Lookup>::register_object_set_IN; 01634 NMSTL::ptr<NMSTL::rpc_request> req(in); 01635 if (is >> *in) return req; 01636 } 01637 case NMSTL::RPCDefs<Borealis::Lookup>::register_objects_METHOD_ID: 01638 { 01639 NMSTL::RPCDefs<Borealis::Lookup>::register_objects_IN *in = new NMSTL::RPCDefs<Borealis::Lookup>::register_objects_IN; 01640 NMSTL::ptr<NMSTL::rpc_request> req(in); 01641 if (is >> *in) return req; 01642 } 01643 case NMSTL::RPCDefs<Borealis::Lookup>::register_object_sets_METHOD_ID: 01644 { 01645 NMSTL::RPCDefs<Borealis::Lookup>::register_object_sets_IN *in = new NMSTL::RPCDefs<Borealis::Lookup>::register_object_sets_IN; 01646 NMSTL::ptr<NMSTL::rpc_request> req(in); 01647 if (is >> *in) return req; 01648 } 01649 case NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_METHOD_ID: 01650 { 01651 NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_IN *in = new NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_IN; 01652 NMSTL::ptr<NMSTL::rpc_request> req(in); 01653 if (is >> *in) return req; 01654 } 01655 case NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_set_METHOD_ID: 01656 { 01657 NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_set_IN *in = new NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_set_IN; 01658 NMSTL::ptr<NMSTL::rpc_request> req(in); 01659 if (is >> *in) return req; 01660 } 01661 case NMSTL::RPCDefs<Borealis::Lookup>::lookup_objects_METHOD_ID: 01662 { 01663 NMSTL::RPCDefs<Borealis::Lookup>::lookup_objects_IN *in = new NMSTL::RPCDefs<Borealis::Lookup>::lookup_objects_IN; 01664 NMSTL::ptr<NMSTL::rpc_request> req(in); 01665 if (is >> *in) return req; 01666 } 01667 case NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_sets_METHOD_ID: 01668 { 01669 NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_sets_IN *in = new NMSTL::RPCDefs<Borealis::Lookup>::lookup_object_sets_IN; 01670 NMSTL::ptr<NMSTL::rpc_request> req(in); 01671 if (is >> *in) return req; 01672 } 01673 case NMSTL::RPCDefs<Borealis::Lookup>::register_node_METHOD_ID: 01674 { 01675 NMSTL::RPCDefs<Borealis::Lookup>::register_node_IN *in = new NMSTL::RPCDefs<Borealis::Lookup>::register_node_IN; 01676 NMSTL::ptr<NMSTL::rpc_request> req(in); 01677 if (is >> *in) return req; 01678 } 01679 case NMSTL::RPCDefs<Borealis::Lookup>::lookup_node_METHOD_ID: 01680 { 01681 NMSTL::RPCDefs<Borealis::Lookup>::lookup_node_IN *in = new NMSTL::RPCDefs<Borealis::Lookup>::lookup_node_IN; 01682 NMSTL::ptr<NMSTL::rpc_request> req(in); 01683 if (is >> *in) return req; 01684 } 01685 case NMSTL::RPCDefs<Borealis::Lookup>::set_backup_pair_METHOD_ID: 01686 { 01687 NMSTL::RPCDefs<Borealis::Lookup>::set_backup_pair_IN *in = new NMSTL::RPCDefs<Borealis::Lookup>::set_backup_pair_IN; 01688 NMSTL::ptr<NMSTL::rpc_request> req(in); 01689 if (is >> *in) return req; 01690 } 01691 case NMSTL::RPCDefs<Borealis::Lookup>::get_backup_METHOD_ID: 01692 { 01693 NMSTL::RPCDefs<Borealis::Lookup>::get_backup_IN *in = new NMSTL::RPCDefs<Borealis::Lookup>::get_backup_IN; 01694 NMSTL::ptr<NMSTL::rpc_request> req(in); 01695 if (is >> *in) return req; 01696 } 01697 case NMSTL::RPCDefs<Borealis::Lookup>::add_responsability_METHOD_ID: 01698 { 01699 NMSTL::RPCDefs<Borealis::Lookup>::add_responsability_IN *in = new NMSTL::RPCDefs<Borealis::Lookup>::add_responsability_IN; 01700 NMSTL::ptr<NMSTL::rpc_request> req(in); 01701 if (is >> *in) return req; 01702 } 01703 case NMSTL::RPCDefs<Borealis::Lookup>::add_responsabilities_METHOD_ID: 01704 { 01705 NMSTL::RPCDefs<Borealis::Lookup>::add_responsabilities_IN *in = new NMSTL::RPCDefs<Borealis::Lookup>::add_responsabilities_IN; 01706 NMSTL::ptr<NMSTL::rpc_request> req(in); 01707 if (is >> *in) return req; 01708 } 01709 case NMSTL::RPCDefs<Borealis::Lookup>::remove_responsability_METHOD_ID: 01710 { 01711 NMSTL::RPCDefs<Borealis::Lookup>::remove_responsability_IN *in = new NMSTL::RPCDefs<Borealis::Lookup>::remove_responsability_IN; 01712 NMSTL::ptr<NMSTL::rpc_request> req(in); 01713 if (is >> *in) return req; 01714 } 01715 case NMSTL::RPCDefs<Borealis::Lookup>::remove_responsabilities_METHOD_ID: 01716 { 01717 NMSTL::RPCDefs<Borealis::Lookup>::remove_responsabilities_IN *in = new NMSTL::RPCDefs<Borealis::Lookup>::remove_responsabilities_IN; 01718 NMSTL::ptr<NMSTL::rpc_request> req(in); 01719 if (is >> *in) return req; 01720 } 01721 case NMSTL::RPCDefs<Borealis::Lookup>::get_responsabilities_METHOD_ID: 01722 { 01723 NMSTL::RPCDefs<Borealis::Lookup>::get_responsabilities_IN *in = new NMSTL::RPCDefs<Borealis::Lookup>::get_responsabilities_IN; 01724 NMSTL::ptr<NMSTL::rpc_request> req(in); 01725 if (is >> *in) return req; 01726 } 01727 } 01728 return NMSTL::ptr<NMSTL::rpc_request>(); 01729 } 01730 01731 01732 #endif 01733