/* process raw auth request from node */
int eh_process_node_auth(int is_reply, void * data, int ent_id)
{
logdebug(_("%s called\n"), __func__);
int ret;
AuthInfo * ai = data;
AuthConfig * ac = ly_entity_auth(ent_id);
if (is_reply) {
loginfo(_("auth reply from node %d(tag)\n"), ai->tag);
ret = lyauth_verify(ac, ai->data, LUOYUN_AUTH_DATA_LEN);
if (ret < 0) {
logerror(_("error in %s(%d)\n"), __func__, __LINE__);
return -1;
}
if (ret) {
loginfo(_("node %d(tag) is authenticated\n"), ai->tag);
if (!ly_entity_is_authenticated(ent_id))
ly_entity_update(ent_id, -1, LY_ENTITY_FLAG_STATUS_AUTHENTICATED);
}
else {
logwarn(_("chanllenge verification for node %d(tag) failed.\n"),
ai->tag);
return 1;
}
return 0;
}
loginfo(_("auth request from node %d(tag)\n"), ai->tag);
LYNodeData * nd = ly_entity_data(ent_id);
if (nd == NULL) {
logerror(_("error in %s(%d)\n"), __func__, __LINE__);
return -1;
}
NodeInfo * nf = &nd->node;
/* get secret */
if (ac->secret == NULL) {
logdebug(_("retrieve auth key for node %d(tag)\n"), ai->tag);
ret = db_node_find_secret(DB_NODE_FIND_BY_ID,
&ai->tag,
&ac->secret);
if (ret < 0) {
logerror(_("error in %s(%d)\n"), __func__, __LINE__);
return -1;
}
else if (ret == 0) {
logerror(_("node(tag: %d) not in db\n"), ai->tag);
return -1;
}
nf->host_tag = ai->tag;
}
/* update node status */
logdebug(_("update node status to %d\n"), NODE_STATUS_AUTHENTICATING);
ret = db_node_update_status(DB_NODE_FIND_BY_ID, &ai->tag,
NODE_STATUS_AUTHENTICATING);
if (ret < 0) {
logerror(_("error in %s(%d)\n"), __func__, __LINE__);
return -1;
}
/* resolve challenge */
logdebug(_("answer auth request\n"));
ret = lyauth_answer(ac, ai->data, LUOYUN_AUTH_DATA_LEN);
if (ret < 0) {
logerror(_("error in %s(%d)\n"), __func__, __LINE__);
return -1;
}
/* send answer back */
int fd = ly_entity_fd(ent_id);
if (ly_packet_send(fd, PKT_TYPE_NODE_AUTH_REPLY,
ai, sizeof(AuthInfo)) < 0) {
logerror(_("error in %s(%d)\n"), __func__, __LINE__);
return -1;
}
/* request challenging */
logdebug(_("clc sends out auth request\n"));
if (lyauth_prepare(ac) < 0) {
logerror(_("error in %s(%d)\n"), __func__, __LINE__);
return -1;
}
bzero(ai->data, LUOYUN_AUTH_DATA_LEN);
strncpy((char *)ai->data, ac->challenge, LUOYUN_AUTH_DATA_LEN);
if (ly_packet_send(fd, PKT_TYPE_NODE_AUTH_REQUEST,
ai, sizeof(AuthInfo)) < 0) {
logerror(_("error in %s(%d)\n"), __func__, __LINE__);
return -1;
}
loginfo(_("node %d(tag) is online\n"), nf->host_tag);
ly_entity_update(ent_id, nf->host_tag, LY_ENTITY_FLAG_STATUS_ONLINE);
return 0;
}
/* process node register request */
static int __node_xml_register(xmlDoc * doc, xmlNode * node, int ent_id)
{
if (ly_entity_is_registered(ent_id)) {
logwarn(_("received node register request again, ignored\n"));
return -1;
}
LYNodeData * nd = ly_entity_data(ent_id);
if (nd == NULL ) {
logerror(_("error in %s(%d)\n"), __func__, __LINE__);
return -1;
}
NodeInfo * nf = &nd->node;
/* Create xpath evaluation context */
xmlXPathContextPtr xpathCtx = xmlXPathNewContext(doc);
if (xpathCtx == NULL) {
logerror(_("unable to create new XPath context %s, %d\n"),
__func__, __LINE__);
return -1;
}
int ret = -1;
char *str;
str = xml_xpath_text_from_ctx(xpathCtx,
"/" LYXML_ROOT "/request/parameters/status");
if (str == NULL)
goto xml_err;
nf->status = atoi(str);
free(str);
str = xml_xpath_text_from_ctx(xpathCtx,
"/" LYXML_ROOT "/request/parameters/hypervisor");
if (str == NULL)
goto xml_err;
nf->hypervisor = atoi(str);
free(str);
str = xml_xpath_text_from_ctx(xpathCtx,
"/" LYXML_ROOT "/request/parameters/host/tag");
int tag = -1;
if (str) {
tag = atoi(str); /* NULL str is allowed for new node */
free(str);
}
str = xml_xpath_text_from_ctx(xpathCtx,
"/" LYXML_ROOT "/request/parameters/host/name");
if (str == NULL)
goto xml_err;
nf->host_name = str;
str = xml_xpath_text_from_ctx(xpathCtx,
"/" LYXML_ROOT "/request/parameters/host/ip");
if (str == NULL)
goto xml_err;
nf->host_ip = str;
str = xml_xpath_text_from_ctx(xpathCtx,
"/" LYXML_ROOT "/request/parameters/cpu/arch");
if (str == NULL)
goto xml_err;
nf->cpu_arch = atoi(str);
free(str);
str = xml_xpath_text_from_ctx(xpathCtx,
"/" LYXML_ROOT "/request/parameters/cpu/model");
if (str == NULL)
goto xml_err;
nf->cpu_model = str;
str = xml_xpath_text_from_ctx(xpathCtx,
"/" LYXML_ROOT "/request/parameters/cpu/mhz");
if (str == NULL)
goto xml_err;
nf->cpu_mhz = atoi(str);
free(str);
str = xml_xpath_text_from_ctx(xpathCtx,
"/" LYXML_ROOT "/request/parameters/cpu/max");
if (str == NULL)
goto xml_err;
nf->cpu_max = atoi(str);
nf->cpu_vlimit = NODE_SCHEDULE_CPU_LIMIT(nf->cpu_max);
free(str);
str = xml_xpath_text_from_ctx(xpathCtx,
"/" LYXML_ROOT "/request/parameters/cpu/commit");
if (str == NULL)
goto xml_err;
nf->cpu_commit = atoi(str);
free(str);
str = xml_xpath_text_from_ctx(xpathCtx,
"/" LYXML_ROOT "/request/parameters/memory/total");
if (str == NULL)
goto xml_err;
nf->mem_max = atoi(str);
nf->mem_vlimit = NODE_SCHEDULE_MEM_LIMIT(nf->mem_max);
free(str);
str = xml_xpath_text_from_ctx(xpathCtx,
"/" LYXML_ROOT "/request/parameters/memory/free");
if (str == NULL)
goto xml_err;
nf->mem_free = atoi(str);
free(str);
str = xml_xpath_text_from_ctx(xpathCtx,
"/" LYXML_ROOT "/request/parameters/memory/commit");
if (str == NULL)
goto xml_err;
nf->mem_commit = atoi(str);
free(str);
str = xml_xpath_text_from_ctx(xpathCtx,
"/" LYXML_ROOT "/request/parameters/storage/total");
if (str == NULL)
goto xml_err;
nf->storage_total = atoi(str);
free(str);
str = xml_xpath_text_from_ctx(xpathCtx,
"/" LYXML_ROOT "/request/parameters/storage/free");
if (str == NULL)
goto xml_err;
nf->storage_free = atoi(str);
free(str);
str = xml_xpath_text_from_ctx(xpathCtx,
"/" LYXML_ROOT "/request/parameters/load/average");
if (str == NULL)
goto xml_err;
nf->load_average = atoi(str);
free(str);
if (nf->status >= NODE_STATUS_REGISTERED) {
logwarn(_("node(%d, %s) tries to register from wrong status(%d)\n"),
nf->host_tag, nf->host_ip, nf->status);
ly_entity_release(ent_id);
ret = 0; /* no need to continue node registration */
goto done;
}
if (ly_entity_node_active(nf->host_ip)) {
logwarn(_("duplicate node ip received. something is wrong...\n"));
ly_entity_release(ent_id);
ret = 0; /* no need to continue node registration */
goto done;
}
if (tag > 0) {
/* check authentication result */
if (nf->host_tag > 0 && tag != nf->host_tag) {
logerror(_("node tag changed, %d -> %d. something is wrong.\n"),
nf->host_tag, tag);
goto done;
}
nf->host_tag = tag;
ret = __node_register_auth(nf, ent_id);
if (ret == LY_S_REGISTERING_DONE_SUCCESS) {
AuthConfig * ac = ly_entity_auth(ent_id);
if (db_node_update_secret(DB_NODE_FIND_BY_ID, &tag,
ac->secret) < 0 ||
db_node_update_status(DB_NODE_FIND_BY_ID, &tag,
NODE_STATUS_REGISTERED) < 0) {
logerror(_("error in %s(%d)\n"), __func__, __LINE__);
ret = -1;
goto done;
}
loginfo(_("node(tag:%d) registered\n"), tag);
ly_entity_update(ent_id, tag, LY_ENTITY_FLAG_STATUS_REGISTERED);
}
goto done;
}
/* new node */
DBNodeRegInfo db_nf;
bzero(&db_nf, sizeof(DBNodeRegInfo));
ret = db_node_find(DB_NODE_FIND_BY_IP, nf->host_ip, &db_nf);
if (ret < 0 || ret > 1) {
logerror(_("error in %s(%d)\n"), __func__, __LINE__);
ret = -1;
goto done;
}
if (ret == 0 || db_nf.secret) {
/* new node */
logdebug(_("new node\n"));
if (nf->status != NODE_STATUS_UNINITIALIZED) {
logwarn(_("node(%d, %s) tries to register from unexpected status(%d)\n"),
nf->host_tag, nf->host_ip, nf->status);
nf->status = NODE_STATUS_UNINITIALIZED;
}
if (db_nf.secret) {
logwarn(_("new node takes ip(%s) used by tagged node\n"), nf->host_ip);
db_node_reginfo_free(&db_nf);
bzero(&db_nf, sizeof(DBNodeRegInfo));
}
ret = db_node_insert(nf);
if (ret < 0) {
logerror(_("error in %s(%d)\n"), __func__, __LINE__);
goto new_done;
}
db_nf.id = ret;
loginfo(_("new node %s added in db(%d)\n"), nf->host_ip, ret);
/* enable node if node is control server */
if (ly_is_clc_ip(nf->host_ip)) {
if (db_node_enable(ret, 1) != 0 ||
db_node_find(DB_NODE_FIND_BY_ID, &ret, &db_nf) != 1) {
logerror(_("error in %s(%d)\n"), __func__, __LINE__);
ret = -1;
goto new_done;
}
}
}
else
logdebug(_("untagged node for ip(%s) found in db\n"), nf->host_ip);
ly_entity_update(ent_id, db_nf.id, LY_ENTITY_FLAG_STATUS_ONLINE);
if (db_nf.enabled) {
AuthConfig * ac = ly_entity_auth(ent_id);
ret = -1;
if (ac->secret) {
logerror(_("error in %s(%d)\n"), __func__, __LINE__);
goto new_done;
}
ac->secret = lyauth_secret();
if (ac->secret == NULL) {
logerror(_("error in %s(%d)\n"), __func__, __LINE__);
goto new_done;
}
nf->host_tag = db_nf.id;
ret = LY_S_REGISTERING_CONFIG;
}
else {
logdebug(_("register request done, node %s not enabled\n"), nf->host_ip);
ret = LY_S_REGISTERING_INIT;
}
nf->status = NODE_STATUS_ONLINE;
if (db_node_update(DB_NODE_FIND_BY_ID, &db_nf.id, nf) < 0) {
logerror(_("error in %s(%d)\n"), __func__, __LINE__);
ret = -1;
}
new_done:
db_node_reginfo_free(&db_nf);
goto done;
xml_err:
logerror(_("invalid node xml register request\n"));
done:
xmlXPathFreeContext(xpathCtx);
logdebug(_("end of %s, node status %d\n"), __func__, nf->status);
return ret;
}
int ly_epoll_entity_recv(int ent_id)
{
if (ly_entity_type(ent_id) == LY_ENTITY_CLC)
return __epoll_work_recv(ent_id);
int fd = ly_entity_fd(ent_id);
if (fd < 0) {
logerror(_("fd for entity %d was closed. ignore event.\n"), ent_id);
return 1;
}
LYPacketRecv *pkt = ly_entity_pkt(ent_id);
if (pkt == NULL)
return -255;
int size;
void * buf = ly_packet_buf(pkt, &size);
if (buf == NULL) {
logerror(_("ly_packet_buf returns NULL buffer. close socket\n"));
return 1;
}
if (size == 0) {
logerror(_("ly_packet_buf returns 0 size buffer. close socket\n"));
return 1;
}
int len = recv(fd, buf, size, 0);
if (len <= 0) {
loginfo(_("socket %d recv returns %d. close socket\n"), fd, len);
if (len < 0)
loginfo(_("socket %d recv, errno %d\n"), fd, errno);
int type = ly_entity_type(ent_id);
int db_id = ly_entity_db_id(ent_id);
if (type == LY_ENTITY_NODE) {
logdebug(_("update node %d status in db to offline\n"), db_id);
db_node_update_status(DB_NODE_FIND_BY_ID, &db_id, NODE_STATUS_OFFLINE);
return 1;
}
if (ly_entity_type(ent_id) != LY_ENTITY_OSM)
return 1;
logdebug(_("update instance %d status in db\n"), db_id);
InstanceInfo ii;
ii.ip = NULL;
ii.status = DOMAIN_S_NEED_QUERY;
db_instance_update_status(db_id, &ii, -1);
job_internal_query_instance(db_id);
return 1;
}
logdebug(_("socket %d recv %d bytes\n"), fd, len);
while(1) {
int ret = ly_packet_recv(pkt, len);
if (ret < 0) {
logerror(_("package recv error in %s\n"), __func__);
__print_recv_buf(buf, len);
break;
}
/* currenly we only support processing a complete packet */
if (ret == 0) {
if (pkt->pkt_buf_received > 0) {
loginfo(_("socket %d recv partial packet(len %d)\n"),
fd, pkt->pkt_buf_received);
__print_recv_buf(buf, len);
}
break;
}
int type = ly_packet_type(pkt);
loginfo(_("socket %d recv packet, type %d\n"), fd, type);
/*
if (type == PKT_TYPE_UNKNOW)
break;
*/
buf = ly_packet_data(pkt, &size);
if (type == PKT_TYPE_WEB_NEW_JOB_REQUEST) {
ly_entity_init(ent_id, LY_ENTITY_WEB);
ret = __process_web_job(buf, size, ent_id);
if (ret < 0)
logerror(_("web packet process error in %s.\n"), __func__);
}
else if (type == PKT_TYPE_NODE_REGISTER_REQUEST) {
ly_entity_init(ent_id, LY_ENTITY_NODE);
ret = eh_process_node_xml(buf, ent_id);
if (ret < 0)
logerror(_("node packet process error in %s.\n"), __func__);
}
else if (type == PKT_TYPE_NODE_AUTH_REQUEST ||
type == PKT_TYPE_NODE_AUTH_REPLY) {
ly_entity_init(ent_id, LY_ENTITY_NODE);
ret = eh_process_node_auth(type == PKT_TYPE_NODE_AUTH_REPLY ?
1 : 0, buf, ent_id);
if (ret < 0)
logerror(_("node auth packet process error in %s.\n"), __func__);
}
else if (type == PKT_TYPE_OSM_AUTH_REQUEST ||
type == PKT_TYPE_OSM_AUTH_REPLY) {
ly_entity_init(ent_id, LY_ENTITY_OSM);
ret = eh_process_osm_auth(type == PKT_TYPE_OSM_AUTH_REPLY ?
1 : 0, buf, ent_id);
if (ret < 0)
logerror(_("osm auth packet process error in %s.\n"), __func__);
}
else if (type == PKT_TYPE_CLC_OSM_QUERY_REPLY) {
ret = eh_process_osm_query(ly_packet_data(pkt, NULL));
if (ret < 0)
logerror(_("osm packet process error in %s\n"), __func__);
}
else if (PKT_TYPE_ENTITY_GROUP_CLC(type) ||
PKT_TYPE_ENTITY_GROUP_NODE(type)) {
ret = eh_process_node_xml(buf, ent_id);
if (ret < 0)
logerror(_("node packet process error in %s.\n"), __func__);
}
else if (type == PKT_TYPE_OSM_REGISTER_REQUEST) {
ly_entity_init(ent_id, LY_ENTITY_OSM);
ret = eh_process_osm_register(buf, size, ent_id);
if (ret < 0)
logerror(_("osm packet process error in %s.\n"), __func__);
}
else if (type == PKT_TYPE_OSM_REPORT) {
ret = eh_process_osm_report(buf, size, ent_id);
if (ret < 0)
logerror(_("osm packet process error in %s.\n"), __func__);
}
else if (type == PKT_TYPE_TEST_ECHO_REQUEST) {
ret = __process_test_echo(buf, size, ent_id);
if (ret < 0)
logerror(_("echo packet process error in %s.\n"), __func__);
}
else {
logerror(_("unrecognized packet type.\n"));
}
if (ly_packet_recv_done(pkt) < 0 || ret < 0) {
logerror(_("%s return error\n"), __func__);
return -1;
}
if (ret > 0)
return ret;
len = 0; /* continue processing data in buffer */
}
return 0;
}
