1 ///////////////////////////////////////////////////////////////////////////////
2 //
3 // CegoAdminHandler.cc
4 // -------------------
5 // Cego admin handler class implementation
6 //
7 // Design and Implementation by Bjoern Lemke
8 //
9 // (C)opyright 2000-2019 Bjoern Lemke
10 //
11 // IMPLEMENTATION MODULE
12 //
13 // Class: CegoAdminHandler
14 //
15 // Description: Administration client service request handler class
16 //
17 // Status: CLEAN
18 //
19 ///////////////////////////////////////////////////////////////////////////////
20
21 // LFC INCLUDES
22 #include <lfcbase/AESCrypt.h>
23 #include <lfcbase/Datetime.h>
24
25 // CEGO INCLUDES
26 #include "CegoDefs.h"
27 #include "CegoXMLdef.h"
28 #include "CegoAdminHandler.h"
29 #include "CegoTypeConverter.h"
30 #include "CegoDatabaseManager.h"
31
32 // POSIX INCLUDES
33 #include <string.h>
34 #include <stdlib.h>
35
36 #define MAX(a,b) ((a) > (b) ? (a) : (b))
37
CegoAdminHandler(CegoModule * pModule,NetHandler * pN)38 CegoAdminHandler::CegoAdminHandler(CegoModule *pModule, NetHandler *pN)
39 {
40 _pN = pN;
41 _pModule = pModule;
42
43 Document *pDoc = new Document(XML_CEGO);
44 pDoc->setAttribute(XML_VERSION_ATTR, XML_VERSION_VALUE);
45
46 _xml.setDocument(pDoc);
47
48 _modId = _pModule->getModId("CegoAdminHandler");
49 }
50
~CegoAdminHandler()51 CegoAdminHandler::~CegoAdminHandler()
52 {
53 Document *pDoc = _xml.getDocument();
54 pDoc->clear();
55 delete pDoc;
56 }
57
requestSession(const Chain & user,const Chain & password,bool doEncrypt)58 CegoAdminHandler::ResultType CegoAdminHandler::requestSession(const Chain& user, const Chain& password, bool doEncrypt)
59 {
60
61 #ifdef CGDEBUG
62 _pModule->log(_modId, Logger::DEBUG, Chain("Request session for user ") + user + Chain("/") + password);
63 #endif
64
65 _xml.getDocument()->clear();
66
67 Element* pRoot = new Element(XML_FRAME_ELEMENT);
68
69 pRoot->setAttribute(XML_NAME_ATTR, user);
70
71 if ( doEncrypt )
72 {
73 AESCrypt aescrypt(CEGOAESKEY, CEGOAESKEYLEN);
74 pRoot->setAttribute(XML_PASSWD_ATTR, aescrypt.encrypt(password));
75 }
76 else
77 {
78 pRoot->setAttribute(XML_PASSWD_ATTR, password);
79 }
80
81 _xml.getDocument()->setRootElement(pRoot);
82 _xml.getDocument()->setDocType(Chain(XML_ADMINSESSION_REQUEST));
83
84 Chain request;
85 _xml.getXMLChain(request);
86
87 _xml.getDocument()->clear();
88
89 _pN->setMsg(request, request.length());
90
91 #ifdef CGDEBUG
92 _pModule->log(_modId, Logger::DEBUG, Chain("Requesting session ..."));
93 #endif
94
95 _pN->writeMsg();
96
97 _pN->readMsg();
98
99 #ifdef CGDEBUG
100 _pModule->log(_modId, Logger::DEBUG, Chain("--- XML ---"));
101 _pModule->log(_modId, Logger::DEBUG, _pN->getMsg());
102 _pModule->log(_modId, Logger::DEBUG, Chain("--- --- ---"));
103 #endif
104
105 _xml.getDocument()->clear();
106 _xml.setChain( _pN->getMsg() );
107 _xml.parse();
108
109 Chain docType = _xml.getDocument()->getDocType();
110
111 if ( docType == Chain(XML_OK_DOC) )
112 {
113 #ifdef CGDEBUG
114 _pModule->log(_modId, Logger::DEBUG, Chain("Session established"));
115 #endif
116 return ADM_OK;
117 }
118 else // if ( docType == Chain(XML_ERROR_DOC) )
119 {
120 #ifdef CGDEBUG
121 _pModule->log(_modId, Logger::DEBUG, Chain("Session rejected"));
122 #endif
123
124 return ADM_ERROR;
125 }
126 }
127
closeSession()128 CegoAdminHandler::ResultType CegoAdminHandler::closeSession()
129 {
130
131 Element* pRoot = new Element(XML_FRAME_ELEMENT);
132
133 _xml.getDocument()->setRootElement(pRoot);
134 _xml.getDocument()->setDocType(XML_SESSION_CLOSE);
135 Chain request;
136 _xml.getXMLChain(request);
137 _xml.getDocument()->clear();
138
139 _pN->setMsg(request, request.length());
140
141 _pN->writeMsg();
142
143 _pN->readMsg();
144
145 #ifdef CGDEBUG
146 _pModule->log(_modId, Logger::DEBUG, Chain("--- XML ---"));
147 _pModule->log(_modId, Logger::DEBUG, _pN->getMsg());
148 _pModule->log(_modId, Logger::DEBUG, Chain("--- --- ---"));
149 #endif
150
151 _xml.getDocument()->clear();
152 _xml.setChain( _pN->getMsg() );
153 _xml.parse();
154
155 Chain docType = _xml.getDocument()->getDocType();
156
157 if ( docType == Chain(XML_OK_DOC) )
158 {
159 #ifdef CGDEBUG
160 _pModule->log(_modId, Logger::DEBUG, Chain("Session closed"));
161 #endif
162
163 return ADM_OK;
164 }
165 else // if ( docType == Chain(XML_ERROR_DOC) )
166 {
167 #ifdef CGDEBUG
168 _pModule->log(_modId, Logger::DEBUG, Chain("Session close failed"));
169 #endif
170
171 return ADM_ERROR;
172 }
173 }
174
acceptSession()175 bool CegoAdminHandler::acceptSession()
176 {
177 #ifdef CGDEBUG
178 _pModule->log(_modId, Logger::DEBUG, Chain("Accepting session"));
179 #endif
180
181 try {
182
183 _xml.getDocument()->clear();
184
185 #ifdef CGDEBUG
186 _pModule->log(_modId, Logger::DEBUG, Chain("--- XML ---"));
187 _pModule->log(_modId, Logger::DEBUG, _pN->getMsg());
188 _pModule->log(_modId, Logger::DEBUG, Chain("--- --- ---"));
189 #endif
190
191 _xml.setChain( _pN->getMsg() );
192 _xml.parse();
193
194
195 Chain docType = _xml.getDocument()->getDocType();
196
197 if ( docType != Chain(XML_ADMINSESSION_REQUEST) )
198 {
199
200 _pModule->log(_modId, Logger::LOGERR, Chain("Invalid request"));
201
202 _xml.getDocument()->clear();
203 Element* pRoot = new Element(XML_FRAME_ELEMENT);
204 pRoot->setAttribute(XML_MSG_ATTR, Chain("Invalid request"));
205
206 _xml.getDocument()->setRootElement(pRoot);
207
208 _xml.getDocument()->setDocType(XML_ERROR_DOC);
209
210 Chain response;
211 _xml.getXMLChain(response);
212
213 #ifdef CGDEBUG
214 _pModule->log(_modId, Logger::DEBUG, Chain("--- XML ---"));
215 _pModule->log(_modId, Logger::DEBUG, response);
216 _pModule->log(_modId, Logger::DEBUG, Chain("--- --- ---"));
217 #endif
218
219 _pN->setMsg(response, response.length());
220
221 _pN->writeMsg();
222
223 return false;
224 }
225 else
226 {
227
228 Element *pRoot = _xml.getDocument()->getRootElement();
229 if ( pRoot )
230 {
231 _user = pRoot->getAttributeValue(XML_NAME_ATTR);
232 _password = pRoot->getAttributeValue(XML_PASSWD_ATTR);
233
234 // response is sent after authorization check
235
236 return true;
237 }
238 else
239 {
240 throw Exception(EXLOC, "Cannot get root element from message");
241 }
242 }
243 }
244 catch ( Exception e)
245 {
246 Chain msg;
247 e.pop(msg);
248 _pModule->log(_modId, Logger::LOGERR, Chain("Aborting session. Reason=") + msg);
249 _pN->sendNack();
250 return false;
251 }
252 }
253
setNetHandle(NetHandler * pN)254 void CegoAdminHandler::setNetHandle(NetHandler *pN)
255 {
256 _pN = pN;
257 }
258
getNetHandle()259 NetHandler* CegoAdminHandler::getNetHandle()
260 {
261 return _pN;
262 }
263
acceptRequest()264 CegoAdminHandler::RequestType CegoAdminHandler::acceptRequest()
265 {
266 #ifdef CGDEBUG
267 _pModule->log(_modId, Logger::DEBUG, Chain("Accepting request"));
268 #endif
269
270 if ( _pN->waitMsg(NETMNG_WAITMSG_TIMEOUT) == false )
271 return CegoAdminHandler::REQTIMEOUT;
272
273 _pN->readMsg();
274
275 #ifdef CGDEBUG
276 _pModule->log(_modId, Logger::DEBUG, Chain("--- XML ---"));
277 _pModule->log(_modId, Logger::DEBUG, _pN->getMsg());
278 _pModule->log(_modId, Logger::DEBUG, Chain("--- --- ---"));
279 #endif
280
281 _xml.getDocument()->clear();
282 _xml.setChain( _pN->getMsg() );
283 _xml.parse();
284
285 Chain docType = _xml.getDocument()->getDocType();
286
287 if ( docType == Chain(XML_RETRIEVETABLESET_REQUEST) )
288 {
289 return CegoAdminHandler::RETRIEVETABLESET;
290 }
291 else if ( docType == Chain(XML_LOCKINFO_REQUEST) )
292 {
293 return CegoAdminHandler::LOCKINFO;
294 }
295 else if ( docType == Chain(XML_LOCKSTAT_REQUEST) )
296 {
297 return CegoAdminHandler::LOCKSTAT;
298 }
299 else if ( docType == Chain(XML_POOLINFO_REQUEST) )
300 {
301 return CegoAdminHandler::POOLINFO;
302 }
303 else if ( docType == Chain(XML_PARAMETERINFO_REQUEST) )
304 {
305 return CegoAdminHandler::PARAMETERINFO;
306 }
307 else if ( docType == Chain(XML_POOLENTRYLIST_REQUEST) )
308 {
309 return CegoAdminHandler::POOLENTRYLIST;
310 }
311 else if ( docType == Chain(XML_THREADINFO_REQUEST) )
312 {
313 return CegoAdminHandler::THREADINFO;
314 }
315 else if ( docType == Chain(XML_DBTHREADABORT_REQUEST) )
316 {
317 return CegoAdminHandler::DBTHREADABORT;
318 }
319 else if ( docType == Chain(XML_DBTHREADINFO_REQUEST) )
320 {
321 return CegoAdminHandler::DBTHREADINFO;
322 }
323 else if ( docType == Chain(XML_ADMTHREADINFO_REQUEST) )
324 {
325 return CegoAdminHandler::ADMTHREADINFO;
326 }
327 else if ( docType == Chain(XML_LOGTHREADINFO_REQUEST) )
328 {
329 return CegoAdminHandler::LOGTHREADINFO;
330 }
331 else if ( docType == Chain(XML_DBSESSIONINFO_REQUEST) )
332 {
333 return CegoAdminHandler::DBSESSIONINFO;
334 }
335 else if ( docType == Chain(XML_COPYINFO_REQUEST) )
336 {
337 return CegoAdminHandler::COPYINFO;
338 }
339 else if ( docType == Chain(XML_LISTQUERYCACHE_REQUEST) )
340 {
341 return CegoAdminHandler::LISTQUERYCACHE;
342 }
343 else if ( docType == Chain(XML_CLEANQUERYCACHE_REQUEST) )
344 {
345 return CegoAdminHandler::CLEANQUERYCACHE;
346 }
347 else if ( docType == Chain(XML_SETQUERYCACHEPARAM_REQUEST) )
348 {
349 return CegoAdminHandler::SETQUERYCACHEPARAM;
350 }
351 else if ( docType == Chain(XML_LISTTABLECACHE_REQUEST) )
352 {
353 return CegoAdminHandler::LISTTABLECACHE;
354 }
355 else if ( docType == Chain(XML_CLEANTABLECACHE_REQUEST) )
356 {
357 return CegoAdminHandler::CLEANTABLECACHE;
358 }
359 else if ( docType == Chain(XML_SETTABLECACHEENTRY_REQUEST) )
360 {
361 return CegoAdminHandler::SETTABLECACHEENTRY;
362 }
363 else if ( docType == Chain(XML_SETTABLECACHESIZE_REQUEST) )
364 {
365 return CegoAdminHandler::SETTABLECACHESIZE;
366 }
367 else if ( docType == Chain(XML_DEFINE_TABLESET_REQUEST) )
368 {
369 return CegoAdminHandler::DEFINE_TABLESET;
370 }
371 else if ( docType == Chain(XML_REMOVE_TABLESET_REQUEST) )
372 {
373 return CegoAdminHandler::REMOVE_TABLESET;
374 }
375 else if ( docType == Chain(XML_RESET_TABLESET_REQUEST) )
376 {
377 return CegoAdminHandler::RESET_TABLESET;
378 }
379 else if ( docType == Chain(XML_CREATE_TABLESET_REQUEST) )
380 {
381 return CegoAdminHandler::CREATE_TABLESET;
382 }
383 else if ( docType == Chain(XML_DROP_TABLESET_REQUEST) )
384 {
385 return CegoAdminHandler::DROP_TABLESET;
386 }
387 else if ( docType == Chain(XML_START_TABLESET_REQUEST) )
388 {
389 return CegoAdminHandler::START_TABLESET;
390 }
391 else if ( docType == Chain(XML_STOP_TABLESET_REQUEST) )
392 {
393 return CegoAdminHandler::STOP_TABLESET;
394 }
395 else if ( docType == Chain(XML_SYNC_TABLESET_REQUEST) )
396 {
397 return CegoAdminHandler::SYNC_TABLESET;
398 }
399 else if ( docType == Chain(XML_INIT_LOGS_REQUEST) )
400 {
401 return CegoAdminHandler::INIT_LOGS;
402 }
403 else if ( docType == Chain(XML_GET_DBSPEC_REQUEST) )
404 {
405 return CegoAdminHandler::GET_DBSPEC;
406 }
407 else if ( docType == Chain(XML_COPY_TABLESET_REQUEST) )
408 {
409 return CegoAdminHandler::COPY_TABLESET;
410 }
411 else if ( docType == Chain(XML_COPY_FILE_REQUEST) )
412 {
413 return CegoAdminHandler::COPY_FILE;
414 }
415 else if ( docType == Chain(XML_START_RECOVER_REQUEST) )
416 {
417 return CegoAdminHandler::START_RECOVERY;
418 }
419 else if ( docType == Chain(XML_STOP_RECOVER_REQUEST) )
420 {
421 return CegoAdminHandler::STOP_RECOVERY;
422 }
423 else if ( docType == Chain(XML_GET_NODELIST_REQUEST) )
424 {
425 return CegoAdminHandler::GET_NODELIST;
426 }
427 else if ( docType == Chain(XML_GET_DBINFO_REQUEST) )
428 {
429 return CegoAdminHandler::GET_DBINFO;
430 }
431 else if ( docType == Chain(XML_GET_TSINFO_REQUEST) )
432 {
433 return CegoAdminHandler::GET_TSINFO;
434 }
435 else if ( docType == Chain(XML_GET_DETAILED_TSINFO_REQUEST) )
436 {
437 return CegoAdminHandler::GET_DETAILED_TSINFO;
438 }
439 else if ( docType == Chain(XML_GET_OBJECT_INFO_REQUEST) )
440 {
441 return CegoAdminHandler::GET_OBJECT_INFO;
442 }
443 else if ( docType == Chain(XML_GET_TRANSACTION_INFO_REQUEST) )
444 {
445 return CegoAdminHandler::GET_TRANSACTION_INFO;
446 }
447 else if ( docType == Chain(XML_GET_BUSTAT_REQUEST) )
448 {
449 return CegoAdminHandler::GET_BUSTAT;
450 }
451 else if ( docType == Chain(XML_PROP_TSINFO_REQUEST) )
452 {
453 return CegoAdminHandler::PROP_TSINFO;
454 }
455 else if ( docType == Chain(XML_SET_TABLESETNODE_REQUEST) )
456 {
457 return CegoAdminHandler::SET_TABLESETNODE;
458 }
459 else if ( docType == Chain(XML_SET_LSN_REQUEST) )
460 {
461 return CegoAdminHandler::SET_LSN;
462 }
463 else if ( docType == Chain(XML_SET_RUNSTATE_REQUEST) )
464 {
465 return CegoAdminHandler::SET_RUNSTATE;
466 }
467 else if ( docType == Chain(XML_SET_SYNCSTATE_REQUEST) )
468 {
469 return CegoAdminHandler::SET_SYNCSTATE;
470 }
471 else if ( docType == Chain(XML_EXPORT_TABLESET_REQUEST) )
472 {
473 return CegoAdminHandler::EXPORT_TABLESET;
474 }
475 else if ( docType == Chain(XML_IMPORT_TABLESET_REQUEST) )
476 {
477 return CegoAdminHandler::IMPORT_TABLESET;
478 }
479 else if ( docType == Chain(XML_EXPORT_TABLE_REQUEST) )
480 {
481 return CegoAdminHandler::EXPORT_TABLE;
482 }
483 else if ( docType == Chain(XML_IMPORT_TABLE_REQUEST) )
484 {
485 return CegoAdminHandler::IMPORT_TABLE;
486 }
487 else if ( docType == Chain(XML_ADD_DATAFILE_REQUEST) )
488 {
489 return CegoAdminHandler::ADD_DATAFILE;
490 }
491 else if ( docType == Chain(XML_SHOW_USER_REQUEST) )
492 {
493 return CegoAdminHandler::SHOW_USER;
494 }
495 else if ( docType == Chain(XML_ADD_USER_REQUEST) )
496 {
497 return CegoAdminHandler::ADD_USER;
498 }
499 else if ( docType == Chain(XML_REMOVE_USER_REQUEST) )
500 {
501 return CegoAdminHandler::REMOVE_USER;
502 }
503 else if ( docType == Chain(XML_CHANGE_PWD_REQUEST) )
504 {
505 return CegoAdminHandler::CHANGE_PWD;
506 }
507 else if ( docType == Chain(XML_ASSIGN_ROLE_REQUEST) )
508 {
509 return CegoAdminHandler::ASSIGN_ROLE;
510 }
511 else if ( docType == Chain(XML_REMOVE_ROLE_REQUEST) )
512 {
513 return CegoAdminHandler::REMOVE_ROLE;
514 }
515 else if ( docType == Chain(XML_LIST_ROLE_REQUEST) )
516 {
517 return CegoAdminHandler::LIST_ROLE;
518 }
519 else if ( docType == Chain(XML_SHOW_ROLE_REQUEST) )
520 {
521 return CegoAdminHandler::SHOW_ROLE;
522 }
523 else if ( docType == Chain(XML_CREATE_ROLE_REQUEST) )
524 {
525 return CegoAdminHandler::CREATE_ROLE;
526 }
527 else if ( docType == Chain(XML_DROP_ROLE_REQUEST) )
528 {
529 return CegoAdminHandler::DROP_ROLE;
530 }
531 else if ( docType == Chain(XML_SET_PERM_REQUEST) )
532 {
533 return CegoAdminHandler::SET_PERM;
534 }
535 else if ( docType == Chain(XML_REMOVE_PERM_REQUEST) )
536 {
537 return CegoAdminHandler::REMOVE_PERM;
538 }
539 else if ( docType == Chain(XML_USER_TRACE_REQUEST) )
540 {
541 return CegoAdminHandler::USER_TRACE;
542 }
543 else if ( docType == Chain(XML_ADD_ARCHLOG_REQUEST) )
544 {
545 return CegoAdminHandler::ADD_ARCHLOG;
546 }
547 else if ( docType == Chain(XML_REMOVE_ARCHLOG_REQUEST) )
548 {
549 return CegoAdminHandler::REMOVE_ARCHLOG;
550 }
551 else if ( docType == Chain(XML_BEGIN_BACKUP_REQUEST) )
552 {
553 return CegoAdminHandler::BEGIN_BACKUP;
554 }
555 else if ( docType == Chain(XML_EXECUTE_BACKUP_REQUEST) )
556 {
557 return CegoAdminHandler::EXECUTE_BACKUP;
558 }
559 else if ( docType == Chain(XML_END_BACKUP_REQUEST) )
560 {
561 return CegoAdminHandler::END_BACKUP;
562 }
563 else if ( docType == Chain(XML_LIST_BACKUP_REQUEST) )
564 {
565 return CegoAdminHandler::LIST_BACKUP;
566 }
567 else if ( docType == Chain(XML_RESTORE_REQUEST) )
568 {
569 return CegoAdminHandler::RESTORE;
570 }
571 else if ( docType == Chain(XML_RECOVER_REQUEST) )
572 {
573 return CegoAdminHandler::RECOVER;
574 }
575 else if ( docType == Chain(XML_SECSWITCH_REQUEST) )
576 {
577 return CegoAdminHandler::SECSWITCH;
578 }
579 else if ( docType == Chain(XML_VERIFY_TABLESET_REQUEST) )
580 {
581 return CegoAdminHandler::VERIFY_TABLESET;
582 }
583 else if ( docType == Chain(XML_CORRECT_TABLESET_REQUEST) )
584 {
585 return CegoAdminHandler::CORRECT_TABLESET;
586 }
587 else if ( docType == Chain(XML_DUMP_OBJECT_REQUEST) )
588 {
589 return CegoAdminHandler::DUMP_OBJECT;
590 }
591 else if ( docType == Chain(XML_SET_LOGMNG_REQUEST) )
592 {
593 return CegoAdminHandler::SET_LOGMNG;
594 }
595 else if ( docType == Chain(XML_SET_BACKUPMNG_REQUEST) )
596 {
597 return CegoAdminHandler::SET_BACKUPMNG;
598 }
599 else if ( docType == Chain(XML_SHOW_LOGMNG_REQUEST) )
600 {
601 return CegoAdminHandler::SHOW_LOGMNG;
602 }
603 else if ( docType == Chain(XML_SHOW_BACKUPMNG_REQUEST) )
604 {
605 return CegoAdminHandler::SHOW_BACKUPMNG;
606 }
607 else if ( docType == Chain(XML_SET_CHECKPOINT_REQUEST) )
608 {
609 return CegoAdminHandler::SET_CHECKPOINT;
610 }
611 else if ( docType == Chain(XML_SET_TSINITFILE_REQUEST) )
612 {
613 return CegoAdminHandler::SET_TSINITFILE;
614 }
615 else if ( docType == Chain(XML_SET_TSSYSSIZE_REQUEST) )
616 {
617 return CegoAdminHandler::SET_TSSYSSIZE;
618 }
619 else if ( docType == Chain(XML_SET_TSTMPSIZE_REQUEST) )
620 {
621 return CegoAdminHandler::SET_TSTMPSIZE;
622 }
623 else if ( docType == Chain(XML_SET_TSAPPSIZE_REQUEST) )
624 {
625 return CegoAdminHandler::SET_TSAPPSIZE;
626 }
627 else if ( docType == Chain(XML_SET_TSROOTPATH_REQUEST) )
628 {
629 return CegoAdminHandler::SET_TSROOTPATH;
630 }
631 else if ( docType == Chain(XML_SET_TSLOGNUM_REQUEST) )
632 {
633 return CegoAdminHandler::SET_TSLOGNUM;
634 }
635 else if ( docType == Chain(XML_SET_TSLOGSIZE_REQUEST) )
636 {
637 return CegoAdminHandler::SET_TSLOGSIZE;
638 }
639 else if ( docType == Chain(XML_SET_TSSORTAREASIZE_REQUEST) )
640 {
641 return CegoAdminHandler::SET_TSSORTAREASIZE;
642 }
643 else if ( docType == Chain(XML_SET_TSLOGUSER_REQUEST) )
644 {
645 return CegoAdminHandler::SET_TSLOGUSER;
646 }
647
648 else if ( docType == Chain(XML_ENABLE_TABLECACHE_REQUEST) )
649 {
650 return CegoAdminHandler::ENABLE_TABLECACHE;
651 }
652 else if ( docType == Chain(XML_DISABLE_TABLECACHE_REQUEST) )
653 {
654 return CegoAdminHandler::DISABLE_TABLECACHE;
655 }
656 else if ( docType == Chain(XML_ENABLE_QUERYCACHE_REQUEST) )
657 {
658 return CegoAdminHandler::ENABLE_QUERYCACHE;
659 }
660 else if ( docType == Chain(XML_DISABLE_QUERYCACHE_REQUEST) )
661 {
662 return CegoAdminHandler::DISABLE_QUERYCACHE;
663 }
664 // mediator requests
665 else if ( docType == Chain(XML_MED_NOTIFY_REQUEST) )
666 {
667 return CegoAdminHandler::MED_NOTIFY;
668 }
669 else if ( docType == Chain(XML_MED_DEFINE_TABLESET_REQUEST) )
670 {
671 return CegoAdminHandler::MED_DEFINE_TABLESET;
672 }
673 else if ( docType == Chain(XML_MED_REMOVE_TABLESET_REQUEST) )
674 {
675 return CegoAdminHandler::MED_REMOVE_TABLESET;
676 }
677 else if ( docType == Chain(XML_MED_RESET_TABLESET_REQUEST) )
678 {
679 return CegoAdminHandler::MED_RESET_TABLESET;
680 }
681 else if ( docType == Chain(XML_MED_CREATE_TABLESET_REQUEST) )
682 {
683 return CegoAdminHandler::MED_CREATE_TABLESET;
684 }
685 else if ( docType == Chain(XML_MED_DROP_TABLESET_REQUEST) )
686 {
687 return CegoAdminHandler::MED_DROP_TABLESET;
688 }
689 else if ( docType == Chain(XML_MED_START_TABLESET_REQUEST) )
690 {
691 return CegoAdminHandler::MED_START_TABLESET;
692 }
693 else if ( docType == Chain(XML_MED_STOP_TABLESET_REQUEST) )
694 {
695 return CegoAdminHandler::MED_STOP_TABLESET;
696 }
697 else if ( docType == Chain(XML_MED_COPY_TABLESET_REQUEST) )
698 {
699 return CegoAdminHandler::MED_COPY_TABLESET;
700 }
701 else if ( docType == Chain(XML_MED_SWITCH_TABLESET_REQUEST) )
702 {
703 return CegoAdminHandler::MED_SWITCH_TABLESET;
704 }
705 else if ( docType == Chain(XML_MED_ADD_ARCHLOG_REQUEST) )
706 {
707 return CegoAdminHandler::MED_ADD_ARCHLOG;
708 }
709 else if ( docType == Chain(XML_MED_REMOVE_ARCHLOG_REQUEST) )
710 {
711 return CegoAdminHandler::MED_REMOVE_ARCHLOG;
712 }
713 else if ( docType == Chain(XML_MED_ADD_DATAFILE_REQUEST) )
714 {
715 return CegoAdminHandler::MED_ADD_DATAFILE;
716 }
717 else if ( docType == Chain(XML_MED_GET_TABLESETLIST_REQUEST) )
718 {
719 return CegoAdminHandler::MED_GET_TABLESETLIST;
720 }
721 else if ( docType == Chain(XML_MED_GET_DETAILEDTABLESETINFO_REQUEST) )
722 {
723 return CegoAdminHandler::MED_GET_DETAILEDTABLESETINFO;
724 }
725 else if ( docType == Chain(XML_MED_GET_OBJECTINFO_REQUEST) )
726 {
727 return CegoAdminHandler::MED_GET_OBJECTINFO;
728 }
729 else if ( docType == Chain(XML_MED_GET_TRANSACTIONINFO_REQUEST) )
730 {
731 return CegoAdminHandler::MED_GET_TRANSACTIONINFO;
732 }
733 else if ( docType == Chain(XML_MED_GET_BUSTAT_REQUEST) )
734 {
735 return CegoAdminHandler::MED_GET_BUSTAT;
736 }
737 else if ( docType == Chain(XML_MED_RESET_BUSTAT_REQUEST) )
738 {
739 return CegoAdminHandler::MED_RESET_BUSTAT;
740 }
741 else if ( docType == Chain(XML_MED_BEGIN_BACKUP_REQUEST) )
742 {
743 return CegoAdminHandler::MED_BEGIN_BACKUP;
744 }
745 else if ( docType == Chain(XML_MED_EXECUTE_BACKUP_REQUEST) )
746 {
747 return CegoAdminHandler::MED_EXECUTE_BACKUP;
748 }
749 else if ( docType == Chain(XML_MED_END_BACKUP_REQUEST) )
750 {
751 return CegoAdminHandler::MED_END_BACKUP;
752 }
753 else if ( docType == Chain(XML_MED_LIST_BACKUP_REQUEST) )
754 {
755 return CegoAdminHandler::MED_LIST_BACKUP;
756 }
757 else if ( docType == Chain(XML_MED_RESTORE_REQUEST) )
758 {
759 return CegoAdminHandler::MED_RESTORE;
760 }
761 else if ( docType == Chain(XML_MED_RECOVER_REQUEST) )
762 {
763 return CegoAdminHandler::MED_RECOVER;
764 }
765 else if ( docType == Chain(XML_MED_SECSWITCH_REQUEST) )
766 {
767 return CegoAdminHandler::MED_SECSWITCH;
768 }
769 else if ( docType == Chain(XML_SEC_MEDSWITCH_REQUEST) )
770 {
771 return CegoAdminHandler::SEC_MEDSWITCH;
772 }
773 else if ( docType == Chain(XML_MED_SECRELOCATE_REQUEST) )
774 {
775 return CegoAdminHandler::MED_SECRELOCATE;
776 }
777 else if ( docType == Chain(XML_SEC_MEDRELOCATE_REQUEST) )
778 {
779 return CegoAdminHandler::SEC_MEDRELOCATE;
780 }
781 else if ( docType == Chain(XML_MED_CHECK_TABLESET_REQUEST) )
782 {
783 return CegoAdminHandler::MED_CHECK_TABLESET;
784 }
785 else if ( docType == Chain(XML_MED_VERIFY_TABLESET_REQUEST) )
786 {
787 return CegoAdminHandler::MED_VERIFY_TABLESET;
788 }
789 else if ( docType == Chain(XML_MED_CORRECT_TABLESET_REQUEST) )
790 {
791 return CegoAdminHandler::MED_CORRECT_TABLESET;
792 }
793 else if ( docType == Chain(XML_MED_ENABLE_ARCHLOG_REQUEST) )
794 {
795 return CegoAdminHandler::MED_ENABLE_ARCHLOG;
796 }
797 else if ( docType == Chain(XML_MED_DISABLE_ARCHLOG_REQUEST) )
798 {
799 return CegoAdminHandler::MED_DISABLE_ARCHLOG;
800 }
801 else if ( docType == Chain(XML_MED_ENABLE_AUTOCORRECT_REQUEST) )
802 {
803 return CegoAdminHandler::MED_ENABLE_AUTOCORRECT;
804 }
805 else if ( docType == Chain(XML_MED_DISABLE_AUTOCORRECT_REQUEST) )
806 {
807 return CegoAdminHandler::MED_DISABLE_AUTOCORRECT;
808 }
809 else if ( docType == Chain(XML_SESSION_CLOSE) )
810 {
811 return CegoAdminHandler::SESSION_CLOSE;
812 }
813 else
814 {
815 return CegoAdminHandler::UNKNOWN;
816 }
817 }
818
reqRetrieveTableSet(const Chain & masterHost)819 CegoAdminHandler::ResultType CegoAdminHandler::reqRetrieveTableSet(const Chain& masterHost)
820 {
821 Element* pRoot = new Element(XML_FRAME_ELEMENT);
822 pRoot->setAttribute(XML_HOSTNAME_ATTR, masterHost);
823 return sendReq(XML_RETRIEVETABLESET_REQUEST, pRoot);
824 }
825
reqLockInfo(const Chain & lockCat)826 CegoAdminHandler::ResultType CegoAdminHandler::reqLockInfo(const Chain& lockCat)
827 {
828 Element* pRoot = new Element(XML_FRAME_ELEMENT);
829 pRoot->setAttribute(XML_LOCKCAT_ATTR, lockCat);
830 return sendReq(XML_LOCKINFO_REQUEST, pRoot);
831 }
832
reqLockStat()833 CegoAdminHandler::ResultType CegoAdminHandler::reqLockStat()
834 {
835 Element* pRoot = new Element(XML_FRAME_ELEMENT);
836 return sendReq(XML_LOCKSTAT_REQUEST, pRoot);
837 }
838
reqPoolInfo()839 CegoAdminHandler::ResultType CegoAdminHandler::reqPoolInfo()
840 {
841 Element* pRoot = new Element(XML_FRAME_ELEMENT);
842 return sendReq(XML_POOLINFO_REQUEST, pRoot);
843 }
844
reqParameterInfo()845 CegoAdminHandler::ResultType CegoAdminHandler::reqParameterInfo()
846 {
847 Element* pRoot = new Element(XML_FRAME_ELEMENT);
848 return sendReq(XML_PARAMETERINFO_REQUEST, pRoot);
849 }
850
reqPoolEntryList()851 CegoAdminHandler::ResultType CegoAdminHandler::reqPoolEntryList()
852 {
853 Element* pRoot = new Element(XML_FRAME_ELEMENT);
854 return sendReq(XML_POOLENTRYLIST_REQUEST, pRoot);
855 }
856
reqThreadInfo()857 CegoAdminHandler::ResultType CegoAdminHandler::reqThreadInfo()
858 {
859 Element* pRoot = new Element(XML_FRAME_ELEMENT);
860 return sendReq(XML_THREADINFO_REQUEST, pRoot);
861 }
862
reqDbThreadAbort(int threadId)863 CegoAdminHandler::ResultType CegoAdminHandler::reqDbThreadAbort(int threadId)
864 {
865 Element* pRoot = new Element(XML_FRAME_ELEMENT);
866 pRoot->setAttribute(XML_THID_ATTR, Chain(threadId));
867 return sendReq(XML_DBTHREADABORT_REQUEST, pRoot);
868 }
869
reqDbThreadInfo()870 CegoAdminHandler::ResultType CegoAdminHandler::reqDbThreadInfo()
871 {
872 Element* pRoot = new Element(XML_FRAME_ELEMENT);
873 return sendReq(XML_DBTHREADINFO_REQUEST, pRoot);
874 }
875
reqAdmThreadInfo()876 CegoAdminHandler::ResultType CegoAdminHandler::reqAdmThreadInfo()
877 {
878 Element* pRoot = new Element(XML_FRAME_ELEMENT);
879 return sendReq(XML_ADMTHREADINFO_REQUEST, pRoot);
880 }
881
reqLogThreadInfo()882 CegoAdminHandler::ResultType CegoAdminHandler::reqLogThreadInfo()
883 {
884 Element* pRoot = new Element(XML_FRAME_ELEMENT);
885 return sendReq(XML_LOGTHREADINFO_REQUEST, pRoot);
886 }
887
reqDbSessionInfo()888 CegoAdminHandler::ResultType CegoAdminHandler::reqDbSessionInfo()
889 {
890 Element* pRoot = new Element(XML_FRAME_ELEMENT);
891 return sendReq(XML_DBSESSIONINFO_REQUEST, pRoot);
892 }
893
reqCopyInfo()894 CegoAdminHandler::ResultType CegoAdminHandler::reqCopyInfo()
895 {
896 Element* pRoot = new Element(XML_FRAME_ELEMENT);
897 return sendReq(XML_COPYINFO_REQUEST, pRoot);
898 }
899
reqListQueryCache(const Chain & tableSet)900 CegoAdminHandler::ResultType CegoAdminHandler::reqListQueryCache(const Chain& tableSet)
901 {
902 Element* pRoot = new Element(XML_FRAME_ELEMENT);
903 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
904 return sendReq(XML_LISTQUERYCACHE_REQUEST, pRoot);
905 }
906
reqCleanQueryCache(const Chain & tableSet)907 CegoAdminHandler::ResultType CegoAdminHandler::reqCleanQueryCache(const Chain& tableSet)
908 {
909 Element* pRoot = new Element(XML_FRAME_ELEMENT);
910 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
911 return sendReq(XML_CLEANQUERYCACHE_REQUEST, pRoot);
912 }
913
reqSetQueryCacheParam(const Chain & tableSet,int maxEntry,int maxSize,int hashRange)914 CegoAdminHandler::ResultType CegoAdminHandler::reqSetQueryCacheParam(const Chain& tableSet, int maxEntry, int maxSize, int hashRange)
915 {
916 Element* pRoot = new Element(XML_FRAME_ELEMENT);
917 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
918 pRoot->setAttribute(XML_MAXQUERYCACHEENTRY_ATTR, Chain(maxEntry));
919 pRoot->setAttribute(XML_MAXQUERYCACHESIZE_ATTR, Chain(maxSize));
920 pRoot->setAttribute(XML_QUERYCACHEHASHRANGE_ATTR, Chain(hashRange));
921
922 return sendReq(XML_SETQUERYCACHEPARAM_REQUEST, pRoot);
923 }
924
reqListTableCache(const Chain & tableSet)925 CegoAdminHandler::ResultType CegoAdminHandler::reqListTableCache(const Chain& tableSet)
926 {
927 Element* pRoot = new Element(XML_FRAME_ELEMENT);
928 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
929 return sendReq(XML_LISTTABLECACHE_REQUEST, pRoot);
930 }
931
reqCleanTableCache(const Chain & tableSet)932 CegoAdminHandler::ResultType CegoAdminHandler::reqCleanTableCache(const Chain& tableSet)
933 {
934 Element* pRoot = new Element(XML_FRAME_ELEMENT);
935 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
936 return sendReq(XML_CLEANTABLECACHE_REQUEST, pRoot);
937 }
938
reqSetTableCacheEntry(const Chain & tableSet,int numEntry)939 CegoAdminHandler::ResultType CegoAdminHandler::reqSetTableCacheEntry(const Chain& tableSet, int numEntry)
940 {
941 Element* pRoot = new Element(XML_FRAME_ELEMENT);
942 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
943 pRoot->setAttribute(XML_NUMENTRY_ATTR, Chain(numEntry));
944 return sendReq(XML_SETTABLECACHEENTRY_REQUEST, pRoot);
945 }
946
reqSetTableCacheSize(const Chain & tableSet,int cacheSize)947 CegoAdminHandler::ResultType CegoAdminHandler::reqSetTableCacheSize(const Chain& tableSet, int cacheSize)
948 {
949 Element* pRoot = new Element(XML_FRAME_ELEMENT);
950 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
951 pRoot->setAttribute(XML_SIZE_ATTR, Chain(cacheSize));
952 return sendReq(XML_SETTABLECACHESIZE_REQUEST, pRoot);
953 }
954
reqDefineTableSet(const Chain & tableSet,const Chain & tsRoot,const Chain & primary,const Chain & secondary,const Chain & mediator,int sysFileId,int tempFileId,int sysFileSize,int tmpFileSize,int appFileSize,int logFileSize,int logFileNum,unsigned long long sortAreaSize)955 CegoAdminHandler::ResultType CegoAdminHandler::reqDefineTableSet(
956 const Chain& tableSet,
957 const Chain& tsRoot,
958 const Chain& primary,
959 const Chain& secondary,
960 const Chain& mediator,
961 int sysFileId, int tempFileId, int sysFileSize, int tmpFileSize, int appFileSize,
962 int logFileSize, int logFileNum, unsigned long long sortAreaSize)
963 {
964
965 Element* pRoot = new Element(XML_FRAME_ELEMENT);
966 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
967 pRoot->setAttribute(XML_TSROOT_ATTR, tsRoot);
968 pRoot->setAttribute(XML_PRIMARY_ATTR, primary);
969 pRoot->setAttribute(XML_SECONDARY_ATTR, secondary);
970 pRoot->setAttribute(XML_MEDIATOR_ATTR, mediator);
971 pRoot->setAttribute(XML_SYSFID_ATTR, Chain(sysFileId));
972 pRoot->setAttribute(XML_TMPFID_ATTR, Chain(tempFileId));
973 pRoot->setAttribute(XML_SYSSIZE_ATTR, Chain(sysFileSize));
974 pRoot->setAttribute(XML_TMPSIZE_ATTR, Chain(tmpFileSize));
975 pRoot->setAttribute(XML_APPSIZE_ATTR, Chain(appFileSize));
976 pRoot->setAttribute(XML_LOGFILESIZE_ATTR, Chain(logFileSize));
977 pRoot->setAttribute(XML_LOGFILENUM_ATTR, Chain(logFileNum));
978 pRoot->setAttribute(XML_SORTAREASIZE_ATTR, Chain(sortAreaSize));
979
980 return sendReq(XML_DEFINE_TABLESET_REQUEST, pRoot);
981 }
982
reqRemoveTableSet(const Chain & tableSet)983 CegoAdminHandler::ResultType CegoAdminHandler::reqRemoveTableSet(const Chain& tableSet)
984 {
985 Element* pRoot = new Element(XML_FRAME_ELEMENT);
986 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
987 return sendReq(XML_REMOVE_TABLESET_REQUEST, pRoot);
988 }
989
reqResetTableSet(const Chain & tableSet)990 CegoAdminHandler::ResultType CegoAdminHandler::reqResetTableSet(const Chain& tableSet)
991 {
992 Element* pRoot = new Element(XML_FRAME_ELEMENT);
993 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
994 return sendReq(XML_RESET_TABLESET_REQUEST, pRoot);
995 }
996
reqCreateTableSet(const Chain & tableSet)997 CegoAdminHandler::ResultType CegoAdminHandler::reqCreateTableSet(const Chain& tableSet)
998 {
999 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1000 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1001 return sendReq(XML_CREATE_TABLESET_REQUEST, pRoot);
1002 }
1003
reqDropTableSet(const Chain & tableSet)1004 CegoAdminHandler::ResultType CegoAdminHandler::reqDropTableSet(const Chain& tableSet)
1005 {
1006 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1007 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1008 return sendReq(XML_DROP_TABLESET_REQUEST, pRoot);
1009 }
1010
reqStartTableSet(const Chain & tableSet,bool cleanIt,bool forceload)1011 CegoAdminHandler::ResultType CegoAdminHandler::reqStartTableSet(const Chain& tableSet, bool cleanIt, bool forceload)
1012 {
1013 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1014 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1015
1016 if ( cleanIt )
1017 pRoot->setAttribute(XML_CLEANUP_ATTR, XML_TRUE_VALUE);
1018 else
1019 pRoot->setAttribute(XML_CLEANUP_ATTR, XML_FALSE_VALUE);
1020
1021 if ( forceload )
1022 pRoot->setAttribute(XML_FORCELOAD_ATTR, XML_TRUE_VALUE);
1023 else
1024 pRoot->setAttribute(XML_FORCELOAD_ATTR, XML_FALSE_VALUE);
1025
1026 return sendReq(XML_START_TABLESET_REQUEST, pRoot);
1027 }
1028
reqStopTableSet(const Chain & tableSet)1029 CegoAdminHandler::ResultType CegoAdminHandler::reqStopTableSet(const Chain& tableSet)
1030 {
1031 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1032 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1033 return sendReq(XML_STOP_TABLESET_REQUEST, pRoot);
1034 }
1035
reqVerifyTableSet(const Chain & tableSet)1036 CegoAdminHandler::ResultType CegoAdminHandler::reqVerifyTableSet(const Chain& tableSet)
1037 {
1038 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1039 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1040 return sendReq(XML_VERIFY_TABLESET_REQUEST, pRoot);
1041 }
1042
reqInitLogs(const Chain & tableSet)1043 CegoAdminHandler::ResultType CegoAdminHandler::reqInitLogs(const Chain& tableSet)
1044 {
1045 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1046 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1047 return sendReq(XML_INIT_LOGS_REQUEST, pRoot);
1048 }
1049
reqSyncTableSet(const Chain & tableSet,const Chain & msg,const Chain & escCmd,int timeout)1050 CegoAdminHandler::ResultType CegoAdminHandler::reqSyncTableSet(const Chain& tableSet, const Chain& msg, const Chain& escCmd, int timeout)
1051 {
1052 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1053 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1054 pRoot->setAttribute(XML_BUMSG_ATTR, msg);
1055
1056 if ( escCmd != Chain("") )
1057 {
1058 pRoot->setAttribute(XML_ESCCMD_ATTR, escCmd);
1059 pRoot->setAttribute(XML_TIMEOUT_ATTR, Chain(timeout));
1060 }
1061 return sendReq(XML_SYNC_TABLESET_REQUEST, pRoot);
1062 }
1063
reqStartRecovery(const Chain & tableSet)1064 CegoAdminHandler::ResultType CegoAdminHandler::reqStartRecovery(const Chain& tableSet)
1065 {
1066 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1067 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1068 return sendReq(XML_START_RECOVER_REQUEST, pRoot);
1069 }
1070
reqStopRecovery(const Chain & tableSet)1071 CegoAdminHandler::ResultType CegoAdminHandler::reqStopRecovery(const Chain& tableSet)
1072 {
1073 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1074 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1075 return sendReq(XML_STOP_RECOVER_REQUEST, pRoot);
1076 }
1077
reqCopyTableSet(const Chain & tableSet,const Chain & secondary,const Chain & mediator)1078 CegoAdminHandler::ResultType CegoAdminHandler::reqCopyTableSet(const Chain& tableSet, const Chain& secondary, const Chain& mediator)
1079 {
1080 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1081 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1082 pRoot->setAttribute(XML_SECONDARY_ATTR, secondary);
1083 pRoot->setAttribute(XML_MEDIATOR_ATTR, mediator);
1084 return sendReq(XML_COPY_TABLESET_REQUEST, pRoot);
1085 }
1086
reqCopyFile(const Chain & fileName,int copyId)1087 CegoAdminHandler::ResultType CegoAdminHandler::reqCopyFile(const Chain& fileName, int copyId)
1088 {
1089 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1090 pRoot->setAttribute(XML_FILENAME_ATTR, fileName);
1091
1092 File copyFile(fileName);
1093 copyFile.open(File::READ);
1094
1095 pRoot->setAttribute(XML_FILESIZE_ATTR, Chain(copyFile.Size()));
1096
1097 _xml.getDocument()->clear();
1098 _xml.getDocument()->setRootElement(pRoot);
1099 _xml.getDocument()->setDocType(XML_COPY_FILE_REQUEST);
1100
1101 Chain request;
1102 _xml.getXMLChain(request);
1103 _xml.getDocument()->clear();
1104
1105 _pN->setMsg(request, request.length());
1106
1107 #ifdef CGDEBUG
1108 _pModule->log(_modId, Logger::DEBUG, Chain("Sending request ") + request);
1109 #endif
1110
1111 _pN->writeMsg();
1112
1113 _pN->readMsg();
1114
1115 #ifdef CGDEBUG
1116 _pModule->log(_modId, Logger::DEBUG, Chain("Got response ") + _pN->getMsg());
1117 #endif
1118
1119 _xml.getDocument()->clear();
1120 _xml.setChain( _pN->getMsg() );
1121 _xml.parse();
1122
1123 Chain docType = _xml.getDocument()->getDocType();
1124
1125 CegoAdminHandler::ResultType res = ADM_OK;
1126
1127 if ( docType == Chain(XML_OK_DOC) )
1128 {
1129
1130 #ifdef CGDEBUG
1131 _pModule->log(_modId, Logger::DEBUG, Chain("Sending file data for ") + fileName);
1132 #endif
1133
1134
1135 char buf[NETMNG_MSG_BUFLEN];
1136 int len;
1137
1138 int sentByte = 0;
1139 while ( ( len = copyFile.readByte(buf, NETMNG_MSG_BUFLEN) ) > 0 )
1140 {
1141 _pN->setMsg(buf, len);
1142 #ifdef CGDEBUG
1143 _pModule->log(_modId, Logger::DEBUG, Chain("Sending ") + Chain(len) + Chain(" bytes"));
1144 #endif
1145
1146 _pN->writeMsg();
1147 _pN->recvAck();
1148
1149 sentByte += len;
1150
1151 }
1152 res = ADM_OK;
1153 }
1154 else // if ( docType == Chain(XML_ERROR_DOC) )
1155 {
1156 res = ADM_ERROR;
1157 }
1158
1159 copyFile.close();
1160 return res;
1161 }
1162
reqGetDbSpec(Chain & dbSpec)1163 CegoAdminHandler::ResultType CegoAdminHandler::reqGetDbSpec(Chain& dbSpec)
1164 {
1165 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1166
1167 _xml.getDocument()->clear();
1168 _xml.getDocument()->setRootElement(pRoot);
1169 _xml.getDocument()->setDocType(XML_GET_DBSPEC_REQUEST);
1170
1171 Chain request;
1172 _xml.getXMLChain(request);
1173 _xml.getDocument()->clear();
1174
1175 _pN->setMsg(request, request.length());
1176
1177 _pN->writeMsg();
1178
1179 _pN->readMsg();
1180
1181 _xml.getDocument()->clear();
1182 _xml.setChain( _pN->getMsg() );
1183 _xml.parse();
1184
1185 Chain docType = _xml.getDocument()->getDocType();
1186
1187 if ( docType == Chain(XML_ERROR_DOC) )
1188 return ADM_ERROR;
1189
1190
1191 if ( docType == Chain(XML_OK_DOC) )
1192 {
1193 pRoot = _xml.getDocument()->getRootElement();
1194
1195 if ( pRoot )
1196 {
1197 ListT<Element*> specList = pRoot->getChildren(XML_DATABASE_ELEMENT);
1198
1199 Element** pSpec = specList.First();
1200
1201 if ( pSpec )
1202 {
1203
1204 Document *pDoc = new Document(XML_CEGO);
1205 pDoc->setAttribute(XML_VERSION_ATTR, XML_VERSION_VALUE);
1206 XMLSuite xml;
1207 xml.setDocument(pDoc);
1208
1209 pDoc->setRootElement(*pSpec);
1210 pDoc->setDocType(XML_CEGO_DB_CONFIG_DOC);
1211
1212 xml.getXMLChain(dbSpec);
1213
1214 delete pDoc;
1215 }
1216 }
1217 }
1218 return ADM_OK;
1219 }
1220
reqGetNodeList()1221 CegoAdminHandler::ResultType CegoAdminHandler::reqGetNodeList()
1222 {
1223 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1224 return sendReq(XML_GET_NODELIST_REQUEST, pRoot);
1225 }
1226
reqGetDbInfo()1227 CegoAdminHandler::ResultType CegoAdminHandler::reqGetDbInfo()
1228 {
1229 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1230 return sendReq(XML_GET_DBINFO_REQUEST, pRoot);
1231 }
1232
reqGetTSInfo(const Chain & tableSet)1233 CegoAdminHandler::ResultType CegoAdminHandler::reqGetTSInfo(const Chain& tableSet)
1234 {
1235 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1236 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1237 return sendReq(XML_GET_TSINFO_REQUEST, pRoot);
1238 }
1239
reqPropTSInfo(Element * pTSInfo)1240 CegoAdminHandler::ResultType CegoAdminHandler::reqPropTSInfo(Element *pTSInfo)
1241 {
1242 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1243 pRoot->addContent(pTSInfo);
1244 return sendReq(XML_PROP_TSINFO_REQUEST, pRoot);
1245 }
1246
reqSetTableSetNode(const Chain & tableSet,const Chain & primary,const Chain & secondary,const Chain & mediator)1247 CegoAdminHandler::ResultType CegoAdminHandler::reqSetTableSetNode(const Chain& tableSet, const Chain& primary, const Chain& secondary, const Chain& mediator)
1248 {
1249 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1250 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1251 pRoot->setAttribute(XML_PRIMARY_ATTR, primary);
1252 pRoot->setAttribute(XML_SECONDARY_ATTR, secondary);
1253 pRoot->setAttribute(XML_MEDIATOR_ATTR, mediator);
1254 return sendReq(XML_SET_TABLESETNODE_REQUEST, pRoot);
1255 }
1256
reqSetLSN(const Chain & tableSet,unsigned long long lsn)1257 CegoAdminHandler::ResultType CegoAdminHandler::reqSetLSN(const Chain& tableSet, unsigned long long lsn)
1258 {
1259 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1260 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1261 pRoot->setAttribute(XML_LSN_ATTR, Chain(lsn));
1262 return sendReq(XML_SET_LSN_REQUEST, pRoot);
1263 }
1264
reqSetRunState(const Chain & tableSet,const Chain & runState)1265 CegoAdminHandler::ResultType CegoAdminHandler::reqSetRunState(const Chain& tableSet, const Chain& runState)
1266 {
1267 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1268 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1269 pRoot->setAttribute(XML_RUNSTATE_ATTR, runState);
1270 return sendReq(XML_SET_RUNSTATE_REQUEST, pRoot);
1271 }
1272
reqSetSyncState(const Chain & tableSet,const Chain & syncState)1273 CegoAdminHandler::ResultType CegoAdminHandler::reqSetSyncState(const Chain& tableSet, const Chain& syncState)
1274 {
1275 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1276 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1277 pRoot->setAttribute(XML_SYNCSTATE_ATTR, syncState);
1278 return sendReq(XML_SET_SYNCSTATE_REQUEST, pRoot);
1279 }
1280
reqExportTableSet(const Chain & tableSet,bool isStructure,const Chain & exportFile,const Chain & expMode)1281 CegoAdminHandler::ResultType CegoAdminHandler::reqExportTableSet(const Chain& tableSet, bool isStructure, const Chain& exportFile, const Chain& expMode)
1282 {
1283 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1284 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1285 pRoot->setAttribute(XML_FILENAME_ATTR, exportFile);
1286 if ( isStructure )
1287 pRoot->setAttribute(XML_ISSTRUCT_ATTR, XML_TRUE_VALUE);
1288 else
1289 pRoot->setAttribute(XML_ISSTRUCT_ATTR, XML_FALSE_VALUE);
1290 pRoot->setAttribute(XML_MODE_ATTR, expMode);
1291
1292 return sendReq(XML_EXPORT_TABLESET_REQUEST, pRoot);
1293 }
1294
reqImportTableSet(const Chain & tableSet,bool isStructure,const Chain & importFile,const Chain & impMode)1295 CegoAdminHandler::ResultType CegoAdminHandler::reqImportTableSet(const Chain& tableSet, bool isStructure, const Chain& importFile, const Chain& impMode)
1296 {
1297 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1298 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1299 pRoot->setAttribute(XML_FILENAME_ATTR, importFile);
1300 if ( isStructure )
1301 pRoot->setAttribute(XML_ISSTRUCT_ATTR, XML_TRUE_VALUE);
1302 else
1303 pRoot->setAttribute(XML_ISSTRUCT_ATTR, XML_FALSE_VALUE);
1304
1305 pRoot->setAttribute(XML_MODE_ATTR, impMode);
1306 return sendReq(XML_IMPORT_TABLESET_REQUEST, pRoot);
1307 }
1308
reqExportTable(const Chain & tableSet,const Chain & tableName,const Chain & exportFile,const Chain & expMode)1309 CegoAdminHandler::ResultType CegoAdminHandler::reqExportTable(const Chain& tableSet, const Chain& tableName, const Chain& exportFile, const Chain& expMode)
1310 {
1311 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1312 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1313 pRoot->setAttribute(XML_TABLENAME_ATTR, tableName);
1314 pRoot->setAttribute(XML_FILENAME_ATTR, exportFile);
1315 pRoot->setAttribute(XML_MODE_ATTR, expMode);
1316 return sendReq(XML_EXPORT_TABLE_REQUEST, pRoot);
1317 }
1318
reqImportTable(const Chain & tableSet,const Chain & tableName,const Chain & importFile,const Chain & impMode)1319 CegoAdminHandler::ResultType CegoAdminHandler::reqImportTable(const Chain& tableSet, const Chain& tableName, const Chain& importFile, const Chain& impMode)
1320 {
1321 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1322 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1323 pRoot->setAttribute(XML_TABLENAME_ATTR, tableName);
1324 pRoot->setAttribute(XML_FILENAME_ATTR, importFile);
1325 pRoot->setAttribute(XML_MODE_ATTR, impMode);
1326 return sendReq(XML_IMPORT_TABLE_REQUEST, pRoot);
1327 }
1328
reqAddDataFile(const Chain & tableSet,const Chain & type,int fileId,const Chain & dataFile,int fileSize)1329 CegoAdminHandler::ResultType CegoAdminHandler::reqAddDataFile(const Chain& tableSet, const Chain& type, int fileId, const Chain& dataFile, int fileSize)
1330 {
1331 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1332 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1333 pRoot->setAttribute(XML_TYPE_ATTR, type);
1334 pRoot->setAttribute(XML_FILEID_ATTR, Chain(fileId));
1335 pRoot->setAttribute(XML_FILENAME_ATTR, dataFile);
1336 pRoot->setAttribute(XML_FILESIZE_ATTR, Chain(fileSize));
1337 return sendReq(XML_ADD_DATAFILE_REQUEST, pRoot);
1338 }
1339
reqShowUser()1340 CegoAdminHandler::ResultType CegoAdminHandler::reqShowUser()
1341 {
1342 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1343 return sendReq(XML_SHOW_USER_REQUEST, pRoot);
1344 }
1345
reqAddUser(const Chain & user,const Chain & password)1346 CegoAdminHandler::ResultType CegoAdminHandler::reqAddUser(const Chain& user, const Chain& password)
1347 {
1348 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1349 pRoot->setAttribute(XML_NAME_ATTR, user);
1350 AESCrypt aescrypt(CEGOAESKEY, CEGOAESKEYLEN);
1351 pRoot->setAttribute(XML_PASSWD_ATTR, aescrypt.encrypt(password));
1352
1353 return sendReq(XML_ADD_USER_REQUEST, pRoot);
1354 }
1355
reqRemoveUser(const Chain & user)1356 CegoAdminHandler::ResultType CegoAdminHandler::reqRemoveUser(const Chain& user)
1357 {
1358 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1359 pRoot->setAttribute(XML_NAME_ATTR, user);
1360 return sendReq(XML_REMOVE_USER_REQUEST, pRoot);
1361 }
1362
reqChangePwd(const Chain & user,const Chain & password)1363 CegoAdminHandler::ResultType CegoAdminHandler::reqChangePwd(const Chain& user, const Chain& password)
1364 {
1365 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1366 pRoot->setAttribute(XML_NAME_ATTR, user);
1367 AESCrypt aescrypt(CEGOAESKEY, CEGOAESKEYLEN);
1368 pRoot->setAttribute(XML_PASSWD_ATTR, aescrypt.encrypt(password));
1369
1370 return sendReq(XML_CHANGE_PWD_REQUEST, pRoot);
1371 }
1372
reqListRole()1373 CegoAdminHandler::ResultType CegoAdminHandler::reqListRole()
1374 {
1375 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1376 return sendReq(XML_LIST_ROLE_REQUEST, pRoot);
1377 }
1378
reqShowRole(const Chain & role)1379 CegoAdminHandler::ResultType CegoAdminHandler::reqShowRole(const Chain& role)
1380 {
1381 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1382 pRoot->setAttribute(XML_ROLE_ATTR, role);
1383 return sendReq(XML_SHOW_ROLE_REQUEST, pRoot);
1384 }
1385
reqCreateRole(const Chain & role)1386 CegoAdminHandler::ResultType CegoAdminHandler::reqCreateRole(const Chain& role)
1387 {
1388 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1389 pRoot->setAttribute(XML_ROLE_ATTR, role);
1390 return sendReq(XML_CREATE_ROLE_REQUEST, pRoot);
1391 }
1392
reqDropRole(const Chain & role)1393 CegoAdminHandler::ResultType CegoAdminHandler::reqDropRole(const Chain& role)
1394 {
1395 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1396 pRoot->setAttribute(XML_ROLE_ATTR, role);
1397 return sendReq(XML_DROP_ROLE_REQUEST, pRoot);
1398 }
1399
reqAssignRole(const Chain & user,const Chain & role)1400 CegoAdminHandler::ResultType CegoAdminHandler::reqAssignRole(const Chain& user, const Chain& role)
1401 {
1402 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1403 pRoot->setAttribute(XML_NAME_ATTR, user);
1404 pRoot->setAttribute(XML_ROLE_ATTR, role);
1405 return sendReq(XML_ASSIGN_ROLE_REQUEST, pRoot);
1406 }
1407
reqRemoveRole(const Chain & user,const Chain & role)1408 CegoAdminHandler::ResultType CegoAdminHandler::reqRemoveRole(const Chain& user, const Chain& role)
1409 {
1410 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1411 pRoot->setAttribute(XML_NAME_ATTR, user);
1412 pRoot->setAttribute(XML_ROLE_ATTR, role);
1413 return sendReq(XML_REMOVE_ROLE_REQUEST, pRoot);
1414 }
1415
reqSetPermission(const Chain & role,const Chain & permid,const Chain & tableSet,const Chain & filter,const Chain & perm)1416 CegoAdminHandler::ResultType CegoAdminHandler::reqSetPermission(const Chain& role, const Chain& permid, const Chain& tableSet, const Chain& filter, const Chain& perm)
1417 {
1418 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1419 pRoot->setAttribute(XML_ROLE_ATTR, role);
1420 pRoot->setAttribute(XML_PERMID_ATTR, permid);
1421 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1422 pRoot->setAttribute(XML_FILTER_ATTR, filter);
1423 pRoot->setAttribute(XML_PERM_ATTR, perm);
1424 return sendReq(XML_SET_PERM_REQUEST, pRoot);
1425 }
1426
reqRemovePermission(const Chain & role,const Chain & permid)1427 CegoAdminHandler::ResultType CegoAdminHandler::reqRemovePermission(const Chain& role, const Chain& permid)
1428 {
1429 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1430 pRoot->setAttribute(XML_ROLE_ATTR, role);
1431 pRoot->setAttribute(XML_PERMID_ATTR, permid);
1432 return sendReq(XML_REMOVE_PERM_REQUEST, pRoot);
1433 }
1434
reqUserTrace(const Chain & user,bool isOn)1435 CegoAdminHandler::ResultType CegoAdminHandler::reqUserTrace( const Chain& user, bool isOn)
1436 {
1437 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1438 pRoot->setAttribute(XML_NAME_ATTR, user);
1439 if ( isOn )
1440 pRoot->setAttribute(XML_TRACE_ATTR, XML_ON_VALUE);
1441 else
1442 pRoot->setAttribute(XML_TRACE_ATTR, XML_OFF_VALUE);
1443
1444 return sendReq(XML_USER_TRACE_REQUEST, pRoot);
1445 }
1446
reqAddArchLog(const Chain & tableSet,const Chain & archId,const Chain & archPath)1447 CegoAdminHandler::ResultType CegoAdminHandler::reqAddArchLog(const Chain& tableSet, const Chain& archId, const Chain& archPath)
1448 {
1449 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1450 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1451 pRoot->setAttribute(XML_ARCHID_ATTR, archId);
1452 pRoot->setAttribute(XML_ARCHPATH_ATTR, archPath);
1453 return sendReq(XML_ADD_ARCHLOG_REQUEST, pRoot);
1454 }
1455
reqBeginBackup(const Chain & tableSet)1456 CegoAdminHandler::ResultType CegoAdminHandler::reqBeginBackup(const Chain& tableSet)
1457 {
1458 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1459 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1460 return sendReq(XML_BEGIN_BACKUP_REQUEST, pRoot);
1461 }
1462
reqExecuteBackup(const Chain & tableSet)1463 CegoAdminHandler::ResultType CegoAdminHandler::reqExecuteBackup(const Chain& tableSet)
1464 {
1465 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1466 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1467 return sendReq(XML_EXECUTE_BACKUP_REQUEST, pRoot);
1468 }
1469
reqEndBackup(const Chain & tableSet,bool keepTicket)1470 CegoAdminHandler::ResultType CegoAdminHandler::reqEndBackup(const Chain& tableSet, bool keepTicket)
1471 {
1472 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1473 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1474 if ( keepTicket )
1475 pRoot->setAttribute(XML_KEEPTICKET_ATTR, XML_TRUE_VALUE);
1476 else
1477 pRoot->setAttribute(XML_KEEPTICKET_ATTR, XML_FALSE_VALUE);
1478
1479 return sendReq(XML_END_BACKUP_REQUEST, pRoot);
1480 }
1481
reqListBackup(const Chain & tableSet)1482 CegoAdminHandler::ResultType CegoAdminHandler::reqListBackup(const Chain& tableSet)
1483 {
1484 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1485 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1486 return sendReq(XML_LIST_BACKUP_REQUEST, pRoot);
1487 }
1488
reqRestore(const Chain & tableSet,const Chain & backupId)1489 CegoAdminHandler::ResultType CegoAdminHandler::reqRestore(const Chain& tableSet, const Chain& backupId)
1490 {
1491 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1492 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1493 pRoot->setAttribute(XML_BACKUPID_ATTR, backupId);
1494 return sendReq(XML_RESTORE_REQUEST, pRoot);
1495 }
1496
reqRecover(const Chain & tableSet,int pit)1497 CegoAdminHandler::ResultType CegoAdminHandler::reqRecover(const Chain& tableSet, int pit)
1498 {
1499 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1500 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1501 pRoot->setAttribute(XML_PIT_ATTR, Chain(pit));
1502 return sendReq(XML_RECOVER_REQUEST, pRoot);
1503 }
1504
reqSecSwitch(const Chain & tableSet,const Chain & secondary)1505 CegoAdminHandler::ResultType CegoAdminHandler::reqSecSwitch(const Chain& tableSet, const Chain& secondary)
1506 {
1507 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1508 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1509 pRoot->setAttribute(XML_SECONDARY_ATTR, secondary);
1510 return sendReq(XML_SECSWITCH_REQUEST, pRoot);
1511 }
1512
reqRemoveArchLog(const Chain & tableSet,const Chain & archId)1513 CegoAdminHandler::ResultType CegoAdminHandler::reqRemoveArchLog(const Chain& tableSet, const Chain& archId)
1514 {
1515 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1516 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1517 pRoot->setAttribute(XML_ARCHID_ATTR, archId);
1518 return sendReq(XML_REMOVE_ARCHLOG_REQUEST, pRoot);
1519 }
1520
reqGetDetailedTSInfo(const Chain & tableSet)1521 CegoAdminHandler::ResultType CegoAdminHandler::reqGetDetailedTSInfo(const Chain& tableSet)
1522 {
1523 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1524 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1525 return sendReq(XML_GET_DETAILED_TSINFO_REQUEST, pRoot);
1526 }
1527
reqGetBUStatInfo(const Chain & tableSet)1528 CegoAdminHandler::ResultType CegoAdminHandler::reqGetBUStatInfo(const Chain& tableSet)
1529 {
1530 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1531 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1532 return sendReq(XML_GET_BUSTAT_REQUEST, pRoot);
1533 }
1534
reqGetObjectInfo(const Chain & tableSet)1535 CegoAdminHandler::ResultType CegoAdminHandler::reqGetObjectInfo(const Chain& tableSet)
1536 {
1537 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1538 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1539 return sendReq(XML_GET_OBJECT_INFO_REQUEST, pRoot);
1540 }
1541
reqGetTransactionInfo(const Chain & tableSet)1542 CegoAdminHandler::ResultType CegoAdminHandler::reqGetTransactionInfo(const Chain& tableSet)
1543 {
1544 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1545 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1546 return sendReq(XML_GET_TRANSACTION_INFO_REQUEST, pRoot);
1547 }
1548
reqDumpObject(const Chain & tableSet,CegoObject::ObjectType type,const Chain & objName)1549 CegoAdminHandler::ResultType CegoAdminHandler::reqDumpObject(const Chain& tableSet, CegoObject::ObjectType type, const Chain& objName)
1550 {
1551 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1552 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1553
1554 pRoot->setAttribute(XML_OBJTYPE_ATTR, CegoTypeConverter::getObjectTypeString(type));
1555 pRoot->setAttribute(XML_OBJNAME_ATTR, objName);
1556 return sendReq(XML_DUMP_OBJECT_REQUEST, pRoot);
1557 }
1558
reqSetLogMng(const Chain & progName,int timeout)1559 CegoAdminHandler::ResultType CegoAdminHandler::reqSetLogMng(const Chain& progName, int timeout)
1560 {
1561 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1562 pRoot->setAttribute(XML_LOGMNGPROG_ATTR, progName);
1563 pRoot->setAttribute(XML_LOGMNGTIMEOUT_ATTR, Chain(timeout));
1564 return sendReq(XML_SET_LOGMNG_REQUEST, pRoot);
1565 }
1566
reqSetBackupMng(const Chain & progName)1567 CegoAdminHandler::ResultType CegoAdminHandler::reqSetBackupMng(const Chain& progName)
1568 {
1569 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1570 pRoot->setAttribute(XML_BACKUPMNGPROG_ATTR, progName);
1571 return sendReq(XML_SET_BACKUPMNG_REQUEST, pRoot);
1572 }
1573
reqShowLogMng()1574 CegoAdminHandler::ResultType CegoAdminHandler::reqShowLogMng()
1575 {
1576 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1577 return sendReq(XML_SHOW_LOGMNG_REQUEST, pRoot);
1578 }
1579
reqShowBackupMng()1580 CegoAdminHandler::ResultType CegoAdminHandler::reqShowBackupMng()
1581 {
1582 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1583 return sendReq(XML_SHOW_BACKUPMNG_REQUEST, pRoot);
1584 }
1585
reqSetCheckpoint(const Chain & tableSet,int timeout)1586 CegoAdminHandler::ResultType CegoAdminHandler::reqSetCheckpoint(const Chain& tableSet, int timeout)
1587 {
1588 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1589 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1590 pRoot->setAttribute(XML_TIMEOUT_ATTR, Chain(timeout));
1591 return sendReq(XML_SET_CHECKPOINT_REQUEST, pRoot);
1592 }
1593
reqSetTSInitFile(const Chain & tableSet,const Chain & initFile)1594 CegoAdminHandler::ResultType CegoAdminHandler::reqSetTSInitFile(const Chain& tableSet, const Chain& initFile)
1595 {
1596 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1597 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1598 pRoot->setAttribute(XML_TSINITFILE_ATTR, initFile);
1599 return sendReq(XML_SET_TSINITFILE_REQUEST, pRoot);
1600 }
1601
reqSetTSSysSize(const Chain & tableSet,int sysSize)1602 CegoAdminHandler::ResultType CegoAdminHandler::reqSetTSSysSize(const Chain& tableSet, int sysSize)
1603 {
1604 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1605 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1606 pRoot->setAttribute(XML_SYSSIZE_ATTR, Chain(sysSize));
1607 return sendReq(XML_SET_TSSYSSIZE_REQUEST, pRoot);
1608 }
1609
reqSetTSTmpSize(const Chain & tableSet,int tmpSize)1610 CegoAdminHandler::ResultType CegoAdminHandler::reqSetTSTmpSize(const Chain& tableSet, int tmpSize)
1611 {
1612 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1613 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1614 pRoot->setAttribute(XML_TMPSIZE_ATTR, Chain(tmpSize));
1615 return sendReq(XML_SET_TSTMPSIZE_REQUEST, pRoot);
1616 }
1617
reqSetTSAppSize(const Chain & tableSet,int appSize)1618 CegoAdminHandler::ResultType CegoAdminHandler::reqSetTSAppSize(const Chain& tableSet, int appSize)
1619 {
1620 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1621 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1622 pRoot->setAttribute(XML_APPSIZE_ATTR, Chain(appSize));
1623 return sendReq(XML_SET_TSAPPSIZE_REQUEST, pRoot);
1624 }
1625
reqSetTSRootPath(const Chain & tableSet,const Chain & tsRoot)1626 CegoAdminHandler::ResultType CegoAdminHandler::reqSetTSRootPath(const Chain& tableSet, const Chain& tsRoot)
1627 {
1628 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1629 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1630 pRoot->setAttribute(XML_TSROOT_ATTR, tsRoot);
1631 return sendReq(XML_SET_TSROOTPATH_REQUEST, pRoot);
1632 }
1633
reqSetTSLogNum(const Chain & tableSet,int logNum)1634 CegoAdminHandler::ResultType CegoAdminHandler::reqSetTSLogNum(const Chain& tableSet, int logNum)
1635 {
1636 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1637 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1638 pRoot->setAttribute(XML_LOGFILENUM_ATTR, Chain(logNum));
1639 return sendReq(XML_SET_TSLOGNUM_REQUEST, pRoot);
1640 }
1641
reqSetTSLogSize(const Chain & tableSet,int logSize)1642 CegoAdminHandler::ResultType CegoAdminHandler::reqSetTSLogSize(const Chain& tableSet, int logSize)
1643 {
1644 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1645 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1646 pRoot->setAttribute(XML_LOGFILESIZE_ATTR, Chain(logSize));
1647 return sendReq(XML_SET_TSLOGSIZE_REQUEST, pRoot);
1648 }
1649
reqSetTSSortAreaSize(const Chain & tableSet,unsigned long long sortAreaSize)1650 CegoAdminHandler::ResultType CegoAdminHandler::reqSetTSSortAreaSize(const Chain& tableSet, unsigned long long sortAreaSize)
1651 {
1652 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1653 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1654 pRoot->setAttribute(XML_SORTAREASIZE_ATTR, Chain(sortAreaSize));
1655 return sendReq(XML_SET_TSSORTAREASIZE_REQUEST, pRoot);
1656 }
1657
reqSetTSLogUser(const Chain & tableSet,const Chain & logUser)1658 CegoAdminHandler::ResultType CegoAdminHandler::reqSetTSLogUser(const Chain& tableSet, const Chain& logUser)
1659 {
1660 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1661 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1662 pRoot->setAttribute(XML_LOGUSER_ATTR, logUser);
1663 return sendReq(XML_SET_TSLOGUSER_REQUEST, pRoot);
1664 }
1665
reqEnableTableCache(const Chain & tableSet)1666 CegoAdminHandler::ResultType CegoAdminHandler::reqEnableTableCache(const Chain& tableSet)
1667 {
1668 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1669 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1670 return sendReq(XML_ENABLE_TABLECACHE_REQUEST, pRoot);
1671 }
1672
reqDisableTableCache(const Chain & tableSet)1673 CegoAdminHandler::ResultType CegoAdminHandler::reqDisableTableCache(const Chain& tableSet)
1674 {
1675 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1676 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1677 return sendReq(XML_DISABLE_TABLECACHE_REQUEST, pRoot);
1678 }
1679
reqEnableQueryCache(const Chain & tableSet)1680 CegoAdminHandler::ResultType CegoAdminHandler::reqEnableQueryCache(const Chain& tableSet)
1681 {
1682 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1683 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1684 return sendReq(XML_ENABLE_QUERYCACHE_REQUEST, pRoot);
1685 }
1686
reqDisableQueryCache(const Chain & tableSet)1687 CegoAdminHandler::ResultType CegoAdminHandler::reqDisableQueryCache(const Chain& tableSet)
1688 {
1689 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1690 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1691 return sendReq(XML_DISABLE_QUERYCACHE_REQUEST, pRoot);
1692 }
1693
1694 ////////////////////////////////////////////////
1695 //////////// Mediator Services /////////////////
1696 ////////////////////////////////////////////////
1697
medNotifyMediator(const Chain & hostName,const Chain & status,const ListT<Chain> & tsList,const ListT<Chain> & runList,const ListT<Chain> & syncList)1698 CegoAdminHandler::ResultType CegoAdminHandler::medNotifyMediator(const Chain& hostName, const Chain& status,
1699 const ListT<Chain>& tsList, const ListT<Chain>& runList, const ListT<Chain>& syncList)
1700 {
1701 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1702 pRoot->setAttribute(XML_HOSTNAME_ATTR, hostName);
1703 pRoot->setAttribute(XML_STATUS_ATTR, status);
1704
1705 Chain *pTS = tsList.First();
1706 Chain *pSync = syncList.First();
1707 Chain *pRun = runList.First();
1708 while ( pTS && pSync )
1709 {
1710 Element* pTE = new Element(XML_TABLESET_ELEMENT);
1711 pTE->setAttribute(XML_NAME_ATTR, *pTS);
1712 pTE->setAttribute(XML_SYNCSTATE_ATTR, *pSync);
1713 pTE->setAttribute(XML_RUNSTATE_ATTR, *pRun);
1714 pRoot->addContent(pTE);
1715
1716 pTS = tsList.Next();
1717 pSync = syncList.Next();
1718 pRun = runList.Next();
1719 }
1720
1721 return sendReq(XML_MED_NOTIFY_REQUEST, pRoot);
1722 }
1723
medStartTableSet(const Chain & tableSet,bool cleanIt,bool forceload,bool cpDump,bool noInit)1724 CegoAdminHandler::ResultType CegoAdminHandler::medStartTableSet(const Chain& tableSet, bool cleanIt, bool forceload, bool cpDump, bool noInit)
1725 {
1726 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1727 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1728 if ( cleanIt )
1729 pRoot->setAttribute(XML_CLEANUP_ATTR, XML_TRUE_VALUE);
1730 else
1731 pRoot->setAttribute(XML_CLEANUP_ATTR, XML_FALSE_VALUE);
1732
1733 if ( forceload )
1734 pRoot->setAttribute(XML_FORCELOAD_ATTR, XML_TRUE_VALUE);
1735 else
1736 pRoot->setAttribute(XML_FORCELOAD_ATTR, XML_FALSE_VALUE);
1737
1738 if ( cpDump )
1739 pRoot->setAttribute(XML_CPDUMP_ATTR, XML_TRUE_VALUE);
1740 else
1741 pRoot->setAttribute(XML_CPDUMP_ATTR, XML_FALSE_VALUE);
1742
1743 if ( noInit )
1744 pRoot->setAttribute(XML_NOINIT_ATTR, XML_TRUE_VALUE);
1745 else
1746 pRoot->setAttribute(XML_NOINIT_ATTR, XML_FALSE_VALUE);
1747
1748 return sendReq(XML_MED_START_TABLESET_REQUEST, pRoot);
1749 }
1750
medStopTableSet(const Chain & tableSet)1751 CegoAdminHandler::ResultType CegoAdminHandler::medStopTableSet(const Chain& tableSet)
1752 {
1753 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1754 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1755 return sendReq(XML_MED_STOP_TABLESET_REQUEST, pRoot);
1756 }
1757
medDefineTableSet(const Chain & tableSet,const Chain & tsRoot,const Chain & primary,const Chain & secondary,int sysFileSize,int tmpFileSize,int appFileSize,int logFileSize,int logFileNum,unsigned long long sortAreaSize)1758 CegoAdminHandler::ResultType CegoAdminHandler::medDefineTableSet(const Chain& tableSet,
1759 const Chain& tsRoot,
1760 const Chain& primary,
1761 const Chain& secondary,
1762 int sysFileSize,
1763 int tmpFileSize,
1764 int appFileSize,
1765 int logFileSize,
1766 int logFileNum,
1767 unsigned long long sortAreaSize)
1768 {
1769 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1770 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1771 pRoot->setAttribute(XML_TSROOT_ATTR, tsRoot);
1772 pRoot->setAttribute(XML_PRIMARY_ATTR, primary);
1773 pRoot->setAttribute(XML_SECONDARY_ATTR, secondary);
1774 pRoot->setAttribute(XML_SYSSIZE_ATTR, Chain(sysFileSize));
1775 pRoot->setAttribute(XML_TMPSIZE_ATTR, Chain(tmpFileSize));
1776 pRoot->setAttribute(XML_APPSIZE_ATTR, Chain(appFileSize));
1777 pRoot->setAttribute(XML_LOGFILESIZE_ATTR, Chain(logFileSize));
1778 pRoot->setAttribute(XML_LOGFILENUM_ATTR, Chain(logFileNum));
1779 pRoot->setAttribute(XML_SORTAREASIZE_ATTR, Chain(sortAreaSize));
1780 return sendReq(XML_MED_DEFINE_TABLESET_REQUEST, pRoot);
1781 }
1782
medDropTableSet(const Chain & tableSet)1783 CegoAdminHandler::ResultType CegoAdminHandler::medDropTableSet(const Chain& tableSet)
1784 {
1785 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1786 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1787 return sendReq(XML_MED_DROP_TABLESET_REQUEST, pRoot);
1788 }
1789
medRemoveTableSet(const Chain & tableSet)1790 CegoAdminHandler::ResultType CegoAdminHandler::medRemoveTableSet(const Chain& tableSet)
1791 {
1792 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1793 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1794 return sendReq(XML_MED_REMOVE_TABLESET_REQUEST, pRoot);
1795 }
1796
medResetTableSet(const Chain & tableSet)1797 CegoAdminHandler::ResultType CegoAdminHandler::medResetTableSet(const Chain& tableSet)
1798 {
1799 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1800 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1801 return sendReq(XML_MED_RESET_TABLESET_REQUEST, pRoot);
1802 }
1803
medCreateTableSet(const Chain & tableSet)1804 CegoAdminHandler::ResultType CegoAdminHandler::medCreateTableSet(const Chain& tableSet)
1805 {
1806 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1807 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1808 return sendReq(XML_MED_CREATE_TABLESET_REQUEST, pRoot);
1809 }
1810
medSwitchTableSet(const Chain & tableSet)1811 CegoAdminHandler::ResultType CegoAdminHandler::medSwitchTableSet(const Chain& tableSet)
1812 {
1813 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1814 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1815 return sendReq(XML_MED_SWITCH_TABLESET_REQUEST, pRoot);
1816 }
1817
medAddDataFile(const Chain & tableSet,const Chain & fileType,const Chain & dataFile,int fileSize)1818 CegoAdminHandler::ResultType CegoAdminHandler::medAddDataFile(const Chain& tableSet, const Chain& fileType, const Chain& dataFile, int fileSize)
1819 {
1820 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1821 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1822 pRoot->setAttribute(XML_TYPE_ATTR, fileType);
1823 pRoot->setAttribute(XML_FILENAME_ATTR, dataFile);
1824 pRoot->setAttribute(XML_FILESIZE_ATTR, Chain(fileSize));
1825 return sendReq(XML_MED_ADD_DATAFILE_REQUEST, pRoot);
1826 }
1827
medAddArchLog(const Chain & tableSet,const Chain & archId,const Chain & archPath)1828 CegoAdminHandler::ResultType CegoAdminHandler::medAddArchLog(const Chain& tableSet, const Chain& archId, const Chain& archPath)
1829 {
1830 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1831 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1832 pRoot->setAttribute(XML_ARCHID_ATTR, archId);
1833 pRoot->setAttribute(XML_ARCHPATH_ATTR, archPath);
1834 return sendReq(XML_MED_ADD_ARCHLOG_REQUEST, pRoot);
1835 }
1836
medRemoveArchLog(const Chain & tableSet,const Chain & archId)1837 CegoAdminHandler::ResultType CegoAdminHandler::medRemoveArchLog(const Chain& tableSet, const Chain& archId)
1838 {
1839 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1840 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1841 pRoot->setAttribute(XML_ARCHID_ATTR, archId);
1842 return sendReq(XML_MED_REMOVE_ARCHLOG_REQUEST, pRoot);
1843 }
1844
medCopyTableSet(const Chain & tableSet)1845 CegoAdminHandler::ResultType CegoAdminHandler::medCopyTableSet(const Chain& tableSet)
1846 {
1847 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1848 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1849 return sendReq(XML_MED_COPY_TABLESET_REQUEST, pRoot);
1850 }
1851
medGetTableSetList(bool getUsage)1852 CegoAdminHandler::ResultType CegoAdminHandler::medGetTableSetList(bool getUsage)
1853 {
1854 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1855 if ( getUsage )
1856 pRoot->setAttribute(XML_USAGE_ATTR, XML_TRUE_VALUE);
1857 else
1858 pRoot->setAttribute(XML_USAGE_ATTR, XML_FALSE_VALUE);
1859
1860 return sendReq(XML_MED_GET_TABLESETLIST_REQUEST, pRoot);
1861 }
1862
medGetDetailedTableSetInfo(const Chain & tableSet)1863 CegoAdminHandler::ResultType CegoAdminHandler::medGetDetailedTableSetInfo(const Chain& tableSet)
1864 {
1865 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1866 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1867 return sendReq(XML_MED_GET_DETAILEDTABLESETINFO_REQUEST, pRoot);
1868 }
1869
medGetObjectInfo(const Chain & tableSet)1870 CegoAdminHandler::ResultType CegoAdminHandler::medGetObjectInfo(const Chain& tableSet)
1871 {
1872 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1873 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1874 return sendReq(XML_MED_GET_OBJECTINFO_REQUEST, pRoot);
1875 }
1876
medGetTransactionInfo(const Chain & tableSet)1877 CegoAdminHandler::ResultType CegoAdminHandler::medGetTransactionInfo(const Chain& tableSet)
1878 {
1879 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1880 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1881 return sendReq(XML_MED_GET_TRANSACTIONINFO_REQUEST, pRoot);
1882 }
1883
medGetBUStatInfo(const Chain & tableSet)1884 CegoAdminHandler::ResultType CegoAdminHandler::medGetBUStatInfo(const Chain& tableSet)
1885 {
1886 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1887 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1888 return sendReq(XML_MED_GET_BUSTAT_REQUEST, pRoot);
1889 }
1890
medResetBUStat(const Chain & tableSet)1891 CegoAdminHandler::ResultType CegoAdminHandler::medResetBUStat(const Chain& tableSet)
1892 {
1893 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1894 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1895 return sendReq(XML_MED_RESET_BUSTAT_REQUEST, pRoot);
1896 }
1897
medBeginBackup(const Chain & tableSet,const Chain & msg)1898 CegoAdminHandler::ResultType CegoAdminHandler::medBeginBackup(const Chain& tableSet, const Chain& msg)
1899 {
1900 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1901 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1902 pRoot->setAttribute(XML_BUMSG_ATTR, msg);
1903 return sendReq(XML_MED_BEGIN_BACKUP_REQUEST, pRoot);
1904 }
1905
medExecuteBackup(const Chain & tableSet,const Chain & msg)1906 CegoAdminHandler::ResultType CegoAdminHandler::medExecuteBackup(const Chain& tableSet, const Chain& msg)
1907 {
1908 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1909 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1910 pRoot->setAttribute(XML_BUMSG_ATTR, msg);
1911 return sendReq(XML_MED_EXECUTE_BACKUP_REQUEST, pRoot);
1912 }
1913
medEndBackup(const Chain & tableSet,const Chain & msg,bool keepTicket)1914 CegoAdminHandler::ResultType CegoAdminHandler::medEndBackup(const Chain& tableSet, const Chain& msg, bool keepTicket)
1915 {
1916 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1917 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1918 pRoot->setAttribute(XML_BUMSG_ATTR, msg);
1919 if ( keepTicket )
1920 pRoot->setAttribute(XML_KEEPTICKET_ATTR, XML_TRUE_VALUE);
1921 else
1922 pRoot->setAttribute(XML_KEEPTICKET_ATTR, XML_FALSE_VALUE);
1923 return sendReq(XML_MED_END_BACKUP_REQUEST, pRoot);
1924 }
1925
medListBackup(const Chain & tableSet)1926 CegoAdminHandler::ResultType CegoAdminHandler::medListBackup(const Chain& tableSet)
1927 {
1928 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1929 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1930 return sendReq(XML_MED_LIST_BACKUP_REQUEST, pRoot);
1931 }
1932
medRestore(const Chain & tableSet,const Chain & backupId)1933 CegoAdminHandler::ResultType CegoAdminHandler::medRestore(const Chain& tableSet, const Chain& backupId)
1934 {
1935 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1936 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1937 pRoot->setAttribute(XML_BACKUPID_ATTR, backupId);
1938 return sendReq(XML_MED_RESTORE_REQUEST, pRoot);
1939 }
1940
medRecover(const Chain & tableSet,const Chain & pit)1941 CegoAdminHandler::ResultType CegoAdminHandler::medRecover(const Chain& tableSet, const Chain& pit)
1942 {
1943 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1944 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1945 pRoot->setAttribute(XML_PIT_ATTR, pit);
1946 return sendReq(XML_MED_RECOVER_REQUEST, pRoot);
1947 }
1948
medSecSwitch(const Chain & tableSet)1949 CegoAdminHandler::ResultType CegoAdminHandler::medSecSwitch(const Chain& tableSet)
1950 {
1951 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1952 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1953 return sendReq(XML_MED_SECSWITCH_REQUEST, pRoot);
1954 }
1955
medSecRelocate(const Chain & tableSet,const Chain & secondary)1956 CegoAdminHandler::ResultType CegoAdminHandler::medSecRelocate(const Chain& tableSet, const Chain& secondary)
1957 {
1958 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1959 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1960 pRoot->setAttribute(XML_SECONDARY_ATTR, secondary);
1961 return sendReq(XML_MED_SECRELOCATE_REQUEST, pRoot);
1962 }
1963
secMedSwitch(const Chain & tableSet)1964 CegoAdminHandler::ResultType CegoAdminHandler::secMedSwitch(const Chain& tableSet)
1965 {
1966 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1967 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1968 return sendReq(XML_SEC_MEDSWITCH_REQUEST, pRoot);
1969 }
1970
medEnableArchLog(const Chain & tableSet)1971 CegoAdminHandler::ResultType CegoAdminHandler::medEnableArchLog(const Chain& tableSet)
1972 {
1973 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1974 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1975 return sendReq(XML_MED_ENABLE_ARCHLOG_REQUEST, pRoot);
1976 }
1977
medDisableArchLog(const Chain & tableSet)1978 CegoAdminHandler::ResultType CegoAdminHandler::medDisableArchLog(const Chain& tableSet)
1979 {
1980 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1981 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1982 return sendReq(XML_MED_DISABLE_ARCHLOG_REQUEST, pRoot);
1983 }
1984
medEnableAutoCorrect(const Chain & tableSet)1985 CegoAdminHandler::ResultType CegoAdminHandler::medEnableAutoCorrect(const Chain& tableSet)
1986 {
1987 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1988 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1989 return sendReq(XML_MED_ENABLE_AUTOCORRECT_REQUEST, pRoot);
1990 }
1991
medDisableAutoCorrect(const Chain & tableSet)1992 CegoAdminHandler::ResultType CegoAdminHandler::medDisableAutoCorrect(const Chain& tableSet)
1993 {
1994 Element* pRoot = new Element(XML_FRAME_ELEMENT);
1995 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
1996 return sendReq(XML_MED_DISABLE_AUTOCORRECT_REQUEST, pRoot);
1997 }
1998
secMedRelocate(const Chain & tableSet,const Chain & mediator)1999 CegoAdminHandler::ResultType CegoAdminHandler::secMedRelocate(const Chain& tableSet, const Chain& mediator)
2000 {
2001 Element* pRoot = new Element(XML_FRAME_ELEMENT);
2002 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
2003 pRoot->setAttribute(XML_MEDIATOR_ATTR, mediator);
2004 return sendReq(XML_SEC_MEDRELOCATE_REQUEST, pRoot);
2005 }
2006
medCheckTableSet(const Chain & tableSet)2007 CegoAdminHandler::ResultType CegoAdminHandler::medCheckTableSet(const Chain& tableSet)
2008 {
2009 Element* pRoot = new Element(XML_FRAME_ELEMENT);
2010 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
2011 return sendReq(XML_MED_CHECK_TABLESET_REQUEST, pRoot);
2012 }
2013
medVerifyTableSet(const Chain & tableSet)2014 CegoAdminHandler::ResultType CegoAdminHandler::medVerifyTableSet(const Chain& tableSet)
2015 {
2016 Element* pRoot = new Element(XML_FRAME_ELEMENT);
2017 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
2018 return sendReq(XML_MED_VERIFY_TABLESET_REQUEST, pRoot);
2019 }
2020
medCorrectTableSet(const Chain & tableSet)2021 CegoAdminHandler::ResultType CegoAdminHandler::medCorrectTableSet(const Chain& tableSet)
2022 {
2023 Element* pRoot = new Element(XML_FRAME_ELEMENT);
2024 pRoot->setAttribute(XML_TABLESET_ATTR, tableSet);
2025 return sendReq(XML_MED_CORRECT_TABLESET_REQUEST, pRoot);
2026 }
2027
sendReq(const Chain & reqType,Element * pRoot)2028 CegoAdminHandler::ResultType CegoAdminHandler::sendReq(const Chain& reqType, Element* pRoot)
2029 {
2030 _xml.getDocument()->clear();
2031 _xml.getDocument()->setRootElement(pRoot);
2032 _xml.getDocument()->setDocType(reqType);
2033
2034 Chain request;
2035 _xml.getXMLChain(request);
2036 _xml.getDocument()->clear();
2037
2038 #ifdef CGDEBUG
2039 _pModule->log(_modId, Logger::DEBUG, Chain("--- XML ---"));
2040 _pModule->log(_modId, Logger::DEBUG, request);
2041 _pModule->log(_modId, Logger::DEBUG, Chain("--- --- ---"));
2042 #endif
2043
2044 _pN->setMsg(request, request.length());
2045
2046 _pN->writeMsg();
2047
2048 _pN->readMsg();
2049
2050 #ifdef CGDEBUG
2051 _pModule->log(_modId, Logger::DEBUG, Chain("--- XML ---"));
2052 _pModule->log(_modId, Logger::DEBUG, _pN->getMsg());
2053 _pModule->log(_modId, Logger::DEBUG, Chain("--- --- ---"));
2054 #endif
2055
2056 _xml.getDocument()->clear();
2057 _xml.setChain( _pN->getMsg() );
2058 _xml.parse();
2059
2060 Chain docType = _xml.getDocument()->getDocType();
2061
2062 if ( docType == Chain(XML_OK_DOC) )
2063 {
2064 return ADM_OK;
2065 }
2066 else if ( docType == Chain(XML_INFO_DOC) )
2067 {
2068 return ADM_INFO;
2069 }
2070 else // if ( docType == Chain(XML_ERROR_DOC) )
2071 {
2072 return ADM_ERROR;
2073 }
2074 }
2075
getMsg(Chain & msg)2076 void CegoAdminHandler::getMsg(Chain& msg)
2077 {
2078 Element *pRoot = _xml.getDocument()->getRootElement();
2079
2080 if ( pRoot )
2081 {
2082 msg = pRoot->getAttributeValue(XML_MSG_ATTR);
2083 }
2084 }
2085
getBUMsg(Chain & msg)2086 void CegoAdminHandler::getBUMsg(Chain& msg)
2087 {
2088 Element *pRoot = _xml.getDocument()->getRootElement();
2089
2090 if ( pRoot )
2091 {
2092 msg = pRoot->getAttributeValue(XML_BUMSG_ATTR);
2093 }
2094 }
2095
getUser()2096 const Chain& CegoAdminHandler::getUser()
2097 {
2098 return _user;
2099 }
2100
getPassword()2101 const Chain& CegoAdminHandler::getPassword()
2102 {
2103 return _password;
2104 }
2105
getBackupId(Chain & backupId)2106 void CegoAdminHandler::getBackupId(Chain& backupId)
2107 {
2108 Element *pRoot = _xml.getDocument()->getRootElement();
2109
2110 if ( pRoot )
2111 {
2112 backupId = pRoot->getAttributeValue(XML_BACKUPID_ATTR);
2113 }
2114 }
2115
getTableSet(Chain & tableSet)2116 void CegoAdminHandler::getTableSet(Chain& tableSet)
2117 {
2118 Element *pRoot = _xml.getDocument()->getRootElement();
2119
2120 if ( pRoot )
2121 {
2122 tableSet = pRoot->getAttributeValue(XML_TABLESET_ATTR);
2123 }
2124 }
2125
getTableSetRoot(Chain & tsRoot)2126 void CegoAdminHandler::getTableSetRoot(Chain& tsRoot)
2127 {
2128 Element *pRoot = _xml.getDocument()->getRootElement();
2129
2130 if ( pRoot )
2131 {
2132 tsRoot = pRoot->getAttributeValue(XML_TSROOT_ATTR);
2133 }
2134 }
2135
getTableSetTSTicket(Chain & tsTicket)2136 void CegoAdminHandler::getTableSetTSTicket(Chain& tsTicket)
2137 {
2138 Element *pRoot = _xml.getDocument()->getRootElement();
2139
2140 if ( pRoot )
2141 {
2142 tsTicket = pRoot->getAttributeValue(XML_TSTICKET_ATTR);
2143 }
2144 }
2145
getTableName(Chain & tableName)2146 void CegoAdminHandler::getTableName(Chain& tableName)
2147 {
2148 Element *pRoot = _xml.getDocument()->getRootElement();
2149
2150 if ( pRoot )
2151 {
2152 tableName = pRoot->getAttributeValue(XML_TABLENAME_ATTR);
2153 }
2154 }
2155
getThreadId(int & threadId)2156 void CegoAdminHandler::getThreadId(int& threadId)
2157 {
2158 Element *pRoot = _xml.getDocument()->getRootElement();
2159
2160 if ( pRoot )
2161 {
2162 threadId = pRoot->getAttributeValue(XML_THID_ATTR).asInteger();
2163 }
2164 }
2165
getEscapeCmd(Chain & escCmd)2166 void CegoAdminHandler::getEscapeCmd(Chain& escCmd)
2167 {
2168 Element *pRoot = _xml.getDocument()->getRootElement();
2169
2170 if ( pRoot )
2171 {
2172 escCmd = pRoot->getAttributeValue(XML_ESCCMD_ATTR);
2173 }
2174 }
2175
getTSInitFile(Chain & initFile)2176 void CegoAdminHandler::getTSInitFile(Chain& initFile)
2177 {
2178 Element *pRoot = _xml.getDocument()->getRootElement();
2179
2180 if ( pRoot )
2181 {
2182 initFile = pRoot->getAttributeValue(XML_TSINITFILE_ATTR);
2183 }
2184 }
2185
getTSRootPath(Chain & tsRoot)2186 void CegoAdminHandler::getTSRootPath(Chain& tsRoot)
2187 {
2188 Element *pRoot = _xml.getDocument()->getRootElement();
2189
2190 if ( pRoot )
2191 {
2192 tsRoot = pRoot->getAttributeValue(XML_TSROOT_ATTR);
2193 }
2194 }
2195
getTSLogUser(Chain & logUser)2196 void CegoAdminHandler::getTSLogUser(Chain& logUser)
2197 {
2198 Element *pRoot = _xml.getDocument()->getRootElement();
2199
2200 if ( pRoot )
2201 {
2202 logUser = pRoot->getAttributeValue(XML_LOGUSER_ATTR);
2203 }
2204 }
2205
2206
getTSTicket(Chain & tsTicket)2207 void CegoAdminHandler::getTSTicket(Chain& tsTicket)
2208 {
2209 Element *pRoot = _xml.getDocument()->getRootElement();
2210
2211 if ( pRoot )
2212 {
2213 tsTicket = pRoot->getAttributeValue(XML_TSTICKET_ATTR);
2214 }
2215 }
2216
getTSLogNum(int & logNum)2217 void CegoAdminHandler::getTSLogNum(int& logNum)
2218 {
2219 Element *pRoot = _xml.getDocument()->getRootElement();
2220
2221 if ( pRoot )
2222 {
2223 logNum = pRoot->getAttributeValue(XML_LOGFILENUM_ATTR).asInteger();
2224 }
2225 }
2226
getTSLogSize(int & logSize)2227 void CegoAdminHandler::getTSLogSize(int& logSize)
2228 {
2229 Element *pRoot = _xml.getDocument()->getRootElement();
2230
2231 if ( pRoot )
2232 {
2233 logSize = pRoot->getAttributeValue(XML_LOGFILESIZE_ATTR).asInteger();
2234 }
2235 }
2236
getTSSortAreaSize(unsigned long long & sortAreaSize)2237 void CegoAdminHandler::getTSSortAreaSize(unsigned long long& sortAreaSize)
2238 {
2239 Element *pRoot = _xml.getDocument()->getRootElement();
2240
2241 if ( pRoot )
2242 {
2243 sortAreaSize = pRoot->getAttributeValue(XML_SORTAREASIZE_ATTR).asUnsignedLongLong();
2244 }
2245 }
2246
getTimeoutValue(int & timeout)2247 void CegoAdminHandler::getTimeoutValue(int& timeout)
2248 {
2249 Element *pRoot = _xml.getDocument()->getRootElement();
2250
2251 if ( pRoot )
2252 {
2253 timeout = pRoot->getAttributeValue(XML_TIMEOUT_ATTR).asInteger();
2254 }
2255 }
2256
getFileName(Chain & fileName)2257 void CegoAdminHandler::getFileName(Chain& fileName)
2258 {
2259 Element *pRoot = _xml.getDocument()->getRootElement();
2260
2261 if ( pRoot )
2262 {
2263 fileName = pRoot->getAttributeValue(XML_FILENAME_ATTR);
2264 }
2265 }
2266
getFileType(Chain & fileType)2267 void CegoAdminHandler::getFileType(Chain& fileType)
2268 {
2269 Element *pRoot = _xml.getDocument()->getRootElement();
2270
2271 if ( pRoot )
2272 {
2273 fileType = pRoot->getAttributeValue(XML_TYPE_ATTR);
2274 }
2275 }
2276
getFileId(int & fileId)2277 void CegoAdminHandler::getFileId(int& fileId)
2278 {
2279 Element *pRoot = _xml.getDocument()->getRootElement();
2280
2281 if ( pRoot )
2282 {
2283 fileId = pRoot->getAttributeValue(XML_FILEID_ATTR).asInteger();
2284 }
2285 }
2286
getFileSize(int & fileSize)2287 void CegoAdminHandler::getFileSize(int& fileSize)
2288 {
2289 Element *pRoot = _xml.getDocument()->getRootElement();
2290
2291 if ( pRoot )
2292 {
2293 fileSize = pRoot->getAttributeValue(XML_FILESIZE_ATTR).asInteger();
2294 }
2295 }
2296
getFilter(Chain & filter)2297 void CegoAdminHandler::getFilter(Chain& filter)
2298 {
2299 Element *pRoot = _xml.getDocument()->getRootElement();
2300
2301 if ( pRoot )
2302 {
2303 filter = pRoot->getAttributeValue(XML_FILTER_ATTR);
2304 }
2305 }
2306
getSysFileId(int & sysFid)2307 void CegoAdminHandler::getSysFileId(int& sysFid)
2308 {
2309 Element *pRoot = _xml.getDocument()->getRootElement();
2310
2311 if ( pRoot )
2312 {
2313 sysFid = pRoot->getAttributeValue(XML_SYSFID_ATTR).asInteger();
2314 }
2315 }
2316
getTmpFileId(int & tmpFid)2317 void CegoAdminHandler::getTmpFileId(int& tmpFid)
2318 {
2319 Element *pRoot = _xml.getDocument()->getRootElement();
2320
2321 if ( pRoot )
2322 {
2323 tmpFid = pRoot->getAttributeValue(XML_TMPFID_ATTR).asInteger();
2324 }
2325 }
2326
getSysSize(int & sysSize)2327 void CegoAdminHandler::getSysSize(int& sysSize)
2328 {
2329 Element *pRoot = _xml.getDocument()->getRootElement();
2330
2331 if ( pRoot )
2332 {
2333 sysSize = pRoot->getAttributeValue(XML_SYSSIZE_ATTR).asInteger();
2334 }
2335 }
2336
getTmpSize(int & tmpSize)2337 void CegoAdminHandler::getTmpSize(int& tmpSize)
2338 {
2339 Element *pRoot = _xml.getDocument()->getRootElement();
2340
2341 if ( pRoot )
2342 {
2343 tmpSize = pRoot->getAttributeValue(XML_TMPSIZE_ATTR).asInteger();
2344 }
2345 }
2346
getAppSize(int & appSize)2347 void CegoAdminHandler::getAppSize(int& appSize)
2348 {
2349 Element *pRoot = _xml.getDocument()->getRootElement();
2350
2351 if ( pRoot )
2352 {
2353 appSize = pRoot->getAttributeValue(XML_APPSIZE_ATTR).asInteger();
2354 }
2355 }
2356
getLogFileSize(int & logFileSize)2357 void CegoAdminHandler::getLogFileSize(int& logFileSize)
2358 {
2359 Element *pRoot = _xml.getDocument()->getRootElement();
2360
2361 if ( pRoot )
2362 {
2363 logFileSize = pRoot->getAttributeValue(XML_LOGFILESIZE_ATTR).asInteger();
2364 }
2365 }
2366
getLogFileNum(int & logFileNum)2367 void CegoAdminHandler::getLogFileNum(int& logFileNum)
2368 {
2369 Element *pRoot = _xml.getDocument()->getRootElement();
2370
2371 if ( pRoot )
2372 {
2373 logFileNum = pRoot->getAttributeValue(XML_LOGFILENUM_ATTR).asInteger();
2374 }
2375 }
2376
getSortAreaSize(unsigned long long & sortAreaSize)2377 void CegoAdminHandler::getSortAreaSize(unsigned long long& sortAreaSize)
2378 {
2379 Element *pRoot = _xml.getDocument()->getRootElement();
2380
2381 if ( pRoot )
2382 {
2383 sortAreaSize = pRoot->getAttributeValue(XML_SORTAREASIZE_ATTR).asUnsignedLongLong();
2384 }
2385 }
2386
getTargetHost(Chain & targetHost)2387 void CegoAdminHandler::getTargetHost(Chain& targetHost)
2388 {
2389 Element *pRoot = _xml.getDocument()->getRootElement();
2390
2391 if ( pRoot )
2392 {
2393 targetHost = pRoot->getAttributeValue(XML_TARGETHOST_ATTR);
2394 }
2395 }
2396
getUser(Chain & user)2397 void CegoAdminHandler::getUser(Chain& user)
2398 {
2399 Element *pRoot = _xml.getDocument()->getRootElement();
2400
2401 if ( pRoot )
2402 {
2403 user = pRoot->getAttributeValue(XML_NAME_ATTR);
2404 }
2405 }
2406
getPassword(Chain & password)2407 void CegoAdminHandler::getPassword(Chain& password)
2408 {
2409 Element *pRoot = _xml.getDocument()->getRootElement();
2410
2411 if ( pRoot )
2412 {
2413 password = pRoot->getAttributeValue(XML_PASSWD_ATTR);
2414 }
2415 }
2416
getPerm(Chain & perm)2417 void CegoAdminHandler::getPerm(Chain& perm)
2418 {
2419 Element *pRoot = _xml.getDocument()->getRootElement();
2420
2421 if ( pRoot )
2422 {
2423 perm = pRoot->getAttributeValue(XML_PERM_ATTR);
2424 }
2425 }
2426
getPermId(Chain & permid)2427 void CegoAdminHandler::getPermId(Chain& permid)
2428 {
2429 Element *pRoot = _xml.getDocument()->getRootElement();
2430
2431 if ( pRoot )
2432 {
2433 permid = pRoot->getAttributeValue(XML_PERMID_ATTR);
2434 }
2435 }
2436
getRole(Chain & role)2437 void CegoAdminHandler::getRole(Chain& role)
2438 {
2439 Element *pRoot = _xml.getDocument()->getRootElement();
2440
2441 if ( pRoot )
2442 {
2443 role = pRoot->getAttributeValue(XML_ROLE_ATTR);
2444 }
2445 }
2446
getTrace(bool & isOn)2447 void CegoAdminHandler::getTrace(bool& isOn)
2448 {
2449 Element *pRoot = _xml.getDocument()->getRootElement();
2450
2451 if ( pRoot )
2452 {
2453 if ( pRoot->getAttributeValue(XML_TRACE_ATTR) == Chain(XML_ON_VALUE) )
2454 isOn = true;
2455 else
2456 isOn = false;
2457 }
2458 }
2459
getUsage(bool & getUsage)2460 void CegoAdminHandler::getUsage(bool& getUsage)
2461 {
2462 Element *pRoot = _xml.getDocument()->getRootElement();
2463
2464 if ( pRoot )
2465 {
2466 if ( pRoot->getAttributeValue(XML_USAGE_ATTR) == Chain(XML_TRUE_VALUE) )
2467 getUsage = true;
2468 else
2469 getUsage = false;
2470 }
2471 }
2472
getLogManager(Chain & progName)2473 void CegoAdminHandler::getLogManager(Chain& progName)
2474 {
2475 Element *pRoot = _xml.getDocument()->getRootElement();
2476
2477 if ( pRoot )
2478 {
2479 progName = pRoot->getAttributeValue(XML_LOGMNGPROG_ATTR);
2480 }
2481 }
2482
getLogManagerTimeout(int & timeout)2483 void CegoAdminHandler::getLogManagerTimeout(int& timeout)
2484 {
2485 Element *pRoot = _xml.getDocument()->getRootElement();
2486
2487 if ( pRoot )
2488 {
2489 timeout = pRoot->getAttributeValue(XML_LOGMNGTIMEOUT_ATTR).asInteger();
2490 }
2491 }
2492
getBackupManager(Chain & progName)2493 void CegoAdminHandler::getBackupManager(Chain& progName)
2494 {
2495 Element *pRoot = _xml.getDocument()->getRootElement();
2496
2497 if ( pRoot )
2498 {
2499 progName = pRoot->getAttributeValue(XML_BACKUPMNGPROG_ATTR);
2500 }
2501 }
2502
getLockCat(Chain & lockCat)2503 void CegoAdminHandler::getLockCat(Chain& lockCat)
2504 {
2505 Element *pRoot = _xml.getDocument()->getRootElement();
2506
2507 if ( pRoot )
2508 {
2509 lockCat = pRoot->getAttributeValue(XML_LOCKCAT_ATTR);
2510 }
2511 }
2512
getPrimary(Chain & primary)2513 void CegoAdminHandler::getPrimary(Chain& primary)
2514 {
2515 Element *pRoot = _xml.getDocument()->getRootElement();
2516
2517 if ( pRoot )
2518 {
2519 primary = pRoot->getAttributeValue(XML_PRIMARY_ATTR);
2520 }
2521 }
2522
getSecondary(Chain & secondary)2523 void CegoAdminHandler::getSecondary(Chain& secondary)
2524 {
2525 Element *pRoot = _xml.getDocument()->getRootElement();
2526
2527 if ( pRoot )
2528 {
2529 secondary = pRoot->getAttributeValue(XML_SECONDARY_ATTR);
2530 }
2531 }
2532
getMediator(Chain & mediator)2533 void CegoAdminHandler::getMediator(Chain& mediator)
2534 {
2535 Element *pRoot = _xml.getDocument()->getRootElement();
2536
2537 if ( pRoot )
2538 {
2539 mediator = pRoot->getAttributeValue(XML_MEDIATOR_ATTR);
2540 }
2541 }
2542
getLSN(unsigned long long & lsn)2543 void CegoAdminHandler::getLSN(unsigned long long& lsn)
2544 {
2545 Element *pRoot = _xml.getDocument()->getRootElement();
2546
2547 if ( pRoot )
2548 {
2549 lsn = pRoot->getAttributeValue(XML_LSN_ATTR).asUnsignedLongLong();
2550 }
2551 }
2552
getRunState(Chain & runState)2553 void CegoAdminHandler::getRunState(Chain& runState)
2554 {
2555 Element *pRoot = _xml.getDocument()->getRootElement();
2556
2557 if ( pRoot )
2558 {
2559 runState = pRoot->getAttributeValue(XML_RUNSTATE_ATTR);
2560 }
2561 }
2562
getSyncState(Chain & syncState)2563 void CegoAdminHandler::getSyncState(Chain& syncState)
2564 {
2565 Element *pRoot = _xml.getDocument()->getRootElement();
2566
2567 if ( pRoot )
2568 {
2569 syncState = pRoot->getAttributeValue(XML_SYNCSTATE_ATTR);
2570 }
2571 }
2572
getDataId(Chain & dataId)2573 void CegoAdminHandler::getDataId(Chain& dataId)
2574 {
2575 Element *pRoot = _xml.getDocument()->getRootElement();
2576
2577 if ( pRoot )
2578 {
2579 dataId = pRoot->getAttributeValue(XML_DATAID_ATTR);
2580 }
2581 }
2582
getPit(Chain & pit)2583 void CegoAdminHandler::getPit(Chain& pit)
2584 {
2585 Element *pRoot = _xml.getDocument()->getRootElement();
2586
2587 if ( pRoot )
2588 {
2589 pit = pRoot->getAttributeValue(XML_PIT_ATTR);
2590 }
2591 }
2592
getIsStructure(bool & isStructure)2593 void CegoAdminHandler::getIsStructure(bool& isStructure)
2594 {
2595 Element *pRoot = _xml.getDocument()->getRootElement();
2596
2597 if ( pRoot )
2598 {
2599 if ( pRoot->getAttributeValue(XML_ISSTRUCT_ATTR) == Chain(XML_TRUE_VALUE) )
2600 isStructure = true;
2601 else
2602 isStructure = false;
2603 }
2604 }
2605
getKeepTicket(bool & keepTicket)2606 void CegoAdminHandler::getKeepTicket(bool& keepTicket)
2607 {
2608 Element *pRoot = _xml.getDocument()->getRootElement();
2609
2610 if ( pRoot )
2611 {
2612 if ( pRoot->getAttributeValue(XML_KEEPTICKET_ATTR) == Chain(XML_TRUE_VALUE) )
2613 keepTicket = true;
2614 else
2615 keepTicket = false;
2616 }
2617 }
2618
getHostRole(Chain & hostRole)2619 void CegoAdminHandler::getHostRole(Chain& hostRole)
2620 {
2621 Element *pRoot = _xml.getDocument()->getRootElement();
2622
2623 if ( pRoot )
2624 {
2625 hostRole = pRoot->getAttributeValue(XML_HOSTROLE_ATTR);
2626 }
2627 }
2628
getHostName(Chain & hostName)2629 void CegoAdminHandler::getHostName(Chain& hostName)
2630 {
2631 Element *pRoot = _xml.getDocument()->getRootElement();
2632
2633 if ( pRoot )
2634 {
2635 hostName = pRoot->getAttributeValue(XML_HOSTNAME_ATTR);
2636 }
2637 }
2638
getHostStatus(Chain & hostStatus)2639 void CegoAdminHandler::getHostStatus(Chain& hostStatus)
2640 {
2641 Element *pRoot = _xml.getDocument()->getRootElement();
2642
2643 if ( pRoot )
2644 {
2645 hostStatus = pRoot->getAttributeValue(XML_STATUS_ATTR);
2646 }
2647 }
2648
getDataPort(int & dataPort)2649 void CegoAdminHandler::getDataPort(int& dataPort)
2650 {
2651 Element *pRoot = _xml.getDocument()->getRootElement();
2652
2653 if ( pRoot )
2654 {
2655 dataPort = pRoot->getAttributeValue(XML_DATAPORT_ATTR).asInteger();
2656 }
2657 }
2658
getAdminPort(int & adminPort)2659 void CegoAdminHandler::getAdminPort(int& adminPort)
2660 {
2661 Element *pRoot = _xml.getDocument()->getRootElement();
2662
2663 if ( pRoot )
2664 {
2665 adminPort = pRoot->getAttributeValue(XML_ADMINPORT_ATTR).asInteger();
2666 }
2667 }
2668
getArchId(Chain & archId)2669 void CegoAdminHandler::getArchId(Chain& archId)
2670 {
2671 Element *pRoot = _xml.getDocument()->getRootElement();
2672
2673 if ( pRoot )
2674 {
2675 archId = pRoot->getAttributeValue(XML_ARCHID_ATTR);
2676 }
2677 }
2678
getArchPath(Chain & archPath)2679 void CegoAdminHandler::getArchPath(Chain& archPath)
2680 {
2681 Element *pRoot = _xml.getDocument()->getRootElement();
2682
2683 if ( pRoot )
2684 {
2685 archPath = pRoot->getAttributeValue(XML_ARCHPATH_ATTR);
2686 }
2687 }
2688
getTableSyncStateList(ListT<Chain> & tsList,ListT<Chain> & runList,ListT<Chain> & syncList)2689 void CegoAdminHandler::getTableSyncStateList(ListT<Chain>& tsList, ListT<Chain>& runList, ListT<Chain>& syncList)
2690 {
2691 Element *pRoot = _xml.getDocument()->getRootElement();
2692
2693 if ( pRoot )
2694 {
2695
2696 ListT<Element*> teList = pRoot->getChildren(XML_TABLESET_ELEMENT);
2697
2698 Element **pTE = teList.First();
2699 while ( pTE )
2700 {
2701
2702 tsList.Insert((*pTE)->getAttributeValue(XML_NAME_ATTR));
2703 runList.Insert((*pTE)->getAttributeValue(XML_RUNSTATE_ATTR));
2704 syncList.Insert((*pTE)->getAttributeValue(XML_SYNCSTATE_ATTR));
2705
2706 pTE = teList.Next();
2707 }
2708 }
2709 }
2710
getMode(Chain & mode)2711 void CegoAdminHandler::getMode(Chain& mode)
2712 {
2713 Element *pRoot = _xml.getDocument()->getRootElement();
2714
2715 if ( pRoot )
2716 {
2717 mode = pRoot->getAttributeValue(XML_MODE_ATTR);
2718 }
2719 }
2720
getCleanup()2721 bool CegoAdminHandler::getCleanup()
2722 {
2723 Element *pRoot = _xml.getDocument()->getRootElement();
2724
2725 if ( pRoot )
2726 {
2727 if ( (Chain)pRoot->getAttributeValue(XML_CLEANUP_ATTR) == Chain(XML_TRUE_VALUE) )
2728 return true;
2729 else
2730 return false;
2731 }
2732 else
2733 {
2734 throw Exception(EXLOC, "No root element found");
2735 }
2736 }
2737
getForceload()2738 bool CegoAdminHandler::getForceload()
2739 {
2740 Element *pRoot = _xml.getDocument()->getRootElement();
2741
2742 if ( pRoot )
2743 {
2744 if ( (Chain)pRoot->getAttributeValue(XML_FORCELOAD_ATTR) == Chain(XML_TRUE_VALUE) )
2745 return true;
2746 else
2747 return false;
2748 }
2749 else
2750 {
2751 throw Exception(EXLOC, "No root element found");
2752 }
2753 }
2754
getCPDump()2755 bool CegoAdminHandler::getCPDump()
2756 {
2757 Element *pRoot = _xml.getDocument()->getRootElement();
2758
2759 if ( pRoot )
2760 {
2761 if ( (Chain)pRoot->getAttributeValue(XML_CPDUMP_ATTR) == Chain(XML_TRUE_VALUE) )
2762 return true;
2763 else
2764 return false;
2765 }
2766 else
2767 {
2768 throw Exception(EXLOC, "No root element found");
2769 }
2770 }
2771
getNoInit()2772 bool CegoAdminHandler::getNoInit()
2773 {
2774 Element *pRoot = _xml.getDocument()->getRootElement();
2775
2776 if ( pRoot )
2777 {
2778 if ( (Chain)pRoot->getAttributeValue(XML_NOINIT_ATTR) == Chain(XML_TRUE_VALUE) )
2779 return true;
2780 else
2781 return false;
2782 }
2783 else
2784 {
2785 throw Exception(EXLOC, "No root element found");
2786 }
2787 }
2788
getObjName(Chain & objName)2789 void CegoAdminHandler::getObjName(Chain& objName)
2790 {
2791 Element *pRoot = _xml.getDocument()->getRootElement();
2792
2793 if ( pRoot )
2794 {
2795 objName = pRoot->getAttributeValue(XML_OBJNAME_ATTR);
2796 }
2797 }
2798
getObjType(CegoObject::ObjectType & type)2799 void CegoAdminHandler::getObjType(CegoObject::ObjectType& type)
2800 {
2801 Element *pRoot = _xml.getDocument()->getRootElement();
2802
2803 if ( pRoot )
2804 {
2805 Chain objType = pRoot->getAttributeValue(XML_OBJTYPE_ATTR);
2806 type = CegoTypeConverter::getObjectTypeId(objType);
2807 }
2808 }
2809
getCacheMaxEntry(int & maxEntry)2810 void CegoAdminHandler::getCacheMaxEntry(int& maxEntry)
2811 {
2812 Element *pRoot = _xml.getDocument()->getRootElement();
2813
2814 if ( pRoot )
2815 {
2816 maxEntry = pRoot->getAttributeValue(XML_MAXQUERYCACHEENTRY_ATTR).asInteger();
2817 }
2818 }
2819
getCacheMaxSize(int & maxSize)2820 void CegoAdminHandler::getCacheMaxSize(int& maxSize)
2821 {
2822 Element *pRoot = _xml.getDocument()->getRootElement();
2823
2824 if ( pRoot )
2825 {
2826 maxSize = pRoot->getAttributeValue(XML_MAXQUERYCACHESIZE_ATTR).asInteger();
2827 }
2828 }
2829
getCacheHashRange(int & hashRange)2830 void CegoAdminHandler::getCacheHashRange(int& hashRange)
2831 {
2832 Element *pRoot = _xml.getDocument()->getRootElement();
2833
2834 if ( pRoot )
2835 {
2836 hashRange = pRoot->getAttributeValue(XML_QUERYCACHEHASHRANGE_ATTR).asInteger();
2837 }
2838 }
2839
sendInfo(const Chain & info)2840 void CegoAdminHandler::sendInfo(const Chain& info)
2841 {
2842 _xml.getDocument()->clear();
2843 _xml.getDocument()->setDocType(XML_INFO_DOC);
2844
2845 Element* pRoot = new Element(XML_FRAME_ELEMENT);
2846 pRoot->setAttribute(XML_MSG_ATTR, info);
2847
2848 _xml.getDocument()->setRootElement(pRoot);
2849
2850 Chain xmlString;
2851 _xml.getXMLChain(xmlString);
2852
2853 _xml.getDocument()->clear();
2854
2855 #ifdef CGDEBUG
2856 _pModule->log(_modId, Logger::DEBUG, Chain("--- XML ---"));
2857 _pModule->log(_modId, Logger::DEBUG, xmlString);
2858 _pModule->log(_modId, Logger::DEBUG, Chain("--- --- ---"));
2859 #endif
2860
2861 _pN->setMsg(xmlString, xmlString.length());
2862 _pN->writeMsg();
2863 if ( _pN->recvAck() == false )
2864 throw Exception(EXLOC, Chain("Admin request aborted"));
2865 }
2866
sendResponse(const Chain & msg,Element * pSubElement)2867 void CegoAdminHandler::sendResponse(const Chain& msg, Element *pSubElement)
2868 {
2869 _xml.getDocument()->clear();
2870 _xml.getDocument()->setDocType(XML_OK_DOC);
2871
2872 Element* pRoot = new Element(XML_FRAME_ELEMENT);
2873 pRoot->setAttribute(XML_MSG_ATTR, msg);
2874
2875 if ( pSubElement )
2876 pRoot->addContent(pSubElement);
2877
2878 _xml.getDocument()->setRootElement(pRoot);
2879
2880 Chain xmlString;
2881 _xml.getXMLChain(xmlString);
2882
2883 _xml.getDocument()->clear();
2884
2885 #ifdef CGDEBUG
2886 _pModule->log(_modId, Logger::DEBUG, Chain("--- XML ---"));
2887 _pModule->log(_modId, Logger::DEBUG, xmlString);
2888 _pModule->log(_modId, Logger::DEBUG, Chain("--- --- ---"));
2889 #endif
2890
2891 _pN->setMsg(xmlString, xmlString.length());
2892 _pN->writeMsg();
2893 }
2894
sendData(const Chain & data)2895 void CegoAdminHandler::sendData(const Chain& data)
2896 {
2897 _xml.getDocument()->clear();
2898 _xml.getDocument()->setDocType(XML_OK_DOC);
2899
2900 Element* pRoot = new Element(XML_FRAME_ELEMENT);
2901 pRoot->setAttribute(XML_DATALEN_ATTR, Chain(data.length()));
2902
2903 _xml.getDocument()->setRootElement(pRoot);
2904
2905 Chain xmlString;
2906 _xml.getXMLChain(xmlString);
2907
2908 #ifdef CGDEBUG
2909 _pModule->log(_modId, Logger::DEBUG, Chain("--- XML ---"));
2910 _pModule->log(_modId, Logger::DEBUG, xmlString);
2911 _pModule->log(_modId, Logger::DEBUG, Chain("--- --- ---"));
2912 #endif
2913
2914 _pN->setMsg(xmlString, xmlString.length());
2915
2916 _pN->writeMsg();
2917
2918 #ifdef CGDEBUG
2919 _pModule->log(_modId, Logger::DEBUG, Chain("Waiting for ack ..."));
2920 #endif
2921
2922 _pN->recvAck();
2923
2924 #ifdef CGDEBUG
2925 _pModule->log(_modId, Logger::DEBUG, Chain("Sending data of size ") + Chain(data.length()) + Chain(" ..."));
2926 #endif
2927
2928 _pN->setMsg(data, data.length());
2929
2930 _pN->writeMsg();
2931 }
2932
abort()2933 CegoAdminHandler::ResultType CegoAdminHandler::abort()
2934 {
2935 _pN->sendNack();
2936 _pN->readMsg();
2937
2938 _xml.getDocument()->clear();
2939 _xml.setChain( _pN->getMsg() );
2940 _xml.parse();
2941
2942 Chain docType = _xml.getDocument()->getDocType();
2943
2944 if ( docType == Chain(XML_OK_DOC) )
2945 {
2946 return ADM_OK;
2947 }
2948 else if ( docType == Chain(XML_ERROR_DOC) )
2949 {
2950 return ADM_ERROR;
2951 }
2952 else if ( docType == Chain(XML_INFO_DOC) )
2953 {
2954 return ADM_INFO;
2955 }
2956 else
2957 {
2958 throw Exception(EXLOC, "Invalid document type");
2959 }
2960 }
2961
nextInfo()2962 CegoAdminHandler::ResultType CegoAdminHandler::nextInfo()
2963 {
2964 _pN->sendAck();
2965 _pN->readMsg();
2966
2967 _xml.getDocument()->clear();
2968 _xml.setChain( _pN->getMsg() );
2969 _xml.parse();
2970
2971 Chain docType = _xml.getDocument()->getDocType();
2972
2973 if ( docType == Chain(XML_OK_DOC) )
2974 {
2975 return ADM_OK;
2976 }
2977 else if ( docType == Chain(XML_ERROR_DOC) )
2978 {
2979 return ADM_ERROR;
2980 }
2981 else if ( docType == Chain(XML_INFO_DOC) )
2982 {
2983 return ADM_INFO;
2984 }
2985 else
2986 {
2987 throw Exception(EXLOC, "Invalid document type");
2988 }
2989 }
2990
syncWithInfo(const Chain & hostRole,const Chain & hostName,const Chain & msg,Element * pInfo)2991 bool CegoAdminHandler::syncWithInfo(const Chain& hostRole, const Chain& hostName, const Chain& msg, Element *pInfo)
2992 {
2993 _xml.getDocument()->clear();
2994
2995 _xml.getDocument()->setDocType(XML_INFO_DOC);
2996
2997 Element* pRoot = new Element(XML_FRAME_ELEMENT);
2998 pRoot->setAttribute(XML_HOSTROLE_ATTR, hostRole);
2999 pRoot->setAttribute(XML_HOSTNAME_ATTR, hostName);
3000 pRoot->setAttribute(XML_MSG_ATTR, msg);
3001 if ( pInfo )
3002 pRoot->addContent(pInfo);
3003
3004 _xml.getDocument()->setRootElement(pRoot);
3005
3006 Chain xmlString;
3007 _xml.getXMLChain(xmlString);
3008
3009 #ifdef CGDEBUG
3010 _pModule->log(_modId, Logger::DEBUG, Chain("--- XML ---"));
3011 _pModule->log(_modId, Logger::DEBUG, xmlString);
3012 _pModule->log(_modId, Logger::DEBUG, Chain("--- --- ---"));
3013 #endif
3014
3015 _pN->setMsg(xmlString, xmlString.length());
3016
3017 _pN->writeMsg();
3018
3019 _xml.getDocument()->clear();
3020
3021 return _pN->recvAck();
3022 }
3023
sendError(const Chain & msg)3024 void CegoAdminHandler::sendError(const Chain& msg)
3025 {
3026 _xml.getDocument()->clear();
3027 _xml.getDocument()->setDocType(XML_ERROR_DOC);
3028
3029 Element* pRoot = new Element(XML_FRAME_ELEMENT);
3030 pRoot->setAttribute(XML_MSG_ATTR, msg);
3031
3032 _xml.getDocument()->setRootElement(pRoot);
3033
3034 Chain xmlString;
3035 _xml.getXMLChain(xmlString);
3036
3037 #ifdef CGDEBUG
3038 _pModule->log(_modId, Logger::DEBUG, Chain("--- XML ---"));
3039 _pModule->log(_modId, Logger::DEBUG, xmlString);
3040 _pModule->log(_modId, Logger::DEBUG, Chain("--- --- ---"));
3041 #endif
3042
3043 _pN->setMsg(xmlString, xmlString.length());
3044
3045 _pN->writeMsg();
3046 }
3047
getThreadInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)3048 void CegoAdminHandler::getThreadInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
3049 {
3050 Element *pRoot = _xml.getDocument()->getRootElement();
3051
3052 if ( pRoot )
3053 {
3054 ListT<Element*> threadInfoList = pRoot->getChildren(XML_THREADINFO_ELEMENT);
3055
3056 Element **pInfo = threadInfoList.First();
3057
3058 if ( pInfo )
3059 {
3060
3061 ListT<CegoField> schema;
3062 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("TYPE"),VARCHAR_TYPE, 20));
3063 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("TOTAL"), INT_TYPE, sizeof(int)));
3064 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("ACTIVE"), INT_TYPE, sizeof(int)));
3065 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("THREADINFO"), schema, Chain("THREADINFO"));
3066
3067
3068 Chain numDbThread = (*pInfo)->getAttributeValue(XML_NUMDBTHREAD_ATTR);
3069 Chain numAdmThread = (*pInfo)->getAttributeValue(XML_NUMADMTHREAD_ATTR);
3070 Chain numLogThread = (*pInfo)->getAttributeValue(XML_NUMLOGTHREAD_ATTR);
3071 Chain actDbThread = (*pInfo)->getAttributeValue(XML_ACTIVEDBTHREAD_ATTR);
3072 Chain actAdmThread = (*pInfo)->getAttributeValue(XML_ACTIVEADMTHREAD_ATTR);
3073 Chain actLogThread = (*pInfo)->getAttributeValue(XML_ACTIVELOGTHREAD_ATTR);
3074
3075
3076 CegoFieldValue f1a(VARCHAR_TYPE, Chain("DatabaseThread"));
3077 CegoFieldValue f1b(INT_TYPE, numDbThread);
3078 CegoFieldValue f1c(INT_TYPE, actDbThread);
3079 ListT<CegoFieldValue> fl1;
3080 fl1.Insert(f1a);
3081 fl1.Insert(f1b);
3082 fl1.Insert(f1c);
3083
3084 info.Insert(fl1);
3085
3086 CegoFieldValue f2a(VARCHAR_TYPE, Chain("AdminThread"));
3087 CegoFieldValue f2b(INT_TYPE, numAdmThread);
3088 CegoFieldValue f2c(INT_TYPE, actAdmThread);
3089 ListT<CegoFieldValue> fl2;
3090 fl2.Insert(f2a);
3091 fl2.Insert(f2b);
3092 fl2.Insert(f2c);
3093
3094 info.Insert(fl2);
3095
3096 CegoFieldValue f3a(VARCHAR_TYPE, Chain("LogThread"));
3097 CegoFieldValue f3b(INT_TYPE, numLogThread);
3098 CegoFieldValue f3c(INT_TYPE, actLogThread);
3099 ListT<CegoFieldValue> fl3;
3100 fl3.Insert(f3a);
3101 fl3.Insert(f3b);
3102 fl3.Insert(f3c);
3103
3104 info.Insert(fl3);
3105 }
3106 }
3107 }
3108
getDbThreadInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info,Chain & format)3109 void CegoAdminHandler::getDbThreadInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info, Chain& format)
3110 {
3111 Element *pRoot = _xml.getDocument()->getRootElement();
3112
3113 if ( pRoot )
3114 {
3115 ListT<CegoField> schema;
3116 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("THREADID"), LONG_TYPE, sizeof(long long)));
3117 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("NUMREQUEST"), LONG_TYPE, sizeof(long long)));
3118 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("NUMQUERYREQ"), LONG_TYPE, sizeof(long long)));
3119 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("THREADLOAD"), LONG_TYPE, sizeof(long long)));
3120 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("ALLOCATEDSORT"), LONG_TYPE, sizeof(long long)));
3121 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("STATUS"), VARCHAR_TYPE, 10));
3122 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("THREADINFO"), schema, Chain("THREADINFO"));
3123
3124 format = Chain("rrrrrl");
3125
3126 ListT<Element*> threadInfoList = pRoot->getChildren(XML_THREADINFO_ELEMENT);
3127
3128 Element **pInfo = threadInfoList.First();
3129
3130 if ( pInfo )
3131 {
3132 ListT<Element*> threadStateList = (*pInfo)->getChildren(XML_THREAD_ELEMENT);
3133 Element **pThreadState = threadStateList.First();
3134
3135 while ( pThreadState )
3136 {
3137 Chain threadId = (*pThreadState)->getAttributeValue(XML_THID_ATTR);
3138 Chain numRequest = (*pThreadState)->getAttributeValue(XML_NUMREQUEST_ATTR);
3139 Chain numQueryRequest = (*pThreadState)->getAttributeValue(XML_NUMQUERYREQUEST_ATTR);
3140 Chain threadLoad = (*pThreadState)->getAttributeValue(XML_THREADLOAD_ATTR);
3141 Chain allocatedSort = (*pThreadState)->getAttributeValue(XML_ALLOCATEDSORT_ATTR);
3142 Chain threadState = (*pThreadState)->getAttributeValue(XML_STATUS_ATTR);
3143
3144 CegoFieldValue f1(LONG_TYPE, threadId);
3145 CegoFieldValue f2(LONG_TYPE, numRequest);
3146 CegoFieldValue f3(LONG_TYPE, numQueryRequest);
3147 CegoFieldValue f4(LONG_TYPE, threadLoad);
3148 CegoFieldValue f5(LONG_TYPE, allocatedSort);
3149 CegoFieldValue f6(VARCHAR_TYPE, threadState);
3150
3151 ListT<CegoFieldValue> fl;
3152
3153 fl.Insert(f1);
3154 fl.Insert(f2);
3155 fl.Insert(f3);
3156 fl.Insert(f4);
3157 fl.Insert(f5);
3158 fl.Insert(f6);
3159
3160 info.Insert(fl);
3161
3162 pThreadState = threadStateList.Next();
3163 }
3164 }
3165 }
3166 }
3167
getDbThreadLastQuery(int threadId,CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info,Chain & format)3168 void CegoAdminHandler::getDbThreadLastQuery(int threadId, CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info, Chain& format)
3169 {
3170 Element *pRoot = _xml.getDocument()->getRootElement();
3171
3172 if ( pRoot )
3173 {
3174 ListT<Element*> threadInfoList = pRoot->getChildren(XML_THREADINFO_ELEMENT);
3175
3176 Element **pInfo = threadInfoList.First();
3177
3178 if ( pInfo )
3179 {
3180 ListT<Element*> threadList = (*pInfo)->getChildren(XML_THREAD_ELEMENT);
3181 Element **pThread = threadList.First();
3182
3183 unsigned int maxActionLen = 10;
3184
3185 while ( pThread )
3186 {
3187 Chain threadAction = (*pThread)->getAttributeValue(XML_LASTACTION_ATTR);
3188
3189 if ( threadAction.length() > maxActionLen )
3190 maxActionLen = threadAction.length();
3191
3192 pThread = threadList.Next();
3193 }
3194
3195 pThread = threadList.First();
3196
3197 ListT<CegoField> schema;
3198 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("LASTACTION"), VARCHAR_TYPE, maxActionLen));
3199 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("THREADINFO"), schema, Chain("THREADINFO"));
3200
3201 format = Chain("l");
3202
3203 while ( pThread )
3204 {
3205 int actThreadId = (*pThread)->getAttributeValue(XML_THID_ATTR).asInteger();
3206
3207 if ( actThreadId == threadId )
3208 {
3209 Chain threadAction = (*pThread)->getAttributeValue(XML_LASTACTION_ATTR);
3210
3211 CegoFieldValue f1(VARCHAR_TYPE, threadAction);
3212
3213 ListT<CegoFieldValue> fl;
3214
3215 fl.Insert(f1);
3216
3217 info.Insert(fl);
3218 }
3219 pThread = threadList.Next();
3220 }
3221 }
3222 }
3223 }
3224
getAdmThreadInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info,Chain & format)3225 void CegoAdminHandler::getAdmThreadInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info, Chain& format)
3226 {
3227 Element *pRoot = _xml.getDocument()->getRootElement();
3228
3229 if ( pRoot )
3230 {
3231 ListT<CegoField> schema;
3232 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("THREADID"), LONG_TYPE, sizeof(long long)));
3233 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("NUMREQUEST"), LONG_TYPE, sizeof(long long)));
3234 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("THREADLOAD"), LONG_TYPE, sizeof(long long)));
3235 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("STATUS"), VARCHAR_TYPE, 10));
3236 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("LASTACTION"), VARCHAR_TYPE, 50));
3237 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("THREADINFO"), schema, Chain("THREADINFO"));
3238
3239 format = Chain("rrrrl");
3240
3241 ListT<Element*> threadInfoList = pRoot->getChildren(XML_THREADINFO_ELEMENT);
3242
3243 Element **pInfo = threadInfoList.First();
3244
3245 if ( pInfo )
3246 {
3247 ListT<Element*> threadStateList = (*pInfo)->getChildren(XML_THREAD_ELEMENT);
3248 Element **pThreadState = threadStateList.First();
3249
3250 while ( pThreadState )
3251 {
3252 Chain threadId = (*pThreadState)->getAttributeValue(XML_THID_ATTR);
3253 Chain numRequest = (*pThreadState)->getAttributeValue(XML_NUMREQUEST_ATTR);
3254 Chain threadLoad = (*pThreadState)->getAttributeValue(XML_THREADLOAD_ATTR);
3255 Chain threadState = (*pThreadState)->getAttributeValue(XML_STATUS_ATTR);
3256 Chain threadAction = (*pThreadState)->getAttributeValue(XML_LASTACTION_ATTR);
3257
3258 CegoFieldValue f1(LONG_TYPE, threadId);
3259 CegoFieldValue f2(LONG_TYPE, numRequest);
3260 CegoFieldValue f3(LONG_TYPE, threadLoad);
3261 CegoFieldValue f4(VARCHAR_TYPE, threadState);
3262 CegoFieldValue f5(VARCHAR_TYPE, threadAction);
3263
3264 ListT<CegoFieldValue> fl;
3265
3266 fl.Insert(f1);
3267 fl.Insert(f2);
3268 fl.Insert(f3);
3269 fl.Insert(f4);
3270 fl.Insert(f5);
3271
3272 info.Insert(fl);
3273
3274 pThreadState = threadStateList.Next();
3275 }
3276 }
3277 }
3278 }
3279
getLogThreadInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info,Chain & format)3280 void CegoAdminHandler::getLogThreadInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info, Chain& format)
3281 {
3282 Element *pRoot = _xml.getDocument()->getRootElement();
3283
3284 if ( pRoot )
3285 {
3286 ListT<CegoField> schema;
3287 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("THREADID"), LONG_TYPE, sizeof(long long)));
3288 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("NUMREQUEST"), LONG_TYPE, sizeof(long long)));
3289 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("THREADLOAD"), LONG_TYPE, sizeof(long long)));
3290 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("STATUS"), VARCHAR_TYPE, 10));
3291 schema.Insert(CegoField(Chain("THREADINFO"), Chain("THREADINFO"), Chain("LASTACTION"), VARCHAR_TYPE, 50));
3292 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("THREADINFO"), schema, Chain("THREADINFO"));
3293
3294 format = Chain("rrrrl");
3295
3296 ListT<Element*> threadInfoList = pRoot->getChildren(XML_THREADINFO_ELEMENT);
3297
3298 Element **pInfo = threadInfoList.First();
3299
3300 if ( pInfo )
3301 {
3302 ListT<Element*> threadStateList = (*pInfo)->getChildren(XML_THREAD_ELEMENT);
3303 Element **pThreadState = threadStateList.First();
3304
3305 while ( pThreadState )
3306 {
3307 Chain threadId = (*pThreadState)->getAttributeValue(XML_THID_ATTR);
3308 Chain numRequest = (*pThreadState)->getAttributeValue(XML_NUMREQUEST_ATTR);
3309 Chain threadLoad = (*pThreadState)->getAttributeValue(XML_THREADLOAD_ATTR);
3310 Chain threadState = (*pThreadState)->getAttributeValue(XML_STATUS_ATTR);
3311 Chain threadAction = (*pThreadState)->getAttributeValue(XML_LASTACTION_ATTR);
3312
3313 CegoFieldValue f1(LONG_TYPE, threadId);
3314 CegoFieldValue f2(LONG_TYPE, numRequest);
3315 CegoFieldValue f3(LONG_TYPE, threadLoad);
3316 CegoFieldValue f4(VARCHAR_TYPE, threadState);
3317 CegoFieldValue f5(VARCHAR_TYPE, threadAction);
3318
3319 ListT<CegoFieldValue> fl;
3320
3321 fl.Insert(f1);
3322 fl.Insert(f2);
3323 fl.Insert(f3);
3324 fl.Insert(f4);
3325 fl.Insert(f5);
3326
3327 info.Insert(fl);
3328
3329 pThreadState = threadStateList.Next();
3330 }
3331 }
3332 }
3333 }
3334
getDbSessionInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)3335 void CegoAdminHandler::getDbSessionInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
3336 {
3337 Element *pRoot = _xml.getDocument()->getRootElement();
3338
3339 if ( pRoot )
3340 {
3341 ListT<CegoField> schema;
3342 schema.Insert(CegoField(Chain("DBSESSION"), Chain("DBSESSION"), Chain("HOST"), VARCHAR_TYPE, 10));
3343 schema.Insert(CegoField(Chain("DBSESSION"), Chain("DBSESSION"), Chain("TABLESET"), VARCHAR_TYPE, 10));
3344 schema.Insert(CegoField(Chain("DBSESSION"), Chain("DBSESSION"), Chain("USER"), VARCHAR_TYPE, 10));
3345 schema.Insert(CegoField(Chain("DBSESSION"), Chain("DBSESSION"), Chain("ISUSED"), VARCHAR_TYPE, 5));
3346 schema.Insert(CegoField(Chain("DBSESSION"), Chain("DBSESSION"), Chain("TTL"), VARCHAR_TYPE, 5));
3347
3348 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("DBSESSIONINFO"), schema, Chain("DBSESSIONINFO"));
3349
3350 ListT<Element*> sessionInfoList = pRoot->getChildren(XML_DBSESSIONINFO_ELEMENT);
3351 Element **pInfo = sessionInfoList.First();
3352
3353 if ( pInfo )
3354 {
3355 ListT<Element*> sessionList = (*pInfo)->getChildren(XML_DBSESSION_ELEMENT);
3356 Element **pSession = sessionList.First();
3357
3358 while ( pSession )
3359 {
3360 Chain hostName = (*pSession)->getAttributeValue(XML_HOSTNAME_ATTR);
3361 Chain tableSet = (*pSession)->getAttributeValue(XML_TABLESET_ATTR);
3362 Chain userName = (*pSession)->getAttributeValue(XML_USER_ATTR);
3363 Chain isUsed = (*pSession)->getAttributeValue(XML_ISUSED_ATTR);
3364 Chain ttl = (*pSession)->getAttributeValue(XML_TTL_ATTR);
3365
3366 CegoFieldValue f1(VARCHAR_TYPE, hostName);
3367 CegoFieldValue f2(VARCHAR_TYPE, tableSet);
3368 CegoFieldValue f3(VARCHAR_TYPE, userName);
3369 CegoFieldValue f4(VARCHAR_TYPE, isUsed);
3370 CegoFieldValue f5(VARCHAR_TYPE, ttl);
3371
3372 ListT<CegoFieldValue> fl;
3373
3374 fl.Insert(f1);
3375 fl.Insert(f2);
3376 fl.Insert(f3);
3377 fl.Insert(f4);
3378 fl.Insert(f5);
3379
3380 info.Insert(fl);
3381
3382 pSession = sessionList.Next();
3383 }
3384 }
3385 }
3386 }
3387
getCopyInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info,Chain & format)3388 void CegoAdminHandler::getCopyInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info, Chain& format)
3389 {
3390 Element *pRoot = _xml.getDocument()->getRootElement();
3391
3392 if ( pRoot )
3393 {
3394 ListT<CegoField> schema;
3395 schema.Insert(CegoField(Chain("COPY"), Chain("COPY"), Chain("ID"), VARCHAR_TYPE, 10));
3396 schema.Insert(CegoField(Chain("COPY"), Chain("COPY"), Chain("TABLESET"), VARCHAR_TYPE, 10));
3397 schema.Insert(CegoField(Chain("COPY"), Chain("COPY"), Chain("TARGET"), VARCHAR_TYPE, 10));
3398 schema.Insert(CegoField(Chain("COPY"), Chain("COPY"), Chain("STATUS"), VARCHAR_TYPE, 50));
3399
3400 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("COPYINFO"), schema, Chain("COPYINFO"));
3401
3402 format = Chain("rlll");
3403
3404 ListT<Element*> copyInfoList = pRoot->getChildren(XML_COPYINFO_ELEMENT);
3405
3406 Element **pInfo = copyInfoList.First();
3407
3408 if ( pInfo )
3409 {
3410 ListT<Element*> copyList = (*pInfo)->getChildren(XML_COPY_ELEMENT);
3411 Element **pCopy = copyList.First();
3412
3413 while ( pCopy )
3414 {
3415 Chain cid = (*pCopy)->getAttributeValue(XML_CID_ATTR);
3416 Chain tableSet = (*pCopy)->getAttributeValue(XML_TABLESET_ATTR);
3417 Chain targetHost = (*pCopy)->getAttributeValue(XML_HOSTNAME_ATTR);
3418 Chain status = (*pCopy)->getAttributeValue(XML_STATUS_ATTR);
3419
3420 CegoFieldValue f1(VARCHAR_TYPE, cid);
3421 CegoFieldValue f2(VARCHAR_TYPE, tableSet);
3422 CegoFieldValue f3(VARCHAR_TYPE, targetHost);
3423 CegoFieldValue f4(VARCHAR_TYPE, status);
3424
3425 ListT<CegoFieldValue> fl;
3426
3427 fl.Insert(f1);
3428 fl.Insert(f2);
3429 fl.Insert(f3);
3430 fl.Insert(f4);
3431
3432 info.Insert(fl);
3433
3434 pCopy = copyList.Next();
3435 }
3436 }
3437 }
3438 }
3439
getCacheInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info,Chain & format)3440 bool CegoAdminHandler::getCacheInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info, Chain& format)
3441 {
3442 Element *pRoot = _xml.getDocument()->getRootElement();
3443
3444 if ( pRoot )
3445 {
3446 ListT<CegoField> schema;
3447 schema.Insert(CegoField(Chain("CACHE"), Chain("CACHE"), Chain("ATTR"), VARCHAR_TYPE, 10));
3448 schema.Insert(CegoField(Chain("CACHE"), Chain("CACHE"), Chain("VALUE"), VARCHAR_TYPE, 10));
3449
3450 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("CACHEINFO"), schema, Chain("CACHEINFO"));
3451
3452 format = Chain("lr");
3453
3454 ListT<Element*> cacheInfoList = pRoot->getChildren(XML_CACHEINFO_ELEMENT);
3455
3456 Element **pInfo = cacheInfoList.First();
3457
3458 if ( pInfo )
3459 {
3460 ListT<Element*> cacheList = (*pInfo)->getChildren(XML_CACHE_ELEMENT);
3461 Element **pCache = cacheList.First();
3462
3463 while ( pCache )
3464 {
3465 Chain attrName = (*pCache)->getAttributeValue(XML_ATTRNAME_ATTR);
3466 Chain attrValue = (*pCache)->getAttributeValue(XML_VALUE_ATTR);
3467
3468 CegoFieldValue f1(VARCHAR_TYPE, attrName);
3469 CegoFieldValue f2(VARCHAR_TYPE, attrValue);
3470
3471 ListT<CegoFieldValue> fl;
3472
3473 fl.Insert(f1);
3474 fl.Insert(f2);
3475
3476 info.Insert(fl);
3477
3478 pCache = cacheList.Next();
3479 }
3480 return true;
3481 }
3482 }
3483 return false;
3484 }
3485
getCacheList(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info,Chain & format)3486 bool CegoAdminHandler::getCacheList(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info, Chain& format)
3487 {
3488 Element *pRoot = _xml.getDocument()->getRootElement();
3489
3490 if ( pRoot )
3491 {
3492 ListT<Element*> cacheInfoList = pRoot->getChildren(XML_CACHEINFO_ELEMENT);
3493
3494 Element **pInfo = cacheInfoList.First();
3495
3496 if ( pInfo )
3497 {
3498 ListT<Element*> cacheList = (*pInfo)->getChildren(XML_CACHE_ELEMENT);
3499 Element **pCache = cacheList.First();
3500
3501 int maxLen=0;
3502 while ( pCache )
3503 {
3504 Chain id = (*pCache)->getAttributeValue(XML_ID_ATTR);
3505 if ( id.length() > maxLen )
3506 maxLen = id.length();
3507
3508 pCache = cacheList.Next();
3509 }
3510
3511 if ( maxLen > INFO_MAXCACHEIDLEN )
3512 maxLen = INFO_MAXCACHEIDLEN;
3513
3514 ListT<CegoField> schema;
3515 schema.Insert(CegoField(Chain("CACHE"), Chain("CACHE"), Chain("POS"), VARCHAR_TYPE, 10));
3516 schema.Insert(CegoField(Chain("CACHE"), Chain("CACHE"), Chain("ID"), VARCHAR_TYPE, maxLen));
3517 schema.Insert(CegoField(Chain("CACHE"), Chain("CACHE"), Chain("NUMROWS"), VARCHAR_TYPE, 10));
3518 schema.Insert(CegoField(Chain("CACHE"), Chain("CACHE"), Chain("NUMHITS"), VARCHAR_TYPE, 10));
3519 schema.Insert(CegoField(Chain("CACHE"), Chain("CACHE"), Chain("SIZE"), VARCHAR_TYPE, 10));
3520
3521 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("CACHEINFO"), schema, Chain("CACHEINFO"));
3522
3523 format = Chain("lrrrr");
3524
3525 pCache = cacheList.First();
3526
3527 while ( pCache )
3528 {
3529 Chain pos = (*pCache)->getAttributeValue(XML_POS_ATTR);
3530 Chain id = (*pCache)->getAttributeValue(XML_ID_ATTR);
3531 if ( id.length() > maxLen )
3532 id = id.subChain(1, maxLen - 3) + Chain("...");
3533 Chain numRows = (*pCache)->getAttributeValue(XML_NUMROWS_ATTR);
3534 Chain numHits = (*pCache)->getAttributeValue(XML_NUMHITS_ATTR);
3535 Chain entrySize = (*pCache)->getAttributeValue(XML_SIZE_ATTR);
3536
3537 CegoFieldValue f1(VARCHAR_TYPE, pos);
3538 CegoFieldValue f2(VARCHAR_TYPE, id);
3539 CegoFieldValue f3(VARCHAR_TYPE, numRows);
3540 CegoFieldValue f4(VARCHAR_TYPE, numHits);
3541 CegoFieldValue f5(VARCHAR_TYPE, entrySize);
3542
3543 ListT<CegoFieldValue> fl;
3544
3545 fl.Insert(f1);
3546 fl.Insert(f2);
3547 fl.Insert(f3);
3548 fl.Insert(f4);
3549 fl.Insert(f5);
3550
3551 info.Insert(fl);
3552
3553 pCache = cacheList.Next();
3554 }
3555 return true;
3556 }
3557 }
3558 return false;
3559 }
3560
getLockInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)3561 void CegoAdminHandler::getLockInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
3562 {
3563 Element *pRoot = _xml.getDocument()->getRootElement();
3564
3565 if ( pRoot )
3566 {
3567 ListT<CegoField> schema;
3568 schema.Insert(CegoField(Chain("LOCKINFO"), Chain("LOCKINFO"), Chain("LOCKID"),VARCHAR_TYPE, 20));
3569 schema.Insert(CegoField(Chain("LOCKINFO"), Chain("LOCKINFO"), Chain("LOCKCOUNT"), LONG_TYPE, sizeof(long long)));
3570 schema.Insert(CegoField(Chain("LOCKINFO"), Chain("LOCKINFO"), Chain("RD HITS"), LONG_TYPE, sizeof(long long)));
3571 schema.Insert(CegoField(Chain("LOCKINFO"), Chain("LOCKINFO"), Chain("RD DELAY"), LONG_TYPE, sizeof(long long)));
3572 schema.Insert(CegoField(Chain("LOCKINFO"), Chain("LOCKINFO"), Chain("WR HITS"), LONG_TYPE, sizeof(long long)));
3573 schema.Insert(CegoField(Chain("LOCKINFO"), Chain("LOCKINFO"), Chain("WR DELAY"), LONG_TYPE, sizeof(long long)));
3574 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("LOCKINFO"), schema, Chain("LOCKINFO"));
3575
3576 ListT<Element*> lockInfoList = pRoot->getChildren(XML_LOCKINFO_ELEMENT);
3577 Element **pInfo = lockInfoList.First();
3578
3579 if ( pInfo )
3580 {
3581 ListT<Element*> lockEntryList = (*pInfo)->getChildren(XML_LOCKENTRY_ELEMENT);
3582 Element **pLockEntry = lockEntryList.First();
3583
3584 while ( pLockEntry )
3585 {
3586 CegoFieldValue f1a(VARCHAR_TYPE, (*pLockEntry)->getAttributeValue(XML_LOCKID_ATTR));
3587 CegoFieldValue f1b(LONG_TYPE, (*pLockEntry)->getAttributeValue(XML_LOCKCOUNT_ATTR));
3588 CegoFieldValue f1c(LONG_TYPE, (*pLockEntry)->getAttributeValue(XML_RDLOCKHIT_ATTR));
3589 CegoFieldValue f1d(LONG_TYPE, (*pLockEntry)->getAttributeValue(XML_RDLOCKDELAY_ATTR));
3590 CegoFieldValue f1e(LONG_TYPE, (*pLockEntry)->getAttributeValue(XML_WRLOCKHIT_ATTR));
3591 CegoFieldValue f1f(LONG_TYPE, (*pLockEntry)->getAttributeValue(XML_WRLOCKDELAY_ATTR));
3592 ListT<CegoFieldValue> fl;
3593 fl.Insert(f1a);
3594 fl.Insert(f1b);
3595 fl.Insert(f1c);
3596 fl.Insert(f1d);
3597 fl.Insert(f1e);
3598 fl.Insert(f1f);
3599
3600 info.Insert(fl);
3601
3602 pLockEntry = lockEntryList.Next();
3603 }
3604 }
3605 }
3606 }
3607
getLockStat(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)3608 void CegoAdminHandler::getLockStat(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
3609 {
3610 Element *pRoot = _xml.getDocument()->getRootElement();
3611
3612 if ( pRoot )
3613 {
3614 ListT<CegoField> schema;
3615 schema.Insert(CegoField(Chain("LOCKSTAT"), Chain("LOCKSTAT"), Chain("LOCKID"),VARCHAR_TYPE, 20));
3616 schema.Insert(CegoField(Chain("LOCKSTAT"), Chain("LOCKSTAT"), Chain("NUMLOCK"), LONG_TYPE, sizeof(long long)));
3617 schema.Insert(CegoField(Chain("LOCKSTAT"), Chain("LOCKSTAT"), Chain("LOCKCOUNT"), LONG_TYPE, sizeof(long long)));
3618 schema.Insert(CegoField(Chain("LOCKSTAT"), Chain("LOCKSTAT"), Chain("RD HITS"), LONG_TYPE, sizeof(long long)));
3619 schema.Insert(CegoField(Chain("LOCKSTAT"), Chain("LOCKSTAT"), Chain("RD DELAY"), LONG_TYPE, sizeof(long long)));
3620 schema.Insert(CegoField(Chain("LOCKSTAT"), Chain("LOCKSTAT"), Chain("WR HITS"), LONG_TYPE, sizeof(long long)));
3621 schema.Insert(CegoField(Chain("LOCKSTAT"), Chain("LOCKSTAT"), Chain("WR DELAY"), LONG_TYPE, sizeof(long long)));
3622 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("LOCKSTAT"), schema, Chain("LOCKSTAT"));
3623
3624 ListT<Element*> lockInfoList = pRoot->getChildren(XML_LOCKSTAT_ELEMENT);
3625 Element **pInfo = lockInfoList.First();
3626
3627 if ( pInfo )
3628 {
3629 ListT<Element*> lockEntryList = (*pInfo)->getChildren(XML_LOCKENTRY_ELEMENT);
3630 Element **pLockEntry = lockEntryList.First();
3631
3632 while ( pLockEntry )
3633 {
3634 CegoFieldValue f1a(VARCHAR_TYPE, (*pLockEntry)->getAttributeValue(XML_LOCKID_ATTR));
3635 CegoFieldValue f1b(LONG_TYPE, (*pLockEntry)->getAttributeValue(XML_NUMLOCK_ATTR));
3636 CegoFieldValue f1c(LONG_TYPE, (*pLockEntry)->getAttributeValue(XML_LOCKCOUNT_ATTR));
3637 CegoFieldValue f1d(LONG_TYPE, (*pLockEntry)->getAttributeValue(XML_RDLOCKHIT_ATTR));
3638 CegoFieldValue f1e(LONG_TYPE, (*pLockEntry)->getAttributeValue(XML_RDLOCKDELAY_ATTR));
3639 CegoFieldValue f1f(LONG_TYPE, (*pLockEntry)->getAttributeValue(XML_WRLOCKHIT_ATTR));
3640 CegoFieldValue f1g(LONG_TYPE, (*pLockEntry)->getAttributeValue(XML_WRLOCKDELAY_ATTR));
3641 ListT<CegoFieldValue> fl;
3642 fl.Insert(f1a);
3643 fl.Insert(f1b);
3644 fl.Insert(f1c);
3645 fl.Insert(f1d);
3646 fl.Insert(f1e);
3647 fl.Insert(f1f);
3648 fl.Insert(f1g);
3649
3650 info.Insert(fl);
3651
3652 pLockEntry = lockEntryList.Next();
3653 }
3654 }
3655 }
3656 }
3657
getPoolInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info1,ListT<ListT<CegoFieldValue>> & info2)3658 void CegoAdminHandler::getPoolInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info1,
3659 ListT<ListT< CegoFieldValue > > & info2)
3660 {
3661 Element *pRoot = _xml.getDocument()->getRootElement();
3662
3663 if ( pRoot )
3664 {
3665 ListT<CegoField> schema;
3666 schema.Insert(CegoField(Chain("POOLINFO"), Chain("POOLINFO"), Chain("PARAMETER"),VARCHAR_TYPE, 20));
3667 schema.Insert(CegoField(Chain("POOLINFO"), Chain("POOLINFO"), Chain("VALUE"), VARCHAR_TYPE, 20));
3668 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("POOLINFO"), schema, Chain("POOLINFO"));
3669
3670 ListT<Element*> poolInfoList = pRoot->getChildren(XML_POOLINFO_ELEMENT);
3671
3672 Element **pInfo = poolInfoList.First();
3673
3674 if ( pInfo )
3675 {
3676 Chain pageSize = (*pInfo)->getAttributeValue(XML_PAGESIZE_ATTR);
3677 Chain numTotal = (*pInfo)->getAttributeValue(XML_NUMTOTAL_ATTR);
3678 Chain numUsed = (*pInfo)->getAttributeValue(XML_NUMUSED_ATTR);
3679 Chain numFree = (*pInfo)->getAttributeValue(XML_NUMFREE_ATTR);
3680 Chain numDirty = (*pInfo)->getAttributeValue(XML_NUMDIRTY_ATTR);
3681 Chain numFixed = (*pInfo)->getAttributeValue(XML_NUMFIXES_ATTR);
3682
3683 Chain numPersistent = (*pInfo)->getAttributeValue(XML_NUMPERSISTENT_ATTR);
3684 Chain numNoSync = (*pInfo)->getAttributeValue(XML_NUMNOSYNC_ATTR);
3685 Chain numDiskRead = (*pInfo)->getAttributeValue(XML_NUMDISKREAD_ATTR);
3686 Chain numDiskWrite = (*pInfo)->getAttributeValue(XML_NUMDISKWRITE_ATTR);
3687
3688 unsigned long long readDelay = (*pInfo)->getAttributeValue(XML_READDELAY_ATTR).asUnsignedLongLong();
3689 unsigned long long writeDelay = (*pInfo)->getAttributeValue(XML_WRITEDELAY_ATTR).asUnsignedLongLong();
3690
3691 Chain hitRate = (*pInfo)->getAttributeValue(XML_BPHITRATE_ATTR);
3692 Chain spreadRate = (*pInfo)->getAttributeValue(XML_SPREADRATE_ATTR);
3693
3694 Chain curFixCount = (*pInfo)->getAttributeValue(XML_CURFIXCOUNT_ATTR);
3695 Chain maxFixCount = (*pInfo)->getAttributeValue(XML_MAXFIXCOUNT_ATTR);
3696
3697 Chain avgFixTry = (*pInfo)->getAttributeValue(XML_AVGFIXTRY_ATTR);
3698
3699 Chain statStart = (*pInfo)->getAttributeValue(XML_STATSTART_ATTR);
3700 unsigned long long uptime = (*pInfo)->getAttributeValue(XML_UPTIME_ATTR).asUnsignedLongLong();
3701
3702 CegoFieldValue f1a(VARCHAR_TYPE, Chain("Page Size"));
3703 CegoFieldValue f1b(VARCHAR_TYPE, pageSize);
3704 ListT<CegoFieldValue> fl1;
3705 fl1.Insert(f1a);
3706 fl1.Insert(f1b);
3707 info1.Insert(fl1);
3708
3709 CegoFieldValue f2a(VARCHAR_TYPE, Chain("Total Pages"));
3710 CegoFieldValue f2b(VARCHAR_TYPE, numTotal);
3711 ListT<CegoFieldValue> fl2;
3712 fl2.Insert(f2a);
3713 fl2.Insert(f2b);
3714 info1.Insert(fl2);
3715
3716 CegoFieldValue f3a(VARCHAR_TYPE, Chain("Used Pages"));
3717 CegoFieldValue f3b(VARCHAR_TYPE, numUsed);
3718 ListT<CegoFieldValue> fl3;
3719 fl3.Insert(f3a);
3720 fl3.Insert(f3b);
3721 info1.Insert(fl3);
3722
3723 CegoFieldValue f4a(VARCHAR_TYPE, Chain("Free Pages"));
3724 CegoFieldValue f4b(VARCHAR_TYPE, numFree);
3725 ListT<CegoFieldValue> fl4;
3726 fl4.Insert(f4a);
3727 fl4.Insert(f4b);
3728 info1.Insert(fl4);
3729
3730 CegoFieldValue f5a(VARCHAR_TYPE, Chain("Dirty Pages"));
3731 CegoFieldValue f5b(VARCHAR_TYPE, numDirty);
3732 ListT<CegoFieldValue> fl5;
3733 fl5.Insert(f5a);
3734 fl5.Insert(f5b);
3735 info1.Insert(fl5);
3736
3737 CegoFieldValue f6a(VARCHAR_TYPE, Chain("Fixed Pages"));
3738 CegoFieldValue f6b(VARCHAR_TYPE, numFixed);
3739 ListT<CegoFieldValue> fl6;
3740 fl6.Insert(f6a);
3741 fl6.Insert(f6b);
3742 info1.Insert(fl6);
3743
3744 CegoFieldValue f7a(VARCHAR_TYPE, Chain("Persistent Pages"));
3745 CegoFieldValue f7b(VARCHAR_TYPE, numPersistent);
3746 ListT<CegoFieldValue> fl7;
3747 fl7.Insert(f7a);
3748 fl7.Insert(f7b);
3749 info1.Insert(fl7);
3750
3751 CegoFieldValue f8a(VARCHAR_TYPE, Chain("No Sync Pages"));
3752 CegoFieldValue f8b(INT_TYPE, numNoSync);
3753 ListT<CegoFieldValue> fl8;
3754 fl8.Insert(f8a);
3755 fl8.Insert(f8b);
3756 info1.Insert(fl8);
3757
3758 CegoFieldValue f9a(VARCHAR_TYPE, Chain("Spread Rate"));
3759 CegoFieldValue f9b(VARCHAR_TYPE, spreadRate);
3760 ListT<CegoFieldValue> fl9;
3761 fl9.Insert(f9a);
3762 fl9.Insert(f9b);
3763 info2.Insert(fl9);
3764
3765 CegoFieldValue f10a(VARCHAR_TYPE, Chain("Stat Start"));
3766 CegoFieldValue f10b(VARCHAR_TYPE, statStart);
3767 ListT<CegoFieldValue> fl10;
3768 fl10.Insert(f10a);
3769 fl10.Insert(f10b);
3770 info2.Insert(fl10);
3771
3772 CegoFieldValue f11a(VARCHAR_TYPE, Chain("Hit Rate"));
3773 CegoFieldValue f11b(VARCHAR_TYPE, hitRate);
3774 ListT<CegoFieldValue> fl11;
3775 fl11.Insert(f11a);
3776 fl11.Insert(f11b);
3777 info2.Insert(fl11);
3778
3779 CegoFieldValue f12a(VARCHAR_TYPE, Chain("Cur Fix Count"));
3780 CegoFieldValue f12b(VARCHAR_TYPE, curFixCount);
3781 ListT<CegoFieldValue> fl12;
3782 fl12.Insert(f12a);
3783 fl12.Insert(f12b);
3784 info2.Insert(fl12);
3785
3786 CegoFieldValue f13a(VARCHAR_TYPE, Chain("Max Fix Count"));
3787 CegoFieldValue f13b(VARCHAR_TYPE, maxFixCount);
3788 ListT<CegoFieldValue> fl13;
3789 fl13.Insert(f13a);
3790 fl13.Insert(f13b);
3791 info2.Insert(fl13);
3792
3793 CegoFieldValue f14a(VARCHAR_TYPE, Chain("Avg Fix Try"));
3794 CegoFieldValue f14b(VARCHAR_TYPE, maxFixCount);
3795 ListT<CegoFieldValue> fl14;
3796 fl14.Insert(f14a);
3797 fl14.Insert(f14b);
3798 info2.Insert(fl14);
3799
3800
3801 CegoFieldValue f15a(VARCHAR_TYPE, Chain("Disk Reads"));
3802 CegoFieldValue f15b(VARCHAR_TYPE, Chain(numDiskRead));
3803 ListT<CegoFieldValue> fl15;
3804 fl15.Insert(f15a);
3805 fl15.Insert(f15b);
3806 info2.Insert(fl15);
3807
3808 CegoFieldValue f16a(VARCHAR_TYPE, Chain("Disk Writes"));
3809 CegoFieldValue f16b(VARCHAR_TYPE, Chain(numDiskWrite));
3810 ListT<CegoFieldValue> fl16;
3811 fl16.Insert(f16a);
3812 fl16.Insert(f16b);
3813 info2.Insert(fl16);
3814
3815 unsigned long long msecDelay;
3816 unsigned long long usecDelay;
3817 Chain delayStr;
3818 Chain fillStr;
3819
3820 msecDelay = readDelay / 1000;
3821 usecDelay = readDelay % 1000;
3822 fillStr = Chain("000") + Chain(usecDelay);
3823 delayStr = Chain(msecDelay) + Chain(".") + fillStr.subChain(fillStr.length()-3, fillStr.length()) + Chain (" msec");
3824
3825 CegoFieldValue f17a(VARCHAR_TYPE, Chain("Read Delay"));
3826 CegoFieldValue f17b(VARCHAR_TYPE, Chain(delayStr));
3827 ListT<CegoFieldValue> fl17;
3828 fl17.Insert(f17a);
3829 fl17.Insert(f17b);
3830 info2.Insert(fl17);
3831
3832 msecDelay = writeDelay / 1000;
3833 usecDelay = writeDelay % 1000;
3834 fillStr = Chain("000") + Chain(usecDelay);
3835 delayStr = Chain(msecDelay) + Chain(".") + fillStr.subChain(fillStr.length()-3, fillStr.length()) + Chain (" msec");
3836
3837 CegoFieldValue f18a(VARCHAR_TYPE, Chain("Write Delay"));
3838 CegoFieldValue f18b(VARCHAR_TYPE, Chain(delayStr));
3839 ListT<CegoFieldValue> fl18;
3840 fl18.Insert(f18a);
3841 fl18.Insert(f18b);
3842 info2.Insert(fl18);
3843
3844 // calculate uptime string
3845 unsigned long long d = uptime / ( 3600 * 24 );
3846 unsigned long long h = ( uptime - ( d * 24 * 3600 )) / 3600;
3847 unsigned long long m = ( uptime - ( d * 24 * 3600 ) - ( h * 3600) ) / 60;
3848 unsigned long long s = uptime % 60;
3849
3850 Chain ss = Chain("0") + Chain(s);
3851 Chain sec = ss.subChain(ss.length()-2,ss.length());
3852
3853 Chain ms = Chain("0") + Chain(m);
3854 Chain min = ms.subChain(ms.length()-2,ms.length());
3855
3856 Chain uptimeString = Chain(d) + Chain("d ") + Chain(h) + Chain(":") + min + Chain(":") + sec;
3857
3858 CegoFieldValue f19a(VARCHAR_TYPE, Chain("Pool Uptime"));
3859 CegoFieldValue f19b(VARCHAR_TYPE, uptimeString);
3860 ListT<CegoFieldValue> fl19;
3861 fl19.Insert(f19a);
3862 fl19.Insert(f19b);
3863 info2.Insert(fl19);
3864 }
3865 }
3866 }
3867
getParameterInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)3868 void CegoAdminHandler::getParameterInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
3869 {
3870 Element *pRoot = _xml.getDocument()->getRootElement();
3871
3872 if ( pRoot )
3873 {
3874 ListT<CegoField> schema;
3875 schema.Insert(CegoField(Chain("PARAMETERINFO"), Chain("PARAMETERINFO"), Chain("PARAMETER"),VARCHAR_TYPE, 20));
3876 schema.Insert(CegoField(Chain("PARAMETERINFO"), Chain("PARAMETERINFO"), Chain("VALUE"), VARCHAR_TYPE, 20));
3877 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("PARAMETERINFO"), schema, Chain("PARAMETERINFO"));
3878
3879
3880 ListT<Element*> pList = pRoot->getChildren(XML_PARAMETERLIST_ELEMENT);
3881 Element **pPL = pList.First();
3882
3883 if ( pPL )
3884 {
3885 ListT<Element*> paramInfoList = (*pPL)->getChildren(XML_PARAMETERINFO_ELEMENT);
3886
3887 Element **pParam = paramInfoList.First();
3888
3889 while ( pParam )
3890 {
3891
3892 Chain paramName = (*pParam)->getAttributeValue(XML_PARAMNAME_ATTR);
3893 Chain paramValue = (*pParam)->getAttributeValue(XML_PARAMVALUE_ATTR);
3894
3895 CegoFieldValue f1a(VARCHAR_TYPE, paramName);
3896 CegoFieldValue f1b(VARCHAR_TYPE, paramValue);
3897 ListT<CegoFieldValue> fl1;
3898 fl1.Insert(f1a);
3899 fl1.Insert(f1b);
3900 info.Insert(fl1);
3901
3902 pParam = paramInfoList.Next();
3903 }
3904 }
3905 }
3906 }
3907
getPoolEntryList(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)3908 void CegoAdminHandler::getPoolEntryList(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
3909 {
3910 Element *pRoot = _xml.getDocument()->getRootElement();
3911
3912 if ( pRoot )
3913 {
3914 ListT<CegoField> schema;
3915 schema.Insert(CegoField(Chain("PEL"), Chain("PEL"), Chain("SEGMENT"),VARCHAR_TYPE, 10));
3916 schema.Insert(CegoField(Chain("PEL"), Chain("PEL"), Chain("POS"),VARCHAR_TYPE, 10));
3917 schema.Insert(CegoField(Chain("PEL"), Chain("PEL"), Chain("OCCSTATE"), VARCHAR_TYPE, 15));
3918 schema.Insert(CegoField(Chain("PEL"), Chain("PEL"), Chain("ISDIRTY"), VARCHAR_TYPE, 15));
3919 schema.Insert(CegoField(Chain("PEL"), Chain("PEL"), Chain("NUMFIXES"), VARCHAR_TYPE, 15));
3920 schema.Insert(CegoField(Chain("PEL"), Chain("PEL"), Chain("TABSETID"), VARCHAR_TYPE, 15));
3921 schema.Insert(CegoField(Chain("PEL"), Chain("PEL"), Chain("FILEID"), VARCHAR_TYPE, 15));
3922 schema.Insert(CegoField(Chain("PEL"), Chain("PEL"), Chain("PAGEID"), VARCHAR_TYPE, 15));
3923 schema.Insert(CegoField(Chain("PEL"), Chain("PEL"), Chain("FIXSTAT"), VARCHAR_TYPE, 15));
3924 schema.Insert(CegoField(Chain("PEL"), Chain("PEL"), Chain("NUMUSAGE"), VARCHAR_TYPE, 25));
3925
3926 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("PEL"), schema, Chain("PEL"));
3927
3928 ListT<Element*> pList = pRoot->getChildren(XML_POOLENTRYLIST_ELEMENT);
3929 Element **pPL = pList.First();
3930
3931 if ( pPL )
3932 {
3933 ListT<Element*> peList = (*pPL)->getChildren(XML_POOLENTRY_ELEMENT);
3934 Element** pPE = peList.First();
3935
3936 while ( pPE )
3937 {
3938 CegoFieldValue f1a(VARCHAR_TYPE, (*pPE)->getAttributeValue(XML_SEGMENT_ATTR));
3939 CegoFieldValue f1b(VARCHAR_TYPE, (*pPE)->getAttributeValue(XML_POS_ATTR));
3940 CegoFieldValue f1c(VARCHAR_TYPE, (*pPE)->getAttributeValue(XML_OCCSTATE_ATTR));
3941 CegoFieldValue f1d(VARCHAR_TYPE, (*pPE)->getAttributeValue(XML_ISDIRTY_ATTR));
3942 CegoFieldValue f1e(VARCHAR_TYPE, (*pPE)->getAttributeValue(XML_NUMFIXES_ATTR));
3943 CegoFieldValue f1f(VARCHAR_TYPE, (*pPE)->getAttributeValue(XML_TSID_ATTR));
3944 CegoFieldValue f1g(VARCHAR_TYPE, (*pPE)->getAttributeValue(XML_FILEID_ATTR));
3945 CegoFieldValue f1h(VARCHAR_TYPE, (*pPE)->getAttributeValue(XML_PAGEID_ATTR));
3946 CegoFieldValue f1i(VARCHAR_TYPE, (*pPE)->getAttributeValue(XML_FIXSTAT_ATTR));
3947 CegoFieldValue f1j(VARCHAR_TYPE, (*pPE)->getAttributeValue(XML_NUMUSAGE_ATTR));
3948
3949 ListT<CegoFieldValue> fl;
3950 fl.Insert(f1a);
3951 fl.Insert(f1b);
3952 fl.Insert(f1c);
3953 fl.Insert(f1d);
3954 fl.Insert(f1e);
3955 fl.Insert(f1f);
3956 fl.Insert(f1g);
3957 fl.Insert(f1h);
3958 fl.Insert(f1i);
3959 fl.Insert(f1j);
3960
3961 info.Insert(fl);
3962
3963 pPE = peList.Next();
3964 }
3965 }
3966 }
3967 }
3968
getTableSetList(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info,bool getUsage)3969 void CegoAdminHandler::getTableSetList(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info, bool getUsage)
3970 {
3971 Element *pRoot = _xml.getDocument()->getRootElement();
3972
3973 if ( pRoot )
3974 {
3975 ListT<CegoField> schema;
3976 schema.Insert(CegoField(Chain("TSL"), Chain("TSL"), Chain("NAME"),VARCHAR_TYPE, 20));
3977 schema.Insert(CegoField(Chain("TSL"), Chain("TSL"), Chain("RUNSTATE"), VARCHAR_TYPE, 15));
3978 schema.Insert(CegoField(Chain("TSL"), Chain("TSL"), Chain("SYNCSTATE"), VARCHAR_TYPE, 15));
3979 if ( getUsage )
3980 {
3981 schema.Insert(CegoField(Chain("TSL"), Chain("TSL"), Chain("SYSUSAGE"), VARCHAR_TYPE, 10));
3982 schema.Insert(CegoField(Chain("TSL"), Chain("TSL"), Chain("TEMPUSAGE"), VARCHAR_TYPE, 10));
3983 schema.Insert(CegoField(Chain("TSL"), Chain("TSL"), Chain("APPUSAGE"), VARCHAR_TYPE, 10));
3984 }
3985
3986 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("TSL"), schema, Chain("TSL"));
3987
3988 ListT<Element*> tList = pRoot->getChildren(XML_TABLESETLIST_ELEMENT);
3989 Element **pTL = tList.First();
3990
3991 if ( pTL )
3992 {
3993 ListT<Element*> tsList = (*pTL)->getChildren(XML_TABLESET_ELEMENT);
3994 Element** pTS = tsList.First();
3995
3996 while ( pTS )
3997 {
3998 Chain tsName = (*pTS)->getAttributeValue(XML_NAME_ATTR);
3999 Chain tsRunState = (*pTS)->getAttributeValue(XML_RUNSTATE_ATTR);
4000 Chain tsSyncState = (*pTS)->getAttributeValue(XML_SYNCSTATE_ATTR);
4001
4002 CegoFieldValue f1a(VARCHAR_TYPE, tsName);
4003 CegoFieldValue f1b(VARCHAR_TYPE, tsRunState);
4004 CegoFieldValue f1c(VARCHAR_TYPE, tsSyncState);
4005
4006 ListT<CegoFieldValue> fl1;
4007 fl1.Insert(f1a);
4008 fl1.Insert(f1b);
4009 fl1.Insert(f1c);
4010
4011 if ( getUsage )
4012 {
4013 Chain tsSysUsage = (*pTS)->getAttributeValue(XML_SYSUSAGE_ATTR);
4014 Chain tsTempUsage = (*pTS)->getAttributeValue(XML_TEMPUSAGE_ATTR);
4015 Chain tsAppUsage = (*pTS)->getAttributeValue(XML_APPUSAGE_ATTR);
4016
4017 CegoFieldValue f1d(VARCHAR_TYPE, tsSysUsage);
4018 CegoFieldValue f1e(VARCHAR_TYPE, tsTempUsage);
4019 CegoFieldValue f1f(VARCHAR_TYPE, tsAppUsage);
4020
4021 fl1.Insert(f1d);
4022 fl1.Insert(f1e);
4023 fl1.Insert(f1f);
4024 }
4025
4026 info.Insert(fl1);
4027
4028 pTS = tsList.Next();
4029 }
4030 }
4031 }
4032 }
4033
getTableSetCheck(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)4034 void CegoAdminHandler::getTableSetCheck(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
4035 {
4036 Element *pRoot = _xml.getDocument()->getRootElement();
4037
4038 if ( pRoot )
4039 {
4040 ListT<CegoField> schema;
4041 schema.Insert(CegoField(Chain("CHK"), Chain("CHK"), Chain("ATTRIBUTE"),VARCHAR_TYPE, 10));
4042 schema.Insert(CegoField(Chain("CHK"), Chain("CHK"), Chain(XML_MEDIATOR_ATTR), VARCHAR_TYPE, 12));
4043 schema.Insert(CegoField(Chain("CHK"), Chain("CHK"), Chain(XML_PRIMARY_ATTR), VARCHAR_TYPE, 12));
4044 schema.Insert(CegoField(Chain("CHK"), Chain("CHK"), Chain(XML_SECONDARY_ATTR), VARCHAR_TYPE, 12));
4045 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("CHK"), schema, Chain("CHK"));
4046
4047 ListT<Element*> tList = pRoot->getChildren(XML_TABLESETCHECK_ELEMENT);
4048 Element **pTL = tList.First();
4049
4050 if ( pTL )
4051 {
4052 ListT<Element*> tsList = (*pTL)->getChildren(XML_ATTRCHECK_ELEMENT);
4053 Element** pTS = tsList.First();
4054
4055 CegoFieldValue f1c(VARCHAR_TYPE, (*pTL)->getAttributeValue(XML_SECONDARY_ATTR));
4056
4057 ListT<CegoFieldValue> fl1;
4058 fl1.Insert( CegoFieldValue(VARCHAR_TYPE, Chain("NAME")));
4059 fl1.Insert( CegoFieldValue(VARCHAR_TYPE, (*pTL)->getAttributeValue(XML_MEDIATOR_ATTR)));
4060 fl1.Insert( CegoFieldValue(VARCHAR_TYPE, (*pTL)->getAttributeValue(XML_PRIMARY_ATTR)));
4061 fl1.Insert( CegoFieldValue(VARCHAR_TYPE, (*pTL)->getAttributeValue(XML_SECONDARY_ATTR)));
4062
4063 info.Insert(fl1);
4064
4065 while ( pTS )
4066 {
4067 Chain attr = (*pTS)->getAttributeValue(XML_CHECKATTR_ATTR);
4068 Chain mVal = (*pTS)->getAttributeValue(XML_MVAL_ATTR);
4069 Chain pVal = (*pTS)->getAttributeValue(XML_PVAL_ATTR);
4070 Chain sVal = (*pTS)->getAttributeValue(XML_SVAL_ATTR);
4071
4072 CegoFieldValue f1a(VARCHAR_TYPE, attr);
4073 CegoFieldValue f1b(VARCHAR_TYPE, mVal);
4074 CegoFieldValue f1c(VARCHAR_TYPE, pVal);
4075 CegoFieldValue f1d(VARCHAR_TYPE, sVal);
4076
4077 ListT<CegoFieldValue> fl1;
4078 fl1.Insert(f1a);
4079 fl1.Insert(f1b);
4080 fl1.Insert(f1c);
4081 fl1.Insert(f1d);
4082
4083 info.Insert(fl1);
4084
4085 pTS = tsList.Next();
4086 }
4087 }
4088 }
4089 }
4090
getTableSetCheckInfo()4091 Element* CegoAdminHandler::getTableSetCheckInfo()
4092 {
4093 Element *pCheck = 0;
4094
4095 Element *pRoot = _xml.getDocument()->getRootElement();
4096
4097 if ( pRoot )
4098 {
4099 ListT<Element*> tsInfoList = pRoot->getChildren(XML_TABLESET_ELEMENT);
4100
4101 Element **pInfo = tsInfoList.First();
4102
4103 if ( pInfo )
4104 {
4105 pCheck = new Element(XML_TABLESET_ELEMENT);
4106
4107 pCheck->setAttribute(XML_RUNSTATE_ATTR, (*pInfo)->getAttributeValue(XML_RUNSTATE_ATTR));
4108 pCheck->setAttribute(XML_SYNCSTATE_ATTR, (*pInfo)->getAttributeValue(XML_SYNCSTATE_ATTR));
4109 pCheck->setAttribute(XML_PRIMARY_ATTR, (*pInfo)->getAttributeValue(XML_PRIMARY_ATTR));
4110 pCheck->setAttribute(XML_SECONDARY_ATTR, (*pInfo)->getAttributeValue(XML_SECONDARY_ATTR));
4111 pCheck->setAttribute(XML_MEDIATOR_ATTR, (*pInfo)->getAttributeValue(XML_MEDIATOR_ATTR));
4112 }
4113 }
4114 return pCheck;
4115 }
4116
getDetailedTableSetInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)4117 void CegoAdminHandler::getDetailedTableSetInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
4118 {
4119 Element *pRoot = _xml.getDocument()->getRootElement();
4120
4121 if ( pRoot )
4122 {
4123 ListT<Element*> tsInfoList = pRoot->getChildren(XML_TABLESET_ELEMENT);
4124
4125 Element **pInfo = tsInfoList.First();
4126 if ( pInfo )
4127 {
4128 int maxLen=20;
4129
4130 Chain tsRunState = (*pInfo)->getAttributeValue(XML_RUNSTATE_ATTR);
4131 Chain tsSyncState = (*pInfo)->getAttributeValue(XML_SYNCSTATE_ATTR);
4132
4133 Chain tsPrimary = (*pInfo)->getAttributeValue(XML_PRIMARY_ATTR);
4134 if ( tsPrimary.length() > maxLen )
4135 maxLen=tsPrimary.length();
4136
4137 Chain tsSecondary = (*pInfo)->getAttributeValue(XML_SECONDARY_ATTR);
4138 if ( tsSecondary.length() > maxLen )
4139 maxLen=tsSecondary.length();
4140
4141 Chain tsMediator = (*pInfo)->getAttributeValue(XML_MEDIATOR_ATTR);
4142 if ( tsMediator.length() > maxLen )
4143 maxLen=tsMediator.length();
4144
4145 Chain tsRoot = (*pInfo)->getAttributeValue(XML_TSROOT_ATTR);
4146 if ( tsRoot.length() > maxLen )
4147 maxLen=tsRoot.length();
4148
4149 Chain tsTicket = (*pInfo)->getAttributeValue(XML_TSTICKET_ATTR);
4150 if ( tsTicket.length() > maxLen )
4151 maxLen=tsTicket.length();
4152
4153 Chain tsInitFile = (*pInfo)->getAttributeValue(XML_TSINITFILE_ATTR);
4154 if ( tsInitFile.length() > maxLen )
4155 maxLen=tsInitFile.length();
4156
4157 Chain tsSysFile = (*pInfo)->getAttributeValue(XML_SYSFILE_ATTR);
4158 if ( tsSysFile.length() > maxLen )
4159 maxLen=tsSysFile.length();
4160
4161 Chain tsTempFile = (*pInfo)->getAttributeValue(XML_TEMPFILE_ATTR);
4162 if ( tsTempFile.length() > maxLen )
4163 maxLen=tsTempFile.length();
4164
4165 ListT<CegoField> schema;
4166 schema.Insert(CegoField(Chain("TABLESETINFO"), Chain("TABLESETINFO"), Chain("PARAMETER"),VARCHAR_TYPE, 20));
4167 schema.Insert(CegoField(Chain("TABLESETINFO"), Chain("TABLESETINFO"), Chain("VALUE"), VARCHAR_TYPE, maxLen));
4168
4169 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("TABLESETINFO"), schema, Chain("TABLESETINFO"));
4170
4171 Chain tableSet = (*pInfo)->getAttributeValue(XML_NAME_ATTR);
4172
4173 Chain checkpoint = (*pInfo)->getAttributeValue(XML_CHECKPOINT_ATTR);
4174
4175 Chain tsSysTotal = (*pInfo)->getAttributeValue(XML_SYSTOTAL_ATTR);
4176 Chain tsSysUsed = (*pInfo)->getAttributeValue(XML_SYSUSED_ATTR);
4177
4178 Chain tsTempTotal = (*pInfo)->getAttributeValue(XML_TEMPTOTAL_ATTR);
4179 Chain tsTempUsed = (*pInfo)->getAttributeValue(XML_TEMPUSED_ATTR);
4180
4181 unsigned long long tsSysSumTotal = tsSysTotal.asUnsignedLongLong();
4182 unsigned long long tsSysSumUsed = tsSysUsed.asUnsignedLongLong();
4183
4184 unsigned long long tsTmpSumTotal = tsTempTotal.asUnsignedLongLong();
4185 unsigned long long tsTmpSumUsed = tsTempUsed.asUnsignedLongLong();
4186
4187 unsigned long long tsAppSumTotal = 0;
4188 unsigned long long tsAppSumUsed = 0;
4189
4190 ListT<Element*> dataFileList = (*pInfo)->getChildren(XML_DATAFILE_ELEMENT);
4191 Element **pDF = dataFileList.First();
4192
4193 while ( pDF )
4194 {
4195 Chain fileType = (*pDF)->getAttributeValue(XML_TYPE_ATTR);
4196
4197 if ( fileType == Chain(XML_SYSFILE_VALUE) )
4198 {
4199 Chain sfNumTotal = (*pDF)->getAttributeValue(XML_NUMTOTAL_ATTR);
4200 Chain sfNumUsed = (*pDF)->getAttributeValue(XML_NUMUSED_ATTR);
4201
4202 tsSysSumTotal += sfNumTotal.asUnsignedLongLong();
4203 tsSysSumUsed += sfNumUsed.asUnsignedLongLong();
4204 }
4205 else if ( fileType == Chain(XML_TEMPFILE_VALUE) )
4206 {
4207 Chain tfNumTotal = (*pDF)->getAttributeValue(XML_NUMTOTAL_ATTR);
4208 Chain tfNumUsed = (*pDF)->getAttributeValue(XML_NUMUSED_ATTR);
4209
4210 tsTmpSumTotal += tfNumTotal.asUnsignedLongLong();
4211 tsTmpSumUsed += tfNumUsed.asUnsignedLongLong();
4212 }
4213 else if ( fileType == Chain(XML_APPFILE_VALUE) )
4214 {
4215 Chain afNumTotal = (*pDF)->getAttributeValue(XML_NUMTOTAL_ATTR);
4216 Chain afNumUsed = (*pDF)->getAttributeValue(XML_NUMUSED_ATTR);
4217
4218 tsAppSumTotal += afNumTotal.asUnsignedLongLong();
4219 tsAppSumUsed += afNumUsed.asUnsignedLongLong();
4220 }
4221 pDF = dataFileList.Next();
4222 }
4223
4224 Chain sortAreaSize = (*pInfo)->getAttributeValue(XML_SORTAREASIZE_ATTR);
4225 Chain clsn = (*pInfo)->getAttributeValue(XML_LSN_ATTR);
4226 Chain tid = (*pInfo)->getAttributeValue(XML_TID_ATTR);
4227 Chain writtenlsn = (*pInfo)->getAttributeValue(XML_WRITTENLSN_ATTR);
4228
4229 Chain archMode = (*pInfo)->getAttributeValue(XML_ARCHMODE_ATTR);
4230 Chain autoCorrect = (*pInfo)->getAttributeValue(XML_AUTOCORRECT_ATTR);
4231 Chain cpDump = (*pInfo)->getAttributeValue(XML_CPDUMP_ATTR);
4232
4233 Chain logUser = (*pInfo)->getAttributeValue(XML_LOGUSER_ATTR);
4234
4235 Chain tableCache = (*pInfo)->getAttributeValue(XML_TABLECACHE_ATTR);
4236 Chain queryCache = (*pInfo)->getAttributeValue(XML_QUERYCACHE_ATTR);
4237
4238 Chain tableCacheMaxEntry = (*pInfo)->getAttributeValue(XML_MAXTABLECACHEENTRY_ATTR);
4239 Chain tableCacheMaxSize = (*pInfo)->getAttributeValue(XML_MAXTABLECACHESIZE_ATTR);
4240 Chain tableCacheUsedSize = (*pInfo)->getAttributeValue(XML_TABLECACHEUSEDSIZE_ATTR);
4241 Chain queryCacheMaxEntry = (*pInfo)->getAttributeValue(XML_MAXQUERYCACHEENTRY_ATTR);
4242 Chain queryCacheMaxSize = (*pInfo)->getAttributeValue(XML_MAXQUERYCACHESIZE_ATTR);
4243 Chain queryCacheHashRange = (*pInfo)->getAttributeValue(XML_QUERYCACHEHASHRANGE_ATTR);
4244 Chain queryCacheUsedSize = (*pInfo)->getAttributeValue(XML_QUERYCACHEUSEDSIZE_ATTR);
4245
4246 CegoFieldValue f0a(VARCHAR_TYPE, Chain(INFO_TABLESET));
4247 CegoFieldValue f0b(VARCHAR_TYPE, tableSet);
4248 ListT<CegoFieldValue> fl0;
4249 fl0.Insert(f0a);
4250 fl0.Insert(f0b);
4251 info.Insert(fl0);
4252
4253 CegoFieldValue f1a(VARCHAR_TYPE, Chain(INFO_RUNSTATE));
4254 CegoFieldValue f1b(VARCHAR_TYPE, tsRunState);
4255 ListT<CegoFieldValue> fl1a;
4256 fl1a.Insert(f1a);
4257 fl1a.Insert(f1b);
4258 info.Insert(fl1a);
4259
4260 CegoFieldValue f1c(VARCHAR_TYPE, Chain(INFO_SYNCSTATE));
4261 CegoFieldValue f1d(VARCHAR_TYPE, tsSyncState);
4262 ListT<CegoFieldValue> fl1b;
4263 fl1b.Insert(f1c);
4264 fl1b.Insert(f1d);
4265 info.Insert(fl1b);
4266
4267 CegoFieldValue f2a(VARCHAR_TYPE, Chain(INFO_PRIMARY));
4268 CegoFieldValue f2b(VARCHAR_TYPE, tsPrimary);
4269 ListT<CegoFieldValue> fl2;
4270 fl2.Insert(f2a);
4271 fl2.Insert(f2b);
4272 info.Insert(fl2);
4273
4274 CegoFieldValue f3a(VARCHAR_TYPE, Chain(INFO_SECONDARY));
4275 CegoFieldValue f3b(VARCHAR_TYPE, tsSecondary);
4276 ListT<CegoFieldValue> fl3;
4277 fl3.Insert(f3a);
4278 fl3.Insert(f3b);
4279 info.Insert(fl3);
4280
4281 CegoFieldValue f4a(VARCHAR_TYPE, Chain(INFO_MEDIATOR));
4282 CegoFieldValue f4b(VARCHAR_TYPE, tsMediator);
4283 ListT<CegoFieldValue> fl4;
4284 fl4.Insert(f4a);
4285 fl4.Insert(f4b);
4286 info.Insert(fl4);
4287
4288 CegoFieldValue f40a(VARCHAR_TYPE, Chain(INFO_ROOTPATH));
4289 CegoFieldValue f40b(VARCHAR_TYPE, tsRoot);
4290 ListT<CegoFieldValue> fl40;
4291 fl40.Insert(f40a);
4292 fl40.Insert(f40b);
4293 info.Insert(fl40);
4294
4295
4296 CegoFieldValue f41a(VARCHAR_TYPE, Chain(INFO_LOGUSER));
4297 CegoFieldValue f41b(VARCHAR_TYPE, logUser);
4298 ListT<CegoFieldValue> fl41;
4299 fl41.Insert(f41a);
4300 fl41.Insert(f41b);
4301 info.Insert(fl41);
4302
4303
4304 CegoFieldValue f42a(VARCHAR_TYPE, Chain(INFO_TICKET));
4305 CegoFieldValue f42b(VARCHAR_TYPE, tsTicket);
4306 ListT<CegoFieldValue> fl42;
4307 fl42.Insert(f42a);
4308 fl42.Insert(f42b);
4309 info.Insert(fl42);
4310
4311 CegoFieldValue f43a(VARCHAR_TYPE, Chain(INFO_TSINITFILE));
4312 CegoFieldValue f43b(VARCHAR_TYPE, tsInitFile);
4313 ListT<CegoFieldValue> fl43;
4314 fl43.Insert(f43a);
4315 fl43.Insert(f43b);
4316 info.Insert(fl43);
4317
4318 CegoFieldValue f44a(VARCHAR_TYPE, Chain(INFO_CHECKPOINT));
4319 CegoFieldValue f44b(VARCHAR_TYPE, checkpoint);
4320 ListT<CegoFieldValue> fl44;
4321 fl44.Insert(f44a);
4322 fl44.Insert(f44b);
4323 info.Insert(fl44);
4324
4325 CegoFieldValue f6a(VARCHAR_TYPE, Chain(INFO_SYSTEMPAGETOTAL));
4326 CegoFieldValue f6b(VARCHAR_TYPE, Chain(tsSysSumTotal));
4327 ListT<CegoFieldValue> fl6;
4328 fl6.Insert(f6a);
4329 fl6.Insert(f6b);
4330 info.Insert(fl6);
4331
4332 CegoFieldValue f7a(VARCHAR_TYPE, Chain(INFO_SYSTEMPAGEUSED));
4333 CegoFieldValue f7b(VARCHAR_TYPE, Chain(tsSysSumUsed));
4334 ListT<CegoFieldValue> fl7;
4335 fl7.Insert(f7a);
4336 fl7.Insert(f7b);
4337 info.Insert(fl7);
4338
4339 // id 8 not used
4340
4341 CegoFieldValue f9a(VARCHAR_TYPE, Chain(INFO_TEMPPAGETOTAL));
4342 CegoFieldValue f9b(VARCHAR_TYPE, Chain(tsTmpSumTotal));
4343 ListT<CegoFieldValue> fl9;
4344 fl9.Insert(f9a);
4345 fl9.Insert(f9b);
4346 info.Insert(fl9);
4347
4348 CegoFieldValue f10a(VARCHAR_TYPE, Chain(INFO_TEMPPAGEUSED));
4349 CegoFieldValue f10b(VARCHAR_TYPE, Chain(tsTmpSumUsed));
4350 ListT<CegoFieldValue> fl10;
4351 fl10.Insert(f10a);
4352 fl10.Insert(f10b);
4353 info.Insert(fl10);
4354
4355 CegoFieldValue f11a(VARCHAR_TYPE, Chain(INFO_APPPAGETOTAL));
4356 CegoFieldValue f11b(VARCHAR_TYPE, Chain(tsAppSumTotal));
4357 ListT<CegoFieldValue> fl11;
4358 fl11.Insert(f11a);
4359 fl11.Insert(f11b);
4360 info.Insert(fl11);
4361
4362 CegoFieldValue f12a(VARCHAR_TYPE, Chain(INFO_APPPAGEUSED));
4363 CegoFieldValue f12b(VARCHAR_TYPE, Chain(tsAppSumUsed));
4364 ListT<CegoFieldValue> fl12;
4365 fl12.Insert(f12a);
4366 fl12.Insert(f12b);
4367 info.Insert(fl12);
4368
4369 CegoFieldValue f13a(VARCHAR_TYPE, Chain(INFO_SORTAREASIZE));
4370 CegoFieldValue f13b(VARCHAR_TYPE, sortAreaSize);
4371 ListT<CegoFieldValue> fl13;
4372 fl13.Insert(f13a);
4373 fl13.Insert(f13b);
4374 info.Insert(fl13);
4375
4376 CegoFieldValue f14a(VARCHAR_TYPE, Chain(INFO_TID));
4377 CegoFieldValue f14b(VARCHAR_TYPE, tid);
4378 ListT<CegoFieldValue> fl14;
4379 fl14.Insert(f14a);
4380 fl14.Insert(f14b);
4381 info.Insert(fl14);
4382
4383 CegoFieldValue f15a(VARCHAR_TYPE, Chain(INFO_CLSN));
4384 CegoFieldValue f15b(VARCHAR_TYPE, clsn);
4385 ListT<CegoFieldValue> fl15;
4386 fl15.Insert(f15a);
4387 fl15.Insert(f15b);
4388 info.Insert(fl15);
4389
4390 CegoFieldValue f16a(VARCHAR_TYPE, Chain(INFO_WLSN));
4391 CegoFieldValue f16b(VARCHAR_TYPE, writtenlsn);
4392 ListT<CegoFieldValue> fl16;
4393 fl16.Insert(f16a);
4394 fl16.Insert(f16b);
4395 info.Insert(fl16);
4396
4397 CegoFieldValue f17a(VARCHAR_TYPE, Chain(INFO_ARCHMODE));
4398 CegoFieldValue f17b(VARCHAR_TYPE, archMode);
4399 ListT<CegoFieldValue> fl17;
4400 fl17.Insert(f17a);
4401 fl17.Insert(f17b);
4402 info.Insert(fl17);
4403
4404 CegoFieldValue f18a(VARCHAR_TYPE, Chain(INFO_AUTOCORRECT));
4405 CegoFieldValue f18b(VARCHAR_TYPE, autoCorrect);
4406 ListT<CegoFieldValue> fl18;
4407 fl18.Insert(f18a);
4408 fl18.Insert(f18b);
4409 info.Insert(fl18);
4410
4411 CegoFieldValue f19a(VARCHAR_TYPE, Chain(INFO_CPDUMP));
4412 CegoFieldValue f19b(VARCHAR_TYPE, cpDump);
4413 ListT<CegoFieldValue> fl19;
4414 fl19.Insert(f19a);
4415 fl19.Insert(f19b);
4416 info.Insert(fl19);
4417
4418
4419 CegoFieldValue f20a(VARCHAR_TYPE, Chain(INFO_TABLECACHE));
4420 CegoFieldValue f20b(VARCHAR_TYPE, tableCache);
4421 ListT<CegoFieldValue> fl20;
4422 fl20.Insert(f20a);
4423 fl20.Insert(f20b);
4424 info.Insert(fl20);
4425
4426 CegoFieldValue f21a(VARCHAR_TYPE, Chain(INFO_TABLECACHEMAXENTRY));
4427 CegoFieldValue f21b(VARCHAR_TYPE, tableCacheMaxEntry);
4428 ListT<CegoFieldValue> fl21;
4429 fl21.Insert(f21a);
4430 fl21.Insert(f21b);
4431 info.Insert(fl21);
4432
4433 CegoFieldValue f22a(VARCHAR_TYPE, Chain(INFO_TABLECACHEMAXSIZE));
4434 CegoFieldValue f22b(VARCHAR_TYPE, tableCacheMaxSize);
4435 ListT<CegoFieldValue> fl22;
4436 fl22.Insert(f22a);
4437 fl22.Insert(f22b);
4438 info.Insert(fl22);
4439
4440 CegoFieldValue f23a(VARCHAR_TYPE, Chain(INFO_TABLECACHEUSEDSIZE));
4441 CegoFieldValue f23b(VARCHAR_TYPE, tableCacheUsedSize);
4442 ListT<CegoFieldValue> fl23;
4443 fl23.Insert(f23a);
4444 fl23.Insert(f23b);
4445 info.Insert(fl23);
4446
4447 CegoFieldValue f24a(VARCHAR_TYPE, Chain(INFO_QUERYCACHE));
4448 CegoFieldValue f24b(VARCHAR_TYPE, queryCache);
4449 ListT<CegoFieldValue> fl24;
4450 fl24.Insert(f24a);
4451 fl24.Insert(f24b);
4452 info.Insert(fl24);
4453
4454 CegoFieldValue f25a(VARCHAR_TYPE, Chain(INFO_QUERYCACHEMAXENTRY));
4455 CegoFieldValue f25b(VARCHAR_TYPE, queryCacheMaxEntry);
4456 ListT<CegoFieldValue> fl25;
4457 fl25.Insert(f25a);
4458 fl25.Insert(f25b);
4459 info.Insert(fl25);
4460
4461 CegoFieldValue f26a(VARCHAR_TYPE, Chain(INFO_QUERYCACHEMAXSIZE));
4462 CegoFieldValue f26b(VARCHAR_TYPE, queryCacheMaxSize);
4463 ListT<CegoFieldValue> fl26;
4464 fl26.Insert(f26a);
4465 fl26.Insert(f26b);
4466 info.Insert(fl26);
4467
4468 CegoFieldValue f27a(VARCHAR_TYPE, Chain(INFO_QUERYCACHEHASHRANGE));
4469 CegoFieldValue f27b(VARCHAR_TYPE, queryCacheHashRange);
4470 ListT<CegoFieldValue> fl27;
4471 fl27.Insert(f27a);
4472 fl27.Insert(f27b);
4473 info.Insert(fl27);
4474
4475
4476 CegoFieldValue f28a(VARCHAR_TYPE, Chain(INFO_QUERYCACHEUSEDSIZE));
4477 CegoFieldValue f28b(VARCHAR_TYPE, queryCacheUsedSize);
4478 ListT<CegoFieldValue> fl28;
4479 fl28.Insert(f28a);
4480 fl28.Insert(f28b);
4481 info.Insert(fl28);
4482
4483 ListT<Element*> logFileList = (*pInfo)->getChildren(XML_LOGFILE_ELEMENT);
4484 Element **pLF = logFileList.First();
4485
4486 if ( pLF )
4487 {
4488 Chain logSize = (*pLF)->getAttributeValue(XML_SIZE_ATTR);
4489 CegoFieldValue fa(VARCHAR_TYPE, Chain(INFO_LOGSIZE));
4490 CegoFieldValue fb(VARCHAR_TYPE, logSize);
4491 ListT<CegoFieldValue> fl;
4492 fl.Insert(fa);
4493 fl.Insert(fb);
4494 info.Insert(fl);
4495 }
4496 while ( pLF )
4497 {
4498 Chain logName = (*pLF)->getAttributeValue(XML_NAME_ATTR);
4499
4500 CegoFieldValue fa(VARCHAR_TYPE, Chain(INFO_LOGFILE));
4501 CegoFieldValue fb(VARCHAR_TYPE, logName);
4502 ListT<CegoFieldValue> fl;
4503 fl.Insert(fa);
4504 fl.Insert(fb);
4505 info.Insert(fl);
4506
4507 pLF = logFileList.Next();
4508 }
4509 }
4510 }
4511 }
4512
getTSInfo()4513 Element* CegoAdminHandler::getTSInfo()
4514 {
4515 Element *pRoot = _xml.getDocument()->getRootElement();
4516
4517 if ( pRoot )
4518 {
4519 ListT<Element*> tList = pRoot->getChildren(XML_TABLESET_ELEMENT);
4520 Element **pTL = tList.First();
4521 if ( pTL )
4522 return *pTL;
4523 }
4524 return 0;
4525 }
4526
getObjectInfo()4527 Element* CegoAdminHandler::getObjectInfo()
4528 {
4529 Element *pRoot = _xml.getDocument()->getRootElement();
4530
4531 if ( pRoot )
4532 {
4533 ListT<Element*> tlist = pRoot->getChildren(XML_OBJLIST_ELEMENT);
4534 Element **pTL = tlist.First();
4535 if ( pTL )
4536 return *pTL;
4537 }
4538 return 0;
4539 }
4540
getTAInfo()4541 Element* CegoAdminHandler::getTAInfo()
4542 {
4543 Element *pRoot = _xml.getDocument()->getRootElement();
4544
4545 if ( pRoot )
4546 {
4547 ListT<Element*> tlist = pRoot->getChildren(XML_TAINFO_ELEMENT);
4548 Element **pTL = tlist.First();
4549 if ( pTL )
4550 return *pTL;
4551 }
4552 return 0;
4553 }
4554
getBuFileInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)4555 void CegoAdminHandler::getBuFileInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
4556 {
4557 Element *pRoot = _xml.getDocument()->getRootElement();
4558
4559 if ( pRoot )
4560 {
4561 ListT<Element*> tsInfoList = pRoot->getChildren(XML_TABLESET_ELEMENT);
4562 Element **pInfo = tsInfoList.First();
4563
4564 if (pInfo )
4565 {
4566 Chain tsTicket = (*pInfo)->getAttributeValue(XML_TSTICKET_ATTR);
4567 unsigned int maxLen=tsTicket.length();
4568
4569 CegoFieldValue b1(VARCHAR_TYPE, tsTicket);
4570
4571 ListT<CegoFieldValue> bl;
4572
4573 bl.Insert(b1);
4574 info.Insert(bl);
4575
4576 Chain sysFile = (*pInfo)->getAttributeValue(XML_SYSFILE_ATTR);
4577 if ( sysFile.length() > maxLen )
4578 maxLen=sysFile.length();
4579
4580 CegoFieldValue s1(VARCHAR_TYPE, sysFile);
4581
4582 ListT<CegoFieldValue> sl;
4583
4584 sl.Insert(s1);
4585 info.Insert(sl);
4586
4587 Chain tempFile = (*pInfo)->getAttributeValue(XML_TEMPFILE_ATTR);
4588 if ( tempFile.length() > maxLen )
4589 maxLen=tempFile.length();
4590
4591 ListT<Element*> dataFileList = (*pInfo)->getChildren(XML_DATAFILE_ELEMENT);
4592 Element **pDF = dataFileList.First();
4593
4594 while ( pDF )
4595 {
4596 Chain fileName = (*pDF)->getAttributeValue(XML_NAME_ATTR);
4597 if ( fileName.length() > maxLen )
4598 maxLen = fileName.length();
4599 pDF = dataFileList.Next();
4600 }
4601
4602 ListT<CegoField> schema;
4603 schema.Insert(CegoField(Chain("BUFILEINFO"), Chain("BUILEINFO"), Chain("FILENAME"), VARCHAR_TYPE, maxLen));
4604 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("DATAFILEINFO"), schema, Chain("DATAFILEINFO"));
4605
4606 CegoFieldValue t1(VARCHAR_TYPE, (*pInfo)->getAttributeValue(XML_TEMPFILE_ATTR));
4607
4608 ListT<CegoFieldValue> tl;
4609
4610 tl.Insert(t1);
4611
4612 info.Insert(tl);
4613
4614 pDF = dataFileList.First();
4615 while ( pDF )
4616 {
4617 Chain fileName = (*pDF)->getAttributeValue(XML_NAME_ATTR);
4618
4619 CegoFieldValue f1(VARCHAR_TYPE, fileName);
4620
4621 ListT<CegoFieldValue> fl;
4622
4623 fl.Insert(f1);
4624
4625 info.Insert(fl);
4626
4627 pDF = dataFileList.Next();
4628 }
4629 }
4630 }
4631 }
4632
getDataFileInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info,Chain & format)4633 void CegoAdminHandler::getDataFileInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info, Chain& format)
4634 {
4635 Element *pRoot = _xml.getDocument()->getRootElement();
4636
4637 if ( pRoot )
4638 {
4639 ListT<Element*> tsInfoList = pRoot->getChildren(XML_TABLESET_ELEMENT);
4640 Element **pInfo = tsInfoList.First();
4641
4642 if ( pInfo )
4643 {
4644 Chain sysFile = (*pInfo)->getAttributeValue(XML_SYSFILE_ATTR);
4645 unsigned int maxLen=sysFile.length();
4646
4647 Chain tempFile = (*pInfo)->getAttributeValue(XML_TEMPFILE_ATTR);
4648 if ( tempFile.length() > maxLen )
4649 maxLen=tempFile.length();
4650
4651 ListT<Element*> dataFileList = (*pInfo)->getChildren(XML_DATAFILE_ELEMENT);
4652 Element **pDF = dataFileList.First();
4653
4654 while ( pDF )
4655 {
4656 Chain fileName = (*pDF)->getAttributeValue(XML_NAME_ATTR);
4657 if ( fileName.length() > maxLen )
4658 maxLen = fileName.length();
4659 pDF = dataFileList.Next();
4660 }
4661
4662 CegoFieldValue s1(VARCHAR_TYPE, sysFile);
4663 CegoFieldValue s2(VARCHAR_TYPE, Chain(XML_SYSFILE_ATTR));
4664 CegoFieldValue s3(INT_TYPE, (*pInfo)->getAttributeValue(XML_SYSTOTAL_ATTR).asInteger());
4665 CegoFieldValue s4(INT_TYPE, (*pInfo)->getAttributeValue(XML_SYSUSED_ATTR).asInteger());
4666
4667 ListT<CegoFieldValue> sl;
4668
4669 sl.Insert(s1);
4670 sl.Insert(s2);
4671 sl.Insert(s3);
4672 sl.Insert(s4);
4673
4674 info.Insert(sl);
4675
4676 ListT<CegoField> schema;
4677 schema.Insert(CegoField(Chain("DATAFILEINFO"), Chain("DATAFILEINFO"), Chain("FILENAME"), VARCHAR_TYPE, maxLen));
4678 schema.Insert(CegoField(Chain("DATAFILEINFO"), Chain("DATAFILEINFO"), Chain("FILETYPE"), VARCHAR_TYPE, 10));
4679 schema.Insert(CegoField(Chain("DATAFILEINFO"), Chain("DATAFILEINFO"), Chain("SIZE"), INT_TYPE, sizeof(int)));
4680 schema.Insert(CegoField(Chain("DATAFILEINFO"), Chain("DATAFILEINFO"), Chain("USED"), INT_TYPE, sizeof(int)));
4681 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("DATAFILEINFO"), schema, Chain("DATAFILEINFO"));
4682
4683 format = Chain("llrr");
4684
4685 CegoFieldValue t1(VARCHAR_TYPE, (*pInfo)->getAttributeValue(XML_TEMPFILE_ATTR));
4686 CegoFieldValue t2(VARCHAR_TYPE, Chain(XML_TEMPFILE_ATTR));
4687 CegoFieldValue t3(INT_TYPE, (*pInfo)->getAttributeValue(XML_TEMPTOTAL_ATTR).asInteger());
4688 CegoFieldValue t4(INT_TYPE, (*pInfo)->getAttributeValue(XML_TEMPUSED_ATTR).asInteger());
4689
4690 ListT<CegoFieldValue> tl;
4691
4692 tl.Insert(t1);
4693 tl.Insert(t2);
4694 tl.Insert(t3);
4695 tl.Insert(t4);
4696
4697 info.Insert(tl);
4698
4699 pDF = dataFileList.First();
4700 while ( pDF )
4701 {
4702 Chain fileName = (*pDF)->getAttributeValue(XML_NAME_ATTR);
4703 Chain fileType = (*pDF)->getAttributeValue(XML_TYPE_ATTR);
4704
4705 Chain numTotal = (*pDF)->getAttributeValue(XML_NUMTOTAL_ATTR);
4706 Chain numUsed = (*pDF)->getAttributeValue(XML_NUMUSED_ATTR);
4707
4708 CegoFieldValue f1(VARCHAR_TYPE, fileName);
4709 CegoFieldValue f2(VARCHAR_TYPE, fileType);
4710 CegoFieldValue f3(INT_TYPE, numTotal);
4711 CegoFieldValue f4(INT_TYPE, numUsed);
4712
4713 ListT<CegoFieldValue> fl;
4714
4715 fl.Insert(f1);
4716 fl.Insert(f2);
4717 fl.Insert(f3);
4718 fl.Insert(f4);
4719
4720 info.Insert(fl);
4721
4722 pDF = dataFileList.Next();
4723 }
4724 }
4725 }
4726 }
4727
getArchLogInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)4728 void CegoAdminHandler::getArchLogInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
4729 {
4730 Element *pRoot = _xml.getDocument()->getRootElement();
4731
4732 if ( pRoot )
4733 {
4734 ListT<Element*> tsInfoList = pRoot->getChildren(XML_TABLESET_ELEMENT);
4735 Element **pInfo = tsInfoList.First();
4736
4737 if ( pInfo )
4738 {
4739 ListT<Element*> archLogList = (*pInfo)->getChildren(XML_ARCHIVELOG_ELEMENT);
4740 Element **pAL = archLogList.First();
4741
4742 unsigned int maxLen = 0;
4743 while ( pAL )
4744 {
4745 Chain archPath = (*pAL)->getAttributeValue(XML_ARCHPATH_ATTR);
4746
4747 if ( maxLen < archPath.length() )
4748 maxLen = archPath.length();
4749
4750 pAL = archLogList.Next();
4751 }
4752
4753 ListT<CegoField> schema;
4754 schema.Insert(CegoField(Chain("ARCHLOGINFO"), Chain("ARCHLOGINFO"), Chain("ARCHID"), VARCHAR_TYPE, 10));
4755 schema.Insert(CegoField(Chain("ARCHLOGINFO"), Chain("ARCHLOGINFO"), Chain("ARCHPATH"), VARCHAR_TYPE, maxLen));
4756 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("ARCHLOGINFO"), schema, Chain("ARCHLOGINFO"));
4757
4758 pAL = archLogList.First();
4759 while ( pAL )
4760 {
4761 Chain archId = (*pAL)->getAttributeValue(XML_ARCHID_ATTR);
4762 Chain archPath = (*pAL)->getAttributeValue(XML_ARCHPATH_ATTR);
4763
4764 CegoFieldValue f1(VARCHAR_TYPE, archId);
4765 CegoFieldValue f2(VARCHAR_TYPE, archPath);
4766
4767 ListT<CegoFieldValue> fl;
4768
4769 fl.Insert(f1);
4770 fl.Insert(f2);
4771
4772 info.Insert(fl);
4773
4774 pAL = archLogList.Next();
4775 }
4776 }
4777 }
4778 }
4779
getObjectInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)4780 void CegoAdminHandler::getObjectInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
4781 {
4782 Element *pRoot = _xml.getDocument()->getRootElement();
4783
4784 if ( pRoot )
4785 {
4786 ListT<Element*> oList = pRoot->getChildren(XML_OBJLIST_ELEMENT);
4787 Element **pOL = oList.First();
4788
4789 ListT<CegoField> schema;
4790 schema.Insert(CegoField(Chain("OBJINFO"), Chain("OBJINFO"), Chain("Type"), VARCHAR_TYPE, 10));
4791 schema.Insert(CegoField(Chain("OBJINFO"), Chain("OBJINFO"), Chain("Name"), VARCHAR_TYPE, 20));
4792 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("OBJINFO"), schema, Chain("OBJINFO"));
4793
4794 if ( pOL )
4795 {
4796 ListT<Element*> oeList = (*pOL)->getChildren(XML_OBJ_ELEMENT);
4797
4798 Element **pOE = oeList.First();
4799
4800 while ( pOE )
4801 {
4802 Chain objType = (*pOE)->getAttributeValue(XML_OBJTYPE_ATTR);
4803 Chain objName = (*pOE)->getAttributeValue(XML_OBJNAME_ATTR);
4804
4805 CegoFieldValue f1(VARCHAR_TYPE, objType);
4806 CegoFieldValue f2(VARCHAR_TYPE, objName);
4807
4808 ListT<CegoFieldValue> fl;
4809
4810 fl.Insert(f1);
4811 fl.Insert(f2);
4812
4813 info.Insert(fl);
4814
4815 pOE = oeList.Next();
4816 }
4817 }
4818 }
4819 }
4820
getTransactionInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)4821 void CegoAdminHandler::getTransactionInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
4822 {
4823 Element *pRoot = _xml.getDocument()->getRootElement();
4824
4825 if ( pRoot )
4826 {
4827 ListT<Element*> taList = pRoot->getChildren(XML_TAINFO_ELEMENT);
4828 Element **pTA = taList.First();
4829
4830 ListT<CegoField> schema;
4831 schema.Insert(CegoField(Chain("TAINFO"), Chain("TAINFO"), Chain("RBO"), VARCHAR_TYPE, 15));
4832 schema.Insert(CegoField(Chain("TAINFO"), Chain("TAINFO"), Chain("NUMOP"), INT_TYPE, sizeof(int)));
4833 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("TAINFO"), schema, Chain("TAINFO"));
4834
4835 if ( pTA )
4836 {
4837 ListT<Element*> teList = (*pTA)->getChildren(XML_TAENTRY_ELEMENT);
4838
4839 Element **pTE = teList.First();
4840
4841 while ( pTE )
4842 {
4843 Chain rbo = (*pTE)->getAttributeValue(XML_RBO_ATTR);
4844 Chain numOp = (*pTE)->getAttributeValue(XML_NUMOP_ATTR);
4845
4846 CegoFieldValue f1(VARCHAR_TYPE, rbo);
4847 CegoFieldValue f2(VARCHAR_TYPE, numOp);
4848
4849 ListT<CegoFieldValue> fl;
4850
4851 fl.Insert(f1);
4852 fl.Insert(f2);
4853
4854 info.Insert(fl);
4855
4856 pTE = teList.Next();
4857 }
4858 }
4859 }
4860 }
4861
getBUStatInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)4862 void CegoAdminHandler::getBUStatInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
4863 {
4864 Element *pRoot = _xml.getDocument()->getRootElement();
4865
4866 if ( pRoot )
4867 {
4868 ListT<Element*> busList = pRoot->getChildren(XML_BUSINFO_ELEMENT);
4869 Element **pBUS = busList.First();
4870
4871 ListT<CegoField> schema;
4872 schema.Insert(CegoField(Chain("BUSTAT"), Chain("BUSTAT"), Chain("TS"), VARCHAR_TYPE, 20));
4873 schema.Insert(CegoField(Chain("BUSTAT"), Chain("BUSTAT"), Chain("BUINFO"), VARCHAR_TYPE, 20));
4874 schema.Insert(CegoField(Chain("BUSTAT"), Chain("BUSTAT"), Chain("BUMSG"), VARCHAR_TYPE, 50));
4875 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("BUSTAT"), schema, Chain("BUSTAT"));
4876
4877 if ( pBUS )
4878 {
4879 ListT<Element*> bueList = (*pBUS)->getChildren(XML_BUENTRY_ELEMENT);
4880
4881 Element **pBUE = bueList.First();
4882
4883 while ( pBUE )
4884 {
4885 Chain ts = (*pBUE)->getAttributeValue(XML_TIMESTAMP_ATTR);
4886 Chain buinfo = (*pBUE)->getAttributeValue(XML_BUINFO_ATTR);
4887 Chain bumsg = (*pBUE)->getAttributeValue(XML_BUMSG_ATTR);
4888
4889 CegoFieldValue f1(VARCHAR_TYPE, ts);
4890 CegoFieldValue f2(VARCHAR_TYPE, buinfo);
4891 CegoFieldValue f3(VARCHAR_TYPE, bumsg);
4892
4893 ListT<CegoFieldValue> fl;
4894
4895 fl.Insert(f1);
4896 fl.Insert(f2);
4897 fl.Insert(f3);
4898
4899 info.Insert(fl);
4900
4901 pBUE = bueList.Next();
4902 }
4903 }
4904 }
4905 }
4906
getBackupInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)4907 void CegoAdminHandler::getBackupInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
4908 {
4909 Element *pRoot = _xml.getDocument()->getRootElement();
4910
4911 if ( pRoot )
4912 {
4913 ListT<Element*> backupInfoList = pRoot->getChildren(XML_BACKUPLIST_ELEMENT);
4914
4915 Element **pInfo = backupInfoList.First();
4916
4917 if ( pInfo )
4918 {
4919 ListT<Element*> backupList = (*pInfo)->getChildren(XML_BACKUP_ELEMENT);
4920
4921 ListT<CegoField> schema;
4922 schema.Insert(CegoField(Chain("BACKUPLIST"), Chain("BACKUPLIST"), Chain("ID"), VARCHAR_TYPE, 25));
4923 schema.Insert(CegoField(Chain("BACKUPLIST"), Chain("BACKUPLIST"), Chain("TS"), VARCHAR_TYPE, 25));
4924 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("BACKUPINFO"), schema, Chain("BACKUPINFO"));
4925
4926 Element **pBackup = backupList.First();
4927
4928 while ( pBackup )
4929 {
4930
4931 ListT<CegoFieldValue> fl;
4932
4933 Chain id = (*pBackup)->getAttributeValue(XML_BACKUPID_ATTR);
4934 CegoFieldValue f1(VARCHAR_TYPE, id);
4935 fl.Insert(f1);
4936
4937 Chain ts = (*pBackup)->getAttributeValue(XML_BACKUPTS_ATTR);
4938 CegoFieldValue f2(VARCHAR_TYPE, ts);
4939 fl.Insert(f2);
4940
4941 info.Insert(fl);
4942
4943 pBackup = backupList.Next();
4944 }
4945 }
4946 }
4947 return;
4948 }
4949
getNodeInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)4950 void CegoAdminHandler::getNodeInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
4951 {
4952 Element *pRoot = _xml.getDocument()->getRootElement();
4953
4954 if ( pRoot )
4955 {
4956 ListT<Element*> nodeInfoList = pRoot->getChildren(XML_NODEINFO_ELEMENT);
4957 Element **pInfo = nodeInfoList.First();
4958
4959 ListT<Element*> nodeList = (*pInfo)->getChildren(XML_NODE_ELEMENT);
4960 Element **pN = nodeList.First();
4961
4962 unsigned int maxLen = 0;
4963 while ( pN )
4964 {
4965 Chain hostName = (*pN)->getAttributeValue(XML_HOSTNAME_ATTR);
4966
4967 if ( maxLen < hostName.length() )
4968 maxLen = hostName.length();
4969
4970 pN = nodeList.Next();
4971 }
4972
4973 ListT<CegoField> schema;
4974 schema.Insert(CegoField(Chain("NODEINFO"), Chain("NODEINFO"), Chain("NAME"), VARCHAR_TYPE, maxLen));
4975 schema.Insert(CegoField(Chain("NODEINFO"), Chain("NODEINFO"), Chain("STATUS"), VARCHAR_TYPE, 10));
4976 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("NODEINFO"), schema, Chain("NODEINFO"));
4977
4978 pN = nodeList.First();
4979 while ( pN )
4980 {
4981 Chain hostName = (*pN)->getAttributeValue(XML_HOSTNAME_ATTR);
4982 Chain status = (*pN)->getAttributeValue(XML_STATUS_ATTR);
4983
4984 CegoFieldValue f1(VARCHAR_TYPE, hostName);
4985 CegoFieldValue f2(VARCHAR_TYPE, status);
4986
4987 ListT<CegoFieldValue> fl;
4988
4989 fl.Insert(f1);
4990 fl.Insert(f2);
4991
4992 info.Insert(fl);
4993
4994 pN = nodeList.Next();
4995 }
4996 }
4997 }
4998
getUserInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)4999 void CegoAdminHandler::getUserInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
5000 {
5001 int userLen=10;
5002 int roleLen=10;
5003
5004 Element *pRoot = _xml.getDocument()->getRootElement();
5005
5006 if ( pRoot )
5007 {
5008 ListT<Element*> userInfoList = pRoot->getChildren(XML_USERINFO_ELEMENT);
5009 Element **pUserInfoElement = userInfoList.First();
5010 if ( pUserInfoElement )
5011 {
5012 ListT<Element*> userElementList = (*pUserInfoElement)->getChildren(XML_USER_ELEMENT);
5013 Element **pUserElement = userElementList.First();
5014
5015 while ( pUserElement )
5016 {
5017 Chain userName = (*pUserElement)->getAttributeValue(XML_NAME_ATTR);
5018 if ( userName.length() > userLen )
5019 userLen=userName.length();
5020
5021 Chain role = (*pUserElement)->getAttributeValue(XML_ROLE_ATTR);
5022 if ( role.length() > roleLen )
5023 roleLen=role.length();
5024
5025 Chain trace = (*pUserElement)->getAttributeValue(XML_TRACE_ATTR);
5026
5027 Chain numReq = (*pUserElement)->getAttributeValue(XML_NUMREQUEST_ATTR);
5028 Chain numQuery = (*pUserElement)->getAttributeValue(XML_NUMQUERY_ATTR);
5029
5030 CegoFieldValue f1(VARCHAR_TYPE, userName);
5031 CegoFieldValue f2(VARCHAR_TYPE, role);
5032 CegoFieldValue f3(VARCHAR_TYPE, trace);
5033 CegoFieldValue f4(VARCHAR_TYPE, numReq);
5034 CegoFieldValue f5(VARCHAR_TYPE, numQuery);
5035
5036 ListT<CegoFieldValue> fl;
5037
5038 fl.Insert(f1);
5039 fl.Insert(f2);
5040 fl.Insert(f3);
5041 fl.Insert(f4);
5042 fl.Insert(f5);
5043
5044 info.Insert(fl);
5045
5046 pUserElement = userElementList.Next();
5047 }
5048 }
5049 }
5050
5051 ListT<CegoField> schema;
5052 schema.Insert(CegoField(Chain("USERINFO"), Chain("USERINFO"), Chain("NAME"), VARCHAR_TYPE, userLen));
5053 schema.Insert(CegoField(Chain("USERINFO"), Chain("USERINFO"), Chain("ROLE"), VARCHAR_TYPE, roleLen));
5054 schema.Insert(CegoField(Chain("USERINFO"), Chain("USERINFO"), Chain("TRACE"), VARCHAR_TYPE, 10));
5055 schema.Insert(CegoField(Chain("USERINFO"), Chain("USERINFO"), Chain("NUMREQ"), VARCHAR_TYPE, 10));
5056 schema.Insert(CegoField(Chain("USERINFO"), Chain("USERINFO"), Chain("NUMQUERY"), VARCHAR_TYPE, 10));
5057
5058 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("USERINFO"), schema, Chain("USERINFO"));
5059 }
5060
getTableSetVerificationInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)5061 void CegoAdminHandler::getTableSetVerificationInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
5062 {
5063 ListT<CegoField> schema;
5064 schema.Insert(CegoField(Chain("TSVERIFY"), Chain("TSVERIFY"), Chain("TYPE"), VARCHAR_TYPE, 15));
5065 schema.Insert(CegoField(Chain("TSVERIFY"), Chain("TSVERIFY"), Chain("NAME"), VARCHAR_TYPE, 40));
5066 schema.Insert(CegoField(Chain("TSVERIFY"), Chain("TSVERIFY"), Chain("STATUS"), VARCHAR_TYPE, 50));
5067 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("TSVERIFY"), schema, Chain("TSVERIFY"));
5068
5069 Element *pRoot = _xml.getDocument()->getRootElement();
5070
5071 if ( pRoot )
5072 {
5073 ListT<Element*> verifyInfoList = pRoot->getChildren(XML_VERIFICATION_ELEMENT);
5074 Element **pVerifyInfoElement = verifyInfoList.First();
5075 if ( pVerifyInfoElement )
5076 {
5077 ListT<Element*> checkElementList = (*pVerifyInfoElement)->getChildren(XML_CHECK_ELEMENT);
5078 Element **pCheckElement = checkElementList.First();
5079
5080 while ( pCheckElement )
5081 {
5082 Chain checkType = (*pCheckElement)->getAttributeValue(XML_TYPE_ATTR);
5083 Chain checkName = (*pCheckElement)->getAttributeValue(XML_NAME_ATTR);
5084 Chain checkStatus = (*pCheckElement)->getAttributeValue(XML_VALUE_ATTR);
5085
5086 CegoFieldValue f1(VARCHAR_TYPE, checkType);
5087 CegoFieldValue f2(VARCHAR_TYPE, checkName);
5088 CegoFieldValue f3(VARCHAR_TYPE, checkStatus);
5089
5090 ListT<CegoFieldValue> fl;
5091
5092 fl.Insert(f1);
5093 fl.Insert(f2);
5094 fl.Insert(f3);
5095
5096 info.Insert(fl);
5097
5098 pCheckElement = checkElementList.Next();
5099 }
5100 }
5101 }
5102 }
5103
getTableSetCorrectionInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)5104 void CegoAdminHandler::getTableSetCorrectionInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
5105 {
5106 ListT<CegoField> schema;
5107 schema.Insert(CegoField(Chain("TSCORRECT"), Chain("TSCORRECT"), Chain("TYPE"), VARCHAR_TYPE, 15));
5108 schema.Insert(CegoField(Chain("TSCORRECT"), Chain("TSCORRECT"), Chain("NAME"), VARCHAR_TYPE, 40));
5109 schema.Insert(CegoField(Chain("TSCORRECT"), Chain("TSCORRECT"), Chain("STATUS"), VARCHAR_TYPE, 50));
5110 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("TSCORRECT"), schema, Chain("TSCORRECT"));
5111
5112 Element *pRoot = _xml.getDocument()->getRootElement();
5113
5114 if ( pRoot )
5115 {
5116 ListT<Element*> correctInfoList = pRoot->getChildren(XML_CORRECTION_ELEMENT);
5117 Element **pCorrectInfoElement = correctInfoList.First();
5118 if ( pCorrectInfoElement )
5119 {
5120 ListT<Element*> checkElementList = (*pCorrectInfoElement)->getChildren(XML_CHECK_ELEMENT);
5121 Element **pCheckElement = checkElementList.First();
5122
5123 while ( pCheckElement )
5124 {
5125 Chain checkType = (*pCheckElement)->getAttributeValue(XML_TYPE_ATTR);
5126 Chain checkName = (*pCheckElement)->getAttributeValue(XML_NAME_ATTR);
5127 Chain checkStatus = (*pCheckElement)->getAttributeValue(XML_VALUE_ATTR);
5128
5129 CegoFieldValue f1(VARCHAR_TYPE, checkType);
5130 CegoFieldValue f2(VARCHAR_TYPE, checkName);
5131 CegoFieldValue f3(VARCHAR_TYPE, checkStatus);
5132
5133 ListT<CegoFieldValue> fl;
5134
5135 fl.Insert(f1);
5136 fl.Insert(f2);
5137 fl.Insert(f3);
5138
5139 info.Insert(fl);
5140
5141 pCheckElement = checkElementList.Next();
5142 }
5143 }
5144 }
5145 }
5146
getRoleList(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)5147 void CegoAdminHandler::getRoleList(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
5148 {
5149 ListT<CegoField> schema;
5150 schema.Insert(CegoField(Chain("ROLELIST"), Chain("ROLELIST"), Chain("ROLE"), VARCHAR_TYPE, 15));
5151 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("ROLELIST"), schema, Chain("ROLELIST"));
5152
5153 Element *pRoot = _xml.getDocument()->getRootElement();
5154
5155 if ( pRoot )
5156 {
5157 ListT<Element*> roleListElementList = pRoot->getChildren(XML_ROLELIST_ELEMENT);
5158 Element **pRoleListElement = roleListElementList.First();
5159 if ( pRoleListElement )
5160 {
5161 ListT<Element*> roleList = (*pRoleListElement)->getChildren(XML_ROLE_ELEMENT);
5162 Element **pRoleElement = roleList.First();
5163 while ( pRoleElement )
5164 {
5165 Chain role = (*pRoleElement)->getAttributeValue(XML_NAME_ATTR);
5166
5167 CegoFieldValue f1(VARCHAR_TYPE, role);
5168
5169 ListT<CegoFieldValue> fl;
5170
5171 fl.Insert(f1);
5172
5173 info.Insert(fl);
5174
5175 pRoleElement = roleList.Next();
5176 }
5177 }
5178 }
5179 }
5180
getRoleInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)5181 void CegoAdminHandler::getRoleInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
5182 {
5183 ListT<CegoField> schema;
5184 schema.Insert(CegoField(Chain("ROLEINFO"), Chain("ROLEINFO"), Chain("PERMID"), VARCHAR_TYPE, 15));
5185 schema.Insert(CegoField(Chain("ROLEINFO"), Chain("ROLEINFO"), Chain("TABLESET"), VARCHAR_TYPE, 20));
5186 schema.Insert(CegoField(Chain("ROLEINFO"), Chain("ROLEINFO"), Chain("FILTER"), VARCHAR_TYPE, 15));
5187 schema.Insert(CegoField(Chain("ROLEINFO"), Chain("ROLEINFO"), Chain("PERM"), VARCHAR_TYPE, 15));
5188 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("ROLEINFO"), schema, Chain("ROLEINFO"));
5189
5190 Element *pRoot = _xml.getDocument()->getRootElement();
5191
5192 if ( pRoot )
5193 {
5194 ListT<Element*> permInfoList = pRoot->getChildren(XML_PERMINFO_ELEMENT);
5195
5196 Element** pPermInfo = permInfoList.First();
5197
5198 if ( pPermInfo )
5199 {
5200 ListT<Element*> permList = (*pPermInfo)->getChildren(XML_PERM_ELEMENT);
5201 Element **pPermElement = permList.First();
5202 while ( pPermElement )
5203 {
5204 Chain permid = (*pPermElement)->getAttributeValue(XML_PERMID_ATTR);
5205 Chain tableSet = (*pPermElement)->getAttributeValue(XML_TABLESET_ATTR);
5206 Chain filter = (*pPermElement)->getAttributeValue(XML_FILTER_ATTR);
5207 Chain perm = (*pPermElement)->getAttributeValue(XML_PERM_ATTR);
5208
5209 CegoFieldValue f1(VARCHAR_TYPE, permid);
5210 CegoFieldValue f2(VARCHAR_TYPE, tableSet);
5211 CegoFieldValue f3(VARCHAR_TYPE, filter);
5212 CegoFieldValue f4(VARCHAR_TYPE, perm);
5213
5214 ListT<CegoFieldValue> fl;
5215
5216 fl.Insert(f1);
5217 fl.Insert(f2);
5218 fl.Insert(f3);
5219 fl.Insert(f4);
5220
5221 info.Insert(fl);
5222
5223 pPermElement = permList.Next();
5224 }
5225 }
5226 }
5227 }
5228
getLogInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)5229 void CegoAdminHandler::getLogInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
5230 {
5231 Element *pRoot = _xml.getDocument()->getRootElement();
5232
5233 if ( pRoot )
5234 {
5235 ListT<Element*> tsInfoList = pRoot->getChildren(XML_TABLESET_ELEMENT);
5236 Element **pInfo = tsInfoList.First();
5237
5238 ListT<Element*> logList = (*pInfo)->getChildren(XML_LOGFILE_ELEMENT);
5239 Element **pL = logList.First();
5240
5241 unsigned int maxLen = 0;
5242 while ( pL )
5243 {
5244 Chain logName = (*pL)->getAttributeValue(XML_NAME_ATTR);
5245
5246 if ( maxLen < logName.length() )
5247 maxLen = logName.length();
5248
5249 pL = logList.Next();
5250 }
5251
5252 ListT<CegoField> schema;
5253 schema.Insert(CegoField(Chain("LOGFILE"), Chain("LOGFILE"), Chain("NAME"), VARCHAR_TYPE, maxLen));
5254 schema.Insert(CegoField(Chain("LOGFILE"), Chain("LOGFILE"), Chain("STATUS"), VARCHAR_TYPE, 10));
5255 schema.Insert(CegoField(Chain("LOGFILE"), Chain("LOGFILE"), Chain("SIZE"), VARCHAR_TYPE, 20));
5256 schema.Insert(CegoField(Chain("LOGFILE"), Chain("LOGFILE"), Chain("OFFSET"), VARCHAR_TYPE, 20));
5257 schema.Insert(CegoField(Chain("LOGFILE"), Chain("LOGFILE"), Chain("USAGE"), VARCHAR_TYPE, 20));
5258
5259 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("LOGFILE"), schema, Chain("LOGFILE"));
5260
5261 pL = logList.First();
5262 while ( pL )
5263 {
5264 Chain logName = (*pL)->getAttributeValue(XML_NAME_ATTR);
5265 Chain logStatus = (*pL)->getAttributeValue(XML_STATUS_ATTR);
5266 Chain logSize = (*pL)->getAttributeValue(XML_SIZE_ATTR);
5267 Chain logOffset = (*pL)->getAttributeValue(XML_OFFSET_ATTR);
5268
5269 CegoFieldValue f1(VARCHAR_TYPE, logName);
5270 CegoFieldValue f2(VARCHAR_TYPE, logStatus);
5271 CegoFieldValue f3(VARCHAR_TYPE, logSize);
5272 CegoFieldValue f4(VARCHAR_TYPE, logOffset);
5273 unsigned long long percentUsage = logOffset.asUnsignedLongLong() / ( logSize.asUnsignedLongLong() / 100 );
5274 CegoFieldValue f5(VARCHAR_TYPE, Chain(percentUsage) + Chain("%"));
5275
5276 ListT<CegoFieldValue> fl;
5277
5278 fl.Insert(f1);
5279 fl.Insert(f2);
5280 fl.Insert(f3);
5281 fl.Insert(f4);
5282 fl.Insert(f5);
5283
5284 info.Insert(fl);
5285
5286 pL = logList.Next();
5287 }
5288 }
5289 }
5290
getLogMngInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)5291 void CegoAdminHandler::getLogMngInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
5292 {
5293 Element *pRoot = _xml.getDocument()->getRootElement();
5294
5295 Chain logMng;
5296 Chain timeout;
5297
5298 if ( pRoot )
5299 {
5300 ListT<Element*> logMngInfo = pRoot->getChildren(XML_LOGMNGINFO_ELEMENT);
5301
5302 Element** pLogMng = logMngInfo.First();
5303
5304 if ( pLogMng )
5305 {
5306 logMng = (*pLogMng)->getAttributeValue(XML_LOGMNGPROG_ATTR);
5307 timeout = (*pLogMng)->getAttributeValue(XML_LOGMNGTIMEOUT_ATTR);
5308
5309
5310 }
5311 }
5312
5313 ListT<CegoField> schema;
5314 schema.Insert(CegoField(Chain("LOGMNGINFO"), Chain("LOGMNGINFO"), Chain("LOGMANAGER"), VARCHAR_TYPE, MAX(logMng.length(),30)));
5315 schema.Insert(CegoField(Chain("LOGMNGINFO"), Chain("LOGMNGINFO"), Chain("TIMEOUT"), VARCHAR_TYPE, 10));
5316 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("LOGMNGINFO"), schema, Chain("LOGMNGINFO"));
5317
5318 CegoFieldValue f1(VARCHAR_TYPE, logMng);
5319 CegoFieldValue f2(VARCHAR_TYPE, timeout);
5320
5321 ListT<CegoFieldValue> fl;
5322
5323 fl.Insert(f1);
5324 fl.Insert(f2);
5325
5326 info.Insert(fl);
5327
5328 }
5329
getBackupMngInfo(CegoTableObject & oe,ListT<ListT<CegoFieldValue>> & info)5330 void CegoAdminHandler::getBackupMngInfo(CegoTableObject& oe, ListT<ListT< CegoFieldValue > > & info)
5331 {
5332 Element *pRoot = _xml.getDocument()->getRootElement();
5333
5334 Chain backupMng;
5335
5336 if ( pRoot )
5337 {
5338 ListT<Element*> backupMngInfo = pRoot->getChildren(XML_BACKUPMNGINFO_ELEMENT);
5339
5340 Element** pBackupMng = backupMngInfo.First();
5341
5342 if ( pBackupMng )
5343 {
5344 backupMng = (*pBackupMng)->getAttributeValue(XML_BACKUPMNGPROG_ATTR);
5345 }
5346 }
5347
5348 ListT<CegoField> schema;
5349 schema.Insert(CegoField(Chain("BACKUPMNGINFO"), Chain("BACKUPMNGINFO"), Chain("BACKUPMANAGER"), VARCHAR_TYPE, MAX(backupMng.length(),30)));
5350 oe = CegoTableObject( 0, CegoObject::SYSTEM, Chain("BACKUPMNGINFO"), schema, Chain("BACKUPMNGINFO"));
5351
5352 CegoFieldValue f1(VARCHAR_TYPE, backupMng);
5353
5354 ListT<CegoFieldValue> fl;
5355
5356 fl.Insert(f1);
5357
5358 info.Insert(fl);
5359 }
5360