ps_client_dbfsms.cpp

这个程序是用来操作Berkeley DB来使用

				
				m_pmutexTmp[t].unlock();
			}
		}
		break;

	default:
		break;
	}

	return 0;
}

int CPSDBFSMS::PS_dbfsms_deletetmp()
{
	int t = m_vecstatTmp.size();
						
	while (t > 0)		
	{
		m_pmutexTmp[t].lock();
		
		int ret = m_pdbfsTmp[t].PS_dbfs_deletetmp(m_vecstatTmp[t].l_time);

		if (ret == 0)
		{
			PSClientDBFS::PSDBFSStat tmp;
			m_pdbfsTmp[t].PS_dbfs_info(&tmp);
			m_vecstatTmp[t].lCurSize = tmp.db_block_count;

			m_pmutexTmp[t].unlock();

			return 1;
		}

		m_pmutexTmp[t].unlock();
	}

	return 0;
}

int CPSDBFSMS::PS_dbfsms_find(const char *key)
{
	int t = m_vecStat.size();
	while (t > 0)
	{
		t--;
		if (m_pdbfs[t].PS_dbfs_find(key) == 0)
		{
			return t;
		}
	}

	return -1;
}

int CPSDBFSMS::PS_dbfsms_findtmp(const char *key)
{	
	int t = m_vecstatTmp.size();
	while (t > 0)
	{
		t--;
		if (0 == m_pdbfsTmp[t].PS_dbfs_find(key))
		{
			return t;
		}
	}

	return -1;
}

int CPSDBFSMS::PS_dbfsms_read(const char *key, void *buf, unsigned long size)
{
	int t = m_vecStat.size();
	while (t > 0)
	{
		t--;
		if (m_pdbfs[t].PS_dbfs_read(key, buf, size) == size)
		{
			return size;
		}
	}

#ifdef __TEMP__
	// read from temp area
	t = m_vecstatTmp.size();
	while (t > 0)
	{
		t--;
		if (m_pdbfsTmp[t].PS_dbfs_read(key, buf, size) == size)
		{
			return size;
		}
	}
#endif

	return -1;
}

int CPSDBFSMS::PS_dbfsms_read(const char *key, DBT *data, unsigned long size)
{
	int t = m_vecStat.size();
	while (t > 0)
	{
		t--;
		if (m_pdbfs[t].PS_dbfs_read(key, data, size) == size)
		{
			return size;
		}
	}

#ifdef __TEMP__
	// read from temp area
	t = m_vecstatTmp.size();
	while (t > 0)
	{
		t--;
		if (m_pdbfsTmp[t].PS_dbfs_read(key, data, size) == size)
		{
			return size;
		}
	}
#endif

	return -1;
}

int CPSDBFSMS::PS_dbfsms_getkeyFile(char *keyFilename, int nDB)
{
	if (nDB >= (m_vecStat.size() + m_vecstatTmp.size()))
	{
		return -1;
	}
	else if (nDB < m_vecStat.size())
	{
		return m_pdbfs[nDB].PS_dbfs_getkeyFile(keyFilename);
	}
	else
	{
		return m_pdbfsTmp[nDB-m_vecStat.size()].PS_dbfs_getkeyFile(keyFilename);
	}
}

#ifndef WIN32
char *_ui64toa(unsigned long long val, char *buf, int radix)
{
	char *p, *first, temp;
	unsigned long digital;
	p = buf;
	if (val < 0)
	{
		*p++ = '-';
		val = -val;
	}
	first = p;
	do
	{
		digital = val%radix;
		val /= radix;
		if (digital > 9)
			*p++ = (char)(digital - 10 + 'a');
		else
			*p++ = (char)(digital + '0');
	}while(val > 0);
	*p-- = '\0';
	
	do
	{
		temp = *p;
		*p = *first;
		*first = temp;
		p--;
		first++;
	}while(first < p);

	return buf;
}
#endif

int CPSDBFSMS::mf_saveStatFile()
{
/*
	if (m_vecStat.size() == 0)
	{
		return -1;
	}

	unlink(m_strStatFileName);
	
	std::ofstream ofs(m_strStatFileName);

	for (int i=0; i<m_vecStat.size(); i++)
	{
		char buf[512] = {0};
		char tmp[64]= {0};
		strcpy(buf, "<dbfile>");
		strcat(buf, m_vecStat[i].dbfile);
		strcat(buf, "</dbfile> ");
		strcat(buf, "<size>");
		strcat(buf, _ui64toa(m_vecStat[i].lSize, tmp, 10));
		strcat(buf, "</size> ");

		ofs << buf << std::endl;
	}
	ofs.close();
*/

	return 0;
}

int CPSDBFSMS::mf_getStatFile()
{
	m_vecStat.clear();

	CPSConf config;

	int ret = config.PS_conf_init(m_strStatFileName);

	if (ret <= 0)
	{
		return -1;
	}

	char *pbuf = new char[ret];

	memset(pbuf, 0, ret);

	if (-1 == config.PS_conf_getNode(pbuf, "<db>", "</db>", 1))
	{
		delete [] pbuf;
		return -1;
	}

	int pos = 0;
	while (1)
	{
		CPSDBFSMSStat test;
		memset(test.dbfile, 0, sizeof(test.dbfile));
		
		if (-1 == config.PS_conf_getItem(pbuf+pos, test.dbfile, "<dbfile>", "</dbfile>"))
		{
			break;
		}

		char tmp[65] = {0};
		int ret = config.PS_conf_getItem(pbuf+pos, tmp, "<size>", "</size>");

		if (ret == -1)
		{
			break;
		}
		else
		{
			pos += ret;
		}
			
#ifdef WIN32
		test.lSize = _atoi64(tmp);
#else
		test.lSize = strtoull(tmp, NULL, 10);
#endif

		if (test.lSize > 4080200000ul && (0 != mf_getFileSytemType(test.dbfile)))
		{
			test.lSize = 4080200000ul;
		}

		m_vecStat.push_back(test);
	}

	delete [] pbuf;

	if (0 == m_vecStat.size())
	{
		return -1;
	}
	
	return 0;
}

int CPSDBFSMS::mf_getTmpStatFile()
{
	m_vecstatTmp.clear();

	CPSConf config;

	int bufsize = config.PS_conf_init(m_strTmpStatFile);

	if (bufsize <= 0)
	{
		return -1;
	}

	char *pbuf = new char[bufsize];

	memset(pbuf, 0, bufsize);

	if (-1 == config.PS_conf_getNode(pbuf, "<db>", "</db>", 1))
	{
		delete [] pbuf;
		return -1;
	}

	int pos = 0;
	while (1)
	{
		CPSDBFSMSStat test;
		memset(test.dbfile, 0, sizeof(test.dbfile));
		
		if (-1 == config.PS_conf_getItem(pbuf+pos, test.dbfile, "<dbfile>", "</dbfile>"))
		{
			break;
		}

		char tmp[65] = {0};
		int ret = config.PS_conf_getItem(pbuf+pos, tmp, "<size>", "</size>");

		if (ret == -1)
		{
			break;
		}
			
#ifdef WIN32
		test.lSize = _atoi64(tmp);
#else
		test.lSize = strtoull(tmp, NULL, 10);
#endif

		if (test.lSize > 4080200000ul && (0 != mf_getFileSytemType(test.dbfile)))
		{
			test.lSize = 4080200000ul;
		}

		memset(tmp, 0, 65);
		if (-1 == config.PS_conf_getItem(pbuf+pos, tmp, "<period>", "</period>"))
		{
			delete [] pbuf;
			return -1;
		}
		else
		{
			pos += ret;
		}

		test.l_time = 86400 * strtol(tmp, NULL, 10);

		m_vecstatTmp.push_back(test);
	}

	if (0 == m_vecstatTmp.size())
	{
		delete [] pbuf;
		return -1;
	}

	memset(pbuf, 0, bufsize);
	if (-1 == config.PS_conf_getNode(pbuf, "<checktime>", "</checktime>", 1))
	{
		delete [] pbuf;
		return -1;
	}

	m_vecTime.clear();
	
	pos = 0;
	while (1)
	{
		char tmp[3] = {0};
		int ret = config.PS_conf_getItem(pbuf+pos, tmp, "<time>", "</time>");
		if (-1 == ret)
		{
			break;
		}

		pos += ret;

		int t = atoi(tmp);

		if (t < 0 || t > 23)
		{
			delete [] pbuf;
			return -1;
		}

		m_vecTime.push_back(t);
	}
		
	delete [] pbuf;

	if (m_vecTime.size() == 0)
	{		
		return -1;
	}

	return 0;
}

int CPSDBFSMS::PS_dbfsms_printStat()
{
	std::cout << "******************** normal area ********************" << std::endl;

	int i;
	for (i=0; i<m_vecStat.size(); i++)
	{
		std::cout << m_vecStat[i].dbfile << std::endl;

#ifdef WIN32
		char buf[33] = {0};
		printf("%s\n", _i64toa(m_vecStat[i].lSize, buf, 10));
		printf("%s\n", _i64toa(m_vecStat[i].lCurSize, buf, 10));
#else
		printf("%llu\n", m_vecStat[i].lSize);
		printf("%llu\n", m_vecStat[i].lCurSize);
#endif
	}

	if (0 == strlen(m_strTmpStatFile))
	{
		return 0;
	}

#ifdef __TEMP__
	std::cout << "******************** temp   area ********************" << std::endl;
	for (i=0; i<m_vecstatTmp.size(); i++)
	{
		std::cout << m_vecstatTmp[i].dbfile << std::endl;
#ifdef WIN32
		char buf[65] = {0};
		printf("%s\n", _i64toa(m_vecstatTmp[i].lSize, buf, 10));
		printf("%s\n", _i64toa(m_vecstatTmp[i].lCurSize, buf, 10));
#else
		printf("%llu\n", m_vecstatTmp[i].lSize);
		printf("%llu\n", m_vecstatTmp[i].lCurSize);
#endif
	}
#endif
	
	return 0;
}

/*
void * CPSDBFSMS::operator new(size_t size)
{
	void *p = &m_dbms;

	return p;
}

void CPSDBFSMS::operator delete(void *p)
{
	p = NULL;
}
*/

int CPSDBFSMS::PS_dbfsms_getLength(const char *key, unsigned long &len)
{
	int t = m_vecStat.size();
	while (t > 0)
	{
		t--;
		int ret = m_pdbfs[t].PS_dbfs_getLength(key, len);
		if (-1 == ret)
		{
			return -1;
		}
		else if (0 == ret)
		{
			return 0;
		}
	}

#ifdef __TEMP__
	t = m_vecstatTmp.size();
	while(t > 0)
	{
		t--;
		int ret = m_pdbfsTmp[t].PS_dbfs_getLength(key, len);

		if (-1 == ret)
		{
			return -1;
		}
		else if (0 == ret)
		{
			return 0;
		}
	}
#endif
	
	return -2;
}

int CPSDBFSMS::PS_dbfsms_getEnv(DB_ENV *&pEnv)
{
	pEnv = m_pEnv;

	return 0;
}

int CPSDBFSMS::mf_getFileSytemType(const char *dbpath)
{
#ifdef WIN32
	char drive[4];
	_splitpath(dbpath, drive, NULL, NULL, NULL);

	strcat(drive, "\\");
	
	char volumName[256], strFS[256] = {0};
	if (0 == GetVolumeInformation(drive, 
		volumName,
		256,
		NULL,
		NULL,
		NULL,
		strFS,
		sizeof(strFS)) )
	{
		return -1;
	}

	if (0 == stricmp(strFS, "ntfs"))
	{
		return 0;
	}
	else if (0 == stricmp(strFS, "fat32"))
	{
		return 1;
	}
	
	return -2;

#else
	return 0;
#endif
}

int CPSDBFSMS::PS_dbfsms_recoverStat(int nDB)
{
	if (nDB >= (m_vecStat.size() + m_vecstatTmp.size()))
	{
		return -1;
	}
	else if (nDB < m_vecStat.size())
	{
		return m_pdbfs[nDB].PS_dbfs_recoverStat();
	}
	else
	{
		return m_pdbfsTmp[nDB-m_vecStat.size()].PS_dbfs_recoverStat();
	}
}