#include "bcv_int.h"
#include "blockcachevfs.h"
#include <assert.h>
#include <string.h>
typedef struct BcvLogHttp BcvLogHttp;
struct BcvLogHttp {
i64 iLogId;
i64 iRequestTime;
i64 iReplyTime;
int eMethod;
int nRetry;
char *zFile;
char *zClientId;
char *zMsg;
int httpcode;
BcvLogHttp *pNext;
BcvLogHttp *pPrev;
};
struct BcvLog {
i64 iTimeout;
i64 iMaxEntry;
i64 iNextLogId;
sqlite3_mutex *mutex;
int nEntry;
BcvLogHttp *pFirst;
BcvLogHttp *pLast;
};
#define BCVLOG_DEFAULT_TIMEOUT 3600
#define BCVLOG_DEFAULT_MAXENTRY -1
BcvLog *bcvLogNew(){
BcvLog *p = sqlite3_malloc(sizeof(BcvLog));
if( p ){
memset(p, 0, sizeof(BcvLog));
p->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_RECURSIVE);
if( p->mutex==0 && sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MAIN) ){
sqlite3_free(p);
p = 0;
}else{
p->iTimeout = BCVLOG_DEFAULT_TIMEOUT;
p->iMaxEntry = BCVLOG_DEFAULT_MAXENTRY;
}
}
return p;
}
void bcvLogDelete(BcvLog *pLog){
if( pLog ){
while( pLog->pFirst ){
BcvLogHttp *pNext = pLog->pFirst->pNext;
sqlite3_free(pLog->pFirst);
pLog->pFirst = pNext;
}
sqlite3_mutex_free(pLog->mutex);
sqlite3_free(pLog);
}
}
static int bcvLogUriLength(const char *zUri){
int nByte;
for(nByte=0; zUri[nByte] && zUri[nByte]!='?'; nByte++);
return nByte;
}
static void bcvLogEnforceLimits(BcvLog *pLog){
if( pLog->iTimeout>0 || pLog->iMaxEntry>0 ){
i64 iLimit = sqlite_timestamp() - (pLog->iTimeout*1000);
while( (pLog->pFirst && pLog->pFirst->iRequestTime<iLimit)
|| (pLog->iMaxEntry>=0 && pLog->nEntry>pLog->iMaxEntry)
){
BcvLogHttp *pDel = pLog->pFirst;
pLog->pFirst = pDel->pNext;
sqlite3_free(pDel);
pLog->nEntry--;
}
if( pLog->pFirst==0 ) pLog->pLast = 0;
}
}
int bcvLogRequest(
BcvLog *pLog,
const char *zClientId,
const char *zLogMsg,
int eMethod,
int nRetry,
const char *zUri,
i64 *piLogId
){
int rc = SQLITE_OK;
if( pLog ){
BcvLogHttp *pNew = 0;
int nByte = sizeof(BcvLogHttp);
int nUri = bcvLogUriLength(zUri);
int nClient = bcvStrlen(zClientId);
int nLogMsg = bcvStrlen(zLogMsg);
nByte += nUri+1 + nClient+1 + nLogMsg+1;
pNew = bcvMallocRc(&rc, nByte);
if( pNew ){
i64 iRequestTime = 0;
pNew->eMethod = eMethod;
pNew->nRetry = nRetry;
pNew->zFile = (char*)&pNew[1];
if( nUri ) memcpy(pNew->zFile, zUri, nUri);
pNew->zClientId = &pNew->zFile[nUri+1];
if( nClient ) memcpy(pNew->zClientId, zClientId, nClient);
pNew->zMsg = &pNew->zClientId[nClient+1];
if( nLogMsg ) memcpy(pNew->zMsg, zLogMsg, nLogMsg);
iRequestTime = pNew->iRequestTime = sqlite_timestamp();
sqlite3_mutex_enter(pLog->mutex);
*piLogId = pNew->iLogId = pLog->iNextLogId++;
pNew->pPrev = pLog->pLast;
if( pLog->pLast ){
assert( pLog->pLast->pNext==0 );
pLog->pLast->pNext = pNew;
}else{
assert( pLog->pFirst==0 );
pLog->pFirst = pNew;
}
pLog->pLast = pNew;
pLog->nEntry++;
bcvLogEnforceLimits(pLog);
sqlite3_mutex_leave(pLog->mutex);
}
}
return rc;
}
int bcvLogReply(
BcvLog *pLog,
i64 iLogId,
int httpcode,
i64 *piMs
){
int rc = SQLITE_OK;
if( pLog ){
BcvLogHttp *pHttp = 0;
i64 iReplyTime = sqlite_timestamp();
sqlite3_mutex_enter(pLog->mutex);
for(pHttp=pLog->pLast; pHttp; pHttp=pHttp->pPrev){
if( pHttp->iLogId==iLogId ) break;
}
if( pHttp ){
pHttp->iReplyTime = iReplyTime;
pHttp->httpcode = httpcode;
*piMs = pHttp->iReplyTime - pHttp->iRequestTime;
}
sqlite3_mutex_leave(pLog->mutex);
}
return rc;
}
static const char *bcvLogMethodString(int eMethod){
const char *azRet[] = {
0, "GET", "PUT", "DELETE", "HEAD"
};
assert( SQLITE_BCV_METHOD_GET==1 );
assert( SQLITE_BCV_METHOD_PUT==2 );
assert( SQLITE_BCV_METHOD_DELETE==3 );
assert( SQLITE_BCV_METHOD_HEAD==4 );
assert( eMethod>=1 && eMethod<sizeof(azRet)/sizeof(azRet[0]) );
return azRet[eMethod];
}
int bcvLogGetData(BcvLog *pLog, BcvBuffer *pBuf){
int rc = SQLITE_OK;
if( pLog ){
BcvLogHttp *p;
sqlite3_mutex_enter(pLog->mutex);
bcvLogEnforceLimits(pLog);
for(p=pLog->pFirst; p; p=p->pNext){
bcvBufferAppendU64(&rc, pBuf, p->iLogId);
bcvBufferAppendU64(&rc, pBuf, p->iRequestTime);
bcvBufferAppendU64(&rc, pBuf, p->iReplyTime);
bcvBufferMsgString(&rc, pBuf, bcvLogMethodString(p->eMethod));
bcvBufferMsgString(&rc, pBuf, p->zClientId);
bcvBufferMsgString(&rc, pBuf, p->zMsg);
bcvBufferMsgString(&rc, pBuf, p->zFile);
bcvBufferAppendU32(&rc, pBuf, p->httpcode);
}
sqlite3_mutex_leave(pLog->mutex);
}
return rc;
}
void bcvLogConfig(BcvLog *pLog, int op, i64 iVal){
assert(
op==SQLITE_BCV_HTTPLOG_TIMEOUT
|| op==SQLITE_BCV_HTTPLOG_NENTRY
);
if( pLog ){
sqlite3_mutex_enter(pLog->mutex);
if( op==SQLITE_BCV_HTTPLOG_TIMEOUT ){
pLog->iTimeout = iVal;
}else{
pLog->iMaxEntry = iVal;
}
bcvLogEnforceLimits(pLog);
sqlite3_mutex_leave(pLog->mutex);
}
}
void bcvTimeToString(i64 iTime, char *zBuf){
int iDay, iMonth, iYear;
int iSec, iMin, iHour;
int Z, A, B, C, D, E, X1;
int s;
Z = (int)((iTime + 43200000)/86400000);
A = (int)((Z - 1867216.25)/36524.25);
A = Z + 1 + A - (A/4);
B = A + 1524;
C = (int)((B - 122.1)/365.25);
D = (36525*(C&32767))/100;
E = (int)((B-D)/30.6001);
X1 = (int)(30.6001*E);
iDay = B - D - X1;
iMonth = E<14 ? E-1 : E-13;
iYear = iMonth>2 ? C - 4716 : C - 4715;
s = (int)((iTime + 43200000) % 86400000);
iSec = s/1000.0;
s = (int)iSec;
iSec -= s;
iHour = s/3600;
s -= iHour*3600;
iMin = s/60;
iSec += s - iMin*60;
sqlite3_snprintf(64, zBuf, "%04d-%02d-%02d %02d:%02d:%02d.%03d",
iYear, iMonth, iDay, iHour, iMin, iSec, (iTime % 1000)
);
}