int main(int argc, char *argv[])
{
int ret;
int sock;
sock = socket(PF_INET, SOCK_STREAM, 0);
if (sock < 0) { do_err("socket"); }
struct sockaddr_in servaddr;
memset(&servaddr, 0, sizeof (servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERVER_PORT);
servaddr.sin_addr.s_addr = inet_addr(SERVER_IP);
ret = connect(sock, (struct sockaddr *) &servaddr, sizeof(servaddr));
if (ret < 0) { do_err("connect"); }
struct sockaddr_in localaddr;
socklen_t addrlen = sizeof(localaddr);
ret = getsockname(sock, (struct sockaddr *) &localaddr, &addrlen);
if (ret < 0) { do_err("getsockname"); }
printf("client: %s:%hu\n", inet_ntoa(localaddr.sin_addr), ntohs(localaddr.sin_port));
struct sockaddr_in peeraddr;
addrlen = sizeof(peeraddr);
ret = getpeername(sock, (struct sockaddr *) &peeraddr, &addrlen);
if (ret < 0) { do_err("getsockname"); }
printf("server: %s:%hu\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
char recvbuff[1024] = {0};
// memset(&sendbuff, 0, sizeof(sendbuff));
while (1) {
if (scanf("%d%d", &sendbuff.fst, &sendbuff.scd) == 2) {
sendbuff.checkvalue = checksum((unsigned char *)&sendbuff, sizeof(sendbuff));
write(sock, &sendbuff, sizeof(sendbuff));
ret = read(sock, recvbuff, sizeof(recvbuff));
if (ret == -1) { do_err("read"); }
else if (ret == 0) {
printf("server closed.\n");
break;
}
printf("result: %s\n", recvbuff);
memset(recvbuff, 0, sizeof(recvbuff));
memset(&sendbuff, 0, sizeof(sendbuff));
}
else {
printf("wrong input\n");
break;
}
}
close(sock);
return 0;
}
int main(int argc, char *argv[]) {
void *buf;
_xcc_status cc;
unsigned short count_read;
unsigned short count_written;
unsigned short count_xferred;
int ferr;
short filenum;
int loop = 16;
char my_name[BUFSIZ];
bool nowait = false;
int nid;
char *p;
int pid;
char recv_buffer[BUFSIZ];
char send_buffer[BUFSIZ];
SB_Tag_Type tag;
short tfilenum;
int tm_seq;
int timeout = -1;
MS_Mon_Transid_Type transid;
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-nowait", TA_Bool, TA_NOMAX, &nowait },
{ "-print", TA_Bool, TA_NOMAX, &print },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "", TA_End, TA_NOMAX, NULL }
};
TRANSID_SET_NULL(curr_transid);
TRANSID_SET_NULL(exp_trans);
ferr = file_init(&argc, &argv);
TEST_CHK_FEOK(ferr);
msfs_util_init_fs(&argc, &argv, file_debug_hook);
arg_proc_args(zargs, false, argc, argv);
util_test_start(client);
ferr = file_mon_process_startup(!client); // system messages
TEST_CHK_FEOK(ferr);
util_gethostname(my_name, sizeof(my_name));
ferr = msg_mon_trans_register_tmlib(tmlib);
TEST_CHK_FEOK(ferr);
ferr = msg_mon_get_process_info(NULL, &nid, &pid);
TEST_CHK_FEOK(ferr);
if (client) {
ferr = XFILE_OPEN_((char *) "$srv", 4, &filenum,
0, 0, nowait ? (short) 1 : (short) 0,
0, 0, 0, 0, NULL);
TEST_CHK_FEOK(ferr);
for (inx = 0; inx < loop; inx++) {
ferr = msg_mon_get_tm_seq(&tm_seq);
TEST_CHK_FEOK(ferr);
if (!do_trans(inx))
tm_seq = 0;
sprintf(send_buffer, "hello, greetings from %s, inx=%d, trans=%d",
my_name, inx, tm_seq);
if (print)
printf("client enlist, transid=%d\n", tm_seq);
TRANSID_SET_SEQ(transid, tm_seq);
trans_set_curr(transid);
if (tm_seq) {
ferr = msg_mon_trans_enlist(nid, pid, transid);
TEST_CHK_FEOK(ferr);
}
if (do_trans(inx))
fun_set(TMLIB_FUN_GET_TX, TMLIB_FUN_REINSTATE_TX);
else
fun_set(TMLIB_FUN_GET_TX, -1);
trans_set(transid);
cc = XWRITEREADX(filenum,
send_buffer,
(short) (strlen(send_buffer) + 1),
BUFSIZ,
&count_read,
0);
if (nowait) {
TEST_CHK_CCEQ(cc);
tfilenum = filenum;
cc = XAWAITIOX(&tfilenum,
&buf,
&count_xferred,
&tag,
timeout,
NULL);
}
if (do_err(inx)) {
if (do_err_inx(inx) == ERR_S2) {
TEST_CHK_CCEQ(cc);
} else if (do_trans(inx)) {
TEST_CHK_CCNE(cc);
} else if (do_err_inx(inx) == ERR_C1) {
TEST_CHK_CCNE(cc);
} else {
TEST_CHK_CCEQ(cc);
}
// fun_check(-1);
} else {
TEST_CHK_CCEQ(cc);
fun_check(-1);
}
if (print)
printf("client end, transid=%d\n", tm_seq);
if (tm_seq) {
ferr = msg_mon_trans_end(nid, pid, transid);
TEST_CHK_FEOK(ferr);
TRANSID_SET_NULL(transid);
trans_set_curr(transid); // no more trans
}
printf("%s\n", send_buffer);
}
ferr = XFILE_CLOSE_(filenum, 0);
TEST_CHK_FEOK(ferr);
} else {
ferr = XFILE_OPEN_((char *) "$RECEIVE", 8, &filenum,
0, 0, nowait ? (short) 1 : (short) 0,
1, 1, // no sys msg
0, 0, NULL);
TEST_CHK_FEOK(ferr);
for (inx = 0; inx < loop; inx++) {
if (do_err(inx)) {
if (do_err_inx(inx) == ERR_C1)
continue; // we don't get these
}
if (do_trans(inx))
fun_set(TMLIB_FUN_REG_TX, -1);
else
fun_set(-1, -1);
cc = XREADUPDATEX(filenum,
recv_buffer,
BUFSIZ,
&count_read,
0);
TEST_CHK_CCEQ(cc);
if (nowait) {
tfilenum = filenum;
cc = XAWAITIOX(&tfilenum,
&buf,
&count_xferred,
&tag,
timeout,
NULL);
TEST_CHK_CCEQ(cc);
}
p = &recv_buffer[strlen(recv_buffer)];
while ((p > recv_buffer) && (*p != '='))
p--;
if (*p == '=') {
p++;
sscanf(p, "%d", &tm_seq);
TRANSID_SET_SEQ(transid, tm_seq);
} else
TRANSID_SET_NULL(transid);
if (!do_trans(inx)) {
MS_Mon_Transid_Type ltransid;
TRANSID_SET_NULL(ltransid);
trans_set_curr(ltransid);
}
trans_set(transid);
trans_check(curr_transid);
fun_check(-1);
if (do_trans(inx))
fun_set(TMLIB_FUN_CLEAR_TX, -1);
else
fun_set(-1, -1);
strcat(recv_buffer, "- reply from ");
strcat(recv_buffer, my_name);
count_read = (short) (strlen(recv_buffer) + 1);
cc = XREPLYX(recv_buffer,
count_read,
&count_written,
0,
XZFIL_ERR_OK);
TEST_CHK_CCEQ(cc);
fun_check(-1);
}
ferr = XFILE_CLOSE_(filenum, 0);
TEST_CHK_FEOK(ferr);
}
ferr = file_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
std::string Get::traitementmap()
{
bool ok;
ok = false;
int lines;
int caractere = 0;
std::string fichier;
std::string mess;
std::string extension;
std::string extendfolder;
std::map<std::string,std::string>::iterator it;
if(serveur::getMap("Protocole", _map).compare("HTTP/1.1") == 0)
{
if(serveur::getMap("host", _map).compare("Erreur") == 0)
{
_Reponse.clear();
do_err("400",_Reponse,_map);
return _Reponse;
}
}
_Reponse = serveur::getMap("Protocole", _map);
fichier = "." + serveur::getMap("get", _map);
std::cout << fichier <<"-" << std::endl;
extension = serveur::getMap("get", _map).substr(serveur::getMap("get", _map).find_last_of('.') + 1,serveur::getMap("get", _map).length());
std::cout << extension <<"-" << std::endl;
if(extension == "html")
extendfolder = "text/html";
else if(extension == "jpeg")
extendfolder = "image/jpeg";
else if(extension == "mpeg")
extendfolder= "audio/mpeg";
else if(extension == "txt")
extendfolder = "text/plain";
else
std::cout << "erreur extension fichier" << std::endl;
std::ifstream file(fichier.c_str());
std::string ligne; // variable contenant chaque ligne lu
if (file)
{
ok = true;
_Reponse += "200 Ok\n" ;
}
else
{
_Reponse += " 404 Not Found\n";
string temp;
temp = "<!DOCTYPE HTML PUBLIC ";//IETF//DTD HTML 2.0//EN">
temp += "<html><head>\n";
temp += "<title>404 Not Found</title>\n";
temp += "</head><body>\n";
temp += "<h1>Not Found</h1>\n";
temp += "<p>The requested URL /ltest.ffd was not found on this server.</p>\n";
temp += "</body></html>\n";
int a;
a = (int)temp.length();
char taile[20];
sprintf(taile, "%d\n",a);
std::string toto = taile;
_Reponse += "Content-Length: ";
_Reponse += toto;
_Reponse += "\n";
_Reponse += temp;
_Reponse += "\n";
return _Reponse;
}
if (ok == true)
{
while ( std::getline(file, ligne ) )
{
mess += ligne;
}
}
std::string temp;
int a;
a = (int)mess.length();
char taile[20];
sprintf(taile, "%d\n",a);
std::string toto = taile;
_Reponse += "Date : ";
_Reponse += serveur::date().c_str();
_Reponse += "\n";
_Reponse += "Server : Zia/0.1\nContent-type: ";
_Reponse += extendfolder.c_str();
_Reponse += "\n";
_Reponse += "Content-Length: " + toto;
_Reponse += "\n";
_Reponse += mess;
_Reponse += "\n";
//std::cout << _Reponse <<"-----------------------------------------" << std::endl;
return _Reponse;
}
int tmlib(MS_Mon_Tmlib_Fun_Type fun,
MS_Mon_Transid_Type transid,
MS_Mon_Transid_Type *transid_out) {
const char *funp;
MS_Mon_Transid_Type ltransid;
int ret;
if (exp_fun < 0) {
printf("client=%d, cb not expected\n", client);
assert(false); // callback not expected
} else
fun_check(fun);
switch (fun) {
case TMLIB_FUN_REG_TX:
funp = "REG";
trans_set_curr(transid);
break;
case TMLIB_FUN_CLEAR_TX:
funp = "CLEAR";
TRANSID_SET_NULL(ltransid);
trans_set_curr(ltransid);
break;
case TMLIB_FUN_REINSTATE_TX:
funp = "REINSTATE";
if (client)
trans_check(transid);
trans_set_curr(transid);
break;
case TMLIB_FUN_GET_TX:
funp = "GET";
break;
default:
funp = "<unknown>";
assert(false);
TRANSID_SET_NULL(ltransid);
trans_set_curr(ltransid);
break;
}
if (print) {
char transidbuf[100];
char curr_transidbuf[100];
const char *clientp = client ? "client" : "server";
util_format_transid(transidbuf, transid);
util_format_transid(curr_transidbuf, curr_transid);
printf("%s tmlib callback, fun=%s(%d), transid=%s, curr-transid=%s\n",
clientp, funp, fun, transidbuf, curr_transidbuf);
}
fun_set(exp_fun_next, -1);
if (fun == TMLIB_FUN_GET_TX)
*transid_out = curr_transid;
ret = 0;
if (do_err(inx)) {
switch (fun) {
case TMLIB_FUN_REG_TX:
if (do_err_inx(inx) == ERR_S1) {
fun_set(TMLIB_FUN_REG_TX, -1);
ret = inx;
inx++; // side-effect
}
break;
case TMLIB_FUN_CLEAR_TX:
if (do_err_inx(inx) == ERR_S2)
ret = inx;
break;
case TMLIB_FUN_REINSTATE_TX:
if (do_err_inx(inx) == ERR_C2)
ret = inx;
break;
case TMLIB_FUN_GET_TX:
if (do_err_inx(inx) == ERR_C1)
ret = inx;
break;
default:
assert(false);
break;
}
}
if (print) {
const char *clientp = client ? "client" : "server";
printf("%s tmlib callback, fun=%s(%d), ret=%d\n",
clientp, funp, fun, ret);
}
return ret;
}
int CThreadBeatHeart::run()
{
#define do_err() if(pconnector != NULL) \
{ \
delete pconnector; \
pconnector = NULL; \
} \
if(preport_stream != NULL) \
{ \
delete preport_stream; \
preport_stream = NULL; \
} \
if(preport_resp_body != NULL) \
{ \
delete [] preport_resp_body; \
preport_resp_body = NULL; \
}
int ret;
int i, vnode_count;
int vnode_id;
int64_t body_len;
byte vnode_status;
time_t nlast_beat_time;
char proxy_ip[KL_COMMON_IP_ADDR_LEN];
CConnector *pconnector = NULL;
CTimedStream *preport_stream = NULL;
pkg_header report_resp_header;
pkg_message *pstorage_sync_msg;
byte *preport_resp_body = NULL;
vnode_resp_info *pvnode_resp_unit;
storage_sync_event *pstorage_sync_event;
try
{
pconnector = new CConnector(m_proxy_addr);
}
catch(std::bad_alloc)
{
pconnector = NULL;
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"no more memory to create beat-hearting connector", \
__LINE__);
return ENOMEM;
}
catch(int errcode)
{
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"call CConnector constructor failed, err: %s", \
__LINE__, strerror(errcode));
return errcode;
}
try
{
preport_stream = new CTimedStream();
}
catch(std::bad_alloc)
{
preport_stream = NULL;
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"no more memory to create beat-hearting sock stream", \
__LINE__);
do_err();
return ENOMEM;
}
catch(int errcode)
{
preport_stream = NULL;
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"call CTimedStream constructor failed, err: %s", \
__LINE__, strerror(errcode));
return errcode;
}
if(pconnector->stream_connect(preport_stream) != 0)
{
m_proxy_addr.getipaddress(proxy_ip, sizeof(proxy_ip));
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"connect to proxy node(ip: %s, port: %d) failed, err: %s", \
__LINE__, proxy_ip, m_proxy_addr.getport(), strerror(errno));
do_err();
return errno;
}
if(join_and_report(preport_stream) != 0)
{
m_proxy_addr.getipaddress(proxy_ip, sizeof(proxy_ip));
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"send join request to proxy node(ip: %s, port: %d) failed", \
__LINE__, proxy_ip, m_proxy_addr.getport());
do_err();
return -1;
}
nlast_beat_time = time(NULL);
while(m_bstop_flag != true)
{
//KL_SYS_INFOLOG("beat-hearting thread report loop");
if(time(NULL) - nlast_beat_time < KL_STORAGE_BEAT_INTERVAL)
{
sleep(1);
continue;
}
//KL_SYS_INFOLOG("beat-hearting thread true report loop");
nlast_beat_time = time(NULL);
if((ret = report_vnode_info(preport_stream)) != 0)
{
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"report storage vnode information failed, err: %s", \
__LINE__, strerror(ret));
do_err();
return ret;
}
//KL_SYS_INFOLOG("beat-hearting thread report success");
//to receive the reponse from proxy node
if((ret = preport_stream->stream_recv(&report_resp_header, \
sizeof(report_resp_header), g_ntimeout)) != 0)
{
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"report thread recv report response header failed, err: %s", \
__LINE__, strerror(ret));
do_err();
return ret;
}
//KL_SYS_INFOLOG("recv header ret: %d, pkg_header len: %d", ret, sizeof(pkg_header));
//check the response status
if(report_resp_header.status != 0)
{
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"storage node beat-hearting msg's response is occured with error", \
__LINE__);
do_err();
return -1;
}
//check whether response message is legal
body_len = CSERIALIZER::buff2int64(report_resp_header.pkg_len);
if(body_len == 0)
{
//proxy resp msg, have no body to merge
continue;
}
else if(report_resp_header.cmd == KL_PROXY_CMD_SLAVER_RESP)
{
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"report thread recv slaver resp msg is illegal", \
__LINE__);
return -1;
}
if((body_len % sizeof(vnode_resp_info) != 0))
{
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"report thread recv master resp body len(body_len: %d) is illegal", \
__LINE__, body_len);
do_err();
return -1;
}
try
{
preport_resp_body = new byte[body_len];
}
catch(std::bad_alloc)
{
preport_resp_body = NULL;
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"no more memory to create report response body buffer(pkg_len: %ld)", \
__LINE__, body_len);
do_err();
return ENOMEM;
}
//to receive response body
if((ret = preport_stream->stream_recv(preport_resp_body, body_len, g_ntimeout)) != 0)
{
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"report thread recv report response body failed, err: %s", \
__LINE__, strerror(ret));
do_err();
return ret;
}
//KL_SYS_INFOLOG("recv body ret: %d, body len: %d", ret, body_len);
//parse response body
vnode_count = body_len / sizeof(vnode_resp_info);
for(i = 0; i < vnode_count; i++)
{
pvnode_resp_unit = (vnode_resp_info *)(preport_resp_body + \
i * sizeof(vnode_resp_info));
vnode_id = CSERIALIZER::buff2int32(pvnode_resp_unit->vnode_id);
vnode_status = pvnode_resp_unit->vnode_status;
//KL_SYS_INFOLOG("vnode_id: %d, vnode_status: %d", vnode_id, vnode_status);
if((ret = merge_vnode_status(vnode_id, vnode_status)) != 0)
{
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"report thread merge vnode status failed, vnode_id: %d, vnode_status: %d, " \
"errcode: %d", \
__LINE__, vnode_id, vnode_status, ret);
do_err();
return ret;
}
//KL_SYS_INFOLOG("beat-hearting merge vnode status success");
if(vnode_status != KL_REPLICA_STATUS_COPY_SRC && \
vnode_status != KL_REPLICA_STATUS_MOVE_SRC)
continue;
try
{
pstorage_sync_event = (storage_sync_event *)(new byte[sizeof(storage_sync_event)]);
}
catch(std::bad_alloc)
{
pstorage_sync_event = NULL;
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"no more memory to create storage sync event obj", \
__LINE__);
do_err();
return ENOMEM;
}
try
{
pstorage_sync_msg = new pkg_message();
}
catch(std::bad_alloc)
{
pstorage_sync_msg = NULL;
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"no more memory to create storage sync msg obj", \
__LINE__);
delete pstorage_sync_event;
do_err();
return ENOMEM;
}
pstorage_sync_event->vnode_id = vnode_id;
pstorage_sync_event->sync_dest_port = \
CSERIALIZER::buff2int32(pvnode_resp_unit->sync_dest_port);
memcpy(pstorage_sync_event->sync_dest_ip, pvnode_resp_unit->sync_dest_ip, \
KL_COMMON_IP_ADDR_LEN);
pstorage_sync_msg->pkg_len = sizeof(storage_sync_event);
pstorage_sync_msg->pkg_ptr = (byte*)pstorage_sync_event;
m_psync_msg_queue->push_msg(pstorage_sync_msg);
//KL_SYS_INFOLOG("push sync event(vnode_id: %d) success", vnode_id);
}
delete [] preport_resp_body;
preport_resp_body = NULL;
g_sync_down_rwlock.wrlock();
if(m_nthread_index == 0 && !g_sync_down_queue.empty())
{
ret = report_sync_down_info(preport_stream);
}
g_sync_down_rwlock.unlock();
if(ret != 0)
{
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"report storage node sync down info failed, err: %s", \
__LINE__, strerror(ret));
do_err();
return ret;
}
}
do_err();
return 0;
}
