Logo ROOT  
Reference Guide
XrdProofdClient.cxx
Go to the documentation of this file.
1// @(#)root/proofd:$Id$
2// Author: G. Ganis June 2007
3
4/*************************************************************************
5 * Copyright (C) 1995-2005, 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//////////////////////////////////////////////////////////////////////////
13// //
14// XrdProofdClient //
15// //
16// Author: G. Ganis, CERN, 2007 //
17// //
18// Auxiliary class describing a PROOF client. //
19// Used by XrdProofdProtocol. //
20// //
21//////////////////////////////////////////////////////////////////////////
22#include <sys/stat.h>
23
24#include "XrdNet/XrdNet.hh"
25#include "XrdSys/XrdSysPriv.hh"
26
27#include "XrdProofdClient.h"
28#include "XrdProofdProtocol.h"
29#include "XrdProofdProofServ.h"
31
32#include "XrdProofdTrace.h"
33
34////////////////////////////////////////////////////////////////////////////////
35/// Constructor
36
38 XrdSysError *, const char *adminpath, int rtime)
39 : fSandbox(ui, master, changeown)
40{
41 XPDLOC(CMGR, "Client::Client")
42
43 fProofServs.clear();
44 fClients.clear();
45 fUI = ui;
46 fROOT = 0;
47 fIsValid = 0;
48 fAskedToTouch = 0;
50 fReconnectTimeOut = rtime;
51
52 // Make sure the admin path exists
53 XPDFORM(fAdminPath, "%s/%s.%s", adminpath, ui.fUser.c_str(), ui.fGroup.c_str());
54 struct stat st;
55 if (stat(adminpath, &st) != 0) {
56 TRACE(XERR, "problems stating admin path "<<adminpath<<"; errno = "<<errno);
57 return;
58 }
59 XrdProofUI effui;
60 XrdProofdAux::GetUserInfo(st.st_uid, effui);
61 if (XrdProofdAux::AssertDir(fAdminPath.c_str(), effui, 1) != 0)
62 return;
63
64 // We must have a valid sandbox
65 if (fSandbox.IsValid()) fIsValid = 1;
66}
67
68////////////////////////////////////////////////////////////////////////////////
69/// Destructor
70
72{
73}
74
75////////////////////////////////////////////////////////////////////////////////
76/// return TRUE if this instance matches 'id' (and 'grp', if defined)
77
78bool XrdProofdClient::Match(const char *usr, const char *grp)
79{
80 if (!fIsValid) return 0;
81
82 bool rc = (usr && !strcmp(usr, User())) ? 1 : 0;
83 if (rc && grp && strlen(grp) > 0)
84 rc = (grp && Group() && !strcmp(grp, Group())) ? 1 : 0;
85
86 return rc;
87}
88
89////////////////////////////////////////////////////////////////////////////////
90/// Get next free client ID. If none is found, increase the vector size
91/// and get the first new one
92
94{
95 XPDLOC(CMGR, "Client::GetClientID")
96
97 XrdClientID *cid = 0;
98 int ic = 0, sz = 0;
100 if (!fIsValid) return -1;
101 // Search for free places in the existing vector
102 for (ic = 0; ic < (int)fClients.size() ; ic++) {
103 if (fClients[ic] && !fClients[ic]->IsValid()) {
104 int rtime = fClients[ic]->ResetTime();
105 if ((rtime >= 0) && ((time(0) - rtime) < fReconnectTimeOut)) {
106 // The session using this cid disconnected too recently, do not reuse yet
107 continue;
108 }
109 cid = fClients[ic];
110 cid->Reset();
111 break;
112 }
113 }
114
115 if (!cid) {
116 // We need to resize (double it)
117 if (ic >= (int)fClients.capacity())
118 fClients.reserve(2*fClients.capacity());
119
120 // Fill in new element
121 cid = new XrdClientID();
122 fClients.push_back(cid);
123 sz = fClients.size();
124 }
125 }
126 // Re-init for this protocol
127 if (cid) {
128 cid->SetP(p);
129 // Reference Stream ID
130 unsigned short sid;
131 memcpy((void *)&sid, (const void *)&(p->Request()->header.streamid[0]), 2);
132 cid->SetSid(sid);
133 }
134
135 TRACE(DBG, "size = "<<sz<<", ic = "<<ic);
136
137 // We are done
138 return ic;
139}
140
141////////////////////////////////////////////////////////////////////////////////
142/// Reserve a client ID. If none is found, increase the vector size
143/// and performe the needed initializations
144
146{
147 XPDLOC(CMGR, "Client::ReserveClientID")
148
149 if (cid < 0)
150 return -1;
151
152 int sz = 0, newsz = 0;
154 if (!fIsValid) return -1;
155 if (cid >= (int)fClients.size()) {
156
157 // We need to resize (double it)
158 newsz = fClients.capacity();
159 if (cid >= (int)fClients.capacity()) {
160 newsz = 2 * fClients.capacity();
161 newsz = (cid < newsz) ? newsz : cid + 1;
162 fClients.reserve(newsz);
163 }
164
165 // Fill in new elements
166 while (cid >= (int)fClients.size())
167 fClients.push_back(new XrdClientID());
168 }
169 sz = fClients.size();
170 }
171
172 TRACE(DBG, "cid = "<<cid<<", size = "<<sz<<", capacity = "<<newsz);
173
174 // We are done
175 return 0;
176}
177
178////////////////////////////////////////////////////////////////////////////////
179/// Get next free server ID. If none is found, increase the vector size
180/// and get the first new one
181
183{
184 XPDLOC(CMGR, "Client::GetFreeServObj")
185
186 int ic = 0, newsz = 0, sz = 0;
187 XrdProofdProofServ *xps = 0;
188 XrdOucString msg;
190 if (!fIsValid) return xps;
191
192 // Search for free places in the existing vector
193 for (ic = 0; ic < (int)fProofServs.size() ; ic++) {
194 if (fProofServs[ic] && !(fProofServs[ic]->IsValid())) {
195 fProofServs[ic]->SetValid();
196 break;
197 }
198 }
199
200 // If we did not find it, we resize the vector (double it)
201 if (ic >= (int)fProofServs.capacity()) {
202 newsz = 2 * fProofServs.capacity();
203 fProofServs.reserve(newsz);
204 }
205 if (ic >= (int)fProofServs.size()) {
206 // Allocate new element
207 fProofServs.push_back(new XrdProofdProofServ());
208 }
209 sz = fProofServs.size();
210
211 xps = fProofServs[ic];
212 xps->SetValid();
213 xps->SetID(ic);
214 }
215
216 // Notify
217 if (TRACING(DBG)) {
218 if (newsz > 0) {
219 XPDFORM(msg, "new capacity = %d, size = %d, ic = %d, xps = %p",
220 newsz, sz, ic, xps);
221 } else {
222 XPDFORM(msg, "size = %d, ic = %d, xps = %p", sz, ic, xps);
223 }
224 XPDPRT(msg);
225 }
226
227 // We are done
228 return xps;
229}
230
231////////////////////////////////////////////////////////////////////////////////
232/// Get server at 'id'. If needed, increase the vector size
233
235{
236 XPDLOC(CMGR, "Client::GetServObj")
237
238 TRACE(DBG, "id: "<< id);
239
240 if (id < 0) {
241 TRACE(XERR, "invalid input: id: "<< id);
242 return (XrdProofdProofServ *)0;
243 }
244
245 XrdOucString dmsg, emsg;
246 XrdProofdProofServ *xps = 0;
247 int siz = 0, cap = 0;
249 if (!fIsValid) return xps;
250 siz = fProofServs.size();
251 cap = fProofServs.capacity();
252 }
253 TRACE(DBG, "size = "<<siz<<"; capacity = "<<cap);
254
256 if (!fIsValid) return xps;
257 if (id < (int)fProofServs.size()) {
258 if (!(xps = fProofServs[id])) {
259 emsg = "instance in use or undefined! protocol error";
260 }
261 } else {
262 // If we did not find it, we first resize the vector if needed (double it)
263 if (id >= (int)fProofServs.capacity()) {
264 int newsz = 2 * fProofServs.capacity();
265 newsz = (id < newsz) ? newsz : id+1;
266 fProofServs.reserve(newsz);
267 cap = fProofServs.capacity();
268 }
269 int nnew = id - fProofServs.size() + 1;
270 while (nnew--)
271 fProofServs.push_back(new XrdProofdProofServ());
272 xps = fProofServs[id];
273 }
274 }
275 if (xps) {
276 xps->SetID(id);
277 xps->SetValid();
278 }
279 if (TRACING(DBG)) {
281 if (fIsValid) {
282 siz = fProofServs.size();
283 cap = fProofServs.capacity();
284 }
285 }
286 TRACE(DBG, "size = "<<siz<<" (capacity = "<<cap<<"); id = "<<id);
287 }
288
289 // We are done
290 return xps;
291}
292
293////////////////////////////////////////////////////////////////////////////////
294/// Get server instance connected via 'p'
295
297{
298 XPDLOC(CMGR, "Client::GetServer")
299
300 TRACE(DBG, "enter: p: " << p);
301
302
303 XrdProofdProofServ *xps = 0;
304 std::vector<XrdProofdProofServ *>::iterator ip;
306 if (!fIsValid) return xps;
307 for (ip = fProofServs.begin(); ip != fProofServs.end(); ++ip) {
308 xps = (*ip);
309 if (xps && xps->SrvPID() == p->Pid())
310 break;
311 xps = 0;
312 }
313 // Done
314 return xps;
315}
316
317////////////////////////////////////////////////////////////////////////////////
318/// Get from the vector server instance with ID psid
319
321{
323 if (fIsValid && psid > -1 && psid < (int) fProofServs.size())
324 return fProofServs.at(psid);
325 // Done
326 return (XrdProofdProofServ *)0;
327}
328
329////////////////////////////////////////////////////////////////////////////////
330/// Erase server with id psid from the list
331
333{
334 XPDLOC(CMGR, "Client::EraseServer")
335
336 TRACE(DBG, "enter: psid: " << psid);
337
338 XrdProofdProofServ *xps = 0;
339 std::vector<XrdProofdProofServ *>::iterator ip;
341 if (!fIsValid) return;
342
343 for (ip = fProofServs.begin(); ip != fProofServs.end(); ++ip) {
344 xps = *ip;
345 if (xps && xps->Match(psid)) {
346 // Reset (invalidate)
347 xps->Reset();
348 break;
349 }
350 }
351}
352
353////////////////////////////////////////////////////////////////////////////////
354/// Return the number of valid proofserv topmaster sessions in the list
355
357{
358 XPDLOC(CMGR, "Client::GetTopServers")
359
360 int nv = 0;
361
362 XrdProofdProofServ *xps = 0;
363 std::vector<XrdProofdProofServ *>::iterator ip;
365 if (!fIsValid) return nv;
366 for (ip = fProofServs.begin(); ip != fProofServs.end(); ++ip) {
367 if ((xps = *ip) && xps->IsValid() && (xps->SrvType() == kXPD_TopMaster)) {
368 TRACE(DBG,"found potentially valid topmaster session: pid "<<xps->SrvPID());
369 nv++;
370 }
371 }
372
373 // Done
374 return nv;
375}
376
377////////////////////////////////////////////////////////////////////////////////
378/// Reset slot at 'ic'
379
381{
382 XPDLOC(CMGR, "Client::ResetClientSlot")
383
384 TRACE(DBG, "enter: ic: " << ic);
385
387 if (fIsValid) {
388 if (ic >= 0 && ic < (int) fClients.size()) {
389 fClients[ic]->Reset();
390 return 0;
391 }
392 }
393 // Done
394 return -1;
395}
396
397////////////////////////////////////////////////////////////////////////////////
398/// Return protocol attached to client slot at 'ic'
399
401{
402 XPDLOC(CMGR, "Client::GetProtocol")
403
404 TRACE(DBG, "enter: ic: " << ic);
405
406 XrdProofdProtocol *p = 0;
407
409 if (fIsValid) {
410 if (ic >= 0 && ic < (int) fClients.size()) {
411 p = fClients[ic]->P();
412 }
413 }
414 // Done
415 return p;
416}
417
418////////////////////////////////////////////////////////////////////////////////
419/// Set slot cid to instance 'p'
420
422{
423 XPDLOC(CMGR, "Client::SetClientID")
424
425 TRACE(DBG, "cid: "<< cid <<", p: " << p);
426
428 if (!fIsValid) return -1;
429
430 if (cid >= 0 && cid < (int) fClients.size()) {
431 if (fClients[cid] && (fClients[cid]->P() != p))
432 fClients[cid]->Reset();
433 fClients[cid]->SetP(p);
434 // Reference Stream ID
435 unsigned short sid;
436 memcpy((void *)&sid, (const void *)&(p->Request()->header.streamid[0]), 2);
437 fClients[cid]->SetSid(sid);
438 return 0;
439 }
440
441 // Not found
442 return -1;
443}
444
445////////////////////////////////////////////////////////////////////////////////
446/// Broadcast message 'msg' to the connected clients
447
448void XrdProofdClient::Broadcast(const char *msg)
449{
450 XPDLOC(CMGR, "Client::Broadcast")
451
452 int len = 0;
453 if (msg && (len = strlen(msg)) > 0) {
454
455 // Notify the attached clients
456 int ic = 0;
457 XrdClientID *cid = 0;
459 for (ic = 0; ic < (int) fClients.size(); ic++) {
460 if ((cid = fClients.at(ic)) && cid->P() && cid->P()->ConnType() == kXPD_ClientMaster) {
461
462 if (cid->P()->Link()) {
463 TRACE(ALL," sending to: "<<cid->P()->Link()->ID);
464 XrdProofdResponse *response = cid->R();
465 if (response)
466 response->Send(kXR_attn, kXPD_srvmsg, (char *) msg, len);
467 }
468 }
469 }
470 }
471}
472
473////////////////////////////////////////////////////////////////////////////////
474/// Send a touch the connected clients: this will remotely touch the associated
475/// TSocket instance and schedule an asynchronous touch of the client admin file.
476/// This request is only sent once per client: this is controlled by the flag
477/// fAskedToTouch, whcih can reset to FALSE by calling this function with reset
478/// TRUE.
479/// Return 0 if the request is sent or if asked to reset.
480/// Retunn 1 if the request was already sent.
481
483{
484 // If we are asked to reset, just do that and return
485 if (reset) {
486 fAskedToTouch = 0;
487 return 0;
488 }
489
490 // If already asked to touch say it by return 1
491 if (fAskedToTouch) return 1;
492
493 // Notify the attached clients
494 int ic = 0;
495 XrdClientID *cid = 0;
497 for (ic = 0; ic < (int) fClients.size(); ic++) {
498 // Do not send to old clients
499 if ((cid = fClients.at(ic)) && cid->P() && cid->P()->ProofProtocol() > 17) {
500 if (cid->P()->ConnType() != kXPD_Internal) {
501 XrdProofdResponse *response = cid->R();
502 if (response) response->Send(kXR_attn, kXPD_touch, (char *)0, 0);
503 }
504 }
505 }
506 // Do it only once a time
507 fAskedToTouch = 1;
508 // Done
509 return 0;
510}
511
512////////////////////////////////////////////////////////////////////////////////
513/// Quick verification of session 'xps' to avoid attaching clients to
514/// non responding sessions. We do here a sort of loose ping.
515/// Return true is responding, false otherwise.
516
518{
519 XPDLOC(CMGR, "Client::VerifySession")
520
521 if (!xps || !(xps->IsValid())) {
522 TRACE(XERR, " session undefined or invalid");
523 return 0;
524 }
525
526 // Admin path
527 XrdOucString path(xps->AdminPath());
528 if (path.length() <= 0) {
529 TRACE(XERR, "admin path is empty! - protocol error");
530 return 0;
531 }
532 path += ".status";
533
534 // Stat the admin file
535 struct stat st0;
536 if (stat(path.c_str(), &st0) != 0) {
537 TRACE(XERR, "cannot stat admin path: "<<path);
538 return 0;
539 }
540 int now = time(0);
541 if (now >= st0.st_mtime && (now - st0.st_mtime) <= 1) return 1;
542 TRACE(ALL, "admin path: "<<path<<", mtime: "<< st0.st_mtime << ", now: "<< now);
543
544 // Take the pid
545 int pid = xps->SrvPID();
546 // If the session is alive ...
547 if (XrdProofdAux::VerifyProcessByID(pid) != 0) {
548 // Send the request (no further propagation)
549 if (xps->VerifyProofServ(0) != 0) {
550 TRACE(XERR, "could not send verify request to proofsrv");
551 return 0;
552 }
553 // Wait for the action for fgMgr->SessionMgr()->VerifyTimeOut() secs,
554 // checking every 1 sec
555 XrdOucString notmsg;
556 struct stat st1;
557 int ns = 10;
558 while (ns--) {
559 if (stat(path.c_str(), &st1) == 0) {
560 if (st1.st_mtime > st0.st_mtime) {
561 return 1;
562 }
563 }
564 // Wait 1 sec
565 TRACE(HDBG, "waiting "<<ns<<" secs for session "<<pid<<
566 " to touch the admin path");
567 if (r && ns == 5) {
568 XPDFORM(notmsg, "verifying existing sessions, %d seconds ...", ns);
569 r->Send(kXR_attn, kXPD_srvmsg, 0, (char *) notmsg.c_str(), notmsg.length());
570 }
571 sleep(1);
572 }
573 }
574
575 // Verification Failed
576 return 0;
577}
578
579////////////////////////////////////////////////////////////////////////////////
580/// Skip the next sessions status check. This is used, for example, when
581/// somebody has shown interest in these sessions to give more time for the
582/// reconnection.
583/// If active is defined, the list of active sessions is filled.
584
585void XrdProofdClient::SkipSessionsCheck(std::list<XrdProofdProofServ *> *active,
586 XrdOucString &emsg, XrdProofdResponse *r)
587{
588 XPDLOC(CMGR, "Client::SkipSessionsCheck")
589
590 XrdProofdProofServ *xps = 0;
591 std::vector<XrdProofdProofServ *>::iterator ip;
592 for (ip = fProofServs.begin(); ip != fProofServs.end(); ++ip) {
593 if ((xps = *ip) && xps->IsValid() && (xps->SrvType() == kXPD_TopMaster)) {
594 if (VerifySession(xps, r)) {
595 xps->SetSkipCheck(); // Skip next validity check
596 if (active) active->push_back(xps);
597 } else {
598 if (xps->SrvPID() > 0) {
599 if (emsg.length() <= 0)
600 emsg = "ignoring (apparently) non-responding session(s): ";
601 else
602 emsg += " ";
603 emsg += xps->SrvPID();
604 }
605 TRACE(ALL,"session "<<xps->SrvPID()<<" does not react: dead?");
606 }
607 }
608 }
609 if (active)
610 TRACE(HDBG, "found: " << active->size() << " sessions");
611
612 // Over
613 return;
614}
615
616////////////////////////////////////////////////////////////////////////////////
617/// Return a string describing the existing sessions
618
619XrdOucString XrdProofdClient::ExportSessions(XrdOucString &emsg,
621{
622 XrdOucString out, buf;
623
624 // Protect from next session check and get the list of actives
625 std::list<XrdProofdProofServ *> active;
626 SkipSessionsCheck(&active, emsg, r);
627
628 // Fill info
629 XrdProofdProofServ *xps = 0;
630 out += (int) active.size();
631 std::list<XrdProofdProofServ *>::iterator ia;
632 for (ia = active.begin(); ia != active.end(); ++ia) {
633 if ((xps = *ia) && xps->IsValid()) {
634 xps->ExportBuf(buf);
635 out += buf;
636 }
637 }
638
639 // Over
640 return out;
641}
642
643////////////////////////////////////////////////////////////////////////////////
644/// Terminate client sessions; IDs of signalled processes are added to sigpid.
645
647 const char *msg, XrdProofdPipe *pipe,
648 bool changeown)
649{
650 XPDLOC(CMGR, "Client::TerminateSessions")
651
652 // Loop over client sessions and terminated them
653 int is = 0;
655 for (is = 0; is < (int) fProofServs.size(); is++) {
656 if ((s = fProofServs.at(is)) && s->IsValid() && (!ref || ref == s) &&
657 (s->SrvType() == srvtype || (srvtype == kXPD_AnyServer))) {
658 TRACE(DBG, "terminating " << s->SrvPID());
659
660 if (srvtype == kXPD_TopMaster && msg && strlen(msg) > 0)
661 // Tell other attached clients, if any, that this session is gone
662 Broadcast(msg);
663
664 // Sendout a termination signal
665 s->TerminateProofServ(changeown);
666
667 // Record this session in the sandbox as old session
668 XrdOucString tag = "-";
669 tag += s->SrvPID();
670 if (fSandbox.GuessTag(tag, 1) == 0)
671 fSandbox.RemoveSession(tag.c_str());
672
673 // Tell the session manager that the session is gone
674 if (pipe) {
675 int rc = 0;
676 XrdOucString buf(s->AdminPath());
677 buf.erase(0, buf.rfind('/') + 1);
678 TRACE(DBG,"posting kSessionRemoval with: '"<<buf<<"'");
679 if ((rc = pipe->Post(XrdProofdProofServMgr::kSessionRemoval, buf.c_str())) != 0) {
680 TRACE(XERR, "problem posting the pipe; errno: "<<-rc);
681 }
682 }
683
684 // Reset this session
685 s->Reset();
686 }
687 }
688}
689
690////////////////////////////////////////////////////////////////////////////////
691/// Reset this instance
692
694{
695 fAskedToTouch = 0;
696
698 std::vector<XrdProofdProofServ *>::iterator ip;
699 for (ip = fProofServs.begin(); ip != fProofServs.end(); ++ip) {
700 // Reset (invalidate) the server instance
701 if (*ip) (*ip)->Reset();
702 }
703}
704
#define TRACE(Flag, Args)
Definition: TGHtml.h:121
winID h TVirtualViewer3D TVirtualGLPainter p
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 r
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize id
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 Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t UChar_t len
R__EXTERN C unsigned int sleep(unsigned int seconds)
#define kXPD_ClientMaster
#define kXPD_TopMaster
#define kXPD_AnyServer
#define kXPD_Internal
@ kXPD_touch
@ kXPD_srvmsg
#define XrdSysError
Definition: XpdSysError.h:8
#define XPDFORM
Definition: XrdProofdAux.h:378
#define XPDPRT(x)
#define XPDLOC(d, x)
#define TRACING(x)
#define XrdSysMutexHelper
Definition: XrdSysToOuc.h:17
XrdProofdResponse * R() const
void SetP(XrdProofdProtocol *p)
XrdProofdProtocol * P() const
void SetSid(unsigned short sid)
XrdOucString fUser
Definition: XrdProofdAux.h:40
XrdOucString fGroup
Definition: XrdProofdAux.h:41
static int GetUserInfo(const char *usr, XrdProofUI &ui)
Get information about user 'usr' in a thread safe way.
static int AssertDir(const char *path, XrdProofUI ui, bool changeown)
Make sure that 'path' exists and is owned by the entity described by 'ui'.
static int VerifyProcessByID(int pid, const char *pname="proofserv")
Check if a process named 'pname' and process 'pid' is still in the process table.
std::vector< XrdClientID * > fClients
virtual ~XrdProofdClient()
Destructor.
bool IsValid() const
void TerminateSessions(int srvtype, XrdProofdProofServ *ref, const char *msg, XrdProofdPipe *pipe, bool changeown)
Terminate client sessions; IDs of signalled processes are added to sigpid.
int ReserveClientID(int cid)
Reserve a client ID.
int GetTopServers()
Return the number of valid proofserv topmaster sessions in the list.
XrdProofdProofServ * GetFreeServObj()
Get next free server ID.
int GetClientID(XrdProofdProtocol *p)
Get next free client ID.
XrdOucString ExportSessions(XrdOucString &emsg, XrdProofdResponse *r=0)
Return a string describing the existing sessions.
const char * Group() const
const char * User() const
int ResetClientSlot(int ic)
Reset slot at 'ic'.
void Broadcast(const char *msg)
Broadcast message 'msg' to the connected clients.
XrdOucString fAdminPath
XrdSysRecMutex fMutex
bool VerifySession(XrdProofdProofServ *xps, XrdProofdResponse *r=0)
Quick verification of session 'xps' to avoid attaching clients to non responding sessions.
void ResetSessions()
Reset this instance.
XrdProofdProofServ * GetServer(int psid)
Get from the vector server instance with ID psid.
std::vector< XrdProofdProofServ * > fProofServs
int Touch(bool reset=0)
Send a touch the connected clients: this will remotely touch the associated TSocket instance and sche...
void EraseServer(int psid)
Erase server with id psid from the list.
XrdProofdProofServ * GetServObj(int id)
Get server at 'id'. If needed, increase the vector size.
int SetClientID(int cid, XrdProofdProtocol *p)
Set slot cid to instance 'p'.
XrdProofdSandbox fSandbox
XrdProofdProtocol * GetProtocol(int ic)
Return protocol attached to client slot at 'ic'.
bool Match(const char *usr, const char *grp=0)
return TRUE if this instance matches 'id' (and 'grp', if defined)
void SkipSessionsCheck(std::list< XrdProofdProofServ * > *active, XrdOucString &emsg, XrdProofdResponse *r=0)
Skip the next sessions status check.
XrdProofdClient(XrdProofUI ui, bool master, bool changeown, XrdSysError *edest, const char *tmp, int rtime)
Constructor.
int Post(int type, const char *msg)
Post message on the pipe.
void SetValid(bool valid=1)
const char * AdminPath() const
void SetID(short int id)
void ExportBuf(XrdOucString &buf)
Fill buf with relevant info about this session.
int VerifyProofServ(bool fw)
Check if the associated proofserv process is alive.
bool Match(short int id) const
void Reset()
Reset this instance.
XrdLink * Link() const
short int ProofProtocol() const
int Send(void)
Auxilliary Send method.
int GuessTag(XrdOucString &tag, int ridx=1)
Guess session tag completing 'tag' (typically "-<pid>") by scanning the active session file or the se...
bool IsValid() const
int RemoveSession(const char *tag)
Move record for tag from the active sessions file to the old sessions file (<SandBox>/....
static double P[]
static constexpr double s
static constexpr double ns
int changeown(const std::string &path, uid_t u, gid_t g)
Change the ownership of 'path' to the entity described by {u,g}.
Definition: proofexecv.cxx:738