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; } } }