void* ppfs_fsinit( struct fuse_conn_info* conn ) { //connect to MDS
fprintf(stderr, "ppfs_fsinit\n");
if((fd = tcpsocket())<0) {
fprintf(stderr, "can't create socket\n");
exit(1);
} else {
fprintf(stderr, "fd:%d\n", fd);
}
tcpnodelay(fd);
if(tcpstrconnect(fd, ip, MDS_PORT_STR)<0) {
fprintf(stderr, "can't connect to MDS (%s:%s)\n", ip, port);
fd = -1;
exit(1);
}
fprintf(stderr, "ppfs_init create socket: %u\n", fd);
local_mds.sockfd = fd;
tcpgetpeer(fd,&(local_mds.peerip),NULL);
remote_mds.sockfd = -1;
remote_mds.peerip = -1;
}
void matoslaserv_serve(int epoll_fd,int count,struct epoll_event *pdesc) {
//uint32_t now=main_time();
serventry *eptr,*weptr;
int ns;
weptr = (serventry *)pdesc[count].data.ptr;
if ((weptr->listen_sock == 1) && (pdesc[count].events & EPOLLIN)) {
ns=tcpaccept(lsock);
if (ns<0) {
MFSLOG(LOG_INFO,"Master<->sla socket: accept error: %m");
} else {
struct epoll_event ev;
tcpnonblock(ns);
tcpnodelay(ns);
eptr = (serventry *)malloc(sizeof(serventry));
eptr->next = matoslaservhead;
matoslaservhead = eptr;
eptr->sock = ns;
eptr->mode = HEADER;
eptr->lastread = eptr->lastwrite = get_current_time();
eptr->inputpacket.next = NULL;
eptr->inputpacket.bytesleft = 8;
eptr->inputpacket.startptr = eptr->hdrbuff;
eptr->inputpacket.packet = NULL;
eptr->outputhead = NULL;
eptr->outputtail = &(eptr->outputhead);
eptr->timeout = 120;
tcpgetpeer(eptr->sock,&(eptr->servip),NULL);
eptr->servstrip = matoslaserv_makestrip(eptr->servip);
eptr->version=0;
eptr->metafd=-1;
eptr->listen_sock = 0;
eptr->connection = 4;
ev.data.ptr = eptr;
ev.events = EPOLLIN | EPOLLOUT;
epoll_ctl(epoll_fd,EPOLL_CTL_ADD,ns,&ev);
}
}
if(weptr->listen_sock == 0) {
if (pdesc[count].events & (EPOLLERR|EPOLLHUP)) {
weptr->mode = KILL;
}
if ((pdesc[count].events & EPOLLIN) && weptr->mode!=KILL) {
matoslaserv_read(weptr);
weptr->lastread = get_current_time();
}
if ((pdesc[count].events & EPOLLOUT) && weptr->mode!=KILL && weptr->outputhead!=NULL) {
matoslaserv_write(weptr);
weptr->lastwrite = get_current_time();
}
}
}
int serv_connect(ppfs_conn_entry* e,int ip,int port){
int fd = tcpsocket();
if(fd < 0){
fprintf(stderr,"cannot create socket\n");
return -1;
}
tcpnodelay(fd);
if(tcpnumconnect(fd,ip,port) < 0){
fprintf(stderr,"cannot connect to %X:%d\n",ip,port);
return -1;
}
e->sockfd = fd;
tcpgetpeer(fd,&(e->peerip),NULL);
//@TODO: add login
return fd;
}
void matomlserv_serve(struct pollfd *pdesc) {
uint32_t now=main_time();
matomlserventry *eptr,**kptr;
packetstruct *pptr,*paptr;
int ns;
static uint64_t lastaction = 0;
uint64_t unow;
uint32_t timeoutadd;
if (lastaction==0) {
lastaction = main_precise_utime();
}
if (lsockpdescpos>=0 && (pdesc[lsockpdescpos].revents & POLLIN)) {
ns=tcpaccept(lsock);
if (ns<0) {
mfs_errlog_silent(LOG_NOTICE,"Master<->ML socket: accept error");
} else {
tcpnonblock(ns);
tcpnodelay(ns);
eptr = malloc(sizeof(matomlserventry));
passert(eptr);
eptr->next = matomlservhead;
matomlservhead = eptr;
eptr->sock = ns;
eptr->pdescpos = -1;
eptr->mode = HEADER;
eptr->lastread = now;
eptr->lastwrite = now;
eptr->inputpacket.next = NULL;
eptr->inputpacket.bytesleft = 8;
eptr->inputpacket.startptr = eptr->hdrbuff;
eptr->inputpacket.packet = NULL;
eptr->outputhead = NULL;
eptr->outputtail = &(eptr->outputhead);
eptr->timeout = 10;
tcpgetpeer(eptr->sock,&(eptr->servip),NULL);
eptr->servstrip = matomlserv_makestrip(eptr->servip);
eptr->version=0;
eptr->metafd=-1;
eptr->chain1fd=-1;
eptr->chain2fd=-1;
eptr->logindex=-1;
eptr->logf=NULL;
eptr->currentversion=0;
}
}
// read
for (eptr=matomlservhead ; eptr ; eptr=eptr->next) {
if (eptr->pdescpos>=0) {
if (pdesc[eptr->pdescpos].revents & (POLLERR|POLLHUP)) {
eptr->mode = KILL;
}
if ((pdesc[eptr->pdescpos].revents & POLLIN) && eptr->mode!=KILL) {
eptr->lastread = now;
matomlserv_read(eptr);
}
}
}
// timeout fix
unow = main_precise_utime();
timeoutadd = (unow-lastaction)/1000000;
if (timeoutadd) {
for (eptr=matomlservhead ; eptr ; eptr=eptr->next) {
eptr->lastread += timeoutadd;
}
}
lastaction = unow;
// write
for (eptr=matomlservhead ; eptr ; eptr=eptr->next) {
if ((uint32_t)(eptr->lastwrite+(eptr->timeout/3))<(uint32_t)now && eptr->outputhead==NULL) {
matomlserv_createpacket(eptr,ANTOAN_NOP,0);
}
if (eptr->pdescpos>=0) {
if ((((pdesc[eptr->pdescpos].events & POLLOUT)==0 && (eptr->outputhead)) || (pdesc[eptr->pdescpos].revents & POLLOUT)) && eptr->mode!=KILL) {
eptr->lastwrite = now;
matomlserv_write(eptr);
}
if (eptr->mode!=KILL && eptr->logf && eptr->outputhead==NULL) {
matomlserv_send_old_changes(eptr, eptr->currentversion);
}
}
if ((uint32_t)(eptr->lastread+eptr->timeout)<(uint32_t)now) {
eptr->mode = KILL;
}
}
// close
kptr = &matomlservhead;
while ((eptr=*kptr)) {
if (eptr->mode == KILL) {
matomlserv_beforeclose(eptr);
tcpclose(eptr->sock);
if (eptr->inputpacket.packet) {
free(eptr->inputpacket.packet);
}
pptr = eptr->outputhead;
while (pptr) {
if (pptr->packet) {
free(pptr->packet);
}
paptr = pptr;
pptr = pptr->next;
free(paptr);
}
if (eptr->servstrip) {
free(eptr->servstrip);
}
*kptr = eptr->next;
free(eptr);
} else {
kptr = &(eptr->next);
}
}
}
//init the thread's socket
static int sla_sync_socket_init(serventry *eptr,pthread_t tid) {
int status;
uint32_t shadow_ip = 0,bind_ip = 0,bip = 0;
uint16_t shadow_port;
int num;
int count = 0;
num = sla_worker_thread_indent(tid);
if (tcpresolve(sla_worker_addr[num].host,sla_worker_addr[num].port,&shadow_ip,&shadow_port,0)>=0) {
eptr->masterip = shadow_ip;
eptr->masterport = shadow_port;
} else {
MFSLOG(LOG_ERR,"resolve shadow's addr failed");
return -1;
}
eptr->sock = tcpsocket();
if (eptr->sock < 0) {
MFSLOG(LOG_ERR,"socket init failed");
return -1;
}
if (tcpnonblock(eptr->sock)<0) {
MFSLOG(LOG_WARNING,"set nonblock, error: %m");
tcpclose(eptr->sock);
eptr->sock=-1;
return -1;
}
tcpgetpeer(eptr->sock,&(eptr->servip),NULL);
eptr->servstrip = matoslaserv_makestrip(eptr->servip);
if (tcpresolve(BindHost,NULL,&bind_ip,NULL,1)>=0) {
eptr->bindip = bip;
} else {
eptr->bindip = 0;
}
if (eptr->bindip>0) {
if (tcpnumbind(eptr->sock,eptr->bindip,0)<0) {
MFSLOG(LOG_WARNING,"can't bind socket to given ip: %m");
tcpclose(eptr->sock);
eptr->sock=-1;
return -1;
}
}
eptr->cur_file = (file_info *)malloc(sizeof(file_info));
if (eptr->cur_file == NULL) {
MFSLOG(LOG_ERR,"FATAL,malloc file_info failed");
} else {
eptr->cur_file->fd = NULL;
eptr->cur_file->idx = 0;
}
while(count < MaxConnect) {
status = tcpnumconnect(eptr->sock,eptr->masterip,eptr->masterport);
if (status<0) {
MFSLOG(LOG_WARNING,"connect failed, error: %m (1)");
tcpclose(eptr->sock);
eptr->sock=-1;
return -1;
}
if (status==0) {
MFSLOG(LOG_NOTICE,"connected to slave");
tcpnodelay(eptr->sock);
eptr->mode=HEADER;
eptr->inputpacket.next = NULL;
eptr->inputpacket.bytesleft = 8;
eptr->inputpacket.startptr = eptr->hdrbuff;
eptr->inputpacket.packet = NULL;
eptr->outputhead = NULL;
eptr->outputtail = &(eptr->outputhead);
eptr->lastread = eptr->lastwrite = get_current_time();
count = 100;
break;
} else {
MFSLOG(LOG_ERR,"connect failed, error: %m (2)");
}
count++;
sleep(1);
}
return 0;
}
void matoslaserv_desc(int epoll_fd) {
//uint32_t now=main_time();
serventry *eptr,**kptr,**wptr;
packetstruct *pptr,*paptr;
struct epoll_event ev;
int ret;
if (first_add_listen_sock==0) {
eptr = (serventry *)malloc(sizeof(serventry));
eptr->next = matoslaservhead;
matoslaservhead = eptr;
eptr->sock = lsock;
eptr->mode = HEADER;
eptr->lastread = eptr->lastwrite = get_current_time();
eptr->inputpacket.next = NULL;
eptr->inputpacket.bytesleft = 8;
eptr->inputpacket.startptr = eptr->hdrbuff;
eptr->inputpacket.packet = NULL;
eptr->outputhead = NULL;
eptr->outputtail = &(eptr->outputhead);
/**
* as the load meta in slave may cost much time which could not send a heartbeat
*
* Dongyang Zhang
*/
eptr->timeout = 300;
tcpgetpeer(eptr->sock,&(eptr->servip),NULL);
eptr->servstrip = matoslaserv_makestrip(eptr->servip);
eptr->version=0;
eptr->metafd=-1;
eptr->listen_sock = 1;
eptr->connection = 4;
ev.data.ptr = eptr;
ev.events = EPOLLIN;
ret = epoll_ctl(epoll_fd,EPOLL_CTL_ADD,lsock,&ev);
if(ret!=0) {
MFSLOG(LOG_NOTICE,"epoll_ctl error 1");
}
first_add_listen_sock = 1;
}
kptr = &matoslaservhead;
wptr = &matoslaservhead;
while ((eptr=*kptr)) {
if (eptr->listen_sock == 0 && eptr->mode != KILL) {
ev.data.ptr = eptr;
ev.events = EPOLLIN;
if (eptr->outputhead != NULL && eptr->mode != KILL) {
ev.events = EPOLLIN|EPOLLOUT;
}
ret = epoll_ctl(epoll_fd,EPOLL_CTL_MOD,eptr->sock,&ev);
if(ret!=0) {
MFSLOG(LOG_NOTICE,"epoll_ctl error 2");
}
}
if (eptr->listen_sock == 1) {
eptr->lastread = eptr->lastwrite = get_current_time();
}
if ((uint32_t)(eptr->lastread+eptr->timeout)<(uint32_t)get_current_time()) {
eptr->mode = KILL;
}
if ((uint32_t)(eptr->lastwrite+(eptr->timeout/2))<(uint32_t)get_current_time()
&& eptr->outputhead==NULL) {
matoslaserv_createpacket(eptr,ANTOAN_NOP,0);
}
if (eptr->mode == KILL) {
ev.data.ptr = eptr;
matoslaserv_beforeclose(eptr);
epoll_ctl(epoll_fd,EPOLL_CTL_DEL,eptr->sock,&ev);
tcpclose(eptr->sock);
if (eptr->inputpacket.packet) {
free(eptr->inputpacket.packet);
}
pptr = eptr->outputhead;
while (pptr) {
if (pptr->packet) {
free(pptr->packet);
}
paptr = pptr;
pptr = pptr->next;
free(paptr);
}
if(eptr == matoslaservhead) {
matoslaservhead = eptr->next;
wptr = &matoslaservhead;
}
else {
(*wptr)->next = eptr->next;
}
*kptr = eptr->next;
free(eptr);
} else {
wptr = &eptr;
kptr = &(eptr->next);
}
}
}
