int create_file_index(const char *file,void *param)
{
KStringBuf s;
cor_result result = cor_failed;
KHttpObject *obj;
s << (char *)param << PATH_SPLIT_CHAR << file;
char *file_name = s.getString();
KFile fp;
if (!fp.open(s.getString(),fileRead)) {
fprintf(stderr,"cann't open file[%s]\n",s.getString());
return 0;
}
if (recreate_start_time>0) {
INT64 t = fp.getCreateTime();
if (t>recreate_start_time) {
klog(KLOG_DEBUG,"file [%s] is new file t=%d\n",file_name,(int)(t-recreate_start_time));
return 0;
}
}
/////////[139]
KHttpObjectFileHeader header;
if(fp.read((char *)&header,sizeof(KHttpObjectFileHeader))!=sizeof(KHttpObjectFileHeader)){
fprintf(stderr,"cann't read head size [%s]\n",file_name);
goto failed;
}
obj = new KHttpObject;
memcpy(&obj->index,&header.index,sizeof(obj->index));
/////////[140]
result = create_http_object(&fp,obj,file_name);
if (result==cor_success) {
#ifdef ENABLE_DB_DISK_INDEX
if (dci) {
dci->start(ci_add,obj);
}
#endif
load_count++;
#if 0
if (rebuild_cache_hash) {
char *file_name2 = obj->getFileName();
if (file_name2) {
if (strcmp(file_name,file_name2)!=0) {
if (rename(file_name,file_name2)!=0) {
rebuild_cache_files.insert(std::pair<std::string,std::string>(file_name,file_name2));
}
/////////[141]
}
free(file_name2);
}
}
#endif
}
obj->release();
failed:
fp.close();
if (result==cor_failed) {
klog(KLOG_NOTICE,"create http object failed,remove file[%s]\n",file_name);
unlink(file_name);
}
return 0;
}
OpenState KLineFile::open(const char *file, time_t &lastModified) {
struct _stati64 sbuf;
if (lstat(file, &sbuf) != 0 || !S_ISREG(sbuf.st_mode)) {
return OPEN_FAILED;
}
if (sbuf.st_mtime == lastModified) {
return OPEN_NOT_MODIFIED;
}
int len = (int)MIN(sbuf.st_size,MAX_OPEN_FILE_SIZE);
if (buf) {
free(buf);
}
buf = (char *) malloc(len + 1);
KFile fp;
if (fp.open(file,fileRead)) {
len = fp.read(buf,len);
if (len >= 0) {
buf[len] = '\0';
hot = buf;
lastModified = sbuf.st_mtime;
return OPEN_SUCCESS;
}
}
return OPEN_FAILED;
}
void init_disk_cache(bool firstTime)
{
#ifdef ENABLE_SQLITE_DISK_INDEX
if (dci==NULL) {
memset(&index_scan_state,0,sizeof(index_scan_state));
load_index_scan_state();
dci = new KSqliteDiskCacheIndex;
char *file_name = getCacheIndexFile();
KStringBuf sqliteIndex;
sqliteIndex << file_name << ".sqt";
free(file_name);
KFile fp;
if (fp.open(sqliteIndex.getString(),fileRead)) {
fp.close();
if (dci->open(sqliteIndex.getString())) {
dci->start(ci_load,NULL);
} else {
klog(KLOG_ERR,"recreate the disk cache index database\n");
dci->close();
unlink(sqliteIndex.getString());
dci->create(sqliteIndex.getString());
rescan_disk_cache();
}
} else {
dci->create(sqliteIndex.getString());
m_thread.start(NULL,load_cache_index);
}
}
#else
memset(&index_scan_state,0,sizeof(index_scan_state));
load_index_scan_state();
m_thread.start(NULL,load_cache_index);
#endif
}
char *KXml::getContent(const std::string &file) {
KFile fp;
if (!fp.open(file.c_str(),fileRead)) {
return NULL;
}
INT64 fileSize = fp.getFileSize();
if (fileSize > 1048576) {
return NULL;
}
char *buf = (char *)malloc((int)fileSize + 1);
if (buf==NULL) {
return NULL;
}
if (fp.read(buf,(int)fileSize) != (int)fileSize) {
free(buf);
return NULL;
}
buf[fileSize] = '\0';
return buf;
/*
KStringBuf s;
char buf[512];
for (;;) {
long readSize = fp.read(buf, sizeof(buf));
if (readSize <= 0) {
break;
}
s.write_all(buf, readSize);
if (s.getSize()>1048576) {
break;
}
}
return s.stealString();
*/
}
bool load_index_scan_state()
{
KStringBuf s;
get_index_scan_state_filename(s);
KFile fp;
if (!fp.open(s.getString(),fileRead)) {
return false;
}
bool result = true;
if (sizeof(index_scan_state_t) != fp.read((char *)&index_scan_state,sizeof(index_scan_state_t))) {
result = false;
}
fp.close();
return result;
}
bool KConfigBuilder::saveConfig() {
KConfigBuilder builder;
#ifdef KANGLE_ETC_DIR
string configFile = KANGLE_ETC_DIR;
#else
string configFile = conf.path + "/etc";
#endif
configFile += CONFIG_FILE;
string tmpfile = configFile + ".tmp";
string lstfile = configFile + ".lst";
KFile fp;
if(!fp.open(tmpfile.c_str(),fileWrite)){
fprintf(stderr, "cann't open configfile[%s] for write\n",
tmpfile.c_str());
return false;
}
stringstream s;
builder.build(s);
s << "\r\n" << CONFIG_FILE_SIGN;
bool result = false;
if ((int)s.str().size() == fp.write(s.str().c_str(), s.str().size())) {
result = true;
}
fp.close();
if (!result) {
fprintf(stderr,"cann't write sign string\n");
return false;
}
unlink(lstfile.c_str());
rename(configFile.c_str(),lstfile.c_str());
rename(tmpfile.c_str(),configFile.c_str());
if (conf.mergeFiles.size()>0) {
//remove the merge config files.
std::list<std::string>::iterator it;
for(it=conf.mergeFiles.begin();it!=conf.mergeFiles.end();it++){
unlink((*it).c_str());
}
conf.mergeFiles.clear();
std::string errMsg;
conf.gvm->saveConfig(errMsg);
}
//°Ñvh.xmlÖØÃüÃû
string file = conf.path;
file += VH_CONFIG_FILE;
string oldfile = file + ".old";
rename(file.c_str(),oldfile.c_str());
return true;
}
bool KProcess::saveFile(const char *dir,const char *unix_file)
{
std::stringstream s;
s << dir << "kp_" << getpid() << "_" << getProcessId() << "_" << sig;
kassert(file==NULL);
file = strdup(s.str().c_str());
KFile fp;
if (fp.open(file,fileWrite)) {
if (unix_file) {
fp.fprintf("%s",unix_file);
}
return true;
} else {
free(file);
file = NULL;
return false;
}
}
bool saveCacheIndex(bool fast)
{
//clean all DEAD obj
cache.syncDisk();
#ifdef ENABLE_DB_DISK_INDEX
if (dci) {
dci->start(ci_close,NULL);
while (!dci->allWorkedDone()) {
my_msleep(100);
}
return false;
}
#endif
HttpObjectIndexHeader indexHeader;
memset(&indexHeader,0,sizeof(HttpObjectIndexHeader));
indexHeader.head_size = sizeof(HttpObjectIndexHeader);
indexHeader.block_size = sizeof(HttpObjectIndex);
indexHeader.cache_dir_mask1 = CACHE_DIR_MASK1;
indexHeader.cache_dir_mask2 = CACHE_DIR_MASK2;
char *file_name = getCacheIndexFile();
KFile fp;
bool result = true;
if(!fp.open(file_name,fileWrite)){
klog(KLOG_ERR,"cann't open cache index file for write [%s]\n",file_name);
xfree(file_name);
return false;
}
fp.write((char *)&indexHeader,sizeof(HttpObjectIndexHeader));
int save_count = cache.save_disk_index(&fp);
if(result){
//set the index file state is clean
indexHeader.state = INDEX_STATE_CLEAN;
indexHeader.object_count = save_count;
fp.seek(0,seekBegin);
fp.write((char *)&indexHeader,sizeof(HttpObjectIndexHeader));
klog(KLOG_ERR,"total save %d object\n",save_count);
}
if(file_name){
xfree(file_name);
}
return result;
}
bool loadCacheIndex()
{
load_count = 0;
bool result = false;
char *file_name = getCacheIndexFile();
#if 0
rebuild_cache_hash = true;
#endif
KFile fp;
if (!fp.open(file_name,fileReadWrite)) {
xfree(file_name);
#ifdef ENABLE_DB_DISK_INDEX
if (dci) {
return true;
}
#endif
recreate_index(time(NULL));
return false;
}
HttpObjectIndexHeader indexHeader;
if(fp.read((char *)&indexHeader,sizeof(HttpObjectIndexHeader))!=sizeof(HttpObjectIndexHeader)){
klog(KLOG_ERR,"cann't read cache index header\n");
recreate_index(time(NULL));
goto done;
}
#if 0
if (indexHeader.cache_dir_mask1==CACHE_DIR_MASK1
&& indexHeader.cache_dir_mask2==CACHE_DIR_MASK2) {
rebuild_cache_hash = false;
}
#endif
if(indexHeader.state != INDEX_STATE_CLEAN
#if 0
|| rebuild_cache_hash
#endif
){
klog(KLOG_ERR,"cache index file not clean.\n");
recreate_index(time(NULL));
goto done;
}
for(;;){
KHttpObject *obj = new KHttpObject;
if (fp.read((char *)&obj->index,sizeof(HttpObjectIndex))!=sizeof(HttpObjectIndex)) {
obj->release();
break;
}
if (create_http_object(&fp,obj)==cor_success) {
load_count++;
#ifdef ENABLE_DB_DISK_INDEX
if (dci) {
dci->start(ci_add,obj);
}
#endif
} else {
SET(obj->index.flags,FLAG_DEAD|FLAG_IN_DISK);
}
obj->release();
}
result = true;
if(load_count!=indexHeader.object_count){
klog(KLOG_ERR,"Warning not all obj have loaded,total obj count=%d,loaded=%d\n",indexHeader.object_count,load_count);
debug("total object count=%d\n",cache.getCount());
}
//设置index为notclean
//fseeko(fp,0,SEEK_SET);
fp.seek(0,seekBegin);
indexHeader.state = INDEX_STATE_UNCLEAN;
fp.write((char *)&indexHeader,sizeof(HttpObjectIndexHeader));
done:
if(file_name){
xfree(file_name);
}
klog(KLOG_ERR,"total load disk obj count=%d\n",load_count);
return result;
}