XrdTlsFlush Namespace Reference

Functions
void *	Flusher (void *parg)
bool	Setup_Flusher (XrdTlsContextImpl *pImpl, int flushT)

Function Documentation

Flusher()

void* XrdTlsFlush::Flusher

(

void *

parg

)

Definition at line 292 of file XrdTlsContext.cc.

{
   EPNAME("Flusher");
   time_t tStart, tWaited;
   int    flushT, waitT, hits, miss, sesn, tmos;
   long   tNow;
 
// Get the implementation details
//
   XrdTlsContextImpl *ctxImpl = static_cast<XrdTlsContextImpl*>(parg);
 
// Get the interval as it may change as we are running
//
   ctxImpl->crlMutex.ReadLock();
   waitT = flushT = ctxImpl->flushT;
   ctxImpl->crlMutex.UnLock();
 
// Indicate we have started in the trace record
//
   DBG_CTX("Cache flusher started; interval="<<flushT<<" seconds.");
 
// Do this forever
//
do{tStart = time(0);
   ctxImpl->flsCVar->Wait(waitT);
   tWaited= time(0) - tStart;
 
// Check if this context is still alive. Generally, it never gets deleted.
//
   ctxImpl->crlMutex.ReadLock();
   if (!ctxImpl->owner) break;
 
// If the interval changed, see if we should wait a bit longer
//
   if (flushT != ctxImpl->flushT && tWaited < ctxImpl->flushT-1)
      {waitT = ctxImpl->flushT - tWaited;
       ctxImpl->crlMutex.UnLock();
       continue;
      }
 
// Get the new values and drop the lock
//
   waitT = flushT = ctxImpl->flushT;
   ctxImpl->crlMutex.UnLock();
 
// Get some relevant statistics
//
   sesn = SSL_CTX_sess_number(ctxImpl->ctx);
   hits = SSL_CTX_sess_hits(ctxImpl->ctx);
   miss = SSL_CTX_sess_misses(ctxImpl->ctx);
   tmos = SSL_CTX_sess_timeouts(ctxImpl->ctx);
 
// Flush the cache
//
   tNow = time(0);
   SSL_CTX_flush_sessions(ctxImpl->ctx, tNow);
 
// Print some stuff should debugging be on
//
   if (TRACING(XrdTls::dbgCTX))
      {char mBuff[512];
       snprintf(mBuff, sizeof(mBuff), "sess=%d hits=%d miss=%d timeouts=%d",
               sesn, hits, miss, tmos);
       DBG_CTX("Cache flushed; " <<mBuff);
      }
  } while(true);
 
// If we are here the context that started us has gone away and we are done
//
   bool keepctx = ctxImpl->crlRunning;
   ctxImpl->flsRunning = false;
   ctxImpl->crlMutex.UnLock();
   if (!keepctx) delete ctxImpl;
   return (void *)0;
}

References XrdTlsContextImpl::crlMutex, XrdTlsContextImpl::crlRunning, XrdTlsContextImpl::ctx, DBG_CTX, XrdTls::dbgCTX, EPNAME, XrdTlsContextImpl::flsCVar, XrdTlsContextImpl::flsRunning, XrdTlsContextImpl::flushT, XrdTlsContextImpl::owner, XrdSysRWLock::ReadLock(), TRACING, XrdSysRWLock::UnLock(), and XrdSysCondVar::Wait().

Referenced by Setup_Flusher().

Here is the call graph for this function:

Here is the caller graph for this function:

Setup_Flusher()

bool XrdTlsFlush::Setup_Flusher	(	XrdTlsContextImpl *	pImpl,
		int	flushT
	)

Definition at line 372 of file XrdTlsContext.cc.

{
   pthread_t tid;
   int rc;
 
// Set the new flush interval
//
   pImpl->crlMutex.WriteLock();
   pImpl->flushT = flushT;
   pImpl->crlMutex.UnLock();
 
// If the flush thread is already running, then wake it up to get the new value
//
   if (pImpl->flsRunning)
      {pImpl->flsCVar->Signal();
       return true;
      }
 
// Start the flusher thread
//
   pImpl->flsCVar = new XrdSysCondVar();
   if ((rc = XrdSysThread::Run(&tid, XrdTlsFlush::Flusher, (void *)pImpl,
                                     0, "Cache Flusher")))
      {char eBuff[512];
       snprintf(eBuff, sizeof(eBuff),
                "Unable to start cache flusher thread; rc=%d", rc);
       XrdTls::Emsg("SessCache:", eBuff, false);
       return false;
      }
 
// Finish up
//
   pImpl->flsRunning = true;
   SSL_CTX_set_session_cache_mode(pImpl->ctx, SSL_SESS_CACHE_NO_AUTO_CLEAR);
   return true;
}

References XrdTlsContextImpl::crlMutex, XrdTlsContextImpl::ctx, XrdTls::Emsg(), XrdTlsContextImpl::flsCVar, XrdTlsContextImpl::flsRunning, Flusher(), XrdTlsContextImpl::flushT, XrdSysThread::Run(), XrdSysCondVar::Signal(), XrdSysRWLock::UnLock(), and XrdSysRWLock::WriteLock().

Referenced by XrdTlsContext::SessionCache().

Here is the call graph for this function:

Here is the caller graph for this function: