void redis_command_cb(redisconn_t conn,struct redisReply* reply,void *pridata)
{
luaRef_t *cbObj = (luaRef_t*)pridata;
const char * error;
//callback,self,error,result
if(!reply){
if((error = push_obj_callback(cbObj->L,"srsp","__callback",*cbObj,"unknow error",NULL))){
SYS_LOG(LOG_ERROR,"error on redis_command_cb:%s\n",error);
}
}
else if(reply->type == REDIS_REPLY_NIL){
if((error = push_obj_callback(cbObj->L,"srpp","__callback",*cbObj,NULL,NULL))){
SYS_LOG(LOG_ERROR,"error on redis_command_cb:%s\n",error);
}
}else if(reply->type == REDIS_REPLY_ERROR){
if((error = push_obj_callback(cbObj->L,"srsp","__callback",*cbObj,reply->str,NULL))){
SYS_LOG(LOG_ERROR,"error on redis_command_cb:%s\n",error);
}
}else{
stPushResultSet st;
st.reply = reply;
st.base.Push = PushResultSet;
if((error = push_obj_callback(cbObj->L,"srsf","__callback",*cbObj,NULL,&st))){
SYS_LOG(LOG_ERROR,"error on redis_command_cb:%s\n",error);
}
}
release_luaRef(cbObj);
free(cbObj);
}
int Timer::scheduleRepeated(const TimerTaskPtr& task, const Time& delay)
{
Monitor<Mutex>::Lock sync(_monitor);
if(_destroyed)
{
#ifdef _NO_EXCEPTION
SYS_LOG(ERROR,"%s","timer destroyed...");
return -1;
#else
throw IllegalArgumentException(__FILE__, __LINE__, "timer destroyed");
#endif
}
const Token token(Time::now(Time::Monotonic) + delay, delay, task);
bool inserted = _tasks.insert(make_pair(task, token.scheduledTime)).second;
if(!inserted)
{
#ifdef _NO_EXCEPTION
SYS_LOG(ERROR,"%s","task is already schedulded...");
return -1;
#else
throw IllegalArgumentException(__FILE__, __LINE__, "task is already schedulded");
#endif
}
_tokens.insert(token);
if(_wakeUpTime == Time() || token.scheduledTime < _wakeUpTime)
{
_monitor.notify();
}
return 0;
}
int main(int argc, char* argv[]) {
time_t ticks;
ssize_t n;
socklen_t len;
struct sockaddr_storage ss;
char time_buf[BUF_SIZE] = {'\0'};
if (1 != argc) {
SYS_LOG("USAGE : %s\n", argv[0]);
}
daemon_inetd(argv[0], 0);
len = sizeof(ss);
if (getpeername(0, (struct sockaddr*)&ss, &len)) {
SYS_LOG("getpeername : %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
print_connection_info(&ss);
ticks = time(NULL);
snprintf(time_buf, sizeof(time_buf), "%.24s\r\n", ctime(&ticks));
SYS_LOG("time is %s\n", time_buf);
n = write(0, time_buf, strlen(time_buf));
if (n < 0 && EINTR == errno) {
SYS_LOG("write");
exit(EXIT_FAILURE);
}
close(0);
exit(EXIT_SUCCESS);
}
void Transport::addComponent(IOComponent *ioc, bool readOn, bool writeOn) {
assert(ioc != NULL);
_iocsMutex.lock();
if (ioc->isUsed()) {
SYS_LOG(ERROR, "已给加过addComponent: %p", ioc);
_iocsMutex.unlock();
return;
}
// 加入iocList上
ioc->_prev = _iocListTail;
ioc->_next = NULL;
if (_iocListTail == NULL) {
_iocListHead = ioc;
} else {
_iocListTail->_next = ioc;
}
_iocListTail = ioc;
// 设置在用
ioc->setUsed(true);
_iocListChanged = true;
_iocListCount ++;
_iocsMutex.unlock();
// 设置socketevent
Socket *socket = ioc->getSocket();
ioc->setSocketEvent(&_socketEvent);
_socketEvent.addEvent(socket, readOn, writeOn);
SYS_LOG(INFO, "ADDIOC, SOCK: %d, %s, RON: %d, WON: %d, IOCount:%d, IOC:%p\n",
socket->getSocketHandle(), ioc->getSocket()->getAddr().c_str(),
readOn, writeOn, _iocListCount, ioc);
}
void Transport::destroy() {
sys::CThreadGuard guard(&_iocsMutex);
IOComponent *list, *ioc;
// 删除iocList
list = _iocListHead;
while (list) {
ioc = list;
list = list->_next;
_iocListCount --;
SYS_LOG(INFO, "DELIOC, IOCount:%d, IOC:%p\n",
_iocListCount, ioc);
delete ioc;
}
_iocListHead = _iocListTail = NULL;
_iocListCount = 0;
// 删除delList
list = _delListHead;
while (list) {
ioc = list;
assert(ioc != NULL);
list = list->_next;
SYS_LOG(INFO, "DELIOC, IOCount:%d, IOC:%p\n",
_iocListCount, ioc);
delete ioc;
}
_delListHead = _delListTail = NULL;
}
static void handle_accept_ack(consensus_component* comp,void* data){
accept_ack* msg = data;
// if currently the node is not the leader, then it should ignore all the
// accept ack, because that can must be the msg from previous view
SYS_LOG(comp,"Node %d Handle Accept Ack From Node %u.\n",
comp->node_id,msg->node_id);
if(comp->my_role!=LEADER){
goto handle_accept_ack_exit;
}
// the request has reached quorum
if(view_stamp_comp(&msg->msg_vs,comp->highest_committed_vs)<=0){
goto handle_accept_ack_exit;
}
db_key_type record_no = vstol(&msg->msg_vs);
request_record* record_data = NULL;
size_t data_size;
retrieve_record(comp->db_ptr,sizeof(record_no),&record_no,&data_size,(void**)&record_data);
if(record_data==NULL){
SYS_LOG(comp,"Received Ack To Non-Exist Record %lu.\n",
record_no);
goto handle_accept_ack_exit;
}
update_record(record_data,msg->node_id);
// we do not care about whether the update is successful, otherwise this can
// be treated as a message loss
store_record(comp->db_ptr,sizeof(record_no),&record_no,REQ_RECORD_SIZE(record_data),record_data);
handle_accept_ack_exit:
try_to_execute(comp);
return;
};
static void deliver_msg_data(consensus_component* comp,view_stamp* vs){
// in order to accelerate deliver process of the program
// we may just give the record number instead of the real data
// to the proxy, and then the proxy will take the overhead of database operation
db_key_type vstokey = vstol(vs);
if(comp->deliver_mode==1)
{
request_record* data = NULL;
size_t data_size=0;
retrieve_record(comp->db_ptr,sizeof(db_key_type),&vstokey,&data_size,(void**)&data);
SYS_LOG(comp,"Node %d Deliver View Stamp %u : %u To The User.\n",
comp->node_id,vs->view_id,vs->req_id);
STAT_LOG(comp,"Request:%lu\n",vstokey);
if(NULL!=data){
if(comp->ucb!=NULL){
comp->ucb(data->data_size,data->data,comp->up_para);
}else{
SYS_LOG(comp,"No Such Call Back Func.\n");
}
}
}else{
STAT_LOG(comp,"Request %lu.\n",vstokey);
if(comp->ucb!=NULL){
comp->ucb(sizeof(db_key_type),&vstokey,comp->up_para);
}else{
SYS_LOG(comp,"No Such Call Back Func.\n");
}
}
return;
}
// leader has another responsibility to update the highest request that can be executed,
// and if the leader is also synchronous, it can execute the record in this stage
static void leader_try_to_execute(consensus_component* comp){
SYS_LOG(comp, "highest_seen_req_id %lu.\n", comp->highest_seen_vs->req_id);
SYS_LOG(comp, "highest_seen_view_id %lu.\n", comp->highest_seen_vs->view_id);
SYS_LOG(comp, "highest_to_commit_vs_req_id %lu.\n", comp->highest_to_commit_vs->req_id);
SYS_LOG(comp, "highest_to_commit_vs_view_id %lu.\n", comp->highest_to_commit_vs->view_id);
db_key_type start;
db_key_type end = vstol(comp->highest_seen_vs);;
size_t data_size;
view_stamp temp_boundary;
view_boundary* boundary_record = NULL;
if(comp->highest_seen_vs->view_id != comp->highest_to_commit_vs->view_id){
// address the boundary
assert(comp->highest_to_commit_vs->view_id + 1 == comp->highest_seen_vs->view_id);
comp->highest_to_commit_vs->view_id += 1;
comp->highest_to_commit_vs->req_id = 0;
comp->highest_committed_vs->view_id = comp->highest_to_commit_vs->view_id;
comp->highest_committed_vs->req_id = comp->highest_to_commit_vs->req_id;
start = vstol(comp->highest_to_commit_vs);
} else{
start = vstol(comp->highest_to_commit_vs)+1;
}
int exec_flag = (!view_stamp_comp(comp->highest_committed_vs,comp->highest_to_commit_vs));
request_record* record_data = NULL;
SYS_LOG(comp,"The Leader Tries To Execute.\n");
SYS_LOG(comp,"The Start Value Is %lu.\n",start);
SYS_LOG(comp,"The End Value Is %lu.\n",end);
for(db_key_type index=start;index<=end;index++){
retrieve_record(comp->db_ptr,sizeof(index),&index,&data_size,(void**)&record_data);
assert(record_data!=NULL && "The Record Should Be Inserted By The Node Itself!");
if(reached_quorum(record_data,comp->group_size)){
view_stamp temp = ltovs(index);
SYS_LOG(comp,"Node %d : View Stamp %u : %u Has Reached Quorum.\n",
comp->node_id,temp.view_id,temp.req_id);
SYS_LOG(comp,"Before Node %d Inc Execute %u : %u.\n",
comp->node_id,
comp->highest_to_commit_vs->view_id,
comp->highest_to_commit_vs->req_id);
view_stamp_inc(comp->highest_to_commit_vs);
SYS_LOG(comp,"After Node %d Inc Execute %u : %u.\n",
comp->node_id,
comp->highest_to_commit_vs->view_id,
comp->highest_to_commit_vs->req_id);
if(exec_flag){
view_stamp vs = ltovs(index);
deliver_msg_data(comp,&vs);
view_stamp_inc(comp->highest_committed_vs);
}
}else{
return;
}
}
}
/**
* rootPath: queue的root路径
* queueName:
* maxFileSize: 最大文件大小
*/
CFileQueue::CFileQueue(char *rootPath, char *queueName, int maxFileSize)
{
char tmp[256];
sprintf(tmp, "%s/%s", rootPath, queueName);
m_queuePath = strdup(tmp);
m_maxFileSize = maxFileSize;
m_infoFd = -1;
m_readFd = -1;
m_writeFd = -1;
// 创建目录
if (CFileUtil::mkdirs(m_queuePath) == false) {
SYS_LOG(ERROR, "create directory failed: %s", m_queuePath);
return;
}
// 头文件
sprintf(tmp, "%s/header.dat", m_queuePath);
m_infoFd = open(tmp, O_RDWR|O_CREAT, 0644);
if (m_infoFd == -1) {
SYS_LOG(ERROR, "open file failed: %s", tmp);
return;
}
// 读进头信息
if (read(m_infoFd, &m_head, sizeof(m_head)) != sizeof(m_head)) {
memset(&m_head, 0, sizeof(m_head));
m_head.read_seqno = 1;
m_head.write_seqno = 1;
}
// 打开写
if (openWriteFile() == CTFO_EXIT_FAILURE) {
return;
}
struct stat st;
if (fstat(m_writeFd, &st) == 0) {
m_head.write_filesize = st.st_size;
}
// 打开读
if (openReadFile() == CTFO_EXIT_FAILURE) {
close(m_writeFd);
m_writeFd = -1;
return;
}
// 恢复记录
if (m_head.exit_status == 0) {
recoverRecord();
}
m_head.exit_status = 0;
}
/**
* 写入一记录
*/
int CFileQueue::push(void *data, int len)
{
if (m_writeFd == -1) {
openWriteFile();
if (m_writeFd == -1) {
SYS_LOG(WARN, "open file failed: %s:%u", m_queuePath, m_head.write_seqno);
return CTFO_EXIT_FAILURE;
}
}
if (data == NULL || len == 0) {
SYS_LOG(WARN, "data: %p, len: %d", data, len);
return CTFO_EXIT_FAILURE;
}
int size = sizeof(int) + sizeof(queue_item) + len;
if (size > CTFO_MAX_FILE_SIZE) {
SYS_LOG(WARN, "size: %d", size);
return CTFO_EXIT_FAILURE;
}
char *buffer = (char*)malloc(size);
assert(buffer != NULL);
*((int*)buffer) = size;
queue_item *item = (queue_item*) (buffer + sizeof(int));
item->len = len;
item->flag = CTFO_FILE_QUEUE_FLAG;
memcpy(&(item->data[0]), data, len);
// 如果文件大于了重新打开一个
if (m_head.write_filesize >= m_maxFileSize) {
m_head.write_seqno ++;
m_head.write_filesize = 0;
openWriteFile();
writeHead();
}
item->pos.seqno = m_head.write_seqno;
item->pos.offset = m_head.write_filesize;
int ret = write(m_writeFd, buffer, size);
if (ret > 0) {
m_head.write_filesize += size;
}
free(buffer);
if (ret != size) { // 写失败
SYS_LOG(WARN, "write faild: %s, fd: %d, len: %d, %d<>%d",
m_queuePath, m_writeFd, len, ret, size);
ret = size - ret;
if (ret>0 && ret<=size && size<m_maxFileSize) {
SYS_LOG(WARN, "skip %d byte", ret);
lseek(m_writeFd, ret, SEEK_CUR);
}
return CTFO_EXIT_FAILURE;
}
m_head.queue_size ++;
return CTFO_EXIT_SUCCESS;
}
int32_t super_processpacket(msgdisp_t disp,rpacket_t rpk)
{
uint16_t cmd = rpk_peek_uint16(rpk);
if(cmd >= CMD_C2GAME && cmd <= CMD_C2GAME_END)
{
if(cmd > CMD_C2BATTLE && cmd < CMD_C2BATTLE_END)
{
//将消息转发到battleservice
uint8_t battleserid = reverse_read_uint8(rpk);
battleservice_t battle = get_battle_by_index(battleserid);
if(battle && 0 == send_msg(NULL,battle->msgdisp,(msg_t)rpk))
return 0;//不销毁rpk,由battleservice负责销毁*/
}else{
ident _ident= reverse_read_ident(rpk);
player_t ply = (player_t)cast_2_refbase(_ident);
if(ply && ply->_status == normal){
if(super_cmd_handlers[cmd]){
rpk_read_uint16(rpk);//丢弃cmd
call_handler(super_cmd_handlers[cmd],rpk,ply);
}else{
SYS_LOG(LOG_INFO,"unknow cmd:%d\n",cmd);
}
}
if(ply) ref_decrease((struct refbase*)ply);
}
}
return 1;
}
void consensus_handle_msg(consensus_component* comp,size_t data_size,void* data){
consensus_msg_header* header = data;
size_t trash_data_size = data_size;
trash_data_size++;
switch(header->msg_type){
case ACCEPT_REQ:
handle_accept_req(comp,data);
break;
case ACCEPT_ACK:
handle_accept_ack(comp,data);
break;
case MISSING_REQ:
handle_missing_req(comp,data);
break;
case MISSING_ACK:
handle_missing_ack(comp,data);
break;
case FORCE_EXEC:
handle_force_exec(comp,data);
break;
case FORWARD_REQ:
handle_forward_req(comp,data);
break;
default:
SYS_LOG(comp,"Unknown Consensus MSG : %d \n",
header->msg_type);
break;
}
return;
}
static void _log_stack(int32_t logLev,int32_t start,char *str) {
void* bt[64];
char** strings;
size_t sz;
int32_t i,f;
int32_t size = 0;
char logbuf[MAX_LOG_SIZE];
char addr[32],buf[1024];
char *ptr;
sz = backtrace(bt, 64);
strings = backtrace_symbols(bt, sz);
size += snprintf(logbuf,MAX_LOG_SIZE,"%s",str);
for(i = start,f = 0; i < sz; ++i) {
if(strstr(strings[i],"main+")) break;
ptr = logbuf + size;
if(getaddr(strings[i],addr,32) && !addr2line(addr,buf,1024))
size += snprintf(ptr,MAX_LOG_SIZE-size,
"\t% 2d: %s %s\n",++f,strings[i],buf);
else
size += snprintf(ptr,MAX_LOG_SIZE-size,
"\t% 2d: %s\n",++f,strings[i]);
}
SYS_LOG(logLev,"%s",logbuf);
free(strings);
}
static void _log_stack(int32_t logLev,int32_t start,const char *prefix,void **bt) {
char** strings;
size_t sz;
int32_t i,f;
int32_t size = 0;
char logbuf[MAX_LOG_SIZE];
char buf[1024];
char *ptr;
void *_bt[LOG_STACK_SIZE];
if(bt){
sz = chk_exp_get_thread_expn()->sz;
strings = backtrace_symbols(bt, sz);
}else{
sz = backtrace(_bt, LOG_STACK_SIZE);
strings = backtrace_symbols(_bt, sz);
}
if(prefix) size += snprintf(logbuf,MAX_LOG_SIZE,"%s\n",prefix);
for(i = start,f = 0; i < sz; ++i) {
if(strstr(strings[i],"main+")) break;
ptr = logbuf + size;
if(0 == getdetail(strings[i],buf,1024))
size += snprintf(ptr,MAX_LOG_SIZE-size,
"\t% 2d: %s %s\n",++f,strings[i],buf);
else
size += snprintf(ptr,MAX_LOG_SIZE-size,
"\t% 2d: %s\n",++f,strings[i]);
}
SYS_LOG(logLev,"%s",logbuf);
free(strings);
}
static void handle_missing_ack(consensus_component* comp,void* data){
missing_ack* msg = data;
request_record* origin = (request_record*)msg->data;
SYS_LOG(comp,"Node %d Handle Missing Ack From Node %d.\n",
comp->node_id,msg->node_id);
if(view_stamp_comp(comp->highest_committed_vs,&msg->missing_vs)>=0){
goto handle_missing_ack_exit;
}else{
db_key_type record_no = vstol(&msg->missing_vs);
request_record* record_data = NULL;
size_t data_size;
retrieve_record(comp->db_ptr,sizeof(record_no),&record_no,&data_size,(void**)&record_data);
if(record_data!=NULL){
goto handle_missing_ack_exit;
}
record_data =(request_record*)malloc(REQ_RECORD_SIZE(origin));
if(record_data==NULL){
goto handle_missing_ack_exit;
}
gettimeofday(&record_data->created_time,NULL);
record_data->data_size = origin->data_size;
memcpy(record_data->data,origin->data,origin->data_size);
store_record(comp->db_ptr,sizeof(record_no),&record_no,REQ_RECORD_SIZE(record_data),record_data);
}
try_to_execute(comp);
handle_missing_ack_exit:
return;
};
static void do_action_tcp_connect(view_stamp clt_id,void* arg){
event_manager* ev_mgr = arg;
replica_tcp_pair* ret;
HASH_FIND(hh, ev_mgr->replica_tcp_map, &clt_id, sizeof(view_stamp), ret);
if(NULL==ret){
ret = malloc(sizeof(replica_tcp_pair));
memset(ret,0,sizeof(replica_tcp_pair));
ret->key = clt_id;
ret->accepted = 0;
HASH_ADD(hh, ev_mgr->replica_tcp_map, key, sizeof(view_stamp), ret);
}
int fd = socket(AF_INET, SOCK_STREAM, 0);
connect(fd, (struct sockaddr*)&ev_mgr->sys_addr.s_addr,ev_mgr->sys_addr.s_sock_len);
ret->p_s = fd;
SYS_LOG(ev_mgr, "EVENT MANAGER sets up socket connection with server application.\n");
set_blocking(fd, 0);
int enable = 1;
if(setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (void*)&enable, sizeof(enable)) < 0)
printf("TCP_NODELAY SETTING ERROR!\n");
keep_alive(fd);
while (!ret->accepted);
return;
}
static void send_complete_callback(connection_t c){
luasocket_t luasock = (luasocket_t)connection_getud(c);
luaRef_t *obj = &luasock->luaObj;
const char *error = push_obj_callback(obj->L,"sr","__send_complete",*obj);
if(error){
SYS_LOG(LOG_ERROR,"error on __send_complete:%s\n",error);
}
}
static void cb_disconnected(redisconn_t conn,void *ud){
luaRef_t *cbObj = (luaRef_t*)ud;
const char *error = push_obj_callback(cbObj->L,"sr","__on_disconnected",*cbObj);
if(error){
SYS_LOG(LOG_ERROR,"error on __on_disconnected:%s\n",error);
}
release_luaRef(cbObj);
free(cbObj);
}
static void on_disconnected(connection_t c,int err){
//printf("on_disconnected\n");
luasocket_t luasock = (luasocket_t)connection_getud(c);
luaRef_t *obj = &luasock->luaObj;
const char *error = push_obj_callback(obj->L,"sri","__on_disconnected",*obj,err);
if(error){
SYS_LOG(LOG_ERROR,"error on __on_disconnected:%s\n",error);
}
}
static void cb_connect(handle_t s,void *remoteaddr,int _ ,int err)
{
((void)_);
luasocket_t luasock = kn_sock_getud(s);
luaRef_t *obj = &luasock->luaObj;
const char *error = push_obj_callback(obj->L,"sri","___cb_connect",*obj,err);
if(error){
SYS_LOG(LOG_ERROR,"error on ___cb_connect:%s\n",error);
}
}
static void check_point_condtion(void* arg)
{
if (checkpoint_flag == DISCONNECTED_REQUEST) {
event_manager* ev_mgr = arg;
unsigned int connection_num = HASH_COUNT(ev_mgr->replica_tcp_map);
if (connection_num == 0)
{
checkpoint_flag = DISCONNECTED_APPROVE;
while(restore_flag == 0);
SYS_LOG(ev_mgr, "start to reconnect\n");
reconnect_inner(ev_mgr);
SYS_LOG(ev_mgr, "reconnect finished\n");
} else {
SYS_LOG(ev_mgr, "flag is set to be NO_DISCONNECTED\n");
checkpoint_flag = NO_DISCONNECTED;
}
}
return;
}
/**
* 写head
*/
int CFileQueue::writeHead()
{
if (m_infoFd != -1) {
lseek(m_infoFd, 0, SEEK_SET);
if (write(m_infoFd, &m_head, sizeof(m_head)) != sizeof(m_head)) {
SYS_LOG(ERROR, "write failed: %s", m_queuePath);
}
}
return CTFO_EXIT_SUCCESS;
}
Connection *Transport::connect(const char *spec, IPacketStreamer *streamer, bool autoReconn) {
char tmp[1024];
char *args[32];
strncpy(tmp, spec, 1024);
tmp[1023] = '\0';
if (parseAddr(tmp, args, 32) != 3) {
return NULL;
}
if (strcasecmp(args[0], "tcp") == 0) {
char *host = args[1];
int port = atoi(args[2]);
// Socket
Socket *socket = new Socket();
if (!socket->setAddress(host, port)) {
delete socket;
SYS_LOG(ERROR, "设置setAddress错误: %s:%d, %s", host, port, spec);
return NULL;
}
// TCPComponent
TCPComponent *component = new TCPComponent(this, socket, streamer, NULL);
// 设置是否自动重连
component->setAutoReconn(autoReconn);
if (!component->init()) {
delete component;
SYS_LOG(ERROR, "初始化失败TCPComponent: %s:%d", host, port);
return NULL;
}
// 加入到iocomponents中，及注册可写到socketevent中
addComponent(component, true, true);
component->addRef();
return component->getConnection();
} else if (strcasecmp(args[0], "udp") == 0) {}
return NULL;
}
static int leader_handle_submit_req(struct consensus_component_t* comp,
size_t data_size,void* data,view_stamp* vs){
int ret = 1;
view_stamp next = get_next_view_stamp(comp);
if(NULL!=vs){
vs->view_id = next.view_id;
vs->req_id = next.req_id;
}
db_key_type record_no = vstol(&next);
request_record* record_data =
(request_record*)malloc(data_size+sizeof(request_record));
gettimeofday(&record_data->created_time,NULL);
record_data->bit_map = (1<<comp->node_id);
record_data->data_size = data_size;
record_data->is_closed = 0;
memcpy(record_data->data,data,data_size);
if(store_record(comp->db_ptr,sizeof(record_no),&record_no,REQ_RECORD_SIZE(record_data),record_data)){
goto handle_submit_req_exit;
}
ret = 0;
view_stamp_inc(comp->highest_seen_vs);
if(comp->group_size>1){
accept_req* msg = build_accept_req(comp,REQ_RECORD_SIZE(record_data),record_data,&next);
SYS_LOG(comp, "group_size > 1, sending out consensus msg.\n");
if(NULL==msg){
goto handle_submit_req_exit;
}
comp->uc(comp->my_node,ACCEPT_REQ_SIZE(msg),msg,-1);
free(msg);
}else{
SYS_LOG(comp, "group_size <= 1, execute by myself.\n");
try_to_execute(comp);
}
handle_submit_req_exit:
// no need to care about database, every time we will override it.
if(record_data!=NULL){
free(record_data);
}
return ret;
}
/**
* 备份文件，进行后面分析
*/
void CFileQueue::backup(uint32_t index) {
int curPos = (int)lseek(m_readFd, 0, SEEK_CUR);
char cmd[512];
sprintf(cmd, "cp -f %s/%08u.dat %s/%08u.dat.backup >/dev/null 2>&1 0>&1",
m_queuePath, m_head.read_seqno,
m_queuePath, m_head.read_seqno);
int rest = system(cmd);
SYS_LOG(WARN, "%s, readpos: %u:%d, currpos: %u:%d, curPos: %d, m_readFd: %d result: %d", cmd,
m_head.pos[index].seqno, m_head.pos[index].offset,
m_head.read_seqno, m_head.read_offset, curPos, m_readFd, rest);
}
static void handle_missing_req(consensus_component* comp,void* data){
SYS_LOG(comp,"Node %d Handle Missing Req.\n",
comp->node_id);
missing_req* msg = data;
SYS_LOG(comp,"Handle Missing Req %u : %u From Node %d.\n",
msg->missing_vs.view_id,msg->missing_vs.req_id,msg->node_id);
missing_ack* reply = build_missing_ack(comp,&msg->missing_vs);
if(NULL!=reply){
SYS_LOG(comp,"Send Missing Ack %u : %u To Node %d.\n",
msg->missing_vs.view_id,msg->missing_vs.req_id,msg->node_id);
comp->uc(comp->my_node,MISSING_ACK_SIZE(reply),reply,msg->node_id);
free(reply);
}
return;
};
static void cb_connect(redisconn_t conn,int err,void *ud){
luaRef_t *cbObj = (luaRef_t*)ud;
const char *e = errmsg[err == 0 ? 0:1];
const char *error = push_obj_callback(cbObj->L,"srps","__cb_connect",*cbObj,conn,e);
if(error)
SYS_LOG(LOG_ERROR,"error on lua redis __cb_connect:%s\n",error);
if(error || e){
release_luaRef(cbObj);
free(cbObj);
}
}
static void on_packet(connection_t c,packet_t p){
luasocket_t luasock = (luasocket_t)connection_getud(c);
luaRef_t *obj = &luasock->luaObj;
stPushPacket st;
st.p = clone_packet(p);
st.base.Push = PushPacket;
const char *error = push_obj_callback(obj->L,"srf","__on_packet",*obj,&st);
if(error){
SYS_LOG(LOG_ERROR,"error on __on_packet:%s\n",error);
}
}
void print_connection_info(struct sockaddr_storage* ss) {
char str[BUF_SIZE] = {'\0'};
struct sockaddr *sa;
struct sockaddr_in *sin;
struct sockaddr_in6 *sin6;
sa = (struct sockaddr*)ss;
switch (sa->sa_family) {
case AF_INET:
SYS_LOG("AF_INET.\n");
sin = (struct sockaddr_in*)ss;
if (NULL == inet_ntop(AF_INET, &(sin->sin_addr), str, sizeof(str))) {
SYS_LOG("inet_ntop : %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
break;
case AF_INET6:
SYS_LOG("AF_INET6.\n");
sin6 = (struct sockaddr_in6*)ss;
if (NULL == inet_ntop(AF_INET6, &(sin6->sin6_addr), str, sizeof(str))) {
SYS_LOG("inet_ntop : %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
break;
default:
SYS_LOG("unknown type.\n");
exit(EXIT_FAILURE);
}
SYS_LOG("connect to %s\n", str);
}
static void* build_missing_req(consensus_component* comp,view_stamp* vs){
missing_req* msg = (missing_req*)malloc(MISSING_REQ);
if(NULL!=msg){
msg->header.msg_type = MISSING_REQ;
msg->missing_vs.view_id = vs->view_id;
msg->missing_vs.req_id = vs->req_id;
msg->node_id = comp->node_id;
SYS_LOG(comp,"In Building Req, The View Stamp Is %u : %u.\n",
msg->missing_vs.view_id,msg->missing_vs.req_id);
}
return msg;
};
