#include <XrdSsiServReal.hh>

Inheritance diagram for XrdSsiServReal:

Collaboration diagram for XrdSsiServReal:

Public Member Functions
	XrdSsiServReal (const char *contact, int hObj)
	~XrdSsiServReal ()
void	ProcessRequest (XrdSsiRequest &reqRef, XrdSsiResource &resRef)
	Process a request; client-side or server-side.
void	Recycle (XrdSsiSessReal *sObj, bool reuse)
bool	Stop (bool immed=false)
	Stop the client-side service. This is never called server-side.
void	StopReuse (const char *resKey)
Public Member Functions inherited from XrdSsiService
	XrdSsiService ()
	Constructor.
virtual bool	Attach (XrdSsiErrInfo &eInfo, const std::string &handle, XrdSsiRequest &reqRef, XrdSsiResource *resP=0)
	Attach to a backgrounded request.
int	GetVersion ()
virtual bool	Prepare (XrdSsiErrInfo &eInfo, const XrdSsiResource &rDesc)
	Prepare for processing subsequent resource request.

Additional Inherited Members
Static Public Attributes inherited from XrdSsiService
static const int	SsiVersion = 0x00020000
Protected Member Functions inherited from XrdSsiService
virtual	~XrdSsiService ()
	Destructor. The service object cannot be explicitly deleted. Use Stop().

Detailed Description

Definition at line 41 of file XrdSsiServReal.hh.

Constructor & Destructor Documentation

◆ XrdSsiServReal()

XrdSsiServReal::XrdSsiServReal	(	const char *	contact,
		int	hObj )

inline

Definition at line 53 of file XrdSsiServReal.hh.

                             : manNode(strdup(contact)), freeSes(0),
                               freeCnt(0), freeMax(hObj), actvSes(0),
                               doStop(false) {}

◆ ~XrdSsiServReal()

XrdSsiServReal::~XrdSsiServReal ( )

Definition at line 61 of file XrdSsiServReal.cc.

{
   XrdSsiSessReal *sP;
 
// Free pointer to the manager node
//
   if (manNode) {free(manNode); manNode = 0;}
 
// Delete all free session objects
//
   while((sP = freeSes))
        {freeSes = sP->nextSess;
         delete sP;
        }
}

References XrdSsiSessReal::nextSess.

Member Function Documentation

◆ ProcessRequest()

void XrdSsiServReal::ProcessRequest	(	XrdSsiRequest &	reqRef,
		XrdSsiResource &	resRef )

virtual

Process a request; client-side or server-side.

When a client calls ProcessRequest() the same method is called server-side with the same parameters that the client specified except for timeOut which is always set to zero server-side.

Parameters

reqRef	Reference to the Request object that describes the request.
resRef	Reference to the Resource object that describes the resource that the request will be using.

All results are returned via the request object callback methods. For background queries, the XrdSsiRequest::ProcessResponse() is called with a response type of isHandle when the request is handed off to the endpoint for execution (see XrdSsiRequest::SetDetachTTL).

Implements XrdSsiService.

Definition at line 170 of file XrdSsiServReal.cc.

{
   static const uint32_t useCache = XrdSsiResource::Reusable
                                  | XrdSsiResource::Discard;
   XrdSysMutexHelper mHelp;
   XrdSsiSessReal   *sObj;
   std::string       resKey;
   int  uEnt;
   bool hold = (resRef.rOpts & XrdSsiResource::Reusable) != 0;
   char epURL[4096];
 
// Validate the resource name
//
   if (resRef.rName.length() == 0)
      {XrdSsiUtils::RetErr(reqRef, "Resource name missing.", EINVAL);
       return;
      }
 
// Check if this is a reusable resource. Reusable resources are a bit more
// complicated to pull off. In any case, we need to hold the cache lock.
//
   if (resRef.rOpts & useCache)
      {mHelp.Lock(&rcMutex);
       if (ResReuse(reqRef, resRef, resKey)) return;
      }
 
// Get a sid entry number
//
   if ((uEnt = sidScale.getEnt()) < 0)
      {XrdSsiUtils::RetErr(reqRef, "Out of stream resources.", ENOSR);
       return;
      }
 
// Construct url
//
   if (!GenURL(&resRef, epURL, sizeof(epURL), uEnt))
      {XrdSsiUtils::RetErr(reqRef, "Resource url is too long.", ENAMETOOLONG);
       sidScale.retEnt(uEnt);
       return;
      }
 
// Obtain a new session object
//
   if (!(sObj = Alloc(resRef.rName.c_str(), uEnt, hold)))
      {XrdSsiUtils::RetErr(reqRef, "Insufficient memory.", ENOMEM);
       sidScale.retEnt(uEnt);
       return;
      }
 
// Tag the session object with the resource key if it is being held. We need
// to do this before doing provision as that may fail at any point.
//
   if (hold) sObj->SetKey(resKey.c_str());
 
// Now just provision this resource which will execute the request should it
// be successful. If Provision() fails, we need to delete the session object
// because its file object now is in an usable state (funky client interface).
//
   if (!(sObj->Provision(&reqRef, epURL))) Recycle(sObj, false);
 
// If this was started with a reusable resource, put the session in the cache.
// The resource key was constructed by the call to ResReuse() and the cache
// mutex is still held at this point (will be released upon return).
//
   if (hold) resCache[resKey] = sObj;
}

References XrdSsiResource::Discard, ENOSR, XrdSysMutexHelper::Lock(), XrdSsiSessReal::Provision(), Recycle(), XrdSsiUtils::RetErr(), XrdSsiResource::Reusable, XrdSsiResource::rName, XrdSsiResource::rOpts, XrdSsiSessReal::SetKey(), and XrdSsi::sidScale.

Here is the call graph for this function:

◆ Recycle()

void XrdSsiServReal::Recycle	(	XrdSsiSessReal *	sObj,
		bool	reuse )

Definition at line 242 of file XrdSsiServReal.cc.

{
   EPNAME("Recycle");
   static const char *tident = 0;
   const char *resKey;
   bool doDel;
 
// Clear all pending events (likely not needed)
//
   sObj->ClrEvent();
 
// Remove entry from the reusable cache if present
//
   if ((resKey = sObj->GetKey())) StopReuse(resKey);
 
// Add to queue unless we have too many of these or caller wants a deletion.
//
   myMutex.Lock();
   actvSes--;
   DEBUG("Sess " <<sObj->GetSID() <<"# reuse=" <<reuse <<" free=" <<freeCnt
                <<" active=" <<actvSes);
 
   doDel = ((actvSes == 0 && doStop) || !reuse || freeCnt >= freeMax);
 
   DEBUG("reuse=" <<reuse <<" del=" <<doDel
         <<"; sessions: free=" <<freeCnt <<" active=" <<actvSes);
 
   if (doDel) {myMutex.UnLock(); delete sObj;}
      else {sObj->nextSess = freeSes;
            freeSes = sObj;
            freeCnt++;
            myMutex.UnLock();
           }
}

References XrdSsiEvent::ClrEvent(), DEBUG, EPNAME, XrdSsiSessReal::GetKey(), XrdSsiSessReal::GetSID(), XrdSsiSessReal::nextSess, StopReuse(), tident, and XrdSsiSessReal::UnLock().

Referenced by ProcessRequest().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Stop()

bool XrdSsiServReal::Stop ( bool immed = false )

virtual

Stop the client-side service. This is never called server-side.

Parameters

immed When true, the service is only stopped if here are no active requests. Otherwise, after all requests have finished. the service object is deleted.

Returns: true Service has been stopped. Once all requests have been completed, the service object will be deleted.; false Service cannot be stopped because there are still active foreground requests and the immed parameter was true.

Reimplemented from XrdSsiService.

Definition at line 322 of file XrdSsiServReal.cc.

{
// Make sure we are clean
//
   myMutex.Lock();
   if (actvSes)
      {if (immed) {myMutex.UnLock(); return false;}
       doStop = true;
       myMutex.UnLock();
       return true;
      }
   myMutex.UnLock();
   delete this;
   return true;
}

◆ StopReuse()

void XrdSsiServReal::StopReuse ( const char * resKey )

Definition at line 342 of file XrdSsiServReal.cc.

{
   EPNAME("StopReuse");
   static const char *tident = "ServReuse";
   std::map<std::string, XrdSsiSessReal *>::iterator it;
 
// Remove this entry from the reuse cache
//
   rcMutex.Lock();
   it = resCache.find(resKey);
   if (it != resCache.end())
      {resCache.erase(it);
       DEBUG("resCache " <<resKey <<" removed.");
      }
    rcMutex.UnLock();
}

References DEBUG, EPNAME, and tident.

Referenced by Recycle().