Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TRootSniffer.cxx
Go to the documentation of this file.
1// $Id$
2// Author: Sergey Linev 22/12/2013
3
4/*************************************************************************
5 * Copyright (C) 1995-2013, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12#include "TRootSniffer.h"
13
14#include "TDirectoryFile.h"
15#include "TKey.h"
16#include "TList.h"
17#include "TBufferJSON.h"
18#include "TROOT.h"
19#include "TFolder.h"
20#include "TClass.h"
21#include "TRealData.h"
22#include "TDataMember.h"
23#include "TDataType.h"
24#include "TObjString.h"
25#include "TObjArray.h"
26#include "TUrl.h"
27#include "TVirtualMutex.h"
28#include "TRootSnifferStore.h"
29#include "THttpCallArg.h"
30
31#include <cstdlib>
32#include <memory>
33#include <vector>
34#include <cstring>
35
36const char *item_prop_kind = "_kind";
37const char *item_prop_more = "_more";
38const char *item_prop_title = "_title";
39const char *item_prop_hidden = "_hidden";
40const char *item_prop_typename = "_typename";
41const char *item_prop_arraydim = "_arraydim";
42const char *item_prop_realname = "_realname"; // real object name
43const char *item_prop_user = "_username";
44const char *item_prop_autoload = "_autoload";
45const char *item_prop_rootversion = "_root_version";
46
47/** \class TRootSnifferScanRec
48\ingroup http
49
50Structure used to scan hierarchies of ROOT objects
51
52Represents single level of hierarchy
53*/
54
55////////////////////////////////////////////////////////////////////////////////
56/// constructor
57
59{
61}
62
63////////////////////////////////////////////////////////////////////////////////
64/// destructor
65
67{
68 CloseNode();
69}
70
71////////////////////////////////////////////////////////////////////////////////
72/// record field for current element
73
74void TRootSnifferScanRec::SetField(const char *name, const char *value, Bool_t with_quotes)
75{
76 if (CanSetFields())
77 fStore->SetField(fLevel, name, value, with_quotes);
78 fNumFields++;
79}
80
81////////////////////////////////////////////////////////////////////////////////
82/// Indicates that new child for current element will be started
83
85{
86 if (CanSetFields())
88 fNumChilds++;
89}
90
91////////////////////////////////////////////////////////////////////////////////
92/// Constructs item name from object name
93/// if special symbols like '/', '#', ':', '&', '?' are used in object name
94/// they will be replaced with '_'.
95/// To avoid item name duplication, additional id number can be appended
96
97void TRootSnifferScanRec::MakeItemName(const char *objname, TString &itemname)
98{
99 std::string nnn = objname;
100
101 size_t pos;
102
103 // replace all special symbols which can make problem to navigate in hierarchy
104 while ((pos = nnn.find_first_of("- []<>#:&?/\'\"\\")) != std::string::npos)
105 nnn.replace(pos, 1, "_");
106
107 itemname = nnn.c_str();
108 Int_t cnt = 0;
109
110 while (fItemsNames.FindObject(itemname.Data())) {
111 itemname.Form("%s_%d", nnn.c_str(), cnt++);
112 }
113
114 fItemsNames.Add(new TObjString(itemname.Data()));
115}
116
117////////////////////////////////////////////////////////////////////////////////
118/// Produce full name, including all parents
119
121{
122 if (!prnt)
123 prnt = fParent;
124
125 if (prnt) {
126 prnt->BuildFullName(buf);
127
128 buf.Append("/");
129 buf.Append(fItemName);
130 }
131}
132
133////////////////////////////////////////////////////////////////////////////////
134/// Creates new node with specified name
135/// if special symbols like "[]&<>" are used, node name
136/// will be replaced by default name like "extra_item_N" and
137/// original node name will be recorded as "_original_name" field
138/// Optionally, object name can be recorded as "_realname" field
139
140void TRootSnifferScanRec::CreateNode(const char *_node_name)
141{
142 if (!CanSetFields())
143 return;
144
146
147 if (fParent)
149
150 if (fStore)
151 fStore->CreateNode(fLevel, _node_name);
152}
153
154////////////////////////////////////////////////////////////////////////////////
155/// Close started node
156
158{
159 if (fStore && fNodeStarted) {
162 }
163}
164
165////////////////////////////////////////////////////////////////////////////////
166/// set root class name as node kind
167/// in addition, path to master item (streamer info) specified
168/// Such master item required to correctly unstream data on JavaScript
169
171{
172 if (cl && CanSetFields())
174}
175
176////////////////////////////////////////////////////////////////////////////////
177/// returns true if scanning is done
178/// Can happen when searched element is found
179
181{
182 if (!fStore)
183 return kFALSE;
184
185 if ((fMask & kSearch) && fStore->GetResPtr())
186 return kTRUE;
187
188 if ((fMask & kCheckChilds) && fStore->GetResPtr() && (fStore->GetResNumChilds() >= 0))
189 return kTRUE;
190
191 return kFALSE;
192}
193
194////////////////////////////////////////////////////////////////////////////////
195/// Checks if result will be accepted.
196/// Used to verify if sniffer should read object from the file
197
199{
200 if (Done())
201 return kFALSE;
202
203 // only when doing search, result will be propagated
204 if ((fMask & (kSearch | kCheckChilds)) == 0)
205 return kFALSE;
206
207 // only when full search path is scanned
208 if (fSearchPath)
209 return kFALSE;
210
211 if (!fStore)
212 return kFALSE;
213
214 return kTRUE;
215}
216
217////////////////////////////////////////////////////////////////////////////////
218/// set results of scanning
219/// when member should be specified, use SetFoundResult instead
220
222{
223 if (!member)
224 return SetFoundResult(obj, cl);
225
226 fStore->Error("SetResult",
227 "When member specified, pointer on object (not member) should be provided; use SetFoundResult");
228 return kFALSE;
229}
230
231////////////////////////////////////////////////////////////////////////////////
232/// set results of scanning
233/// when member specified, obj is pointer on object to which member belongs
234
236{
237 if (Done())
238 return kTRUE;
239
240 if (!IsReadyForResult())
241 return kFALSE;
242
243 fStore->SetResult(obj, cl, member, fNumChilds, fRestriction);
244
245 return Done();
246}
247
248////////////////////////////////////////////////////////////////////////////////
249/// returns current depth of scanned hierarchy
250
252{
253 Int_t cnt = 0;
254 const TRootSnifferScanRec *rec = this;
255 while (rec->fParent) {
256 rec = rec->fParent;
257 cnt++;
258 }
259
260 return cnt;
261}
262
263////////////////////////////////////////////////////////////////////////////////
264/// returns true if current item can be expanded - means one could explore
265/// objects members
266
268{
269 if (fMask & (kExpand | kSearch | kCheckChilds))
270 return kTRUE;
271
272 if (!fHasMore)
273 return kFALSE;
274
275 // if parent has expand mask, allow to expand item
276 if (fParent && (fParent->fMask & kExpand))
277 return kTRUE;
278
279 return kFALSE;
280}
281
282////////////////////////////////////////////////////////////////////////////////
283/// returns read-only flag for current item
284/// Depends from default value and current restrictions
285
287{
288 if (fRestriction == 0)
289 return dflt;
290
291 return fRestriction != 2;
292}
293
294////////////////////////////////////////////////////////////////////////////////
295/// Method verifies if new level of hierarchy
296/// should be started with provided object.
297/// If required, all necessary nodes and fields will be created
298/// Used when different collection kinds should be scanned
299
301{
302 if (super.Done())
303 return kFALSE;
304
305 if (obj && !obj_name)
306 obj_name = obj->GetName();
307
308 // exclude zero names
309 if (!obj_name || (*obj_name == 0))
310 return kFALSE;
311
312 const char *full_name = nullptr;
313
314 // remove slashes from file names
315 if (obj && obj->InheritsFrom(TDirectoryFile::Class())) {
316 const char *slash = strrchr(obj_name, '/');
317 if (slash) {
318 full_name = obj_name;
319 obj_name = slash + 1;
320 if (*obj_name == 0)
321 obj_name = "file";
322 }
323 }
324
325 super.MakeItemName(obj_name, fItemName);
326
327 if (sniffer && sniffer->HasRestriction(fItemName.Data())) {
328 // check restriction more precisely
329 TString fullname;
330 BuildFullName(fullname, &super);
331 fRestriction = sniffer->CheckRestriction(fullname.Data());
332 if (fRestriction < 0)
333 return kFALSE;
334 }
335
336 fParent = &super;
337 fLevel = super.fLevel;
338 fStore = super.fStore;
339 fSearchPath = super.fSearchPath;
340 fMask = super.fMask & kActions;
341 if (fRestriction == 0)
342 fRestriction = super.fRestriction; // get restriction from parent
343 Bool_t topelement = kFALSE;
344
345 if (fMask & kScan) {
346 // if scanning only fields, ignore all childs
347 if (super.ScanOnlyFields())
348 return kFALSE;
349 // only when doing scan, increment level, used for text formatting
350 fLevel++;
351 } else {
352 if (!fSearchPath)
353 return kFALSE;
354
355 if (strncmp(fSearchPath, fItemName.Data(), fItemName.Length()) != 0)
356 return kFALSE;
357
358 const char *separ = fSearchPath + fItemName.Length();
359
360 Bool_t isslash = kFALSE;
361 while (*separ == '/') {
362 separ++;
363 isslash = kTRUE;
364 }
365
366 if (*separ == 0) {
367 fSearchPath = nullptr;
368 if (fMask & kExpand) {
369 topelement = kTRUE;
371 fHasMore = (fMask & kOnlyFields) == 0;
372 }
373 } else {
374 if (!isslash)
375 return kFALSE;
376 fSearchPath = separ;
377 }
378 }
379
381
382 if (obj_name && (fItemName != obj_name))
383 SetField(item_prop_realname, obj_name);
384
385 if (full_name)
386 SetField("_fullname", full_name);
387
388 if (topelement)
389 SetField(item_prop_rootversion, TString::Format("%d", gROOT->GetVersionCode()), kFALSE);
390
391 if (topelement && sniffer->GetAutoLoad())
393
394 return kTRUE;
395}
396
397
398/** \class TRootSniffer
399\ingroup http
400
401Sniffer of ROOT objects, data provider for THttpServer
402
403Provides methods to scan different structures like folders,
404directories, files and collections. Can locate objects (or its data member) per name.
405Can be extended to application-specific classes.
406
407Normally TRootSnifferFull class is used which able to access data from trees, canvases, histograms.
408*/
409
411
412////////////////////////////////////////////////////////////////////////////////
413/// constructor
414
415TRootSniffer::TRootSniffer(const char *name, const char *objpath)
416 : TNamed(name, "sniffer of root objects"), fObjectsPath(objpath)
417{
419}
420
421////////////////////////////////////////////////////////////////////////////////
422/// destructor
423
425{
426}
427
428////////////////////////////////////////////////////////////////////////////////
429/// set current http arguments, which then used in different process methods
430/// For instance, if user authorized with some user name,
431/// depending from restrictions some objects will be invisible
432/// or user get full access to the element
433/// Returns previous argument which was set before
434
436{
437 auto res = fCurrentArg;
438 fCurrentArg = arg;
441 return res;
442}
443
444////////////////////////////////////////////////////////////////////////////////
445/// Restrict access to the specified location
446///
447/// Hides or provides read-only access to different parts of the hierarchy
448/// Restriction done base on user-name specified with http requests
449/// Options can be specified in URL style (separated with &)
450/// Following parameters can be specified:
451///
452/// visible = [all|user(s)] - make item visible for all users or only specified user
453/// hidden = [all|user(s)] - make item hidden from all users or only specified user
454/// readonly = [all|user(s)] - make item read-only for all users or only specified user
455/// allow = [all|user(s)] - make full access for all users or only specified user
456/// allow_method = method(s) - allow method(s) execution even when readonly flag specified for the object
457///
458/// Like make command seen by all but can be executed only by admin
459///
460/// sniff->Restrict("/CmdReset","allow=admin");
461///
462/// Or fully hide command from guest account
463///
464/// sniff->Restrict("/CmdRebin","hidden=guest");
465
466void TRootSniffer::Restrict(const char *path, const char *options)
467{
468 const char *rslash = strrchr(path, '/');
469 if (rslash)
470 rslash++;
471 if (!rslash || (*rslash == 0))
472 rslash = path;
473
474 fRestrictions.Add(new TNamed(rslash, TString::Format("%s%s%s", path, "%%%", options).Data()));
475}
476
477////////////////////////////////////////////////////////////////////////////////
478/// When specified, _autoload attribute will be always add
479/// to top element of h.json/h.hml requests
480/// Used to instruct browser automatically load special code
481
482void TRootSniffer::SetAutoLoad(const char *scripts)
483{
484 fAutoLoad = scripts ? scripts : "";
485}
486
487////////////////////////////////////////////////////////////////////////////////
488/// return name of configured autoload scripts (or 0)
489
490const char *TRootSniffer::GetAutoLoad() const
491{
492 return fAutoLoad.Length() > 0 ? fAutoLoad.Data() : nullptr;
493}
494
495////////////////////////////////////////////////////////////////////////////////
496/// Made fast check if item with specified name is in restriction list
497/// If returns true, requires precise check with CheckRestriction() method
498
500{
501 if (!item_name || (*item_name == 0) || !fCurrentArg)
502 return kFALSE;
503
504 return fRestrictions.FindObject(item_name) != nullptr;
505}
506
507////////////////////////////////////////////////////////////////////////////////
508/// return 2 when option match to current user name
509/// return 1 when option==all
510/// return 0 when option does not match user name
511
513{
514 const char *username = fCurrentArg ? fCurrentArg->GetUserName() : nullptr;
515
516 if (!username || !option || (*option == 0))
517 return 0;
518
519 if (strcmp(option, "all") == 0)
520 return 1;
521
522 if (strcmp(username, option) == 0)
523 return 2;
524
525 if (strstr(option, username) == 0)
526 return -1;
527
528 TObjArray *arr = TString(option).Tokenize(",");
529
530 Bool_t find = arr->FindObject(username) != nullptr;
531
532 delete arr;
533
534 return find ? 2 : -1;
535}
536
537////////////////////////////////////////////////////////////////////////////////
538/// Checked if restriction is applied to the item full_item_name
539/// should have full path to the item. Returns:
540///
541/// * -1 - object invisible, cannot be accessed or listed
542/// * 0 - no explicit restrictions, use default
543/// * 1 - read-only access
544/// * 2 - full access
545
546Int_t TRootSniffer::CheckRestriction(const char *full_item_name)
547{
548 if (!full_item_name || (*full_item_name == 0))
549 return 0;
550
551 const char *item_name = strrchr(full_item_name, '/');
552 if (item_name)
553 item_name++;
554 if (!item_name || (*item_name == 0))
555 item_name = full_item_name;
556
557 TString pattern1 = TString("*/") + item_name + "%%%";
558 TString pattern2 = TString(full_item_name) + "%%%";
559
560 const char *options = nullptr;
561 TIter iter(&fRestrictions);
562
563 while (auto obj = iter()) {
564 const char *title = obj->GetTitle();
565
566 if (strstr(title, pattern1.Data()) == title) {
567 options = title + pattern1.Length();
568 break;
569 }
570 if (strstr(title, pattern2.Data()) == title) {
571 options = title + pattern2.Length();
572 break;
573 }
574 }
575
576 if (!options)
577 return 0;
578
579 TUrl url;
580 url.SetOptions(options);
581 url.ParseOptions();
582
583 Int_t can_see =
585
586 Int_t can_access =
588
589 if (can_access > 0)
590 return 2; // first of all, if access enabled, provide it
591 if (can_see < 0)
592 return -1; // if object to be hidden, do it
593
594 const char *methods = url.GetValueFromOptions("allow_method");
595 if (methods)
596 fCurrentAllowedMethods = methods;
597
598 if (can_access < 0)
599 return 1; // read-only access
600
601 return 0; // default behavior
602}
603
604////////////////////////////////////////////////////////////////////////////////
605/// scan object data members
606/// some members like enum or static members will be excluded
607
609{
610 if (!cl || !ptr || rec.Done())
611 return;
612
613 // ensure that real class data (including parents) exists
614 if (!(cl->Property() & kIsAbstract))
615 cl->BuildRealData();
616
617 // scan only real data
618 TIter iter(cl->GetListOfRealData());
619 while (auto obj = iter()) {
620 TRealData *rdata = dynamic_cast<TRealData *>(obj);
621 if (!rdata || strchr(rdata->GetName(), '.'))
622 continue;
623
624 TDataMember *member = rdata->GetDataMember();
625 // exclude enum or static variables
626 if (!member || (member->Property() & (kIsStatic | kIsEnum | kIsUnion)))
627 continue;
628 char *member_ptr = ptr + rdata->GetThisOffset();
629
630 if (member->IsaPointer())
631 member_ptr = *((char **)member_ptr);
632
634
635 if (chld.GoInside(rec, member, 0, this)) {
636
637 TClass *mcl = (member->IsBasic() || member->IsSTLContainer()) ? nullptr : gROOT->GetClass(member->GetTypeName());
638
639 Int_t coll_offset = mcl ? mcl->GetBaseClassOffset(TCollection::Class()) : -1;
640 if (coll_offset >= 0) {
641 chld.SetField(item_prop_more, "true", kFALSE);
642 chld.fHasMore = kTRUE;
643 }
644
645 if (chld.SetFoundResult(ptr, cl, member))
646 break;
647
648 const char *title = member->GetTitle();
649 if (title && *title)
650 chld.SetField(item_prop_title, title);
651
652 if (member->GetTypeName())
653 chld.SetField(item_prop_typename, member->GetTypeName());
654
655 if (member->GetArrayDim() > 0) {
656 // store array dimensions in form [N1,N2,N3,...]
657 TString dim("[");
658 for (Int_t n = 0; n < member->GetArrayDim(); n++) {
659 if (n > 0)
660 dim.Append(",");
661 dim.Append(TString::Format("%d", member->GetMaxIndex(n)));
662 }
663 dim.Append("]");
665 } else if (member->GetArrayIndex() != 0) {
666 TRealData *idata = cl->GetRealData(member->GetArrayIndex());
667 TDataMember *imember = idata ? idata->GetDataMember() : nullptr;
668 if (imember && (strcmp(imember->GetTrueTypeName(), "int") == 0)) {
669 Int_t arraylen = *((int *)(ptr + idata->GetThisOffset()));
670 chld.SetField(item_prop_arraydim, TString::Format("[%d]", arraylen), kFALSE);
671 }
672 }
673
674 chld.SetRootClass(mcl);
675
676 if (chld.CanExpandItem()) {
677 if (coll_offset >= 0) {
678 // chld.SetField("#members", "true", kFALSE);
679 ScanCollection(chld, (TCollection *)(member_ptr + coll_offset));
680 }
681 }
682
683 if (chld.SetFoundResult(ptr, cl, member))
684 break;
685 }
686 }
687}
688
689////////////////////////////////////////////////////////////////////////////////
690/// Scans object properties
691/// here such fields as _autoload or _icon properties depending on class or object name could be assigned
692/// By default properties, coded in the Class title are scanned. Example:
693///
694/// ClassDef(UserClassName, 1) // class comments *SNIFF* _field1=value _field2="string value"
695///
696/// Here *SNIFF* mark is important. After it all expressions like field=value are parsed
697/// One could use double quotes to code string values with spaces.
698/// Fields separated from each other with spaces
699
701{
702 TClass *cl = obj ? obj->IsA() : nullptr;
703
704 const char *pos = strstr(cl ? cl->GetTitle() : "", "*SNIFF*");
705 if (!pos)
706 return;
707
708 pos += 7;
709 while (*pos) {
710 if (*pos == ' ') {
711 pos++;
712 continue;
713 }
714 // first locate identifier
715 const char *pos0 = pos;
716 while (*pos && (*pos != '='))
717 pos++;
718 if (*pos == 0)
719 return;
720 TString name(pos0, pos - pos0);
721 pos++;
722 Bool_t quotes = (*pos == '\"');
723 if (quotes)
724 pos++;
725 pos0 = pos;
726 // then value with or without quotes
727 while (*pos && (*pos != (quotes ? '\"' : ' ')))
728 pos++;
729 TString value(pos0, pos - pos0);
730 rec.SetField(name, value);
731 if (quotes)
732 pos++;
733 pos++;
734 }
735}
736
737////////////////////////////////////////////////////////////////////////////////
738/// Scans TKey properties
739/// in special cases load objects from the file
740
742{
743 if (strcmp(key->GetClassName(), "TDirectoryFile") == 0) {
744 if (rec.fLevel == 0) {
745 auto dir = key->ReadObject<TDirectory>();
746 if (dir) {
747 obj = dir;
748 obj_class = dir->IsA();
749 }
750 } else {
751 rec.SetField(item_prop_more, "true", kFALSE);
752 rec.fHasMore = kTRUE;
753 }
754 }
755}
756
757////////////////////////////////////////////////////////////////////////////////
758/// scans object childs (if any)
759/// here one scans collection, branches, trees and so on
760
762{
763 if (obj->InheritsFrom(TFolder::Class())) {
764 ScanCollection(rec, ((TFolder *)obj)->GetListOfFolders());
765 } else if (obj->InheritsFrom(TDirectory::Class())) {
766 TDirectory *dir = (TDirectory *)obj;
767 ScanCollection(rec, dir->GetList(), nullptr, dir->GetListOfKeys());
768 } else if (rec.CanExpandItem()) {
769 ScanObjectMembers(rec, obj->IsA(), (char *)obj);
770 }
771}
772
773////////////////////////////////////////////////////////////////////////////////
774/// Scan collection content
775
776void TRootSniffer::ScanCollection(TRootSnifferScanRec &rec, TCollection *lst, const char *foldername,
777 TCollection *keys_lst)
778{
779 if ((!lst || (lst->GetSize() == 0)) && (!keys_lst || (keys_lst->GetSize() == 0)))
780 return;
781
782 TRootSnifferScanRec folderrec;
783 if (foldername) {
784 if (!folderrec.GoInside(rec, nullptr, foldername, this))
785 return;
786 }
787
788 TRootSnifferScanRec &master = foldername ? folderrec : rec;
789
790 if (lst) {
791 TIter iter(lst);
792 TObject *next = iter();
793 Bool_t isany = kFALSE;
794
795 while (next) {
796 if (IsItemField(next)) {
797 // special case - in the beginning one could have items for master folder
798 if (!isany && (next->GetName() != nullptr) && ((*(next->GetName()) == '_') || master.ScanOnlyFields()))
799 master.SetField(next->GetName(), next->GetTitle());
800 next = iter();
801 continue;
802 }
803
804 isany = kTRUE;
805 TObject *obj = next;
806
808 if (!chld.GoInside(master, obj, nullptr, this)) {
809 next = iter();
810 continue;
811 }
812
813 if (chld.SetResult(obj, obj->IsA()))
814 return;
815
816 Bool_t has_kind = kFALSE, has_title = kFALSE;
817
818 ScanObjectProperties(chld, obj);
819 // now properties, coded as TNamed objects, placed after object in the hierarchy
820 while ((next = iter()) != nullptr) {
821 if (!IsItemField(next))
822 break;
823 if ((next->GetName() != nullptr) && ((*(next->GetName()) == '_') || chld.ScanOnlyFields())) {
824 // only fields starting with _ are stored
825 chld.SetField(next->GetName(), next->GetTitle());
826 if (strcmp(next->GetName(), item_prop_kind) == 0)
827 has_kind = kTRUE;
828 if (strcmp(next->GetName(), item_prop_title) == 0)
829 has_title = kTRUE;
830 }
831 }
832
833 if (!has_kind)
834 chld.SetRootClass(obj->IsA());
835 if (!has_title && obj->GetTitle())
836 chld.SetField(item_prop_title, obj->GetTitle());
837
838 ScanObjectChilds(chld, obj);
839
840 if (chld.SetResult(obj, obj->IsA()))
841 return;
842 }
843 }
844
845 if (keys_lst) {
846 TIter iter(keys_lst);
847
848 while (auto kobj = iter()) {
849 TKey *key = dynamic_cast<TKey *>(kobj);
850 if (!key)
851 continue;
852 TObject *obj = lst ? lst->FindObject(key->GetName()) : nullptr;
853
854 // even object with the name exists, it should also match with class name
855 if (obj && (strcmp(obj->ClassName(), key->GetClassName()) != 0))
856 obj = nullptr;
857
858 // if object of that name and of that class already in the list, ignore appropriate key
859 if (obj && (master.fMask & TRootSnifferScanRec::kScan))
860 continue;
861
862 Bool_t iskey = kFALSE;
863 // if object not exists, provide key itself for the scan
864 if (!obj) {
865 obj = key;
866 iskey = kTRUE;
867 }
868
870 TString fullname = TString::Format("%s;%d", key->GetName(), key->GetCycle());
871
872 if (chld.GoInside(master, obj, fullname.Data(), this)) {
873
874 if (!chld.IsReadOnly(fReadOnly) && iskey && chld.IsReadyForResult()) {
875 TObject *keyobj = key->ReadObj();
876 if (keyobj)
877 if (chld.SetResult(keyobj, keyobj->IsA()))
878 return;
879 }
880
881 if (chld.SetResult(obj, obj->IsA()))
882 return;
883
884 TClass *obj_class = obj->IsA();
885
886 ScanObjectProperties(chld, obj);
887
888 if (obj->GetTitle())
889 chld.SetField(item_prop_title, obj->GetTitle());
890
891 // special handling of TKey class - in non-readonly mode
892 // sniffer allowed to fetch objects
893 if (!chld.IsReadOnly(fReadOnly) && iskey)
894 ScanKeyProperties(chld, key, obj, obj_class);
895
896 rec.SetRootClass(obj_class);
897
898 ScanObjectChilds(chld, obj);
899
900 // here we should know how many childs are accumulated
901 if (chld.SetResult(obj, obj_class))
902 return;
903 }
904 }
905 }
906}
907
908////////////////////////////////////////////////////////////////////////////////
909/// Create own TFolder structures independent from gROOT
910/// This allows to have many independent TRootSniffer instances
911/// At the same time such sniffer lost access to all global lists and folders
912
914{
915 if (fTopFolder) return;
916
918
919 // this only works with c++14, use ROOT wrapper
920 fTopFolder = std::make_unique<TFolder>("http","Dedicated instance");
921
922 // not sure if we have to add that private folder to global list of cleanups
923
924 // R__LOCKGUARD(gROOTMutex);
925 // gROOT->GetListOfCleanups()->Add(fTopFolder.get());
926
927}
928
929////////////////////////////////////////////////////////////////////////////////
930/// Returns top TFolder instance for the sniffer
931
933{
934 if (fTopFolder) return fTopFolder.get();
935
936 TFolder *topf = gROOT->GetRootFolder();
937
938 if (!topf) {
939 Error("RegisterObject", "Not found top ROOT folder!!!");
940 return nullptr;
941 }
942
943 TFolder *httpfold = dynamic_cast<TFolder *>(topf->FindObject("http"));
944 if (!httpfold) {
945 if (!force)
946 return nullptr;
947 httpfold = topf->AddFolder("http", "ROOT http server");
948 httpfold->SetBit(kCanDelete);
949 // register top folder in list of cleanups
951 gROOT->GetListOfCleanups()->Add(httpfold);
952 }
953
954 return httpfold;
955}
956
957////////////////////////////////////////////////////////////////////////////////
958/// scan complete ROOT objects hierarchy
959/// For the moment it includes objects in gROOT directory
960/// and list of canvases and files
961/// Also all registered objects are included.
962/// One could re-implement this method to provide alternative
963/// scan methods or to extend some collection kinds
964
966{
967 rec.SetField(item_prop_kind, "ROOT.Session");
969 rec.SetField(item_prop_user, fCurrentArg->GetUserName());
970
971 // should be on the top while //root/http folder could have properties for itself
972 TFolder *topf = GetTopFolder();
973 if (topf) {
974 rec.SetField(item_prop_title, topf->GetTitle());
975 ScanCollection(rec, topf->GetListOfFolders());
976 }
977
978 if (HasStreamerInfo()) {
980 if (chld.GoInside(rec, nullptr, "StreamerInfo", this)) {
981 chld.SetField(item_prop_kind, "ROOT.TStreamerInfoList");
982 chld.SetField(item_prop_title, "List of streamer infos for binary I/O");
983 chld.SetField(item_prop_hidden, "true", kFALSE);
984 chld.SetField("_module", "hierarchy");
985 chld.SetField("_after_request", "markAsStreamerInfo");
986 }
987 }
988
989 if (IsScanGlobalDir()) {
990 ScanCollection(rec, gROOT->GetList());
991
992 ScanCollection(rec, gROOT->GetListOfCanvases(), "Canvases");
993
994 ScanCollection(rec, gROOT->GetListOfFiles(), "Files");
995 }
996}
997
998////////////////////////////////////////////////////////////////////////////////
999/// scan ROOT hierarchy with provided store object
1000
1001void TRootSniffer::ScanHierarchy(const char *topname, const char *path, TRootSnifferStore *store,
1002 Bool_t only_fields)
1003{
1005 rec.fSearchPath = path;
1006 if (rec.fSearchPath) {
1007 while (*rec.fSearchPath == '/')
1008 rec.fSearchPath++;
1009 if (*rec.fSearchPath == 0)
1010 rec.fSearchPath = nullptr;
1011 }
1012
1013 // if path non-empty, we should find item first and than start scanning
1014 rec.fMask = !rec.fSearchPath ? TRootSnifferScanRec::kScan : TRootSnifferScanRec::kExpand;
1015 if (only_fields)
1017
1018 rec.fStore = store;
1019
1020 rec.CreateNode(topname);
1021
1022 if (!rec.fSearchPath)
1024
1025 if (!rec.fSearchPath && GetAutoLoad())
1026 rec.SetField(item_prop_autoload, GetAutoLoad());
1027
1028 ScanRoot(rec);
1029
1030 rec.CloseNode();
1031}
1032
1033////////////////////////////////////////////////////////////////////////////////
1034/// Search element with specified path
1035/// Returns pointer on element
1036/// Optionally one could obtain element class, member description
1037/// and number of childs. When chld!=nullptr, not only element is searched,
1038/// but also number of childs are counted. When member!=0, any object
1039/// will be scanned for its data members (disregard of extra options)
1040
1041void *TRootSniffer::FindInHierarchy(const char *path, TClass **cl, TDataMember **member, Int_t *chld)
1042{
1043 TRootSnifferStore store;
1044
1046 rec.fSearchPath = path;
1048 if (*rec.fSearchPath == '/')
1049 rec.fSearchPath++;
1050 rec.fStore = &store;
1051
1052 ScanRoot(rec);
1053
1054 TDataMember *res_member = store.GetResMember();
1055 TClass *res_cl = store.GetResClass();
1056 void *res = store.GetResPtr();
1057
1058 if (res_member && res_cl && !member) {
1059 res_cl = (res_member->IsBasic() || res_member->IsSTLContainer()) ? nullptr : gROOT->GetClass(res_member->GetTypeName());
1060 TRealData *rdata = res_cl ? res_cl->GetRealData(res_member->GetName()) : nullptr;
1061 if (rdata) {
1062 res = (char *)res + rdata->GetThisOffset();
1063 if (res_member->IsaPointer())
1064 res = *((char **)res);
1065 } else {
1066 res = nullptr; // should never happen
1067 }
1068 }
1069
1070 if (cl)
1071 *cl = res_cl;
1072 if (member)
1073 *member = res_member;
1074 if (chld)
1075 *chld = store.GetResNumChilds();
1076
1077 // remember current restriction
1079
1080 return res;
1081}
1082
1083////////////////////////////////////////////////////////////////////////////////
1084/// Search element in hierarchy, derived from TObject
1085
1087{
1088 TClass *cl = nullptr;
1089
1090 void *obj = FindInHierarchy(path, &cl);
1091
1092 return cl && (cl->GetBaseClassOffset(TObject::Class()) == 0) ? (TObject *)obj : nullptr;
1093}
1094
1095////////////////////////////////////////////////////////////////////////////////
1096/// Get hash function for specified item
1097/// used to detect any changes in the specified object
1098
1100{
1101 TObject *obj = FindTObjectInHierarchy(itemname);
1102
1103 return !obj ? 0 : TString::Hash(obj, obj->IsA()->Size());
1104}
1105
1106////////////////////////////////////////////////////////////////////////////////
1107/// Method verifies if object can be drawn
1108
1110{
1111 TClass *obj_cl = nullptr;
1112 void *res = FindInHierarchy(path, &obj_cl);
1113 return (res != nullptr) && CanDrawClass(obj_cl);
1114}
1115
1116////////////////////////////////////////////////////////////////////////////////
1117/// Method returns true when object has childs or
1118/// one could try to expand item
1119
1121{
1122 TClass *obj_cl = nullptr;
1123 Int_t obj_chld(-1);
1124 void *res = FindInHierarchy(path, &obj_cl, nullptr, &obj_chld);
1125 return res && (obj_chld > 0);
1126}
1127
1128////////////////////////////////////////////////////////////////////////////////
1129/// Produce JSON data for specified item
1130/// For object conversion TBufferJSON is used
1131
1132Bool_t TRootSniffer::ProduceJson(const std::string &path, const std::string &options, std::string &res)
1133{
1134 if (path.empty())
1135 return kFALSE;
1136
1137 const char *path_ = path.c_str();
1138 if (*path_ == '/')
1139 path_++;
1140
1141 TUrl url;
1142 url.SetOptions(options.c_str());
1143 url.ParseOptions();
1144 Int_t compact = -1;
1145 if (url.GetValueFromOptions("compact"))
1146 compact = url.GetIntValueFromOptions("compact");
1147
1148 TClass *obj_cl = nullptr;
1149 TDataMember *member = nullptr;
1150 void *obj_ptr = FindInHierarchy(path_, &obj_cl, &member);
1151 if (!obj_ptr || (!obj_cl && !member))
1152 return kFALSE;
1153
1154 // TODO: implement direct storage into std::string
1155 TString buf = TBufferJSON::ConvertToJSON(obj_ptr, obj_cl, compact >= 0 ? compact : 0, member ? member->GetName() : nullptr);
1156 res = buf.Data();
1157
1158 return !res.empty();
1159}
1160
1161////////////////////////////////////////////////////////////////////////////////
1162/// Execute command marked as _kind=='Command'
1163
1164Bool_t TRootSniffer::ExecuteCmd(const std::string &path, const std::string &options, std::string &res)
1165{
1166 TFolder *parent = nullptr;
1167 TObject *obj = GetItem(path.c_str(), parent, kFALSE, kFALSE);
1168
1169 const char *kind = GetItemField(parent, obj, item_prop_kind);
1170 if ((kind == 0) || (strcmp(kind, "Command") != 0)) {
1171 if (gDebug > 0)
1172 Info("ExecuteCmd", "Entry %s is not a command", path.c_str());
1173 res = "false";
1174 return kTRUE;
1175 }
1176
1177 const char *cmethod = GetItemField(parent, obj, "method");
1178 if (!cmethod || (strlen(cmethod) == 0)) {
1179 if (gDebug > 0)
1180 Info("ExecuteCmd", "Entry %s do not defines method for execution", path.c_str());
1181 res = "false";
1182 return kTRUE;
1183 }
1184
1185 // if read-only specified for the command, it is not allowed for execution
1186 if (fRestrictions.GetLast() >= 0) {
1187 FindInHierarchy(path.c_str()); // one need to call method to check access rights
1188 if (fCurrentRestrict == 1) {
1189 if (gDebug > 0)
1190 Info("ExecuteCmd", "Entry %s not allowed for specified user", path.c_str());
1191 res = "false";
1192 return kTRUE;
1193 }
1194 }
1195
1196 TString method = cmethod;
1197
1198 const char *cnumargs = GetItemField(parent, obj, "_numargs");
1199 Int_t numargs = cnumargs ? TString(cnumargs).Atoi() : 0;
1200 if (numargs > 0) {
1201 TUrl url;
1202 url.SetOptions(options.c_str());
1203 url.ParseOptions();
1204
1205 for (Int_t n = 0; n < numargs; n++) {
1206 TString argname = TString::Format("arg%d", n + 1);
1207 const char *argvalue = url.GetValueFromOptions(argname);
1208 if (!argvalue) {
1209 if (gDebug > 0)
1210 Info("ExecuteCmd", "For command %s argument %s not specified in options %s", path.c_str(), argname.Data(),
1211 options.c_str());
1212 res = "false";
1213 return kTRUE;
1214 }
1215
1216 TString svalue = DecodeUrlOptionValue(argvalue, kTRUE);
1217 argname = TString("%") + argname + TString("%");
1218 method.ReplaceAll(argname, svalue);
1219 }
1220 }
1221
1222 if (gDebug > 0)
1223 Info("ExecuteCmd", "Executing command %s method:%s", path.c_str(), method.Data());
1224
1225 TObject *item_obj = nullptr;
1226 Ssiz_t separ = method.Index("/->");
1227
1228 if (method.Index("this->") == 0) {
1229 // if command name started with this-> means method of sniffer will be executed
1230 item_obj = this;
1231 separ = 3;
1232 } else if (separ != kNPOS) {
1233 item_obj = FindTObjectInHierarchy(TString(method.Data(), separ).Data());
1234 }
1235
1236 if (item_obj) {
1237 method = TString::Format("((%s*)%zu)->%s", item_obj->ClassName(), (size_t)item_obj, method.Data() + separ + 3);
1238 if (gDebug > 2)
1239 Info("ExecuteCmd", "Executing %s", method.Data());
1240 }
1241
1242 auto v = gROOT->ProcessLineSync(method.Data());
1243
1244 res = std::to_string(v);
1245
1246 return kTRUE;
1247}
1248
1249////////////////////////////////////////////////////////////////////////////////
1250/// Produce JSON/XML for specified item
1251///
1252/// Contrary to h.json request, only fields for specified item are stored
1253
1254Bool_t TRootSniffer::ProduceItem(const std::string &path, const std::string &options, std::string &res, Bool_t asjson)
1255{
1256 TString buf; // TODO: implement direct storage into std::string
1257 if (asjson) {
1258 TRootSnifferStoreJson store(buf, options.find("compact") != std::string::npos);
1259 ScanHierarchy("top", path.c_str(), &store, kTRUE);
1260 } else {
1261 TRootSnifferStoreXml store(buf, options.find("compact") != std::string::npos);
1262 ScanHierarchy("top", path.c_str(), &store, kTRUE);
1263 }
1264 res = buf.Data();
1265 return !res.empty();
1266}
1267
1268////////////////////////////////////////////////////////////////////////////////
1269/// Produce XML data for specified item
1270///
1271/// For object conversion TBufferXML is used
1272/// Method implemented only in TRootSnifferFull class
1273
1274Bool_t TRootSniffer::ProduceXml(const std::string &/* path */, const std::string & /* options */, std::string & /* res */)
1275{
1276 return kFALSE;
1277}
1278
1279////////////////////////////////////////////////////////////////////////////////
1280/// Method replaces all kind of special symbols, which could appear in URL options
1281
1283{
1284 if (!value || (strlen(value) == 0))
1285 return TString();
1286
1287 TString res = value;
1288
1289 res.ReplaceAll("%27", "\'");
1290 res.ReplaceAll("%22", "\"");
1291 res.ReplaceAll("%3E", ">");
1292 res.ReplaceAll("%3C", "<");
1293 res.ReplaceAll("%20", " ");
1294 res.ReplaceAll("%5B", "[");
1295 res.ReplaceAll("%5D", "]");
1296 res.ReplaceAll("%3D", "=");
1297
1298 if (remove_quotes && (res.Length() > 1) && ((res[0] == '\'') || (res[0] == '\"')) &&
1299 (res[0] == res[res.Length() - 1])) {
1300 res.Remove(res.Length() - 1);
1301 res.Remove(0, 1);
1302 }
1303
1304 return res;
1305}
1306
1307////////////////////////////////////////////////////////////////////////////////
1308/// Execute command for specified object
1309///
1310/// Options include method and extra list of parameters
1311/// sniffer should be not-readonly to allow execution of the commands
1312/// reskind defines kind of result 0 - debug, 1 - json, 2 - binary
1313///
1314/// Method implemented only in TRootSnifferFull class
1315
1316Bool_t TRootSniffer::ProduceExe(const std::string & /*path*/, const std::string & /*options*/, Int_t /*reskind*/,
1317 std::string & /*res*/)
1318{
1319 return kFALSE;
1320}
1321
1322////////////////////////////////////////////////////////////////////////////////
1323/// Process several requests, packing all results into binary or JSON buffer
1324///
1325/// Input parameters should be coded in the POST block and has
1326/// individual request relative to current path, separated with '\n' symbol like
1327/// item1/root.bin\n
1328/// item2/exe.bin?method=GetList\n
1329/// item3/exe.bin?method=GetTitle\n
1330/// Request requires 'number' URL option which contains number of requested items
1331///
1332/// In case of binary request output buffer looks like:
1333///
1334/// 4bytes length + payload,
1335/// 4bytes length + payload, ...
1336///
1337/// In case of JSON request output is array with results for each item
1338/// multi.json request do not support binary requests for the items
1339
1340Bool_t TRootSniffer::ProduceMulti(const std::string &path, const std::string &options, std::string &str, Bool_t asjson)
1341{
1343 return kFALSE;
1344
1345 const char *args = (const char *)fCurrentArg->GetPostData();
1346 const char *ends = args + fCurrentArg->GetPostDataLength();
1347
1348 TUrl url;
1349 url.SetOptions(options.c_str());
1350
1351 Int_t number = 0;
1352 if (url.GetValueFromOptions("number"))
1353 number = url.GetIntValueFromOptions("number");
1354
1355 // binary buffers required only for binary requests, json output can be produced as is
1356 std::vector<std::string> mem;
1357
1358 if (asjson)
1359 str = "[";
1360
1361 for (Int_t n = 0; n < number; n++) {
1362 const char *next = args;
1363 while ((next < ends) && (*next != '\n'))
1364 next++;
1365 if (next == ends) {
1366 Error("ProduceMulti", "Not enough arguments in POST block");
1367 break;
1368 }
1369
1370 std::string file1(args, next - args);
1371 args = next + 1;
1372
1373 std::string path1, opt1;
1374
1375 // extract options
1376 std::size_t pos = file1.find_first_of('?');
1377 if (pos != std::string::npos) {
1378 opt1 = file1.substr(pos + 1, file1.length() - pos);
1379 file1.resize(pos);
1380 }
1381
1382 // extract extra path
1383 pos = file1.find_last_of('/');
1384 if (pos != std::string::npos) {
1385 path1 = file1.substr(0, pos);
1386 file1.erase(0, pos + 1);
1387 }
1388
1389 if (!path.empty())
1390 path1 = path + "/" + path1;
1391
1392 std::string res1;
1393
1394 // produce next item request
1395 Produce(path1, file1, opt1, res1);
1396
1397 if (asjson) {
1398 if (n > 0)
1399 str.append(", ");
1400 if (res1.empty())
1401 str.append("null");
1402 else
1403 str.append(res1);
1404 } else {
1405 mem.emplace_back(std::move(res1));
1406 }
1407 }
1408
1409 if (asjson) {
1410 str.append("]");
1411 } else {
1412 Int_t length = 0;
1413 for (unsigned n = 0; n < mem.size(); n++)
1414 length += 4 + mem[n].length();
1415 str.resize(length);
1416 char *curr = (char *)str.data();
1417 for (unsigned n = 0; n < mem.size(); n++) {
1418 Long_t l = mem[n].length();
1419 *curr++ = (char)(l & 0xff);
1420 l = l >> 8;
1421 *curr++ = (char)(l & 0xff);
1422 l = l >> 8;
1423 *curr++ = (char)(l & 0xff);
1424 l = l >> 8;
1425 *curr++ = (char)(l & 0xff);
1426 if (!mem[n].empty())
1427 memcpy(curr, mem[n].data(), mem[n].length());
1428 curr += mem[n].length();
1429 }
1430 }
1431
1432 return kTRUE;
1433}
1434
1435////////////////////////////////////////////////////////////////////////////////
1436/// Produce binary data for specified item
1437///
1438/// If "zipped" option specified in query, buffer will be compressed
1439///
1440/// Implemented only in TRootSnifferFull class
1441
1442Bool_t TRootSniffer::ProduceBinary(const std::string & /*path*/, const std::string & /*query*/, std::string & /*res*/)
1443{
1444 return kFALSE;
1445}
1446
1447////////////////////////////////////////////////////////////////////////////////
1448/// Produce ROOT file for specified item
1449///
1450/// Implemented only in TRootSnifferFull class
1451
1452Bool_t TRootSniffer::ProduceRootFile(const std::string & /*path*/, const std::string & /*query*/, std::string & /*res*/)
1453{
1454 return kFALSE;
1455}
1456
1457////////////////////////////////////////////////////////////////////////////////
1458/// Method to produce image from specified object
1459///
1460/// Parameters:
1461///
1462/// kind - image kind TImage::kPng, TImage::kJpeg, TImage::kGif
1463/// path - path to object
1464/// options - extra options
1465///
1466/// By default, image 300x200 is produced
1467/// In options string one could provide following parameters:
1468///
1469/// w - image width
1470/// h - image height
1471/// opt - draw options
1472///
1473/// For instance:
1474///
1475/// http://localhost:8080/Files/hsimple.root/hpx/get.png?w=500&h=500&opt=lego1
1476///
1477/// Returns produced image in the res string
1478///
1479/// Method implemented only in TRootSnifferFull class
1480
1481Bool_t TRootSniffer::ProduceImage(Int_t /*kind*/, const std::string & /*path*/, const std::string & /*options*/, std::string & /*res*/)
1482{
1483 return kFALSE;
1484}
1485
1486////////////////////////////////////////////////////////////////////////////////
1487/// Invokes TRootSniffer::ProduceIamge, converting kind into TImage::EImageFileTypes type
1488
1489Bool_t TRootSniffer::CallProduceImage(const std::string &/*kind*/, const std::string &/*path*/, const std::string &/*options*/, std::string &/*res*/)
1490{
1491 return kFALSE;
1492}
1493
1494////////////////////////////////////////////////////////////////////////////////
1495/// Method produce different kind of data out of object
1496///
1497/// @param path specifies object or object member
1498/// @param file can be:
1499///
1500/// * "root.bin" - binary data
1501/// * "root.png" - png image
1502/// * "root.jpeg" - jpeg image
1503/// * "root.gif" - gif image
1504/// * "root.xml" - xml representation
1505/// * "root.json" - json representation
1506/// * "file.root" - ROOT file with stored object
1507/// * "exe.json" - method execution with json reply
1508/// * "exe.bin" - method execution with binary reply
1509/// * "exe.txt" - method execution with debug output
1510/// * "cmd.json" - execution of registered commands
1511///
1512/// @param res returns result - binary or text.
1513
1514Bool_t TRootSniffer::Produce(const std::string &path, const std::string &file, const std::string &options, std::string &res)
1515{
1516 if (file.empty())
1517 return kFALSE;
1518
1519 if (file == "root.bin")
1520 return ProduceBinary(path, options, res);
1521
1522 if (file == "root.png")
1523 return CallProduceImage("png", path, options, res);
1524
1525 if (file == "root.jpeg")
1526 return CallProduceImage("jpeg", path, options, res);
1527
1528 if (file == "root.gif")
1529 return CallProduceImage("gif", path, options, res);
1530
1531 if (file == "exe.bin")
1532 return ProduceExe(path, options, 2, res);
1533
1534 if (file == "root.xml")
1535 return ProduceXml(path, options, res);
1536
1537 if (file == "root.json")
1538 return ProduceJson(path, options, res);
1539
1540 if (file == "file.root")
1541 return ProduceRootFile(path, options, res);
1542
1543 // used for debugging
1544 if (file == "exe.txt")
1545 return ProduceExe(path, options, 0, res);
1546
1547 if (file == "exe.json")
1548 return ProduceExe(path, options, 1, res);
1549
1550 if (file == "cmd.json")
1551 return ExecuteCmd(path, options, res);
1552
1553 if (file == "item.json")
1554 return ProduceItem(path, options, res, kTRUE);
1555
1556 if (file == "item.xml")
1557 return ProduceItem(path, options, res, kFALSE);
1558
1559 if (file == "multi.bin")
1560 return ProduceMulti(path, options, res, kFALSE);
1561
1562 if (file == "multi.json")
1563 return ProduceMulti(path, options, res, kTRUE);
1564
1565 return kFALSE;
1566}
1567
1568////////////////////////////////////////////////////////////////////////////////
1569/// Return item from the subfolders structure
1570
1571TObject *TRootSniffer::GetItem(const char *fullname, TFolder *&parent, Bool_t force, Bool_t within_objects)
1572{
1573 TFolder *httpfold = GetTopFolder(force);
1574 if (!httpfold) return nullptr;
1575
1576 parent = httpfold;
1577 TObject *obj = httpfold;
1578
1579 if (!fullname)
1580 return httpfold;
1581
1582 // when full path started not with slash, "Objects" subfolder is appended
1583 TString path = fullname;
1584 if (within_objects && ((path.Length() == 0) || (path[0] != '/')))
1585 path = fObjectsPath + "/" + path;
1586
1587 TString tok;
1588 Ssiz_t from = 0;
1589
1590 while (path.Tokenize(tok, from, "/")) {
1591 if (tok.Length() == 0)
1592 continue;
1593
1594 TFolder *fold = dynamic_cast<TFolder *>(obj);
1595 if (!fold)
1596 return nullptr;
1597
1598 TIter iter(fold->GetListOfFolders());
1599 while ((obj = iter()) != nullptr) {
1600 if (IsItemField(obj))
1601 continue;
1602 if (tok.CompareTo(obj->GetName()) == 0)
1603 break;
1604 }
1605
1606 if (!obj) {
1607 if (!force)
1608 return nullptr;
1609 obj = fold->AddFolder(tok, "sub-folder");
1610 obj->SetBit(kCanDelete);
1611 }
1612
1613 parent = fold;
1614 }
1615
1616 return obj;
1617}
1618
1619////////////////////////////////////////////////////////////////////////////////
1620/// Creates subfolder where objects can be registered
1621
1622TFolder *TRootSniffer::GetSubFolder(const char *subfolder, Bool_t force)
1623{
1624 TFolder *parent = nullptr;
1625
1626 return dynamic_cast<TFolder *>(GetItem(subfolder, parent, force));
1627}
1628
1629////////////////////////////////////////////////////////////////////////////////
1630/// Register object in subfolder structure
1631///
1632/// @param subfolder can have many levels like:
1633///
1634/// TRootSniffer* sniff = new TRootSniffer("sniff");
1635/// sniff->RegisterObject("my/sub/subfolder", h1);
1636///
1637/// Such objects can be later found in "Objects" folder of sniffer like
1638///
1639/// auto h1 = sniff->FindTObjectInHierarchy("/Objects/my/sub/subfolder/h1");
1640///
1641/// If subfolder name starts with '/', object will be registered starting from top folder.
1642///
1643/// One could provide additional fields for registered objects
1644/// For instance, setting "_more" field to true let browser
1645/// explore objects members. For instance:
1646///
1647/// TEvent* ev = new TEvent("ev");
1648/// sniff->RegisterObject("Events", ev);
1649/// sniff->SetItemField("Events/ev", "_more", "true");
1650
1651Bool_t TRootSniffer::RegisterObject(const char *subfolder, TObject *obj)
1652{
1653 TFolder *f = GetSubFolder(subfolder, kTRUE);
1654 if (!f)
1655 return kFALSE;
1656
1657 // If object will be destroyed, it will be removed from the folders automatically
1658 obj->SetBit(kMustCleanup);
1659
1660 f->Add(obj);
1661
1662 return kTRUE;
1663}
1664
1665////////////////////////////////////////////////////////////////////////////////
1666/// Unregister (remove) object from folders structures
1667///
1668/// Folder itself will remain even when it will be empty
1669
1671{
1672 if (!obj)
1673 return kTRUE;
1674
1675 TFolder *topf = GetTopFolder();
1676
1677 if (!topf) {
1678 Error("UnregisterObject", "Not found top folder");
1679 return kFALSE;
1680 }
1681
1682 // TODO - probably we should remove all set properties as well
1683 topf->RecursiveRemove(obj);
1684
1685 return kTRUE;
1686}
1687
1688////////////////////////////////////////////////////////////////////////////////
1689/// Create item element
1690
1691Bool_t TRootSniffer::CreateItem(const char *fullname, const char *title)
1692{
1693 TFolder *f = GetSubFolder(fullname, kTRUE);
1694 if (!f)
1695 return kFALSE;
1696
1697 if (title)
1698 f->SetTitle(title);
1699
1700 return kTRUE;
1701}
1702
1703////////////////////////////////////////////////////////////////////////////////
1704/// Return true when object is TNamed with kItemField bit set
1705///
1706/// such objects used to keep field values for item
1707
1709{
1710 return (obj != nullptr) && (obj->IsA() == TNamed::Class()) && obj->TestBit(kItemField);
1711}
1712
1713////////////////////////////////////////////////////////////////////////////////
1714/// Set or get field for the child
1715///
1716/// each field coded as TNamed object, placed after chld in the parent hierarchy
1717
1718Bool_t TRootSniffer::AccessField(TFolder *parent, TObject *chld, const char *name, const char *value, TNamed **only_get)
1719{
1720 if (!parent)
1721 return kFALSE;
1722
1723 if (!chld) {
1724 Info("AccessField", "Should be special case for top folder, support later");
1725 return kFALSE;
1726 }
1727
1728 TIter iter(parent->GetListOfFolders());
1729
1730 Bool_t find = kFALSE, last_find = kFALSE;
1731 // this is special case of top folder - fields are on very top
1732 if (parent == chld)
1733 last_find = find = kTRUE;
1734
1735 TNamed *curr = nullptr;
1736 while (auto obj = iter()) {
1737 if (IsItemField(obj)) {
1738 if (last_find && obj->GetName() && !strcmp(name, obj->GetName()))
1739 curr = (TNamed *)obj;
1740 } else {
1741 last_find = (obj == chld);
1742 if (last_find)
1743 find = kTRUE;
1744 if (find && !last_find)
1745 break; // no need to continue
1746 }
1747 }
1748
1749 // object must be in childs list
1750 if (!find)
1751 return kFALSE;
1752
1753 if (only_get) {
1754 *only_get = curr;
1755 return curr != nullptr;
1756 }
1757
1758 if (curr) {
1759 if (value) {
1760 curr->SetTitle(value);
1761 } else {
1762 parent->Remove(curr);
1763 delete curr;
1764 }
1765 return kTRUE;
1766 }
1767
1768 curr = new TNamed(name, value);
1769 curr->SetBit(kItemField);
1770
1771 if (last_find) {
1772 // object is on last place, therefore just add property
1773 parent->Add(curr);
1774 return kTRUE;
1775 }
1776
1777 // only here we do dynamic cast to the TList to use AddAfter
1778 TList *lst = dynamic_cast<TList *>(parent->GetListOfFolders());
1779 if (!lst) {
1780 Error("AccessField", "Fail cast to TList");
1781 return kFALSE;
1782 }
1783
1784 if (parent == chld)
1785 lst->AddFirst(curr);
1786 else
1787 lst->AddAfter(chld, curr);
1788
1789 return kTRUE;
1790}
1791
1792////////////////////////////////////////////////////////////////////////////////
1793/// Set field for specified item
1794
1795Bool_t TRootSniffer::SetItemField(const char *fullname, const char *name, const char *value)
1796{
1797 if (!fullname || !name)
1798 return kFALSE;
1799
1800 TFolder *parent = nullptr;
1801 TObject *obj = GetItem(fullname, parent);
1802
1803 if (!parent || !obj)
1804 return kFALSE;
1805
1806 if (strcmp(name, item_prop_title) == 0) {
1807 TNamed *n = dynamic_cast<TNamed *>(obj);
1808 if (n) {
1809 n->SetTitle(value);
1810 return kTRUE;
1811 }
1812 }
1813
1814 return AccessField(parent, obj, name, value);
1815}
1816
1817////////////////////////////////////////////////////////////////////////////////
1818/// Return field for specified item
1819
1820const char *TRootSniffer::GetItemField(TFolder *parent, TObject *obj, const char *name)
1821{
1822 if (!parent || !obj || !name)
1823 return nullptr;
1824
1825 TNamed *field = nullptr;
1826
1827 if (!AccessField(parent, obj, name, nullptr, &field))
1828 return nullptr;
1829
1830 return field ? field->GetTitle() : nullptr;
1831}
1832
1833////////////////////////////////////////////////////////////////////////////////
1834/// Return field for specified item
1835
1836const char *TRootSniffer::GetItemField(const char *fullname, const char *name)
1837{
1838 if (!fullname)
1839 return nullptr;
1840
1841 TFolder *parent = nullptr;
1842 TObject *obj = GetItem(fullname, parent);
1843
1844 return GetItemField(parent, obj, name);
1845}
1846
1847////////////////////////////////////////////////////////////////////////////////
1848/// Register command which can be executed from web interface
1849///
1850/// As method one typically specifies string, which is executed with
1851/// gROOT->ProcessLine() method. For instance:
1852///
1853/// serv->RegisterCommand("Invoke","InvokeFunction()");
1854///
1855/// Or one could specify any method of the object which is already registered
1856/// to the server. For instance:
1857///
1858/// serv->Register("/", hpx);
1859/// serv->RegisterCommand("/ResetHPX", "/hpx/->Reset()");
1860///
1861/// Here symbols '/->' separates item name from method to be executed
1862///
1863/// One could specify additional arguments in the command with
1864/// syntax like %arg1%, %arg2% and so on. For example:
1865///
1866/// serv->RegisterCommand("/ResetHPX", "/hpx/->SetTitle(\"%arg1%\")");
1867/// serv->RegisterCommand("/RebinHPXPY", "/hpxpy/->Rebin2D(%arg1%,%arg2%)");
1868///
1869/// Such parameter(s) will be requested when command clicked in the browser.
1870///
1871/// Once command is registered, one could specify icon which will appear in the browser:
1872///
1873/// serv->SetIcon("/ResetHPX", "rootsys/icons/ed_execute.png");
1874///
1875/// One also can set extra property '_fastcmd', that command appear as
1876/// tool button on the top of the browser tree:
1877///
1878/// serv->SetItemField("/ResetHPX", "_fastcmd", "true");
1879///
1880/// Or it is equivalent to specifying extra argument when register command:
1881///
1882/// serv->RegisterCommand("/ResetHPX", "/hpx/->Reset()", "button;rootsys/icons/ed_delete.png");
1883
1884Bool_t TRootSniffer::RegisterCommand(const char *cmdname, const char *method, const char *icon)
1885{
1886 CreateItem(cmdname, TString::Format("command %s", method).Data());
1887 SetItemField(cmdname, "_kind", "Command");
1888 if (icon) {
1889 if (strncmp(icon, "button;", 7) == 0) {
1890 SetItemField(cmdname, "_fastcmd", "true");
1891 icon += 7;
1892 }
1893 if (*icon)
1894 SetItemField(cmdname, "_icon", icon);
1895 }
1896 SetItemField(cmdname, "method", method);
1897 Int_t numargs = 0;
1898 do {
1899 TString nextname = TString::Format("%sarg%d%s", "%", numargs + 1, "%");
1900 if (strstr(method, nextname.Data()) == nullptr)
1901 break;
1902 numargs++;
1903 } while (numargs < 100);
1904 if (numargs > 0)
1905 SetItemField(cmdname, "_numargs", TString::Format("%d", numargs));
1906
1907 return kTRUE;
1908}
#define f(i)
Definition RSha256.hxx:104
#define ROOT_VERSION_CODE
Definition RVersion.hxx:24
unsigned long ULong_t
Definition RtypesCore.h:55
long Long_t
Definition RtypesCore.h:54
constexpr Bool_t kFALSE
Definition RtypesCore.h:101
constexpr Ssiz_t kNPOS
Definition RtypesCore.h:124
constexpr Bool_t kTRUE
Definition RtypesCore.h:100
#define ClassImp(name)
Definition Rtypes.h:377
@ kIsEnum
Definition TDictionary.h:68
@ kIsAbstract
Definition TDictionary.h:71
@ kIsStatic
Definition TDictionary.h:80
@ kIsUnion
Definition TDictionary.h:67
Option_t Option_t option
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h length
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
char name[80]
Definition TGX11.cxx:110
Int_t gDebug
Definition TROOT.cxx:597
R__EXTERN TVirtualMutex * gROOTMutex
Definition TROOT.h:63
#define gROOT
Definition TROOT.h:406
const char * item_prop_typename
const char * item_prop_realname
const char * item_prop_user
const char * item_prop_autoload
const char * item_prop_more
const char * item_prop_kind
const char * item_prop_arraydim
const char * item_prop_title
const char * item_prop_rootversion
const char * item_prop_hidden
#define R__LOCKGUARD(mutex)
static TString ConvertToJSON(const TObject *obj, Int_t compact=0, const char *member_name=nullptr)
Converts object, inherited from TObject class, to JSON string Lower digit of compact parameter define...
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:81
void BuildRealData(void *pointer=nullptr, Bool_t isTransient=kFALSE)
Build a full list of persistent data members.
Definition TClass.cxx:2031
TList * GetListOfRealData() const
Definition TClass.h:453
Int_t Size() const
Return size of object of this class.
Definition TClass.cxx:5704
Int_t GetBaseClassOffset(const TClass *toBase, void *address=nullptr, bool isDerivedObject=true)
Definition TClass.cxx:2791
Long_t Property() const override
Returns the properties of the TClass as a bit field stored as a Long_t value.
Definition TClass.cxx:6086
TClass * IsA() const override
Definition TClass.h:618
TRealData * GetRealData(const char *name) const
Return pointer to TRealData element with name "name".
Definition TClass.cxx:3503
Collection abstract base class.
Definition TCollection.h:65
static TClass * Class()
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
TObject * FindObject(const char *name) const override
Find an object in this collection using its name.
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
All ROOT classes may have RTTI (run time type identification) support added.
Definition TDataMember.h:31
Int_t GetMaxIndex(Int_t dim) const
Return maximum index for array dimension "dim".
const char * GetTrueTypeName() const
Get the desugared type name of this data member, including const and volatile qualifiers.
Long_t Property() const override
Get property description word. For meaning of bits see EProperty.
Int_t GetArrayDim() const
Return number of array dimensions.
Bool_t IsBasic() const
Return true if data member is a basic type, e.g. char, int, long...
Int_t IsSTLContainer()
The return type is defined in TDictionary (kVector, kList, etc.)
Bool_t IsaPointer() const
Return true if data member is a pointer.
const char * GetTypeName() const
Get the decayed type name of this data member, removing const and volatile qualifiers,...
const char * GetArrayIndex() const
If the data member is pointer and has a valid array size in its comments GetArrayIndex returns a stri...
static TClass * Class()
Describe directory structure in memory.
Definition TDirectory.h:45
static TClass * Class()
virtual TList * GetList() const
Definition TDirectory.h:222
virtual TList * GetListOfKeys() const
Definition TDirectory.h:223
<div class="legacybox"><h2>Legacy Code</h2> TFolder is a legacy interface: there will be no bug fixes...
Definition TFolder.h:30
void RecursiveRemove(TObject *obj) override
Recursively remove object from a folder.
Definition TFolder.cxx:449
TCollection * GetListOfFolders() const
Definition TFolder.h:55
TFolder * AddFolder(const char *name, const char *title, TCollection *collection=nullptr)
Create a new folder and add it to the list of folders of this folder, return a pointer to the created...
Definition TFolder.cxx:182
virtual void Add(TObject *obj)
Add object to this folder. obj must be a TObject or a TFolder.
Definition TFolder.cxx:166
TObject * FindObject(const char *name) const override
Search object identified by name in the tree of folders inside this folder.
Definition TFolder.cxx:306
static TClass * Class()
virtual void Remove(TObject *obj)
Remove object from this folder. obj must be a TObject or a TFolder.
Definition TFolder.cxx:457
Contains arguments for single HTTP call.
const char * GetUserName() const
return authenticated user name (0 - when no authentication)
const void * GetPostData() const
return pointer on posted with request data
Long_t GetPostDataLength() const
return length of posted with request data
Book space in a file, create I/O buffers, to fill them, (un)compress them.
Definition TKey.h:28
T * ReadObject()
To read an object (non deriving from TObject) from the file.
Definition TKey.h:103
virtual const char * GetClassName() const
Definition TKey.h:75
Short_t GetCycle() const
Return cycle number associated to this key.
Definition TKey.cxx:581
virtual TObject * ReadObj()
To read a TObject* from the file.
Definition TKey.cxx:762
A doubly linked list.
Definition TList.h:38
void AddAfter(const TObject *after, TObject *obj) override
Insert object after object after in the list.
Definition TList.cxx:248
TObject * FindObject(const char *name) const override
Find an object in this list using its name.
Definition TList.cxx:576
void Add(TObject *obj) override
Definition TList.h:83
void AddFirst(TObject *obj) override
Add object at the beginning of the list.
Definition TList.cxx:98
The TNamed class is the base class for all named ROOT classes.
Definition TNamed.h:29
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition TNamed.cxx:164
const char * GetName() const override
Returns name of object.
Definition TNamed.h:47
const char * GetTitle() const override
Returns title of object.
Definition TNamed.h:48
TNamed()
Definition TNamed.h:36
static TClass * Class()
An array of TObjects.
Definition TObjArray.h:31
TObject * FindObject(const char *name) const override
Find an object in this collection using its name.
Collectable string class.
Definition TObjString.h:28
Mother of all ROOT objects.
Definition TObject.h:41
virtual const char * GetName() const
Returns name of object.
Definition TObject.cxx:439
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition TObject.h:199
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition TObject.cxx:207
static TClass * Class()
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition TObject.cxx:780
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition TObject.cxx:525
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition TObject.cxx:987
virtual const char * GetTitle() const
Returns title of object.
Definition TObject.cxx:483
virtual TClass * IsA() const
Definition TObject.h:243
@ kCanDelete
if object in a list can be deleted
Definition TObject.h:62
@ kMustCleanup
if object destructor must call RecursiveRemove()
Definition TObject.h:64
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition TObject.cxx:961
The TRealData class manages the effective list of all data members for a given class.
Definition TRealData.h:30
const char * GetName() const override
Returns name of object.
Definition TRealData.h:52
TDataMember * GetDataMember() const
Definition TRealData.h:53
Long_t GetThisOffset() const
Definition TRealData.h:55
Structure used to scan hierarchies of ROOT objects.
TString fItemName
! name of current item
Int_t fLevel
! current level of hierarchy
Int_t fRestriction
! restriction 0 - default, 1 - read-only, 2 - full access
Bool_t CanExpandItem()
Returns true when item can be expanded.
TRootSnifferStore * fStore
! object to store results
@ kSearch
search for specified item (only objects and collections)
@ kOnlyFields
if set, only fields for specified item will be set (but all fields)
@ kExpand
expand of specified item - allowed to scan object members
@ kCheckChilds
check if there childs, very similar to search
@ kScan
normal scan of hierarchy
@ kActions
mask for actions, only actions copied to child rec
virtual ~TRootSnifferScanRec()
destructor
void SetField(const char *name, const char *value, Bool_t with_quotes=kTRUE)
Set item field only when creating is specified.
void CloseNode()
Close started node.
Bool_t CanSetFields() const
return true when fields could be set to the hierarchy item
UInt_t fMask
! defines operation kind
void MakeItemName(const char *objname, TString &itemname)
Construct item name, using object name as basis.
Bool_t IsReadyForResult() const
Checks if result will be accepted.
Bool_t SetResult(void *obj, TClass *cl, TDataMember *member=nullptr)
Obsolete, use SetFoundResult instead.
Bool_t fHasMore
! indicates that potentially there are more items can be found
Bool_t IsReadOnly(Bool_t dflt=kTRUE)
Returns read-only flag for current item.
Bool_t GoInside(TRootSnifferScanRec &super, TObject *obj, const char *obj_name=nullptr, TRootSniffer *sniffer=nullptr)
Method verifies if new level of hierarchy should be started with provided object.
void BeforeNextChild()
Indicates that new child for current element will be started.
TRootSnifferScanRec * fParent
! pointer on parent record
void SetRootClass(TClass *cl)
Mark item with ROOT class and correspondent streamer info.
void CreateNode(const char *_node_name)
Starts new node, must be closed at the end.
Int_t fNumChilds
! number of childs
Int_t fNumFields
! number of fields
Bool_t fNodeStarted
! indicate if node was started
Bool_t SetFoundResult(void *obj, TClass *cl, TDataMember *member=nullptr)
Set found element with class and datamember (optional)
const char * fSearchPath
! current path searched
Int_t Depth() const
Returns depth of hierarchy.
TList fItemsNames
! list of created items names, need to avoid duplication
Bool_t Done() const
Method indicates that scanning can be interrupted while result is set.
Bool_t ScanOnlyFields() const
return true when only fields are scanned by the sniffer
void BuildFullName(TString &buf, TRootSnifferScanRec *prnt=nullptr)
Produces full name for the current item.
TRootSnifferScanRec()
constructor
Storage of hierarchy scan in TRootSniffer in JSON format.
Storage of hierarchy scan in TRootSniffer in XML format.
Abstract interface for storage of hierarchy scan in TRootSniffer.
Int_t GetResNumChilds() const
TDataMember * GetResMember() const
virtual void CreateNode(Int_t, const char *)
void * GetResPtr() const
void SetResult(void *_res, TClass *_rescl, TDataMember *_resmemb, Int_t _res_chld, Int_t restr=0)
set pointer on found element, class and number of childs
virtual void CloseNode(Int_t, Int_t)
TClass * GetResClass() const
virtual void BeforeNextChild(Int_t, Int_t, Int_t)
Int_t GetResRestrict() const
virtual void SetField(Int_t, const char *, const char *, Bool_t)
Sniffer of ROOT objects, data provider for THttpServer.
void ScanObjectMembers(TRootSnifferScanRec &rec, TClass *cl, char *ptr)
scan object data members some members like enum or static members will be excluded
const char * GetAutoLoad() const
return name of configured autoload scripts (or 0)
TString fObjectsPath
! default path for registered objects
void ScanHierarchy(const char *topname, const char *path, TRootSnifferStore *store, Bool_t only_fields=kFALSE)
Method scans normal objects, registered in ROOT.
TRootSniffer(const char *name="sniff", const char *objpath="Objects")
constructor
TList fRestrictions
! list of restrictions for different locations
Bool_t RegisterObject(const char *subfolder, TObject *obj)
Register object in subfolder structure.
virtual void ScanObjectChilds(TRootSnifferScanRec &rec, TObject *obj)
scans object childs (if any) here one scans collection, branches, trees and so on
TString fCurrentAllowedMethods
! list of allowed methods, extracted when analyzed object restrictions
virtual Bool_t HasStreamerInfo() const
Bool_t UnregisterObject(TObject *obj)
Unregister (remove) object from folders structures.
virtual void ScanKeyProperties(TRootSnifferScanRec &rec, TKey *key, TObject *&obj, TClass *&obj_class)
Scans TKey properties in special cases load objects from the file.
Bool_t CreateItem(const char *fullname, const char *title)
Create item element.
virtual Bool_t ExecuteCmd(const std::string &path, const std::string &options, std::string &res)
Execute command marked as _kind=='Command'.
Bool_t HasRestriction(const char *item_name)
Made fast check if item with specified name is in restriction list If returns true,...
virtual void ScanObjectProperties(TRootSnifferScanRec &rec, TObject *obj)
Scans object properties here such fields as _autoload or _icon properties depending on class or objec...
virtual void ScanRoot(TRootSnifferScanRec &rec)
scan complete ROOT objects hierarchy For the moment it includes objects in gROOT directory and list o...
Bool_t Produce(const std::string &path, const std::string &file, const std::string &options, std::string &res)
Method produce different kind of data out of object.
virtual Bool_t ProduceJson(const std::string &path, const std::string &options, std::string &res)
Produce JSON data for specified item For object conversion TBufferJSON is used.
void CreateOwnTopFolder()
Create own TFolder structures independent from gROOT This allows to have many independent TRootSniffe...
virtual Bool_t ProduceExe(const std::string &path, const std::string &options, Int_t reskind, std::string &res)
Execute command for specified object.
virtual Bool_t ProduceXml(const std::string &path, const std::string &options, std::string &res)
Produce XML data for specified item.
TString DecodeUrlOptionValue(const char *value, Bool_t remove_quotes=kTRUE)
Method replaces all kind of special symbols, which could appear in URL options.
THttpCallArg * SetCurrentCallArg(THttpCallArg *arg)
set current http arguments, which then used in different process methods For instance,...
void Restrict(const char *path, const char *options)
Restrict access to the specified location.
virtual ULong_t GetItemHash(const char *itemname)
Get hash function for specified item used to detect any changes in the specified object.
Bool_t fReadOnly
! indicate if sniffer allowed to change ROOT structures - like read objects from file
void SetScanGlobalDir(Bool_t on=kTRUE)
When enabled (default), sniffer scans gROOT for files, canvases, histograms.
TObject * GetItem(const char *fullname, TFolder *&parent, Bool_t force=kFALSE, Bool_t within_objects=kTRUE)
Return item from the subfolders structure.
THttpCallArg * fCurrentArg
! current http arguments (if any)
virtual Bool_t ProduceImage(Int_t kind, const std::string &path, const std::string &options, std::string &res)
Method to produce image from specified object.
TObject * FindTObjectInHierarchy(const char *path)
Search element in hierarchy, derived from TObject.
void SetAutoLoad(const char *scripts="")
When specified, _autoload attribute will be always add to top element of h.json/h....
virtual void * FindInHierarchy(const char *path, TClass **cl=nullptr, TDataMember **member=nullptr, Int_t *chld=nullptr)
Search element with specified path Returns pointer on element Optionally one could obtain element cla...
virtual Bool_t ProduceItem(const std::string &path, const std::string &options, std::string &res, Bool_t asjson=kTRUE)
Produce JSON/XML for specified item.
Int_t CheckRestriction(const char *item_name)
Checked if restriction is applied to the item full_item_name should have full path to the item.
virtual Bool_t CallProduceImage(const std::string &kind, const std::string &path, const std::string &options, std::string &res)
Invokes TRootSniffer::ProduceIamge, converting kind into TImage::EImageFileTypes type.
Bool_t IsItemField(TObject *obj) const
Return true when object is TNamed with kItemField bit set.
virtual ~TRootSniffer()
destructor
virtual Bool_t CanDrawClass(TClass *)
Int_t fCurrentRestrict
! current restriction for last-found object
TFolder * GetTopFolder(Bool_t force=kFALSE)
Returns top TFolder instance for the sniffer.
const char * GetItemField(TFolder *parent, TObject *item, const char *name)
Return field for specified item.
std::unique_ptr< TFolder > fTopFolder
! own top TFolder object, used for registering objects
Bool_t CanExploreItem(const char *path)
Method returns true when object has childs or one could try to expand item.
Bool_t SetItemField(const char *fullname, const char *name, const char *value)
Set field for specified item.
Int_t WithCurrentUserName(const char *option)
return 2 when option match to current user name return 1 when option==all return 0 when option does n...
Bool_t RegisterCommand(const char *cmdname, const char *method, const char *icon)
Register command which can be executed from web interface.
TString fAutoLoad
! scripts names, which are add as _autoload parameter to h.json request
Bool_t IsScanGlobalDir() const
Returns true when sniffer allowed to scan global directories.
virtual Bool_t ProduceBinary(const std::string &path, const std::string &options, std::string &res)
Produce binary data for specified item.
TFolder * GetSubFolder(const char *foldername, Bool_t force=kFALSE)
Creates subfolder where objects can be registered.
virtual Bool_t ProduceRootFile(const std::string &path, const std::string &options, std::string &res)
Produce ROOT file for specified item.
void ScanCollection(TRootSnifferScanRec &rec, TCollection *lst, const char *foldername=nullptr, TCollection *keys_lst=nullptr)
Scan collection content.
Bool_t AccessField(TFolder *parent, TObject *item, const char *name, const char *value, TNamed **only_get=nullptr)
Set or get field for the child.
virtual Bool_t ProduceMulti(const std::string &path, const std::string &options, std::string &res, Bool_t asjson=kTRUE)
Process several requests, packing all results into binary or JSON buffer.
Bool_t CanDrawItem(const char *path)
Method verifies if object can be drawn.
virtual Int_t GetLast() const
Returns index of last object in collection.
Basic string class.
Definition TString.h:139
Ssiz_t Length() const
Definition TString.h:417
int CompareTo(const char *cs, ECaseCompare cmp=kExact) const
Compare a string to char *cs2.
Definition TString.cxx:457
Int_t Atoi() const
Return integer value of string.
Definition TString.cxx:1988
const char * Data() const
Definition TString.h:376
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition TString.h:704
TObjArray * Tokenize(const TString &delim) const
This function is used to isolate sequential tokens in a TString.
Definition TString.cxx:2264
UInt_t Hash(ECaseCompare cmp=kExact) const
Return hash value.
Definition TString.cxx:677
TString & Remove(Ssiz_t pos)
Definition TString.h:685
TString & Append(const char *cs)
Definition TString.h:572
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
Definition TString.cxx:2378
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition TString.cxx:2356
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition TString.h:651
This class represents a WWW compatible URL.
Definition TUrl.h:33
const char * GetValueFromOptions(const char *key) const
Return a value for a given key from the URL options.
Definition TUrl.cxx:660
Int_t GetIntValueFromOptions(const char *key) const
Return a value for a given key from the URL options as an Int_t, a missing key returns -1.
Definition TUrl.cxx:672
void SetOptions(const char *opt)
Definition TUrl.h:87
void ParseOptions() const
Parse URL options into a key/value map.
Definition TUrl.cxx:626
const Int_t n
Definition legend1.C:16
TCanvas * slash()
Definition slash.C:1
TLine l
Definition textangle.C:4