int main()
{
rowMutation *rm = NULL;
columnFamily *cf = NULL;
column *x = NULL;
queryPath qp = {"Test", "cf1", "key0", NULL, "name", 0};
// char path[1000] = "/home/ydx/test/commitlog/commitlog-1317532982.db";
if(loadConfig(config) < 0 ){
LOG_WRITE("cannot load configure ");
return -1;
}
printTableMetadata();
if(initDM() < 0){
LOG_WRITE("INIT dataModel error\n");
}
//here is the marked
int i;
for(i = 0; i < 100000; i++){
char keytmp[300];
sprintf(keytmp, "key%d", i);
if(!(rm = (rowMutation *)calloc(sizeof(rowMutation), 1))){
return -1;
}
rm->keyspaceName = strdup("Test");
rm->key = strdup(keytmp);
rm->cfName = strdup("cf1");
columnFamilyMetadata *cfmd = findCFMetaData(rm->keyspaceName,
rm->cfName);
if(!cfmd || !(cf = getCF(cfmd))){
return -1;
}
cf->localDelete = 2000;
cf->markedForDelete= 2000;
x = getColumn();
if(!x){
return -1;
}
x->name = strdup("name");
x->value = strdup("ydx");
x->timestamp = 20000;
//return -1表明必须释放column的空间,这里为了节省空间
//不得不这样纠结的设计
if(addCFColumn(cf, x) < 0){
LOG_WRITE("cannot add column to cf\n");
decrColumnRef(x);
x = NULL;
}
rm->cf = cf;
if(insertDM(rm) < 0){
LOG_WRITE("insert error\n");
freeHeapRM(rm);
continue;
}
// LOG_WRITE("insert succeed\n");
freeHeapRM(rm);
}
// forceFlushDM("Test", "cf1");
//printf("please input the path to test replay\n");
//scanf("%s", path);
// auxilary_recover(path);
// column *v = NULL;
// printf("getColumnDM return %d\n", getColumnDM(&qp, &v));
// if(v)
// printf("name :%s", v->value);
//
//
return 0;
// getchar();
}
char* code_convert(const char *str,
const char *to_codeset,
const char *from_codeset)
{
iconv_t cd;
char *dest;
char *outp;
char *p, *startp;
size_t inbytes_remaining;
size_t outbytes_remaining;
size_t err;
size_t outbuf_size;
int have_error = 0;
int len;
if (strcmp (to_codeset, from_codeset) == 0)
{
char *p;
p = (char*)malloc (sizeof(char) * (strlen (str) + 1));
if (!p)
return NULL;
strcpy (p, str);
return p;
}
cd = iconv_open (to_codeset, from_codeset);
if (cd == (iconv_t) - 1)
return NULL;
p = (char*)malloc (sizeof(char) * (strlen (str) + 1));
strcpy (p, str);
if (p == NULL) return NULL;
len = strlen (p);
startp = p;
inbytes_remaining = len;
outbuf_size = len + 1; /* + 1 for nul in case len == 1 */
outbytes_remaining = outbuf_size - 1; /* -1 for nul */
outp = dest = (char*)malloc (outbuf_size);
again:
err = iconv (cd, (ICONV_CONST char **) &p, &inbytes_remaining, &outp, &outbytes_remaining);
if (err == (size_t) - 1)
{
switch (errno)
{
case EINVAL:
/* Incomplete text, do not report an error */
LOG_WRITE("code_convert error EINVAL");
have_error = 1;
break;
case E2BIG:
{
size_t used = outp - dest;
outbuf_size *= 2;
dest = (char*)realloc (dest, outbuf_size);
outp = dest + used;
outbytes_remaining = outbuf_size - used - 1; /* -1 for nul */
goto again;
}
break;
case EILSEQ:
have_error = 1;
LOG_WRITE("code_convert error EILSEQ");
break;
default:
LOG_WRITE("code_convert error default");
have_error = 1;
break;
}
}
*outp = '\0';
if ((p - startp) != len)
have_error = 1;
free (startp);
iconv_close (cd);
if (have_error)
{
free (dest);
dest = NULL;
}
return dest;
}
static void TEST_CORE_Log(void)
{
/* LOG */
LOG x_log;
/* protective MT-lock */
MT_LOCK x_lock;
/* ELOG_Level, LOG_LevelStr() */
int x_level;
for (x_level = 0; x_level <= (int) eLOG_Fatal; x_level++) {
switch ( (ELOG_Level) x_level ) {
case eLOG_Trace:
case eLOG_Note:
case eLOG_Warning:
case eLOG_Error:
case eLOG_Critical:
case eLOG_Fatal:
assert(LOG_LevelStr((ELOG_Level) x_level));
printf("LOG_LevelStr(level = %d): \"%s\"\n",
x_level, LOG_LevelStr((ELOG_Level) x_level));
break;
default:
assert(0);
}
}
/* LOG API */
/* MT-lock */
x_lock = MT_LOCK_Create(&TEST_CORE_LockUserData,
TEST_CORE_LockHandler, TEST_CORE_LockCleanup);
/* dummy */
TEST_CORE_LogUserData = 1;
x_log = LOG_Create(&TEST_CORE_LogUserData,
TEST_CORE_LogHandler, TEST_CORE_LogCleanup,
x_lock);
assert(x_log);
verify(LOG_AddRef(x_log) == x_log);
verify(LOG_AddRef(x_log) == x_log);
verify(LOG_Delete(x_log) == x_log);
assert(TEST_CORE_LogUserData == 1);
LOG_WRITE(0, 0, 0, eLOG_Trace, 0);
LOG_Write(0, 0, 0, eLOG_Trace, 0, 0, 0, 0, 0, 0);
LOG_WRITE(x_log, 0, 0, eLOG_Trace, 0);
LOG_Write(x_log, 0, 0, eLOG_Trace, 0, 0, 0, 0, 0, 0);
verify(LOG_Delete(x_log) == x_log);
assert(TEST_CORE_LogUserData == 1);
/* reset to "real" logging */
LOG_Reset(x_log, &TEST_CORE_LogUserData,
TEST_CORE_LogHandler, TEST_CORE_LogCleanup);
assert(TEST_CORE_LogUserData == 444);
TEST_CORE_LogUserData = 2;
/* do the test logging */
LOG_WRITE(x_log, 0, 0, eLOG_Trace, 0);
LOG_Write(x_log, 0, 0, eLOG_Trace, 0, 0, 0, 0, 0, 0);
LOG_WRITE(x_log, 0, 0, eLOG_Warning, "");
/* LOG_WRITE(x_log, eLOG_Fatal, "Something fatal"); */
#undef THIS_MODULE
#define THIS_MODULE "FooModuleName"
LOG_WRITE(x_log, 0, 0, eLOG_Error, "With changed module name");
#undef THIS_FILE
#define THIS_FILE "BarFileName"
LOG_WRITE(x_log, 0, 0, eLOG_Critical, "With changed module and file name");
#undef THIS_FILE
#define THIS_FILE __FILE__
#undef THIS_MODULE
#define THIS_MODULE 0
/* delete */
verify(LOG_Delete(x_log) == 0);
assert(TEST_CORE_LogUserData == 444);
}
bool ColorCfgLoad::Parsing(const string& section, const string& var, const string& val)
{
int fcol = 0, bcol = 0;
string::size_type p = val.find(',');
LOG_WRITE("Parsing sSection [%s] var [%s] val [%s]", section.c_str(), var.c_str(), val.c_str());
try
{
if (p != string::npos)
{
fcol = strtoint(val.substr(0, p).c_str());
bcol = strtoint(val.substr(p+1).c_str());
}
else
{
fcol = strtoint(val.c_str());
bcol = GetColorEntry("Default").back;
}
}
catch(Exception& ex)
{
LOG_WRITE("Color File Loading Exception : %s", (char*)ex);
return false;
}
ColorEntry cur(fcol, bcol);
if (var.substr(0, 4) == "mask")
{
int num = strtol(getbetween(var, '[', ']').c_str(), NULL, 8);
_mapMask[num] = cur;
}
else if(var.substr(0, 4) == "name")
{
StringToken st(getbetween(var, '[', ']'), ";");
while(st.Next())
{
if (st.Get().empty()) continue;
_mapName[Tolower(st.Get())] = cur;
LOG_WRITE("_mapName [%s [%d:%d]]", Tolower(st.Get()).c_str(), cur.font, cur.back);
}
}
else if (var.substr(0, 3) == "ext")
{
StringToken st(getbetween(var, '[', ']'), ";");
while(st.Next())
{
if (st.Get().empty()) continue;
_mapExt[st.Get()] = cur;
LOG_WRITE("_mapExt [%s [%d:%d]]", st.Get().c_str(), cur.font, cur.back);
}
}
else
{
_mapColor[Tolower(var)] = cur;
LOG_WRITE("_mapColor [%s [%d:%d]]", var.c_str(), cur.font, cur.back);
if (Tolower(var) == "default")
_DefaultColor = cur;
}
return false;
}
void FileParser::cb(Kernal::MessageHandlerArg* arg) {
LOG("FileParser::cb");
if (arg == NULL) {
LOG_ERROR("NULL message received.");
return;
}
unsigned int send_id = 0;
if (arg->message_type
== Kernal::GetMessage(Letters::FileParserLetter::ID)) {
send_id = Kernal::GetMessage(Letters::ParsedBlockLetter::ID);
} else {
std::map<std::string, std::string>::iterator iter =
this->comm_matrix.find(Kernal::GetMessage(arg->message_type));
if (iter != this->comm_matrix.end()) {
send_id = Kernal::GetMessage(iter->second);
}
}
if (send_id != 0) {
Lock lock(arg->letter->letterMutex);
std::string filename = "";
Letters::FileParserLetter *fpLetter =
reinterpret_cast<Letters::FileParserLetter*>(arg->letter);
filename = fpLetter->filename;
LOG_WRITE("Received file to parse: " + filename);
char *buffer = NULL;
std::ifstream is;
is.open(filename.c_str(), std::ios::binary);
is.seekg(0, std::ios::end);
int length = is.tellg();
is.seekg(0, std::ios::beg);
int read = 0;
while (!is.eof()) {
int toRead = LEAST(FileParser::MAX_READ, length - read);
buffer = new char[toRead];
is.read(buffer, toRead);
read += toRead;
Letters::ParsedBlockLetter *letter =
new Letters::ParsedBlockLetter();
letter->origFile = filename;
letter->offset = read;
letter->size = toRead;
letter->block = buffer;
Kernal::MessageHandlerArg *send_arg =
new Kernal::MessageHandlerArg();
send_arg->message_type = send_id;
send_arg->priority = arg->priority + 1;
send_arg->blocking = arg->blocking + 1;
send_arg->letter = letter;
this->Send(send_arg);
}
is.close();
}
}
void FBD03_ALARAM_2(FBFR * temp)
{
LOG_WRITE();
}
//
// NetSocket::VHandleInput - Chapter 19, page 671
//
void NetSocket::VHandleInput()
{
bool bPktRecieved = false;
u_long packetSize = 0;
int rc = recv(m_sock, m_recvBuf+m_recvBegin+m_recvOfs, RECV_BUFFER_SIZE-(m_recvBegin+m_recvOfs), 0);
char metrics[1024];
sprintf_s(metrics, 1024, "Incoming: %6d bytes. Begin %6d Offset %4d\n", rc, m_recvBegin, m_recvOfs);
std::stringstream ss;
ss << "Network" << metrics;
LOG_WRITE(ss.str());
if (rc==0)
{
return;
}
if (rc==SOCKET_ERROR)
{
m_deleteFlag = 1;
return;
}
const int hdrSize = sizeof(u_long);
unsigned int newData = m_recvOfs + rc;
int processedData = 0;
while (newData > hdrSize)
{
// There are two types of packets at the lowest level of our design:
// BinaryPacket - Sends the size as a positive 4 byte integer
// TextPacket - Sends 0 for the size, the parser will search for a CR
packetSize = *(reinterpret_cast<u_long*>(m_recvBuf+m_recvBegin));
packetSize = ntohl(packetSize);
if (m_bBinaryProtocol)
{
// we don't have enough new data to grab the next packet
if (newData < packetSize)
break;
if (packetSize > MAX_PACKET_SIZE)
{
// prevent nasty buffer overruns!
HandleException();
return;
}
if (newData >= packetSize)
{
// we know how big the packet is...and we have the whole thing
//
//[mrmike] - a little code to aid debugging network packets here!
//char test[1024];
//memcpy(test, &m_recvBuf[m_recvBegin+hdrSize], packetSize);
//test[packetSize+1]='\r';
//test[packetSize+2]='\n';
//test[packetSize+3]=0;
//LOG_WRITE("Network", test);
shared_ptr<BinaryPacket> pkt(QSE_NEW BinaryPacket(&m_recvBuf[m_recvBegin+hdrSize], packetSize-hdrSize));
m_InList.push_back(pkt);
bPktRecieved = true;
processedData += packetSize;
newData -= packetSize;
m_recvBegin += packetSize;
}
}
else
{
// the text protocol waits for a carraige return and creates a string
char *cr = static_cast<char *>(memchr(&m_recvBuf[m_recvBegin], 0x0a, rc));
if (cr)
{
*(cr+1) = 0;
shared_ptr<TextPacket> pkt(QSE_NEW TextPacket(&m_recvBuf[m_recvBegin]));
m_InList.push_back(pkt);
packetSize = cr - &m_recvBuf[m_recvBegin];
bPktRecieved = true;
processedData += packetSize;
newData -= packetSize;
m_recvBegin += packetSize;
}
}
}
g_pSocketManager->AddToInbound(rc);
m_recvOfs = newData;
if (bPktRecieved)
{
if (m_recvOfs == 0)
{
m_recvBegin = 0;
}
else if (m_recvBegin + m_recvOfs + MAX_PACKET_SIZE > RECV_BUFFER_SIZE)
{
// we don't want to overrun the buffer - so we copy the leftover bits
// to the beginning of the recieve buffer and start over
int leftover = m_recvOfs;
memcpy(m_recvBuf, &m_recvBuf[m_recvBegin], m_recvOfs);
m_recvBegin = 0;
}
}
}
