static void connect_done_handler(lcb_connection_t conn, lcb_error_t err) { http_provider *http = (http_provider *)conn->data; const lcb_host_t *host = lcb_connection_get_host(conn); if (err != LCB_SUCCESS) { lcb_log(LOGARGS(http, ERR), "Connection to REST API @%s:%s failed with code=0x%x", host->host, host->port, err); io_error(http, err); return; } lcb_log(LOGARGS(http, DEBUG), "Successfuly connected to REST API %s:%s", host->host, host->port); lcb_connection_reset_buffers(conn); ringbuffer_strcat(conn->output, http->request_buf); lcb_assert(conn->output->nbytes > 0); lcb_sockrw_set_want(conn, LCB_RW_EVENT, 0); lcb_sockrw_apply_want(conn); lcb_timer_rearm(http->io_timer, PROVIDER_SETTING(&http->base, config_node_timeout)); }
static void socket_connected(connmgr_request *req) { cccp_provider *cccp = req->data; lcb_connection_t conn = req->conn; struct lcb_nibufs_st nistrs; struct lcb_io_use_st use; struct negotiation_context *ctx; lcb_error_t err; free(req); cccp->cur_connreq = NULL; LOG(cccp, DEBUG, "CCCP Socket connected"); if (!conn) { mcio_error(cccp, LCB_CONNECT_ERROR); return; } lcb_connuse_easy(&use, cccp, io_read_handler, io_error_handler); lcb_connection_transfer_socket(conn, &cccp->connection, &use); conn = NULL; if (cccp->connection.protoctx) { /** Already have SASL */ if ((err = lcb_connection_reset_buffers(&cccp->connection)) != LCB_SUCCESS) { mcio_error(cccp, err); return; } request_config(cccp); return; } if (!lcb_get_nameinfo(&cccp->connection, &nistrs)) { mcio_error(cccp, LCB_EINTERNAL); return; } ctx = lcb_negotiation_create(&cccp->connection, cccp->base.parent->settings, PROVIDER_SETTING(&cccp->base, config_node_timeout), nistrs.remote, nistrs.local, &err); if (!ctx) { mcio_error(cccp, err); } ctx->complete = negotiation_done; ctx->data = cccp; cccp->connection.protoctx = ctx; cccp->connection.protoctx_dtor = (protoctx_dtor_t)lcb_negotiation_destroy; }
static void reset_stream_state(lcb_t instance) { struct lcb_http_bootstrap_st *http = &instance->bootstrap.via.http; free(http->stream.input.data); free(http->stream.chunk.data); free(http->stream.header); memset(&http->stream, 0, sizeof(http->stream)); lcb_assert(LCB_SUCCESS == lcb_connection_reset_buffers(&http->connection)); }
static void reset_stream_state(http_provider *http) { lcb_string_clear(&http->stream.chunk); lcb_string_clear(&http->stream.input); lcb_string_clear(&http->stream.header); if (http->stream.config) { lcb_clconfig_decref(http->stream.config); } http->stream.config = NULL; lcb_assert(LCB_SUCCESS == lcb_connection_reset_buffers(&http->connection)); }
/** * Schedule a connection to the server */ void lcb_server_connect(lcb_server_t *server) { lcb_connection_t conn = &server->connection; conn->on_connect_complete = lcb_server_connect_handler; conn->on_timeout = server_timeout_handler; conn->evinfo.handler = lcb_server_v0_event_handler; conn->completion.read = lcb_server_v1_read_handler; conn->completion.write = lcb_server_v1_write_handler; conn->completion.error = lcb_server_v1_error_handler; conn->timeout.usec = server->instance->config.operation_timeout; if (lcb_connection_reset_buffers(&server->connection) != LCB_SUCCESS) { lcb_error_handler(server->instance, LCB_CLIENT_ENOMEM, NULL); } lcb_connection_start(conn, LCB_CONNSTART_NOCB | LCB_CONNSTART_ASYNCERR); }
static lcb_error_t cccp_connect(lcb_t instance) { lcb_error_t rc; lcb_connection_result_t connrc; protocol_binary_request_set_cluster_config req; lcb_server_t *server = &instance->bootstrap.via.cccp.server; lcb_connection_t conn = &server->connection; rc = lcb_init_next_host(instance, 11210); if (rc != LCB_SUCCESS) { return rc; } conn->on_connect_complete = lcb_server_connect_handler; conn->on_timeout = lcb_bootstrap_timeout_handler; conn->evinfo.handler = lcb_server_v0_event_handler; conn->completion.read = lcb_server_v1_read_handler; conn->completion.write = lcb_server_v1_write_handler; conn->completion.error = lcb_server_v1_error_handler; conn->timeout.usec = instance->config.bootstrap_timeout; if (lcb_connection_reset_buffers(conn) != LCB_SUCCESS) { return LCB_CLIENT_ENOMEM; } memset(&req, 0, sizeof(req)); req.message.header.request.magic = PROTOCOL_BINARY_REQ; req.message.header.request.opcode = CMD_GET_CLUSTER_CONFIG; req.message.header.request.opaque = ++instance->seqno; lcb_server_complete_packet(server, NULL, req.bytes, sizeof(req.bytes)); instance->last_error = LCB_SUCCESS; connrc = lcb_connection_start(conn, LCB_CONNSTART_NOCB | LCB_CONNSTART_ASYNCERR); if (connrc == LCB_CONN_ERROR) { return LCB_NETWORK_ERROR; } if (instance->config.syncmode == LCB_SYNCHRONOUS) { lcb_wait(instance); } return instance->last_error; }
lcb_error_t lcb_connection_init(lcb_connection_t conn, lcb_t instance) { conn->instance = instance; conn->sockfd = INVALID_SOCKET; conn->state = LCB_CONNSTATE_UNINIT; conn->timeout.timer = instance->io->v.v0.create_timer(instance->io); if (LCB_SUCCESS != lcb_connection_reset_buffers(conn)) { lcb_connection_cleanup(conn); return LCB_CLIENT_ENOMEM; } if (conn->timeout.timer == NULL) { lcb_connection_cleanup(conn); return LCB_CLIENT_ENOMEM; } return LCB_SUCCESS; }