/**
* New Pomelo package arrived callback.
*
* @param type Pomelo package type
* @param data package body
* @param len package body length
* @param attach attach pointer pass to pc_pkg_parser_t
*/
void pc__pkg_cb(pc_pkg_type type, const char *data, size_t len, void *attach) {
pc_client_t *client = (pc_client_t *)attach;
int status = 0;
switch(type) {
case PC_PKG_HANDSHAKE:
status = pc__handshake_resp(client, data, len);
break;
case PC_PKG_HEARBEAT:
status = pc__heartbeat(client);
break;
case PC_PKG_DATA:
status = pc__data(client, data, len);
break;
case PC_PKG_KICK:
pc_emit_event(client, PC_EVENT_KICK, NULL);
break;
default:
fprintf(stderr, "Unknown Pomelo package type: %d.\n", type);
status = -1;
break;
}
if(status == -1) {
pc_client_stop(client);
}
}
void pc_client_destroy(pc_client_t *client) {
if(PC_ST_INITED == client->state) {
pc__client_clear(client);
goto finally;
}
if(PC_ST_CLOSED == client->state) {
pc__client_clear(client);
goto finally;
}
// 1. asyn worker thread
// 2. wait work thread exit
// 3. free client
uv_async_send(client->close_async);
pc_client_join(client);
if(PC_ST_CLOSED != client->state) {
pc_client_stop(client);
// wait uv_loop_t stop
sleep(1);
pc__client_clear(client);
}
finally:
if(client->uv_loop) {
uv_loop_delete(client->uv_loop);
client->uv_loop = NULL;
}
free(client);
}
void pc__client_reconnect_timer_cb(uv_timer_t* timer, int status) {
/* unused */
(void)status;
pc_client_t* client = (pc_client_t*)timer->data;
pc_connect_t* conn_req = pc_connect_req_new(&client->addr);
if (!conn_req) {
fprintf(stderr, "out of memory");
pc_client_stop(client);
}
if(pc_connect(client, conn_req, NULL, pc__client_reconnected_cb)) {
fprintf(stderr, "Fail to connect to server.\n");
pc_connect_req_destroy(conn_req);
client->reconnecting = 0;
pc_client_stop(client);
}
}
void pc__heartbeat_cb(uv_timer_t* heartbeat_timer, int status) {
uv_timer_stop(heartbeat_timer);
pc_client_t *client = (pc_client_t *)heartbeat_timer->data;
if(status == -1) {
fprintf(stderr, "Pomelo heartbeat timer error, %s\n",
uv_err_name(uv_last_error(client->uv_loop)));
pc_client_stop(client);
return;
}
if(pc__heartbeat_req(client)) {
pc_client_stop(client);
return;
}
uv_timer_again(client->timeout_timer);
}
// server push message "onHey" callback.
void on_hey(pc_client_t *client, const char *event, void *data) {
json_t *push_msg = (json_t *)data;
const char *json_str = json_dumps(push_msg, 0);
printf("on event: %s, serve push msg: %s\n", event, json_str);
free((void *)json_str);
// stop the working thread.
pc_client_stop(client);
}
static void pc__client_connect3_cb(pc_connect_t* req, int status) {
if(status == -1) {
pc_client_stop(req->client);
pc_connect_req_destroy(req);
return;
}
pc_emit_event(req->client, PC_EVENT_RECONNECT, req->client);
pc_connect_req_destroy(req);
}
void pc__client_reconnected_cb(pc_connect_t* conn_req, int status) {
pc_client_t* client = conn_req->client;
client->reconnecting = 0;
uv_timer_stop(&client->reconnect_timer);
if (status == 0) {
client->reconnects = 0;
pc_emit_event(client, PC_EVENT_RECONNECT, client);
} else {
pc_client_stop(client);
}
}
void pc__timeout_cb(uv_timer_t* timeout_timer, int status) {
uv_timer_stop(timeout_timer);
pc_client_t *client = (pc_client_t *)timeout_timer->data;
if(status == -1) {
fprintf(stderr, "Pomelo timeout timer error, %s\n",
uv_err_name(uv_last_error(client->uv_loop)));
} else {
fprintf(stderr, "Pomelo client heartbeat timeout.\n");
}
pc_client_stop(client);
}
void on_request_gate_cb(pc_request_t *req, int status, json_t *resp) {
if (status == -1) {
printf("Fail to send request to server.\n");
} else if (status == 0) {
connectorHost = json_string_value(json_object_get(resp, "host"));
connectorPort = json_number_value(json_object_get(resp, "port"));
pc_client_t *client = pc_client_new();
struct sockaddr_in address;
memset(&address, 0, sizeof(struct sockaddr_in));
address.sin_family = AF_INET;
address.sin_port = htons(connectorPort);
address.sin_addr.s_addr = inet_addr(connectorHost);
// add pomelo events listener
pc_add_listener(client, "disconnect", on_disconnect);
pc_add_listener(client, "onChat", on_chat);
pc_add_listener(client, "onAdd", on_add);
pc_add_listener(client, "onLeave", on_leave);
printf("try to connect to connector server %s %d\n", connectorHost, connectorPort);
// try to connect to server.
if (pc_client_connect(client, &address)) {
printf("fail to connect connector server.\n");
pc_client_destroy(client);
return ;
}
const char *route = "connector.entryHandler.enter";
json_t *msg = json_object();
json_t *str = json_string(user);
json_t *channel_str = json_string(channel);
json_object_set_new(msg, "username", str);
json_object_set_new(msg, "rid", channel_str);
pc_request_t *request = pc_request_new();
printf("%s %s\n", user, channel);
pc_request(client, request, route, msg, on_request_connector_cb);
}
// release relative resource with pc_request_t
json_t *pc_msg = req->msg;
pc_client_t *pc_client = req->client;
json_decref(pc_msg);
pc_request_destroy(req);
pc_client_stop(pc_client);
}
static void pc__heartbeat_req_cb(uv_write_t* req, int status) {
void **data = (void **)req->data;
pc_client_t *client = (pc_client_t *)data[0];
char *base = (char *)data[1];
free(base);
free(data);
free(req);
if(status == -1) {
fprintf(stderr, "Fail to write heartbeat async, %s.\n",
uv_err_name(uv_last_error(client->uv_loop)));
pc_client_stop(client);
}
}
// request callback
void on_request_cb(pc_request_t *req, int status, json_t *resp) {
if(status == -1) {
printf("Fail to send request to server.\n");
} else if(status == 0) {
printf("server response: %s\n", json_dumps(resp, 0));
}
// release relative resource with pc_request_t
json_t *msg = req->msg;
json_decref(msg);
pc_request_destroy(req);
count--;
if(count == 0)
pc_client_stop(req->client);
}
void on_request_cb(pc_request_t* req, int status, json_t* resp)
{
if (status == -1)
{
printf("Fail to request to server.\n");
}
else if (status == 0)
{
char * json_str = json_dumps(resp, 0);
if (json_str != NULL)
{
printf("server response:%s\n", json_str);
free(json_str);
}
}
json_t *msg = req->msg;
pc_client_t *client = req->client;
json_decref(msg);
pc_request_destroy(req);
pc_client_stop(client);
}
void NetImpl::on_request_cb( pc_request_t* __req, int __status, json_t* __resp )
{
if(__status == -1) {
printf("Fail to send request to server.\n");
} else if(__status == 0) {
char* __json_str = json_dumps(__resp, 0);
if(__json_str != NULL) {
printf("server response: %s\n", __json_str);
free(__json_str);
}
}
// release relative resource with pc_request_t
json_t*__msg = __req->msg;
pc_client_t* __client = __req->client;
json_decref(__msg);
pc_request_destroy(__req);
// stop client
pc_client_stop(__client);
}
void Login::requstGateCallback(pc_request_t *req, int status, json_t *resp)
{
if(status == -1) {
CCLOG("Fail to send request to server.\n");
} else if(status == 0) {
connectorHost = json_string_value(json_object_get(resp, "host"));
connectorPort = json_number_value(json_object_get(resp, "port"));
CCLOG("%s %d", connectorHost,connectorPort);
pc_client_t *client = pc_client_new();
struct sockaddr_in address;
memset(&address, 0, sizeof(struct sockaddr_in));
address.sin_family = AF_INET;
address.sin_port = htons(connectorPort);
address.sin_addr.s_addr = inet_addr(connectorHost);
// add pomelo events listener
void (*on_disconnect)(pc_client_t *client, const char *event, void *data) = &Login::onDisconnectCallback;
void (*on_chat)(pc_client_t *client, const char *event, void *data) = &Login::onChatCallback;
void (*on_add)(pc_client_t *client, const char *event, void *data) = &Login::onAddCallback;
void (*on_leave)(pc_client_t *client, const char *event, void *data) = &Login::onLeaveCallback;
pc_add_listener(client, "disconnect", on_disconnect);
pc_add_listener(client, "onChat", on_chat);
pc_add_listener(client, "onAdd", on_add);
pc_add_listener(client, "onLeave", on_leave);
// try to connect to server.
if(pc_client_connect(client, &address)) {
CCLOG("fail to connect server.\n");
pc_client_destroy(client);
return ;
}
const char *route = "connector.entryHandler.enter";
json_t *msg = json_object();
json_t *str = json_string(username.c_str());
json_t *channel_str = json_string(channel.c_str());
json_object_set(msg, "username", str);
json_object_set(msg, "rid", channel_str);
// decref for json object
json_decref(str);
json_decref(channel_str);
pc_request_t *request = pc_request_new();
void (*connect_cb)(pc_request_t *req, int status, json_t *resp )= &Login::requstConnectorCallback;
pc_request(client, request, route, msg, connect_cb);
/*
char *json_str = json_dumps(resp, 0);
if(json_str != NULL) {
CCLOG("server response: %s %d\n", connectorHost, connectorPort);
free(json_str);
}
*/
}
// release relative resource with pc_request_t
json_t *pc_msg = req->msg;
pc_client_t *pc_client = req->client;
json_decref(pc_msg);
pc_request_destroy(req);
pc_client_stop(pc_client);
}
