Logo ROOT   6.10/09
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"
30 #include "XrdProofdProofServMgr.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 
78 bool 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 
448 void 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 
482 int XrdProofdClient::Touch(bool reset)
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 
585 void 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 
619 XrdOucString 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;
654  XrdProofdProofServ *s = 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 
void ExportBuf(XrdOucString &buf)
Fill buf with relevant info about this session.
int GetClientID(XrdProofdProtocol *p)
Get next free client ID.
#define kXPD_TopMaster
virtual ~XrdProofdClient()
Destructor.
int ResetClientSlot(int ic)
Reset slot at &#39;ic&#39;.
int ReserveClientID(int cid)
Reserve a client ID.
#define TRACING(x)
static int GetUserInfo(const char *usr, XrdProofUI &ui)
Get information about user &#39;usr&#39; in a thread safe way.
XrdLink * Link() const
const char * Group() const
#define TRACE(Flag, Args)
Definition: TGHtml.h:120
void SetSid(unsigned short sid)
XrdProofdProofServ * GetServObj(int id)
Get server at &#39;id&#39;. If needed, increase the vector size.
void Reset()
Reset this instance.
bool Match(short int id) const
#define kXPD_ClientMaster
short int ProofProtocol() const
bool IsValid() const
XrdProofdProtocol * P() const
#define XPDPRT(x)
struct ClientRequestHdr header
XrdSysRecMutex fMutex
std::vector< XrdClientID * > fClients
const char * User() const
XrdOucString ExportSessions(XrdOucString &emsg, XrdProofdResponse *r=0)
Return a string describing the existing sessions.
XrdOucString fUser
Definition: XrdProofdAux.h:40
#define XPDLOC(d, x)
bool Match(const char *usr, const char *grp=0)
return TRUE if this instance matches &#39;id&#39; (and &#39;grp&#39;, if defined)
void Broadcast(const char *msg)
Broadcast message &#39;msg&#39; to the connected clients.
XrdProofdClient(XrdProofUI ui, bool master, bool changeown, XrdSysError *edest, const char *tmp, int rtime)
Constructor.
TRandom2 r(17)
int changeown(const std::string &path, uid_t u, gid_t g)
Change the ownership of &#39;path&#39; to the entity described by {u,g}.
Definition: proofexecv.cxx:808
XrdOucString fGroup
Definition: XrdProofdAux.h:41
void SetP(XrdProofdProtocol *p)
#define XrdSysMutexHelper
Definition: XrdSysToOuc.h:17
#define XrdSysError
Definition: XpdSysError.h:8
static double P[]
bool VerifySession(XrdProofdProofServ *xps, XrdProofdResponse *r=0)
Quick verification of session &#39;xps&#39; to avoid attaching clients to non responding sessions.
int TerminateProofServ(bool changeown)
Terminate the associated process.
int GuessTag(XrdOucString &tag, int ridx=1)
Guess session tag completing &#39;tag&#39; (typically "-<pid>") by scanning the active session file or the se...
void Reset(Detail::TBranchProxy *x)
void SetID(short int id)
#define kXPD_AnyServer
int RemoveSession(const char *tag)
Move record for tag from the active sessions file to the old sessions file (<SandBox>/.sessions).
#define kXPD_Internal
const char * AdminPath() const
int Touch(bool reset=0)
Send a touch the connected clients: this will remotely touch the associated TSocket instance and sche...
static int AssertDir(const char *path, XrdProofUI ui, bool changeown)
Make sure that &#39;path&#39; exists and is owned by the entity described by &#39;ui&#39;.
void TerminateSessions(int srvtype, XrdProofdProofServ *ref, const char *msg, XrdProofdPipe *pipe, bool changeown)
Terminate client sessions; IDs of signalled processes are added to sigpid.
#define XPDFORM
Definition: XrdProofdAux.h:381
XrdProofdSandbox fSandbox
void SetValid(bool valid=1)
int GetTopServers()
Return the number of valid proofserv topmaster sessions in the list.
R__EXTERN C unsigned int sleep(unsigned int seconds)
XrdProofdProtocol * GetProtocol(int ic)
Return protocol attached to client slot at &#39;ic&#39;.
void EraseServer(int psid)
Erase server with id psid from the list.
void SkipSessionsCheck(std::list< XrdProofdProofServ *> *active, XrdOucString &emsg, XrdProofdResponse *r=0)
Skip the next sessions status check.
int Post(int type, const char *msg)
Post message on the pipe.
static int VerifyProcessByID(int pid, const char *pname="proofserv")
Check if a process named &#39;pname&#39; and process &#39;pid&#39; is still in the process table. ...
bool IsValid() const
XrdProofdProofServ * GetServer(int psid)
Get from the vector server instance with ID psid.
std::vector< XrdProofdProofServ * > fProofServs
int VerifyProofServ(bool fw)
Check if the associated proofserv process is alive.
XrdProofdProofServ * GetFreeServObj()
Get next free server ID.
int Send(void)
Auxilliary Send method.
XrdProofdResponse * R() const
XPClientRequest * Request() const
XrdOucString fAdminPath
void ResetSessions()
Reset this instance.
int SetClientID(int cid, XrdProofdProtocol *p)
Set slot cid to instance &#39;p&#39;.