sbcache.cpp

sloedgy open sip stack source code

 }
 
 
 /********************************************************/
 /* Map the static functions to the real implementations */
 /********************************************************/
 VXIint32 SBcacheInterface::GetVersion(void)
 {
   return VXI_CURRENT_VERSION;
 }
 
 const VXIchar* SBcacheInterface::GetImplementationName(void)
 {
   static const VXIchar IMPLEMENTATION_NAME[] = SBCACHE_IMPLEMENTATION_NAME;
   return IMPLEMENTATION_NAME;
 }
 
 VXIcacheResult
 SBcacheInterface::CallOpen(struct VXIcacheInterface *pThis,
                            const VXIchar *moduleName,
                            const VXIchar *key,
                            VXIcacheOpenMode mode,
                            VXIint32 flags,
                            const VXIMap *properties,
                            VXIMap *streamInfo,
                            VXIcacheStream **stream )
 {
   if (!pThis) return VXIcache_RESULT_INVALID_ARGUMENT;
   SBcacheInterface * me = static_cast<SBcacheInterface *>(pThis);
 
   const VXIchar *modeName;
   switch ( mode ) {
   case CACHE_MODE_READ:
     modeName = L"read";
     break;
   case CACHE_MODE_WRITE:
     modeName = L"write";
     break;
   case CACHE_MODE_READ_CREATE:
     modeName = L"readCreate";
     break;
   default:
     modeName = L"unknownMode";
     break;
   }
     
   me->Diag (SBCACHE_API_TAGID, L"Open", 
 	    L"entering: 0x%p, %s, %0.256s, 0x%x [%s], 0x%x [%s%s%s], 0x%p, "
 	    L"0x%p, 0x%p", pThis, moduleName, key, mode, modeName,
 	    flags, ((flags & CACHE_FLAG_LOCK) ? L"lock, " : L""),
 	    ((flags & CACHE_FLAG_LOCK_MEMORY) ? L"memory lock, " : L""),
 	    ((flags & CACHE_FLAG_NONBLOCKING_IO) ? L"non-blocking I/O" : L""),
 	    properties, streamInfo, stream);
   
   *stream = NULL;
   VXIcacheResult rc = me->Open (moduleName, key, mode, flags, properties,
 				streamInfo, stream);
 
   me->Diag (SBCACHE_API_TAGID, L"Open", L"exiting: %d, 0x%p", rc,
 	    (stream ? *stream : NULL));
   return rc;
 }
 
 
 VXIcacheResult
 SBcacheInterface::CallClose(struct VXIcacheInterface *pThis,
                             VXIcacheStream **stream )
 {
   if(!pThis) return VXIcache_RESULT_INVALID_ARGUMENT;
   SBcacheInterface * me = static_cast<SBcacheInterface *>(pThis);
   
   me->Diag (SBCACHE_API_TAGID, L"Close", L"entering: 0x%p, 0x%p [0x%p]",
 	    pThis, stream, (stream ? *stream : NULL));
 
   VXIcacheResult rc = me->Close (TRUE, stream);
 
   me->Diag (SBCACHE_API_TAGID, L"Close", L"exiting: %d", rc);
   return rc;
 }
 
 VXIcacheResult
 SBcacheInterface::CallUnlock(struct VXIcacheInterface *pThis,
                              const VXIchar *key)
 {
   if(!pThis) return VXIcache_RESULT_INVALID_ARGUMENT;
   SBcacheInterface * me = static_cast<SBcacheInterface *>(pThis);
 
   me->Diag (SBCACHE_API_TAGID, L"Unlock", L"entering: 0x%p, %0.256s",
 	    pThis, key);
 
   VXIcacheResult rc = me->Unlock (key);
 
   me->Diag (SBCACHE_API_TAGID, L"Unlock", L"exiting: %d", rc);
   return rc;
 }
 
 VXIcacheResult
 SBcacheInterface::CallRead(struct VXIcacheInterface *pThis,
                            VXIbyte   *buffer,
                            VXIulong   buflen,
                            VXIulong  *nread,
                            VXIcacheStream *stream )
 {
   if(!pThis) return VXIcache_RESULT_INVALID_ARGUMENT;
   SBcacheInterface * me = static_cast<SBcacheInterface *>(pThis);
   
   me->Diag (SBCACHE_API_TAGID, L"Read", 
 	    L"entering: 0x%p, 0x%p, %lu, 0x%p, 0x%p",
 	    pThis, buffer, buflen, nread, stream);
 
   VXIcacheResult rc = me->Read(buffer, buflen, nread, stream );
 
   me->Diag (SBCACHE_API_TAGID, L"Read", L"exiting: %d, %lu", rc,
 	    (nread ? *nread : 0));
   return rc;
 }
     
 VXIcacheResult
 SBcacheInterface::CallWrite(struct VXIcacheInterface *pThis,
                             const VXIbyte *buffer,
                             VXIulong buflen,
                             VXIulong *nwritten,
                             VXIcacheStream *stream )
 {
   if(!pThis) return VXIcache_RESULT_INVALID_ARGUMENT;
   SBcacheInterface * me = static_cast<SBcacheInterface *>(pThis);
 
   me->Diag (SBCACHE_API_TAGID, L"Write", 
 	    L"entering: 0x%p, 0x%p, %lu, 0x%p, 0x%p",
 	    pThis, buffer, buflen, nwritten, stream);
   
   VXIcacheResult rc = me->Write (buffer, buflen, nwritten, stream );
 
   me->Diag (SBCACHE_API_TAGID, L"Write", L"exiting: %d, %lu", rc,
 	    (nwritten ? *nwritten : 0));
   return rc;
 }
 
 VXIcacheResult
 SBcacheInterface::CallOpenEx(struct VXIcacheInterface *pThis,
 			     const VXIchar *moduleName,
 			     const VXIbyte *key,
 			     VXIulong keySizeBytes,
 			     VXIcacheOpenMode mode,
 			     VXIint32 flags,
 			     const VXIMap *properties,
 			     VXIMap *streamInfo,
 			     VXIcacheStream **stream )
 {
   if (!pThis) return VXIcache_RESULT_INVALID_ARGUMENT;
   SBcacheInterface * me = static_cast<SBcacheInterface *>(pThis);
 
   me->Diag (SBCACHE_API_TAGID, L"OpenEx", 
 	    L"entering: 0x%p, %s, 0x%p, %lu, 0x%x [%s], 0x%x [%s%s%s], 0x%p, "
 	    L"0x%p, 0x%p", pThis, moduleName, key, keySizeBytes, mode, 
 	    (mode == CACHE_MODE_READ ? L"read" :
 	     (mode == CACHE_MODE_WRITE ? L"write" : L"<unknown>")),
 	    flags, ((flags & CACHE_FLAG_LOCK) ? L"lock, " : L""),
 	    ((flags & CACHE_FLAG_LOCK_MEMORY) ? L"memory lock, " : L""),
 	    ((flags & CACHE_FLAG_NONBLOCKING_IO) ? L"non-blocking I/O" : L""),
 	    properties, streamInfo, stream);
   
   VXIcacheResult rc = me->Open (moduleName, key, keySizeBytes, mode, flags,
 				properties, streamInfo, stream);
 
   me->Diag (SBCACHE_API_TAGID, L"OpenEx", L"exiting: %d, 0x%p", rc,
 	    (stream ? *stream : NULL));
   return rc;
 }
 
 
 VXIcacheResult
 SBcacheInterface::CallCloseEx(struct VXIcacheInterface *pThis,
 			      VXIbool keepEntry,
 			      VXIcacheStream **stream )
 {
   if(!pThis) return VXIcache_RESULT_INVALID_ARGUMENT;
   SBcacheInterface * me = static_cast<SBcacheInterface *>(pThis);
   
   me->Diag (SBCACHE_API_TAGID, L"CloseEx", L"entering: 0x%p, %s, 0x%p [0x%p]",
 	    pThis, (keepEntry ? L"TRUE" : L"FALSE"), stream, 
 	    (stream ? *stream : NULL));
 
   VXIcacheResult rc = me->Close (keepEntry, stream);
 
   me->Diag (SBCACHE_API_TAGID, L"CloseEx", L"exiting: %d", rc);
   return rc;
 }
 
 VXIcacheResult
 SBcacheInterface::CallUnlockEx(struct VXIcacheInterface *pThis,
 			       const VXIbyte *key,
 			       VXIulong keySizeBytes)
 {
   if(!pThis) return VXIcache_RESULT_INVALID_ARGUMENT;
   SBcacheInterface * me = static_cast<SBcacheInterface *>(pThis);
 
   me->Diag (SBCACHE_API_TAGID, L"UnlockEx", L"entering: 0x%p, 0x%p, %lu",
 	    pThis, key, keySizeBytes);
 
   VXIcacheResult rc = me->Unlock (key, keySizeBytes);
 
   me->Diag (SBCACHE_API_TAGID, L"UnlockEx", L"exiting: %d", rc);
   return rc;
 }
 
 
 /********************************************/
 /* Public Interface DLL Functions           */
 /********************************************/
 
 SBCACHE_API
 VXIcacheResult SBcacheInit( VXIlogInterface    *log,
                             const VXIunsigned   diagTagBase,
                             const VXIchar      *pCacheFolder,
                             const VXIint        nCacheTotalSizeMB,
                             const VXIint        nCacheEntryMaxSizeMB,
                             const VXIint        nCacheEntryExpTimeSec,
                             VXIbool             fUnlockEntries,
                             const VXIint        nCacheLowWaterMB)
 {
   if (log == NULL)
     return VXIcache_RESULT_INVALID_ARGUMENT;
 
   VXIcacheResult rc = VXIcache_RESULT_SUCCESS;
   SBinetLogFunc apiTrace (log, diagTagBase + SBCACHE_API_TAGID, 
 			  L"SBcacheInit", (int *) &rc, 
 			  L"entering: 0x%p, %u, %s, %d, %d, %d, %d",
 			  log, diagTagBase, pCacheFolder, 
 			  nCacheTotalSizeMB, nCacheEntryMaxSizeMB,
 			  nCacheEntryExpTimeSec, fUnlockEntries);
   
   // Avoid double initialization
   if ( gblCacheMgr ) {
     SBinetLogger::Error (log, MODULE_SBCACHE, 101, NULL);
     return (rc = VXIcache_RESULT_SUCCESS);
   }
 
   // Copy over globals
   gblDiagTagBase = diagTagBase;
 
   // Check the remaining arguments
   if ((! pCacheFolder) || (! pCacheFolder[0])) {
     SBinetLogger::Error (log, MODULE_SBCACHE, 102, NULL);
     rc = VXIcache_RESULT_INVALID_ARGUMENT;
   } else {
     // Ensure we only have 8 bit characters for the folder name
     int i;
     for (i = 0; 
 	 (pCacheFolder[i] != L'\0') && ((pCacheFolder[i] & 0xff00) == 0); i++)
       ; /* keep going */
     
     if ( pCacheFolder[i] != L'\0' ) {
       SBinetLogger::Error (log, MODULE_SBCACHE, 103, L"%s%s",
 			   L"configured", pCacheFolder);
       rc = VXIcache_RESULT_INVALID_ARGUMENT;
     }
   }
 
   if ( nCacheTotalSizeMB < 0 ) {
     SBinetLogger::Error (log, MODULE_SBCACHE, 104, L"%s%d", L"configured",
 			 nCacheTotalSizeMB);
     rc = VXIcache_RESULT_INVALID_ARGUMENT;
   }
 
   if ( nCacheEntryMaxSizeMB < 0 ) {
     SBinetLogger::Error (log, MODULE_SBCACHE, 105, L"%s%d", L"configured",
 			 nCacheEntryMaxSizeMB);
     rc = VXIcache_RESULT_INVALID_ARGUMENT;
   }
 
   if ( nCacheEntryExpTimeSec <= 0 ) {
     SBinetLogger::Error (log, MODULE_SBCACHE, 106, L"%s%d", L"configured",
 			 nCacheEntryExpTimeSec);
     rc = VXIcache_RESULT_INVALID_ARGUMENT;
   }
 
   if ( nCacheEntryMaxSizeMB > nCacheTotalSizeMB ) {
     SBinetLogger::Error (log, MODULE_SBCACHE, 107, L"%s%d%s%d", 
 			 L"entryMaxSizeMB", nCacheEntryMaxSizeMB, 
 			 L"totalSizeMB", nCacheTotalSizeMB);
     rc = VXIcache_RESULT_INVALID_ARGUMENT;
   }
 
   if ( nCacheLowWaterMB > nCacheTotalSizeMB ) {
     SBinetLogger::Error (log, MODULE_SBCACHE, 107, L"%s%d%s%d", 
 			 L"cacheLowWaterMB", nCacheLowWaterMB,
 			 L"totalSizeMB", nCacheTotalSizeMB);
     rc = VXIcache_RESULT_INVALID_ARGUMENT;
   }
 
   // Create the cache manager
   if ( rc == VXIcache_RESULT_SUCCESS ) {
     gblCacheMgr = new SBcacheManager (log, diagTagBase);
     if (! gblCacheMgr) {
       SBinetLogger::Error (log, MODULE_SBCACHE, 100, NULL);    
       rc = VXIcache_RESULT_OUT_OF_MEMORY;
     } else {
       SBcacheNString nCacheFolderStr;
       for (int i = 0; pCacheFolder[i] != L'\0'; i++)
 	nCacheFolderStr += SBinetW2C (pCacheFolder[i]);
       
       rc = gblCacheMgr->Create (nCacheFolderStr, nCacheTotalSizeMB * 1000000, 
 				nCacheEntryMaxSizeMB * 1000000, 
 				nCacheEntryExpTimeSec, fUnlockEntries,
                                 nCacheLowWaterMB * 1000000);
       
       if ( rc != VXIcache_RESULT_SUCCESS ) {
 	// Error already reported
 	delete gblCacheMgr;
 	gblCacheMgr = NULL;
       }
     }
   }
 
   return rc;
 }
 
 
 OSBCACHE_API
 VXIcacheResult OSBcacheInit( VXIlogInterface    *log,
 			     const VXIunsigned   diagTagBase,
 			     const VXIchar      *pCacheFolder,
 			     const VXIint        nCacheTotalSizeMB,
 			     const VXIint        nCacheEntryMaxSizeMB,
 			     const VXIint        nCacheEntryExpTimeSec,
 			     VXIbool             fUnlockEntries)
 {
   return SBcacheInit (log, diagTagBase, pCacheFolder, nCacheTotalSizeMB,
 		      nCacheEntryMaxSizeMB, nCacheEntryExpTimeSec,
 		      fUnlockEntries, nCacheTotalSizeMB - nCacheEntryMaxSizeMB);
 }
 
 
 SBCACHE_API
 VXIcacheResult SBcacheShutDown( VXIlogInterface *log )
 {
   if ( !log )
     return VXIcache_RESULT_INVALID_ARGUMENT;
 
   VXIcacheResult rc = VXIcache_RESULT_SUCCESS;
   SBinetLogFunc apiTrace (log, gblDiagTagBase + SBCACHE_API_TAGID, 
 			  L"SBcacheShutDown", (int *) &rc, 
 			  L"entering: 0x%p", log);
 
   // Destroy the cache manager
   if (! gblCacheMgr) {
     SBinetLogger::Error (log, MODULE_SBCACHE, 205, NULL);
     rc = VXIcache_RESULT_NON_FATAL_ERROR;
   } else {
     delete gblCacheMgr;
     gblCacheMgr = NULL;
   }
 
   return rc;
 }
 
 
 OSBCACHE_API
 VXIcacheResult OSBcacheShutDown( VXIlogInterface *log )
 {
   return SBcacheShutDown (log);
 }
 
 
 SBCACHE_API
 VXIcacheResult SBcacheCreateResource( VXIlogInterface    *log,
                                       VXIcacheInterface **ppVXIcache)  
 {
   if ( !log )
     return VXIcache_RESULT_INVALID_ARGUMENT;
 
   VXIcacheResult rc = VXIcache_RESULT_SUCCESS;
   SBinetLogFunc apiTrace (log, gblDiagTagBase + SBCACHE_API_TAGID, 
 			  L"SBcacheCreateResource", (int *) &rc, 
 			  L"entering: 0x%p, 0x%p", log, ppVXIcache);
   
   // Create the cache interface
   if ( ! ppVXIcache ) {
     SBinetLogger::Error (log, MODULE_SBCACHE, 108, NULL);
     rc = VXIcache_RESULT_INVALID_ARGUMENT;
   } else {
     *ppVXIcache = new SBcacheInterface (log, gblDiagTagBase);
     if ( ! *ppVXIcache ) {
       SBinetLogger::Error (log, MODULE_SBCACHE, 100, NULL);
       rc = VXIcache_RESULT_OUT_OF_MEMORY;
     }
   }
 
   return rc;
 }
 
 
 OSBCACHE_API
 VXIcacheResult OSBcacheCreateResource( VXIlogInterface    *log,
 				       VXIcacheInterface **ppVXIcache)  
 {
   return SBcacheCreateResource (log, ppVXIcache);
 }
 
 
 SBCACHE_API
 VXIcacheResult SBcacheDestroyResource( VXIcacheInterface **ppVXIcache )
 {
   if (( ! ppVXIcache ) || ( ! *ppVXIcache ))
     return VXIcache_RESULT_INVALID_ARGUMENT;
 
   SBcacheInterface * me = static_cast<SBcacheInterface *>(*ppVXIcache);
   VXIcacheResult rc = VXIcache_RESULT_SUCCESS;
   SBinetLogFunc apiTrace (me->GetLog( ), 
 			  me->GetDiagBase( ) + SBCACHE_API_TAGID,
 			  L"Read", (int *) &rc, L"entering: 0x%p [0x%p]", 
 			  ppVXIcache, *ppVXIcache);
 
   // Destroy the cache interface
   delete me;
   *ppVXIcache = NULL;
   
   return rc;
 }
 
 
 OSBCACHE_API
 VXIcacheResult OSBcacheDestroyResource( VXIcacheInterface **ppVXIcache )
 {
   return SBcacheDestroyResource (ppVXIcache);
 }

#endif // P_VXI