Borealis: rpc_HA.h Source File

00001 /***** 00002 * 00003 * ../ha/rpc_HA.h 00004 * 00005 * Include this file to gain access to the following classes: 00006 * 00007 * - Remote<HA> 00008 * 00009 * This file is automatically generated by nmstl-rpcgen. 00010 * Do not modify it! 00011 * 00012 *****/ 00013 00014 #ifndef ___HA_RPC_HA_H 00015 #define ___HA_RPC_HA_H 00016 00017 #include <NMSTL/rpc> 00018 #include "Name.h" 00019 #include "Query.h" 00020 #include "Schema.h" 00021 #include "StreamDef.h" 00022 00023 namespace Borealis { class HA; }; 00024 00025 00026 NMSTL_NAMESPACE_BEGIN; 00027 00028 #ifdef DOXYGEN_SKIP 00029 00030 00031 00032 00033 /***** 00034 * 00035 * Following are the public interfaces to RPC objects. 00036 * 00037 *****/ 00038 00039 template<typename T> class Remote; 00040 class Remote<Borealis::HA> { 00041 public: 00044 void replicate_query(const Callback<void, RPC< void > >& completion, 00045 MedusaID primary, Query query); 00046 00048 RPC< void > replicate_query(MedusaID primary, Query query); 00049 00052 void replicate_subs(const Callback<void, RPC< void > >& completion, 00053 MedusaID primary, vector<Subscription> subs); 00054 00056 RPC< void > replicate_subs(MedusaID primary, vector<Subscription> subs); 00057 00060 void keep_alive(const Callback<void, RPC< void > >& completion); 00061 00063 RPC< void > keep_alive(); 00064 00067 void failure_notification(const Callback<void, RPC< void > >& completion, 00068 MedusaID failed_node, Time time_failure_detected); 00069 00071 RPC< void > failure_notification(MedusaID failed_node, Time time_failure_detected); 00072 00075 void start(const Callback<void, RPC< void > >& completion); 00076 00078 RPC< void > start(); 00079 00082 void stop(const Callback<void, RPC< void > >& completion); 00083 00085 RPC< void > stop(); 00086 00089 void get_secondary_ids(const Callback<void, RPC< vector<MedusaID> > >& completion); 00090 00092 RPC< vector<MedusaID> > get_secondary_ids(); 00093 00094 }; 00095 00096 00097 /***** 00098 * 00099 * You can safely ignore everything after here. 00100 * 00101 *****/ 00102 00103 00104 00105 00106 00107 #else // !defined(DOXYGEN_SKIP) 00108 00109 namespace __nmstl_tmp_rpc_defs { 00110 template<typename X> struct RPCDefs; 00111 template<typename X> struct Remote; 00112 using namespace Borealis; 00113 template<> 00114 struct RPCDefs<Borealis::HA> { 00115 static const int replicate_query_METHOD_ID = 20000; 00116 struct replicate_query_IN : public rpc_request_1< void > { 00117 MedusaID primary; Query query; 00118 replicate_query_IN() {} 00119 replicate_query_IN(MedusaID primary, Query query) : primary(primary), query(query) {} 00120 rpc_message *clone() const { return new replicate_query_IN(*this); } 00121 string as_string() const { 00122 string out; 00123 out << "replicate_query_IN{" << "primary=" << primary << ", query=" << query << "}"; 00124 return out; 00125 } 00126 NMSTL_SIMPLY_SERIALIZABLE(replicate_query_IN, << Serial::tag("param") << primary << query ); 00127 NMSTL_SERIAL_TAG(replicate_query_IN, "params"); 00128 }; 00129 class replicate_query_OUT { 00130 RPCStatus m_stat; 00131 public: 00132 operator const void * () const { return m_stat; } 00133 const RPCStatus& stat() const { return m_stat; } 00134 bool get() const { return true; } 00135 }; 00136 static const int replicate_subs_METHOD_ID = 20001; 00137 struct replicate_subs_IN : public rpc_request_1< void > { 00138 MedusaID primary; vector<Subscription> subs; 00139 replicate_subs_IN() {} 00140 replicate_subs_IN(MedusaID primary, vector<Subscription> subs) : primary(primary), subs(subs) {} 00141 rpc_message *clone() const { return new replicate_subs_IN(*this); } 00142 string as_string() const { 00143 string out; 00144 out << "replicate_subs_IN{" << "primary=" << primary << ", subs=" << subs << "}"; 00145 return out; 00146 } 00147 NMSTL_SIMPLY_SERIALIZABLE(replicate_subs_IN, << Serial::tag("param") << primary << subs ); 00148 NMSTL_SERIAL_TAG(replicate_subs_IN, "params"); 00149 }; 00150 class replicate_subs_OUT { 00151 RPCStatus m_stat; 00152 public: 00153 operator const void * () const { return m_stat; } 00154 const RPCStatus& stat() const { return m_stat; } 00155 bool get() const { return true; } 00156 }; 00157 static const int keep_alive_METHOD_ID = 20002; 00158 struct keep_alive_IN : public rpc_request_1< void > { 00159 00160 keep_alive_IN() {} 00161 rpc_message *clone() const { return new keep_alive_IN(*this); } 00162 string as_string() const { 00163 string out; 00164 out << "keep_alive_IN{" << "}"; 00165 return out; 00166 } 00167 NMSTL_SIMPLY_SERIALIZABLE(keep_alive_IN, << Serial::tag("param") ); 00168 NMSTL_SERIAL_TAG(keep_alive_IN, "params"); 00169 }; 00170 class keep_alive_OUT { 00171 RPCStatus m_stat; 00172 public: 00173 operator const void * () const { return m_stat; } 00174 const RPCStatus& stat() const { return m_stat; } 00175 bool get() const { return true; } 00176 }; 00177 static const int failure_notification_METHOD_ID = 20003; 00178 struct failure_notification_IN : public rpc_request_1< void > { 00179 MedusaID failed_node; Time time_failure_detected; 00180 failure_notification_IN() {} 00181 failure_notification_IN(MedusaID failed_node, Time time_failure_detected) : failed_node(failed_node), time_failure_detected(time_failure_detected) {} 00182 rpc_message *clone() const { return new failure_notification_IN(*this); } 00183 string as_string() const { 00184 string out; 00185 out << "failure_notification_IN{" << "failed_node=" << failed_node << ", time_failure_detected=" << time_failure_detected << "}"; 00186 return out; 00187 } 00188 NMSTL_SIMPLY_SERIALIZABLE(failure_notification_IN, << Serial::tag("param") << failed_node << time_failure_detected ); 00189 NMSTL_SERIAL_TAG(failure_notification_IN, "params"); 00190 }; 00191 class failure_notification_OUT { 00192 RPCStatus m_stat; 00193 public: 00194 operator const void * () const { return m_stat; } 00195 const RPCStatus& stat() const { return m_stat; } 00196 bool get() const { return true; } 00197 }; 00198 static const int start_METHOD_ID = 20004; 00199 struct start_IN : public rpc_request_1< void > { 00200 00201 start_IN() {} 00202 rpc_message *clone() const { return new start_IN(*this); } 00203 string as_string() const { 00204 string out; 00205 out << "start_IN{" << "}"; 00206 return out; 00207 } 00208 NMSTL_SIMPLY_SERIALIZABLE(start_IN, << Serial::tag("param") ); 00209 NMSTL_SERIAL_TAG(start_IN, "params"); 00210 }; 00211 class start_OUT { 00212 RPCStatus m_stat; 00213 public: 00214 operator const void * () const { return m_stat; } 00215 const RPCStatus& stat() const { return m_stat; } 00216 bool get() const { return true; } 00217 }; 00218 static const int stop_METHOD_ID = 20005; 00219 struct stop_IN : public rpc_request_1< void > { 00220 00221 stop_IN() {} 00222 rpc_message *clone() const { return new stop_IN(*this); } 00223 string as_string() const { 00224 string out; 00225 out << "stop_IN{" << "}"; 00226 return out; 00227 } 00228 NMSTL_SIMPLY_SERIALIZABLE(stop_IN, << Serial::tag("param") ); 00229 NMSTL_SERIAL_TAG(stop_IN, "params"); 00230 }; 00231 class stop_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 get_secondary_ids_METHOD_ID = 20006; 00239 struct get_secondary_ids_IN : public rpc_request_1< vector<MedusaID> > { 00240 00241 get_secondary_ids_IN() {} 00242 rpc_message *clone() const { return new get_secondary_ids_IN(*this); } 00243 string as_string() const { 00244 string out; 00245 out << "get_secondary_ids_IN{" << "}"; 00246 return out; 00247 } 00248 NMSTL_SIMPLY_SERIALIZABLE(get_secondary_ids_IN, << Serial::tag("param") ); 00249 NMSTL_SERIAL_TAG(get_secondary_ids_IN, "params"); 00250 }; 00251 class get_secondary_ids_OUT { 00252 RPCStatus m_stat; 00253 vector<MedusaID> m_val; 00254 public: 00255 operator const void * () const { return m_stat; } 00256 const RPCStatus& stat() const { return m_stat; } 00257 vector<MedusaID> get() const { return m_val; } 00258 }; 00259 static const vector<pair<string, int> >& method_list() { 00260 static const pair<string, int> methods[] = { 00261 pair<string, int>("replicate_query", 20000), 00262 pair<string, int>("replicate_subs", 20001), 00263 pair<string, int>("keep_alive", 20002), 00264 pair<string, int>("failure_notification", 20003), 00265 pair<string, int>("start", 20004), 00266 pair<string, int>("stop", 20005), 00267 pair<string, int>("get_secondary_ids", 20006) 00268 }; 00269 static const vector<pair<string, int> > ret(methods, methods + sizeof methods / sizeof methods[0]); 00270 return ret; 00271 }; 00272 static const map<string, int>& method_id_by_name() { 00273 static const map<string, int> ret(method_list().begin(), method_list().end()); 00274 return ret; 00275 } 00276 static const map<int, string>& method_name_by_id() { 00277 static const map<int, string> ret = RPCObject::reverse_map(method_id_by_name()); 00278 return ret; 00279 } 00280 }; 00281 template<> 00282 class Remote<Borealis::HA> : public RemoteObject { 00283 friend class RPCClient; 00284 protected: 00285 Remote<Borealis::HA>(RPCClient& cli, rpc_object_id object_id) : 00286 RemoteObject(cli, object_id) {} 00287 00288 public: 00289 Remote<Borealis::HA>() {} 00290 void replicate_query(const Callback<void, RPC< void > >& completion, MedusaID primary, Query query) const { 00291 RPCDefs<Borealis::HA>::replicate_query_IN *req = 00292 new RPCDefs<Borealis::HA>::replicate_query_IN(primary, query); 00293 req->object_id = object_id(); 00294 req->method_id = RPCDefs<Borealis::HA>::replicate_query_METHOD_ID; 00295 req->method_name = "replicate_query"; 00296 req->cb = completion; 00297 client().send_request(ptr<rpc_request>(req)); 00298 } 00299 RPC< void > replicate_query(MedusaID primary, Query query) const { 00300 RPCDefs<Borealis::HA>::replicate_query_IN *req = 00301 new RPCDefs<Borealis::HA>::replicate_query_IN(primary, query); 00302 ptr<rpc_request> preq(req); 00303 req->object_id = object_id(); 00304 req->method_id = RPCDefs<Borealis::HA>::replicate_query_METHOD_ID; 00305 req->method_name = "replicate_query"; 00306 bool done = false; RPC< void > ret; 00307 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00308 client().send_request(preq); 00309 while (!done && client().block()) ; 00310 req->cb = Callback<void, RPC< void > >(); 00311 return ret; 00312 } 00313 typedef const RPCDefs<Borealis::HA>::replicate_query_OUT &replicate_query_result; 00314 void replicate_subs(const Callback<void, RPC< void > >& completion, MedusaID primary, vector<Subscription> subs) const { 00315 RPCDefs<Borealis::HA>::replicate_subs_IN *req = 00316 new RPCDefs<Borealis::HA>::replicate_subs_IN(primary, subs); 00317 req->object_id = object_id(); 00318 req->method_id = RPCDefs<Borealis::HA>::replicate_subs_METHOD_ID; 00319 req->method_name = "replicate_subs"; 00320 req->cb = completion; 00321 client().send_request(ptr<rpc_request>(req)); 00322 } 00323 RPC< void > replicate_subs(MedusaID primary, vector<Subscription> subs) const { 00324 RPCDefs<Borealis::HA>::replicate_subs_IN *req = 00325 new RPCDefs<Borealis::HA>::replicate_subs_IN(primary, subs); 00326 ptr<rpc_request> preq(req); 00327 req->object_id = object_id(); 00328 req->method_id = RPCDefs<Borealis::HA>::replicate_subs_METHOD_ID; 00329 req->method_name = "replicate_subs"; 00330 bool done = false; RPC< void > ret; 00331 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00332 client().send_request(preq); 00333 while (!done && client().block()) ; 00334 req->cb = Callback<void, RPC< void > >(); 00335 return ret; 00336 } 00337 typedef const RPCDefs<Borealis::HA>::replicate_subs_OUT &replicate_subs_result; 00338 void keep_alive(const Callback<void, RPC< void > >& completion) const { 00339 RPCDefs<Borealis::HA>::keep_alive_IN *req = 00340 new RPCDefs<Borealis::HA>::keep_alive_IN(); 00341 req->object_id = object_id(); 00342 req->method_id = RPCDefs<Borealis::HA>::keep_alive_METHOD_ID; 00343 req->method_name = "keep_alive"; 00344 req->cb = completion; 00345 client().send_request(ptr<rpc_request>(req)); 00346 } 00347 RPC< void > keep_alive() const { 00348 RPCDefs<Borealis::HA>::keep_alive_IN *req = 00349 new RPCDefs<Borealis::HA>::keep_alive_IN(); 00350 ptr<rpc_request> preq(req); 00351 req->object_id = object_id(); 00352 req->method_id = RPCDefs<Borealis::HA>::keep_alive_METHOD_ID; 00353 req->method_name = "keep_alive"; 00354 bool done = false; RPC< void > ret; 00355 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00356 client().send_request(preq); 00357 while (!done && client().block()) ; 00358 req->cb = Callback<void, RPC< void > >(); 00359 return ret; 00360 } 00361 typedef const RPCDefs<Borealis::HA>::keep_alive_OUT &keep_alive_result; 00362 void failure_notification(const Callback<void, RPC< void > >& completion, MedusaID failed_node, Time time_failure_detected) const { 00363 RPCDefs<Borealis::HA>::failure_notification_IN *req = 00364 new RPCDefs<Borealis::HA>::failure_notification_IN(failed_node, time_failure_detected); 00365 req->object_id = object_id(); 00366 req->method_id = RPCDefs<Borealis::HA>::failure_notification_METHOD_ID; 00367 req->method_name = "failure_notification"; 00368 req->cb = completion; 00369 client().send_request(ptr<rpc_request>(req)); 00370 } 00371 RPC< void > failure_notification(MedusaID failed_node, Time time_failure_detected) const { 00372 RPCDefs<Borealis::HA>::failure_notification_IN *req = 00373 new RPCDefs<Borealis::HA>::failure_notification_IN(failed_node, time_failure_detected); 00374 ptr<rpc_request> preq(req); 00375 req->object_id = object_id(); 00376 req->method_id = RPCDefs<Borealis::HA>::failure_notification_METHOD_ID; 00377 req->method_name = "failure_notification"; 00378 bool done = false; RPC< void > ret; 00379 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00380 client().send_request(preq); 00381 while (!done && client().block()) ; 00382 req->cb = Callback<void, RPC< void > >(); 00383 return ret; 00384 } 00385 typedef const RPCDefs<Borealis::HA>::failure_notification_OUT &failure_notification_result; 00386 void start(const Callback<void, RPC< void > >& completion) const { 00387 RPCDefs<Borealis::HA>::start_IN *req = 00388 new RPCDefs<Borealis::HA>::start_IN(); 00389 req->object_id = object_id(); 00390 req->method_id = RPCDefs<Borealis::HA>::start_METHOD_ID; 00391 req->method_name = "start"; 00392 req->cb = completion; 00393 client().send_request(ptr<rpc_request>(req)); 00394 } 00395 RPC< void > start() const { 00396 RPCDefs<Borealis::HA>::start_IN *req = 00397 new RPCDefs<Borealis::HA>::start_IN(); 00398 ptr<rpc_request> preq(req); 00399 req->object_id = object_id(); 00400 req->method_id = RPCDefs<Borealis::HA>::start_METHOD_ID; 00401 req->method_name = "start"; 00402 bool done = false; RPC< void > ret; 00403 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00404 client().send_request(preq); 00405 while (!done && client().block()) ; 00406 req->cb = Callback<void, RPC< void > >(); 00407 return ret; 00408 } 00409 typedef const RPCDefs<Borealis::HA>::start_OUT &start_result; 00410 void stop(const Callback<void, RPC< void > >& completion) const { 00411 RPCDefs<Borealis::HA>::stop_IN *req = 00412 new RPCDefs<Borealis::HA>::stop_IN(); 00413 req->object_id = object_id(); 00414 req->method_id = RPCDefs<Borealis::HA>::stop_METHOD_ID; 00415 req->method_name = "stop"; 00416 req->cb = completion; 00417 client().send_request(ptr<rpc_request>(req)); 00418 } 00419 RPC< void > stop() const { 00420 RPCDefs<Borealis::HA>::stop_IN *req = 00421 new RPCDefs<Borealis::HA>::stop_IN(); 00422 ptr<rpc_request> preq(req); 00423 req->object_id = object_id(); 00424 req->method_id = RPCDefs<Borealis::HA>::stop_METHOD_ID; 00425 req->method_name = "stop"; 00426 bool done = false; RPC< void > ret; 00427 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00428 client().send_request(preq); 00429 while (!done && client().block()) ; 00430 req->cb = Callback<void, RPC< void > >(); 00431 return ret; 00432 } 00433 typedef const RPCDefs<Borealis::HA>::stop_OUT &stop_result; 00434 void get_secondary_ids(const Callback<void, RPC< vector<MedusaID> > >& completion) const { 00435 RPCDefs<Borealis::HA>::get_secondary_ids_IN *req = 00436 new RPCDefs<Borealis::HA>::get_secondary_ids_IN(); 00437 req->object_id = object_id(); 00438 req->method_id = RPCDefs<Borealis::HA>::get_secondary_ids_METHOD_ID; 00439 req->method_name = "get_secondary_ids"; 00440 req->cb = completion; 00441 client().send_request(ptr<rpc_request>(req)); 00442 } 00443 RPC< vector<MedusaID> > get_secondary_ids() const { 00444 RPCDefs<Borealis::HA>::get_secondary_ids_IN *req = 00445 new RPCDefs<Borealis::HA>::get_secondary_ids_IN(); 00446 ptr<rpc_request> preq(req); 00447 req->object_id = object_id(); 00448 req->method_id = RPCDefs<Borealis::HA>::get_secondary_ids_METHOD_ID; 00449 req->method_name = "get_secondary_ids"; 00450 bool done = false; RPC< vector<MedusaID> > ret; 00451 req->cb = wrap(&rpc_sync_completion< vector<MedusaID> >, &done, &ret); 00452 client().send_request(preq); 00453 while (!done && client().block()) ; 00454 req->cb = Callback<void, RPC< vector<MedusaID> > >(); 00455 return ret; 00456 } 00457 typedef const RPCDefs<Borealis::HA>::get_secondary_ids_OUT &get_secondary_ids_result; 00458 }; 00459 }; 00460 template<> struct RPCDefs<Borealis::HA> : __nmstl_tmp_rpc_defs::RPCDefs<Borealis::HA> {}; 00461 template<> struct Remote<Borealis::HA> : __nmstl_tmp_rpc_defs::Remote<Borealis::HA> { 00462 Remote<Borealis::HA>() {} 00463 Remote<Borealis::HA>(RPCClient& cli, rpc_object_id object_id) : 00464 __nmstl_tmp_rpc_defs::Remote<Borealis::HA>(cli, object_id) {} 00465 00466 Remote<Borealis::HA>(const __nmstl_tmp_rpc_defs::Remote<Borealis::HA>& x) : 00467 __nmstl_tmp_rpc_defs::Remote<Borealis::HA>(x) {} 00468 }; 00469 00470 00471 #endif // !defined(DOXYGEN_SKIP) 00472 00473 NMSTL_NAMESPACE_END; 00474 00475 #endif // !defined(___HA_RPC_HA_H) 00476 00477 00478 00479 00480 00481 #ifdef NMSTL_RPC_DEFINE 00482 00483 #include <string> 00484 #include <map> 00485 #include <NMSTL/rpc> 00486 00487 void Borealis::HA::handle_request(const NMSTL::RPCObject::response_cb& cb, const NMSTL::ptr<NMSTL::rpc_request>& req) { 00488 switch(req->method_id) { 00489 case NMSTL::RPCDefs<Borealis::HA>::replicate_query_METHOD_ID: 00490 { 00491 const NMSTL::RPCDefs<Borealis::HA>::replicate_query_IN* inp = 00492 dynamic_cast<const NMSTL::RPCDefs<Borealis::HA>::replicate_query_IN*>(req.get()); 00493 00494 if (!inp) { 00495 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 00496 " to Borealis::HA::replicate_query; expected " + 00497 typeid(NMSTL::RPCDefs<Borealis::HA>::replicate_query_IN); 00498 WARN << err; 00499 cb(err, 0, true); 00500 return; 00501 } 00502 00503 const NMSTL::RPCDefs<Borealis::HA>::replicate_query_IN& in = *inp; 00504 NMSTL::AsyncRPC< void > pending = replicate_query(in.primary, in.query); 00505 pending.set_response_handler(cb); 00506 break; 00507 } 00508 case NMSTL::RPCDefs<Borealis::HA>::replicate_subs_METHOD_ID: 00509 { 00510 const NMSTL::RPCDefs<Borealis::HA>::replicate_subs_IN* inp = 00511 dynamic_cast<const NMSTL::RPCDefs<Borealis::HA>::replicate_subs_IN*>(req.get()); 00512 00513 if (!inp) { 00514 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 00515 " to Borealis::HA::replicate_subs; expected " + 00516 typeid(NMSTL::RPCDefs<Borealis::HA>::replicate_subs_IN); 00517 WARN << err; 00518 cb(err, 0, true); 00519 return; 00520 } 00521 00522 const NMSTL::RPCDefs<Borealis::HA>::replicate_subs_IN& in = *inp; 00523 NMSTL::AsyncRPC< void > pending = replicate_subs(in.primary, in.subs); 00524 pending.set_response_handler(cb); 00525 break; 00526 } 00527 case NMSTL::RPCDefs<Borealis::HA>::keep_alive_METHOD_ID: 00528 { 00529 const NMSTL::RPCDefs<Borealis::HA>::keep_alive_IN* inp = 00530 dynamic_cast<const NMSTL::RPCDefs<Borealis::HA>::keep_alive_IN*>(req.get()); 00531 00532 if (!inp) { 00533 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 00534 " to Borealis::HA::keep_alive; expected " + 00535 typeid(NMSTL::RPCDefs<Borealis::HA>::keep_alive_IN); 00536 WARN << err; 00537 cb(err, 0, true); 00538 return; 00539 } 00540 00541 RPC< void > result = keep_alive(); 00542 if (result.valid()) { 00543 NMSTL::rpc_message_1< void > ret; 00544 cb(true, &ret, true); 00545 } else { 00546 cb(result.stat(), 0, true); 00547 } 00548 break; 00549 } 00550 case NMSTL::RPCDefs<Borealis::HA>::failure_notification_METHOD_ID: 00551 { 00552 const NMSTL::RPCDefs<Borealis::HA>::failure_notification_IN* inp = 00553 dynamic_cast<const NMSTL::RPCDefs<Borealis::HA>::failure_notification_IN*>(req.get()); 00554 00555 if (!inp) { 00556 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 00557 " to Borealis::HA::failure_notification; expected " + 00558 typeid(NMSTL::RPCDefs<Borealis::HA>::failure_notification_IN); 00559 WARN << err; 00560 cb(err, 0, true); 00561 return; 00562 } 00563 00564 const NMSTL::RPCDefs<Borealis::HA>::failure_notification_IN& in = *inp; 00565 RPC< void > result = failure_notification(in.failed_node, in.time_failure_detected); 00566 if (result.valid()) { 00567 NMSTL::rpc_message_1< void > ret; 00568 cb(true, &ret, true); 00569 } else { 00570 cb(result.stat(), 0, true); 00571 } 00572 break; 00573 } 00574 case NMSTL::RPCDefs<Borealis::HA>::start_METHOD_ID: 00575 { 00576 const NMSTL::RPCDefs<Borealis::HA>::start_IN* inp = 00577 dynamic_cast<const NMSTL::RPCDefs<Borealis::HA>::start_IN*>(req.get()); 00578 00579 if (!inp) { 00580 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 00581 " to Borealis::HA::start; expected " + 00582 typeid(NMSTL::RPCDefs<Borealis::HA>::start_IN); 00583 WARN << err; 00584 cb(err, 0, true); 00585 return; 00586 } 00587 00588 RPC< void > result = start(); 00589 if (result.valid()) { 00590 NMSTL::rpc_message_1< void > ret; 00591 cb(true, &ret, true); 00592 } else { 00593 cb(result.stat(), 0, true); 00594 } 00595 break; 00596 } 00597 case NMSTL::RPCDefs<Borealis::HA>::stop_METHOD_ID: 00598 { 00599 const NMSTL::RPCDefs<Borealis::HA>::stop_IN* inp = 00600 dynamic_cast<const NMSTL::RPCDefs<Borealis::HA>::stop_IN*>(req.get()); 00601 00602 if (!inp) { 00603 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 00604 " to Borealis::HA::stop; expected " + 00605 typeid(NMSTL::RPCDefs<Borealis::HA>::stop_IN); 00606 WARN << err; 00607 cb(err, 0, true); 00608 return; 00609 } 00610 00611 RPC< void > result = stop(); 00612 if (result.valid()) { 00613 NMSTL::rpc_message_1< void > ret; 00614 cb(true, &ret, true); 00615 } else { 00616 cb(result.stat(), 0, true); 00617 } 00618 break; 00619 } 00620 case NMSTL::RPCDefs<Borealis::HA>::get_secondary_ids_METHOD_ID: 00621 { 00622 const NMSTL::RPCDefs<Borealis::HA>::get_secondary_ids_IN* inp = 00623 dynamic_cast<const NMSTL::RPCDefs<Borealis::HA>::get_secondary_ids_IN*>(req.get()); 00624 00625 if (!inp) { 00626 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 00627 " to Borealis::HA::get_secondary_ids; expected " + 00628 typeid(NMSTL::RPCDefs<Borealis::HA>::get_secondary_ids_IN); 00629 WARN << err; 00630 cb(err, 0, true); 00631 return; 00632 } 00633 00634 RPC< vector<MedusaID> > result = get_secondary_ids(); 00635 if (result.valid()) { 00636 NMSTL::rpc_message_1< vector<MedusaID> > ret(*result); 00637 cb(true, &ret, true); 00638 } else { 00639 cb(result.stat(), 0, true); 00640 } 00641 break; 00642 } 00643 default: 00644 string err = string("Unknown method_id ") + req->method_id + " in Borealis::HA::handle_request"; 00645 WARN << err; 00646 cb(err, 0, true); 00647 } 00648 } 00649 void Borealis::HA::handle_request(const response_cb& cb, rpc_id method_id, ISerial& is) { 00650 switch(method_id) { 00651 case RPCDefs<Borealis::HA>::replicate_query_METHOD_ID: 00652 { 00653 RPCDefs<Borealis::HA>::replicate_query_IN in; 00654 is >> in; 00655 if (!is) { 00656 WARN << "Invalid RPC request to Borealis::HA::replicate_query: " << is.stat(); 00657 cb(is.stat(), 0, true); 00658 return; 00659 } 00660 DEBUG << "Handling replicate_query"; 00661 AsyncRPC< void > pending = replicate_query(in.primary, in.query); 00662 pending.set_response_handler(cb); 00663 break; 00664 } 00665 case RPCDefs<Borealis::HA>::replicate_subs_METHOD_ID: 00666 { 00667 RPCDefs<Borealis::HA>::replicate_subs_IN in; 00668 is >> in; 00669 if (!is) { 00670 WARN << "Invalid RPC request to Borealis::HA::replicate_subs: " << is.stat(); 00671 cb(is.stat(), 0, true); 00672 return; 00673 } 00674 DEBUG << "Handling replicate_subs"; 00675 AsyncRPC< void > pending = replicate_subs(in.primary, in.subs); 00676 pending.set_response_handler(cb); 00677 break; 00678 } 00679 case RPCDefs<Borealis::HA>::keep_alive_METHOD_ID: 00680 { 00681 RPCDefs<Borealis::HA>::keep_alive_IN in; 00682 is >> in; 00683 if (!is) { 00684 WARN << "Invalid RPC request to Borealis::HA::keep_alive: " << is.stat(); 00685 cb(is.stat(), 0, true); 00686 return; 00687 } 00688 DEBUG << "Handling keep_alive"; 00689 RPC< void > result = keep_alive(); 00690 if (result.valid()) { 00691 NMSTL::rpc_message_1< void > ret; 00692 cb(true, &ret, true); 00693 } else { 00694 cb(result.stat(), 0, true); 00695 } 00696 break; 00697 } 00698 case RPCDefs<Borealis::HA>::failure_notification_METHOD_ID: 00699 { 00700 RPCDefs<Borealis::HA>::failure_notification_IN in; 00701 is >> in; 00702 if (!is) { 00703 WARN << "Invalid RPC request to Borealis::HA::failure_notification: " << is.stat(); 00704 cb(is.stat(), 0, true); 00705 return; 00706 } 00707 DEBUG << "Handling failure_notification"; 00708 RPC< void > result = failure_notification(in.failed_node, in.time_failure_detected); 00709 if (result.valid()) { 00710 NMSTL::rpc_message_1< void > ret; 00711 cb(true, &ret, true); 00712 } else { 00713 cb(result.stat(), 0, true); 00714 } 00715 break; 00716 } 00717 case RPCDefs<Borealis::HA>::start_METHOD_ID: 00718 { 00719 RPCDefs<Borealis::HA>::start_IN in; 00720 is >> in; 00721 if (!is) { 00722 WARN << "Invalid RPC request to Borealis::HA::start: " << is.stat(); 00723 cb(is.stat(), 0, true); 00724 return; 00725 } 00726 DEBUG << "Handling start"; 00727 RPC< void > result = start(); 00728 if (result.valid()) { 00729 NMSTL::rpc_message_1< void > ret; 00730 cb(true, &ret, true); 00731 } else { 00732 cb(result.stat(), 0, true); 00733 } 00734 break; 00735 } 00736 case RPCDefs<Borealis::HA>::stop_METHOD_ID: 00737 { 00738 RPCDefs<Borealis::HA>::stop_IN in; 00739 is >> in; 00740 if (!is) { 00741 WARN << "Invalid RPC request to Borealis::HA::stop: " << is.stat(); 00742 cb(is.stat(), 0, true); 00743 return; 00744 } 00745 DEBUG << "Handling stop"; 00746 RPC< void > result = stop(); 00747 if (result.valid()) { 00748 NMSTL::rpc_message_1< void > ret; 00749 cb(true, &ret, true); 00750 } else { 00751 cb(result.stat(), 0, true); 00752 } 00753 break; 00754 } 00755 case RPCDefs<Borealis::HA>::get_secondary_ids_METHOD_ID: 00756 { 00757 RPCDefs<Borealis::HA>::get_secondary_ids_IN in; 00758 is >> in; 00759 if (!is) { 00760 WARN << "Invalid RPC request to Borealis::HA::get_secondary_ids: " << is.stat(); 00761 cb(is.stat(), 0, true); 00762 return; 00763 } 00764 DEBUG << "Handling get_secondary_ids"; 00765 RPC< vector<MedusaID> > result = get_secondary_ids(); 00766 if (result.valid()) { 00767 NMSTL::rpc_message_1< vector<MedusaID> > ret(*result); 00768 cb(true, &ret, true); 00769 } else { 00770 cb(result.stat(), 0, true); 00771 } 00772 break; 00773 } 00774 default: 00775 string err = string("Unknown method_id ") + method_id + " in Borealis::HA::handle_request"; 00776 WARN << err; 00777 cb(err, 0, true); 00778 } 00779 } 00780 NMSTL::rpc_id Borealis::HA::method_id_for_name(string method_name) { 00781 map<string, int>::const_iterator i = RPCDefs<Borealis::HA>::method_id_by_name().find(method_name); 00782 return (i == RPCDefs<Borealis::HA>::method_id_by_name().end()) ? rpc_id() : i->second; 00783 } 00784 string Borealis::HA::method_name_for_id(NMSTL::rpc_id method_id) { 00785 map<int, string>::const_iterator i = RPCDefs<Borealis::HA>::method_name_by_id().find(method_id); 00786 return (i == RPCDefs<Borealis::HA>::method_name_by_id().end()) ? string() : i->second; 00787 } 00788 NMSTL::ptr<NMSTL::rpc_request> Borealis::HA::make_request(NMSTL::rpc_id method_id, NMSTL::ISerial& is) { 00789 switch(method_id) { 00790 case NMSTL::RPCDefs<Borealis::HA>::replicate_query_METHOD_ID: 00791 { 00792 NMSTL::RPCDefs<Borealis::HA>::replicate_query_IN *in = new NMSTL::RPCDefs<Borealis::HA>::replicate_query_IN; 00793 NMSTL::ptr<NMSTL::rpc_request> req(in); 00794 if (is >> *in) return req; 00795 } 00796 case NMSTL::RPCDefs<Borealis::HA>::replicate_subs_METHOD_ID: 00797 { 00798 NMSTL::RPCDefs<Borealis::HA>::replicate_subs_IN *in = new NMSTL::RPCDefs<Borealis::HA>::replicate_subs_IN; 00799 NMSTL::ptr<NMSTL::rpc_request> req(in); 00800 if (is >> *in) return req; 00801 } 00802 case NMSTL::RPCDefs<Borealis::HA>::keep_alive_METHOD_ID: 00803 { 00804 NMSTL::RPCDefs<Borealis::HA>::keep_alive_IN *in = new NMSTL::RPCDefs<Borealis::HA>::keep_alive_IN; 00805 NMSTL::ptr<NMSTL::rpc_request> req(in); 00806 if (is >> *in) return req; 00807 } 00808 case NMSTL::RPCDefs<Borealis::HA>::failure_notification_METHOD_ID: 00809 { 00810 NMSTL::RPCDefs<Borealis::HA>::failure_notification_IN *in = new NMSTL::RPCDefs<Borealis::HA>::failure_notification_IN; 00811 NMSTL::ptr<NMSTL::rpc_request> req(in); 00812 if (is >> *in) return req; 00813 } 00814 case NMSTL::RPCDefs<Borealis::HA>::start_METHOD_ID: 00815 { 00816 NMSTL::RPCDefs<Borealis::HA>::start_IN *in = new NMSTL::RPCDefs<Borealis::HA>::start_IN; 00817 NMSTL::ptr<NMSTL::rpc_request> req(in); 00818 if (is >> *in) return req; 00819 } 00820 case NMSTL::RPCDefs<Borealis::HA>::stop_METHOD_ID: 00821 { 00822 NMSTL::RPCDefs<Borealis::HA>::stop_IN *in = new NMSTL::RPCDefs<Borealis::HA>::stop_IN; 00823 NMSTL::ptr<NMSTL::rpc_request> req(in); 00824 if (is >> *in) return req; 00825 } 00826 case NMSTL::RPCDefs<Borealis::HA>::get_secondary_ids_METHOD_ID: 00827 { 00828 NMSTL::RPCDefs<Borealis::HA>::get_secondary_ids_IN *in = new NMSTL::RPCDefs<Borealis::HA>::get_secondary_ids_IN; 00829 NMSTL::ptr<NMSTL::rpc_request> req(in); 00830 if (is >> *in) return req; 00831 } 00832 } 00833 return NMSTL::ptr<NMSTL::rpc_request>(); 00834 } 00835 00836 00837 #endif 00838