cache.c

Go to the documentation of this file.

/*
 * This file is part of Titan2Reader
 *
 * Copyright (C) 2006, Sebastien Judenherc <sebastien.judenherc@agecodagis.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *
 */

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <ctype.h>
#include <math.h>
#include <assert.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdarg.h>
#include <dirent.h>

#include "common.h"

/*
#CST fichier offset     // indique une fin de segment continu
#TIME fichier offset sismotime // de temps en temps (10Mo?), on pousse ces
                                lignes pour que les recherches soient plus
                                rapides
*/
struct dirent **cacheFileList=NULL;

FILE * cacheFile=NULL; //<! the current cache file, r/w
char cacheFileName[128]; //<! current cache filename
char cacheDir[128]; //<! current cache directory

time_t lastCacheTime=0; //<! last time stored in the cache file

int64_t lastCacheOffset=0; //<! last offset stored in the cache file

int cacheOutput=-1; //<! is the cache built: -1 unknown 1=write, 0=read

int startCacheTime=0; //<! start time of the cache

char testForSN[128]; //<! the serial number we are looking for
time_t testForTime; //<! the time we are looking for

int nTimesInCache=0; //<! the number of #TIME lines un the cache file

void ResetCacheCounters(void)
{
        cacheOutput=-1;
        lastCacheTime=0;
        lastCacheOffset=0;
}

int CacheFileSelect(const struct dirent* t)
{
        int t1,t2,ok;
        char s[128];
        struct stat st;
        //PrintDebug("test %s t='%s'\n",t->d_name,testForSN);
        if (sscanf(t->d_name,"%s %d %d",s,&t1,&t2)==3)
        {
                if ((t1<0)||(t2<0))
                {
                        return(0);
                }
                ok=1;
                // if we are cleaning the cache, then all the cache files are accepted
                if ((strlen(testForSN)>0)&&(testForTime!=-2))
                {
                        // check the serial number
                        if (strcmp(s,testForSN)!=0)
                        {
                                ok=0;
                        }
                        // check the time
                        if ( (testForTime<t1) || ((testForTime>t2)&&(t2!=0)) )
                        {
                                ok=0;
                        }
                }
                if (ok==0)
                {
                        // remove files older than 1 week
                        sprintf(s,"%s/%s",cacheDir,t->d_name);
                        if (stat(s,&st)==0)
                        {
                                if (abs(time(NULL)-st.st_mtime)>7*86400)
                                {
                                        unlink(s);
                                }
                        }
                }
                return(ok);
        }
        return(0);
}


void OpenCacheFileWrite(int wr)
{
        char *t;
        PrintDebug("open cache file for write: %d\n",wr);
        strcpy(cacheFileName,"");
        strcpy(cacheDir,".");
        t=getenv("TITAN2CACHE");
        if (localCache)
        {
                strcpy(cacheDir,"./");
                strcpy(cacheFileName,"");
        }
        else
        {
                if (t)
                {
                        strcpy(cacheDir,t);
                        strcpy(cacheFileName,t);
                        strcat(cacheFileName,"/");
                }
                else
                {
                        t=getenv("HOME");
                        if (t)
                        {
                                strcpy(cacheFileName,t);
                                strcat(cacheFileName,"/");
                                strcat(cacheFileName,".titancache");
                                strcpy(cacheDir,cacheFileName);
                                mkdir(cacheFileName,S_IRWXU);
                        }
                        strcat(cacheFileName,"/");
                }
        }
        if (wr)
        {
                int fd;
                if (localCache)
                {
                        strcpy(cacheFileName,".LocalTitanCache");
                        assert((cacheFile=fopen(cacheFileName,"at"))!=NULL);
                }
                else
                {
                        strcat(cacheFileName,"titancacheXXXXXX");
                        fd=OpenTempFile(cacheFileName);
                        assert((cacheFile=fdopen(fd,"wt"))!=NULL);
                }
                fprintf(cacheFile,"#ROOT %s\n",baseDir);
                startCacheTime=(int)(currentTime.usecond>>32);
                PrintDebug("open (W): %s\n",cacheFileName);
                cacheOutput=1;
        }
        nTimesInCache=0;
}

char *CacheRead(char *line)
{
        if (cacheOutput!=0)
        {
                return(NULL);
        }
        return(fgets(line,127,cacheFile));
}

void RewindCache(void)
{
        if (cacheFile!=NULL)
        {
                if (cacheOutput==0)
                {
                        rewind(cacheFile);
                }
        }
}

int OpenCacheFileRead(char *SN, time_t t)
{
        int nfiles,i;

        // if the file is already open, this test is always performed first
        if (cacheFile!=NULL)
        {
                // keep it
                return(cacheOutput);
        }

        // first examine the local cache case
        if (localCache)
        {
                strcpy(cacheFileName,".LocalTitanCache");
                cacheFile=fopen(cacheFileName,"rt");
                if (cacheFile!=NULL)
                {
                        PrintDebug("open (R): %s\n",cacheFileName);
                        cacheOutput=0;
                }
                else
                {
                        cacheOutput=-1;
                }
                return(cacheOutput);
        }

        // then continue with the regular cache
        // if we are not asking for a cache reset
        if ((SN!=NULL)&&(t!=-2))
        {
                // if we still don't know who is the station
                if (strlen(SN)==0)
                {
                        // give up
                        return(cacheOutput);
                }
                strcpy(testForSN,SN);
        }
        else
        {
                PrintLog("clearing cache\n");
                // we are cleaning the cache
                OpenCacheFileWrite(0);
                testForSN[0]=0;
        }
        testForTime=t;
        nfiles=__scandir(cacheDir,&cacheFileList,CacheFileSelect,__alphasort);
        PrintDebug("there: '%s', T=%d, n=%d (%s)\n",SN?SN:"null",t,nfiles,cacheDir);
        if ((nfiles>1)&&((SN!=NULL)&&(t!=-2)))
        {
                PrintWarning("multiple cachefile for %s [%d]\n",
                                testForSN,testForTime);
        }

        if (nfiles>0)
        {
                for (i=0; i<nfiles; i++)
                {
                        // build the compete path of the cache file
                        sprintf(cacheFileName,"%s%s%s",
                                        cacheDir,
                                        "/",
                                        cacheFileList[i]->d_name);
                        // if we are NOT cleaning the cache
                        if ((SN!=NULL)&&(t!=-2))
                        {
                                // try to open the file
                                if (cacheFile==NULL)
                                {
                                        cacheFile=fopen(cacheFileName,"rt");
                                        if (cacheFile!=NULL)
                                        {
                                                PrintDebug("open (R): %s\n",cacheFileName);
                                                cacheOutput=0;
                                                break;
                                        }
                                }
                        }
                        // else
                        else
                        {
                                // kill the file
                                unlink(cacheFileName);
                                PrintDebug("%s removed\n");
                        }
                }
        }
        else
        {
                cacheOutput=-1;
        }
        return(cacheOutput);
}

int CompareCacheLines(const void *p1, const void *p2)
{
        char *s1=*(char **)p1;
        char *s2=*(char **)p2;
        // if s1 and s2 are a TIME line
        if ((memcmp("#TIME",s1,5)==0)&&(memcmp("#TIME",s2,5)==0))
        {
                int t1=0,t2=0;
                // compare the times
                sscanf(s1,"%*s %*s %*s %d",&t1);
                sscanf(s2,"%*s %*s %*s %d",&t2);
                return(t1-t2);
        }
        else
        // else (at leat one of them is not a TIME line)
        {
                // do not change their order
                return(0);
        // endif
        }
}

void SortCacheFile(char *fn)
{
        FILE *f;
        char **table=NULL;
        int nlines=0,nbuff=0,i;
        int NL_STEP=1024,LL=80;
        // open the cache file for read
        f=fopen(fn,"rt");
        // stop on error
        if (!f)
        {
                return;
        }
        // read the file, allocate buffer dynamically
        while (!feof(f))
        {
                if (nlines>=nbuff)
                {
                        nbuff+=NL_STEP;
                        table=(char **)realloc(table,nbuff*sizeof(char *));
                        for (i=nlines; i<nbuff; i++)
                        {
                                table[i]=(char *)malloc(LL);
                                memset(table[i],0,LL);
                        }
                }
                fgets(table[nlines],79,f);
                nlines++;
        }
        // close the file
        fclose(f);
        // sanity checks
        if (nlines==0)
        {
                return;
        }
        // run qsort
        qsort(table,nlines,sizeof(char*),CompareCacheLines);
        // if the file is too short
        if (nlines<10) // 10 lines...
        {
        // then
                // do not create the sorted file
                PrintDebug("killing the small cache file\n");
        }
        // else
        else
        {
                // open the file for write
                f=fopen(fn,"wt");
                // write the file killing duplicates
                fprintf(f,"%s",table[0]);
                for (i=1; i<nlines; i++)
                {
                        if (strcmp(table[i-1],table[i])!=0)
                        {
                                fprintf(f,"%s",table[i]);
                        }
                }
                // close the file
                fclose(f);
                // free buffers
        // endif
        }
        for (i=0; i<nbuff; i++)
        {
                free(table[i]);
        }
        free(table);
}

void CloseCacheFile(int cancel)
{
        char line[128];
        // if we use the local cache, then perform a special processing
        if (localCache!=0)
        {
                if (cacheFile!=NULL)
                {
                        fclose(cacheFile);
                }
                cacheFile=NULL;
                SortCacheFile(cacheFileName);
                return;
        }

        // process the normal case
        if (cacheFile)
        {
                PrintDebug("close: %s\n",cacheFileName);
                fclose(cacheFile);
                cacheFile=NULL;
                PrintDebug("sort cache file...\n");
                SortCacheFile(cacheFileName);
                if (cacheOutput==1)
                {
                        if (cancel==0)
                        {
                                int end=(int)(currentTime.usecond>>32);
                                if (end<0)
                                {
                                        end=0;
                                }
                                sprintf(line,"%s%s%s %d %d",
                                                cacheDir,
                                                "/",
                                                HWConfig.serialNumber,
                                                startCacheTime,end);
                                if ((strlen(HWConfig.serialNumber)>0)&&(nTimesInCache>5))
                                {
                                        PrintDebug("rename: %s -> %s\n",
                                                        cacheFileName,line);
                                        Rename(cacheFileName,line);
                                }
                        }
                        unlink(cacheFileName);
                }
        }
        ResetCacheCounters();
}

void CachePrint(const char *format, ...)
{
        va_list ap;
        if (noCache==1)
        {
                return;
        }
        if (cacheFile==NULL)
        {
                OpenCacheFileWrite(1);
        }
        if (cacheFile!=NULL)
        {
                if (startCacheTime<0)
                {
                        startCacheTime=(int)(currentTime.usecond>>32);
                }
                va_start(ap,format);
                vfprintf(cacheFile,format,ap);
                va_end(ap);
        }
}

void CachePrintCST(void)
{
        if (cacheOutput==0)
        {
                return;
        }
        // do not issue the CST line, it is not used !
        //CachePrint("#CST %s %ld\n",currentFile,SafeFtell(titan2File)-12);
}

void CachePrintTIME(void)
{
        if (cacheOutput==0)
        {
                return;
        }
        if (currentTime.usecond>>32!=-1)
        {
                if (titan2File!=NULL)
                {
                        CachePrint("#TIME %s %ld %ld\n",currentFile,SafeFtell(titan2File),
                                        (int)((currentTime.usecond>>32)));
                        fflush(cacheFile);
                }
        }
        nTimesInCache++;
}

void CacheCallBack(void)
{
        if (noCache==1)
        {
                return;
        }
        // try to open an existing cache file for the current data stream
        // if the file is open for read
        // then
                // cacheOutput=0
        // else
                // cacheOutput=1
        // endif
        // all the job is done here:
        if (cacheOutput==-1)
        {
                OpenCacheFileRead(HWConfig.serialNumber,currentTime.usecond>>32);
        }
        if (cacheOutput==0)
        {
                return;
        }

        // if a time window is defined, then the cache cannot be written
        if (beginWindow>0)
        {
                return;
        }

        // first test the offset in the file
        if (abs(lastCacheTime-(currentTime.usecond>>32))>12*3600) // 12h
        {
                CachePrintTIME();
                lastCacheTime=currentTime.usecond>>32;
                return;
        }
        // then the last time
        if (abs(lastCacheOffset-totalFrameProcessed*12)>(10<<20)) // 10Mo
        {
                CachePrintTIME();
                lastCacheOffset=totalFrameProcessed*12;
                return;
        }
}

void InitCache(void)
{
        if (noCache==1)
        {
                PrintDebug("no cache ?\n");
                //return;
        }
        OpenCacheFileWrite(0);
        PrintDebug("cache dir: %s\n",cacheDir);
}

---