static int
ConnectionObject_init(ConnectionObject *self, PyObject *args, PyObject *kwargs)
{
drizzle_con_st *con;
//Not support
PyObject *ssl = NULL;
char *host = DRIZZLE_DEFAULT_TCP_HOST;
char *user = NULL, *passwd = NULL, *db = NULL, *unix_socket = NULL;
unsigned int port = 3306;
unsigned int client_flag = 0;
int connect_timeout = 0;
static char *kwlist[] = { "host", "user", "passwd", "db", "port", "unix_socket", "connect_timeout", NULL } ;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ssssisi:connect",
kwlist,
&host, &user, &passwd, &db,
&port, &unix_socket,
&connect_timeout
)){
return -1;
}
DEBUG("init %p", self);
//set NON_BLOKING
/* drizzle_add_options(self->drizzle, DRIZZLE_NON_BLOCKING); */
Py_BEGIN_ALLOW_THREADS ;
if (connect_timeout) {
drizzle_set_timeout(drizzle, connect_timeout);
DEBUG("set timeout %d", connect_timeout);
}
DEBUG("host %s", host);
DEBUG("port %d", port);
DEBUG("user %s", user);
DEBUG("passwd %s", passwd);
DEBUG("db %s", db);
if (!unix_socket) {
con = drizzle_con_add_tcp(drizzle, NULL, host, port, user, passwd, db, DRIZZLE_CON_MYSQL);
} else {
con = drizzle_con_add_uds(drizzle, NULL, unix_socket, user, passwd, db, DRIZZLE_CON_MYSQL);
}
Py_END_ALLOW_THREADS;
DEBUG("created drizzle conn %p", con);
DEBUG("connect %p", con);
if (!con) {
PyErr_SetString(PyExc_IOError, drizzle_error(drizzle));
RDEBUG("drizzle connection failed");
return -1;
}
self->con = con;
if (wait_connect(con) == -1) {
return -1;
}
return 0;
}
int main(void)
{
close(STDOUT_FILENO);
drizzle_st drizzle;
drizzle_con_st listen_con;
drizzle_con_st client;
drizzle_con_st server;
drizzle_return_t ret;
bool server_accepted = false;
server_state_st server_state;
client_state_st client_state;
drizzle_test("drizzle_create");
if (drizzle_create(&drizzle) == NULL)
{
drizzle_test_error("returned NULL");
}
drizzle_test("drizzle_con_add_tcp_listen");
if (drizzle_con_add_tcp_listen(&drizzle, &listen_con, DRIZZLE_TEST_HOST,
DRIZZLE_TEST_PORT, 1,
DRIZZLE_CON_NONE) == NULL)
{
drizzle_test_error("returned NULL");
}
drizzle_test("drizzle_con_listen");
ret= drizzle_con_listen(&listen_con);
if (ret != DRIZZLE_RETURN_OK)
{
drizzle_test_error("returned %s (%d)", drizzle_error(&drizzle), ret);
}
drizzle_test("drizzle_con_add_tcp");
if (drizzle_con_add_tcp(&drizzle, &client, DRIZZLE_TEST_HOST,
DRIZZLE_TEST_PORT, NULL, NULL, NULL,
DRIZZLE_CON_NONE) == NULL)
{
drizzle_test_error("returned NULL");
}
drizzle_test("drizzle_add_options");
drizzle_add_options(&drizzle, DRIZZLE_NON_BLOCKING);
server_state.state= SERVER_STATE_START;
client_state.state= CLIENT_STATE_START;
while (true)
{
if (server_accepted == false)
{
drizzle_test("drizzle_con_accept");
(void)drizzle_con_accept(&drizzle, &server, &ret);
if (ret == DRIZZLE_RETURN_OK)
{
server_accepted = true;
}
else if (ret == DRIZZLE_RETURN_COULD_NOT_CONNECT || ret == DRIZZLE_RETURN_NO_ACTIVE_CONNECTIONS)
{
break;
}
else if (ret != DRIZZLE_RETURN_IO_WAIT)
{
drizzle_test_error("returned %s (%s)", drizzle_error(&drizzle), drizzle_strerror(ret));
}
}
if (server_accepted)
{
_server(&server, &server_state);
}
_client(&client, &client_state);
if (server_state.state == SERVER_STATE_DONE &&
client_state.state == CLIENT_STATE_DONE)
{
break;
}
drizzle_test("drizzle_con_wait");
ret= drizzle_con_wait(&drizzle);
if (ret == DRIZZLE_RETURN_COULD_NOT_CONNECT || ret == DRIZZLE_RETURN_NO_ACTIVE_CONNECTIONS)
{
break;
}
else if (ret != DRIZZLE_RETURN_OK)
{
drizzle_test_error("returned %s (%d)", drizzle_error(&drizzle), ret);
}
}
if (server_accepted)
{
drizzle_test("drizzle_con_free");
drizzle_con_free(&server);
}
drizzle_test("drizzle_con_free");
drizzle_con_free(&client);
drizzle_test("drizzle_con_free");
drizzle_con_free(&listen_con);
drizzle_test("drizzle_free");
drizzle_free(&drizzle);
return 0;
}
int main(void)
{
close(STDOUT_FILENO);
if (getenv("TESTS_ENVIRONMENT") && strstr(getenv("TESTS_ENVIRONMENT"), "valgrind"))
{
return EXIT_SUCCESS;
}
drizzle_verbose_t verbose;
drizzle_st *drizzle;
drizzle_st drizzle_buffer;
drizzle_st *clone;
drizzle_st clone_buffer;
drizzle_con_st *con;
drizzle_con_st *listen_con;
drizzle_return_t ret;
printf("sizeof(drizzle_st) = %zu\n", sizeof(drizzle_st));
printf("sizeof(drizzle_return_t) = %zu\n", sizeof(drizzle_return_t));
printf("sizeof(drizzle_verbose_t) = %zu\n", sizeof(drizzle_verbose_t));
printf("sizeof(drizzle_options_t) = %zu\n", sizeof(drizzle_options_t));
drizzle_test("drizzle_version");
printf(" %s\n", drizzle_version());
drizzle_test("drizzle_bugreport");
printf(" %s\n", drizzle_bugreport());
drizzle_test("drizzle_verbose_name");
for (verbose= DRIZZLE_VERBOSE_NEVER; verbose <= DRIZZLE_VERBOSE_MAX;
verbose++)
{
printf(" %s\n", drizzle_verbose_name(verbose));
}
drizzle_test("drizzle_create buffer");
if ((drizzle= drizzle_create(&drizzle_buffer)) == NULL)
{
drizzle_test_error("returned NULL");
}
drizzle_test("drizzle_free buffer");
drizzle_free(drizzle);
drizzle_test("drizzle_create");
if ((drizzle= drizzle_create(NULL)) == NULL)
{
drizzle_test_error("returned NULL");
}
drizzle_test("drizzle_clone");
if ((clone= drizzle_clone(NULL, drizzle)) == NULL)
{
drizzle_test_error("drizzle_clone");
}
drizzle_test("drizzle_free");
drizzle_free(clone);
drizzle_test("drizzle_clone buffer");
if ((clone= drizzle_clone(&clone_buffer, drizzle)) == NULL)
{
drizzle_test_error("returned NULL");
}
drizzle_test("drizzle_free buffer");
drizzle_free(clone);
drizzle_test("drizzle_error");
if (strcmp(drizzle_error(drizzle), ""))
{
drizzle_test_error("error not empty");
}
drizzle_test("drizzle_errno");
if (drizzle_errno(drizzle) != 0)
{
drizzle_test_error("errno not 0");
}
drizzle_test("drizzle_error_code");
if (drizzle_error_code(drizzle) != 0)
{
drizzle_test_error("error_code not 0");
}
drizzle_test("drizzle_sqlstate");
if (strcmp(drizzle_sqlstate(drizzle), ""))
{
drizzle_test_error("sqlstate not empty");
}
/* @todo remove this option with new API. */
drizzle_remove_options(drizzle, DRIZZLE_FREE_OBJECTS);
drizzle_test("drizzle_options");
if (drizzle_options(drizzle) != DRIZZLE_ALLOCATED)
{
drizzle_test_error("expected options not set");
}
drizzle_test("drizzle_add_options");
drizzle_add_options(drizzle, DRIZZLE_NON_BLOCKING);
drizzle_test("drizzle_options");
if (drizzle_options(drizzle) != (DRIZZLE_ALLOCATED | DRIZZLE_NON_BLOCKING))
{
drizzle_test_error("expected options not set");
}
drizzle_test("drizzle_remove_options");
drizzle_remove_options(drizzle, DRIZZLE_NON_BLOCKING);
drizzle_test("drizzle_options");
if (drizzle_options(drizzle) != DRIZZLE_ALLOCATED)
{
drizzle_test_error("expected options not set");
}
drizzle_test("drizzle_set_options");
drizzle_set_options(drizzle, DRIZZLE_ALLOCATED | DRIZZLE_NON_BLOCKING);
drizzle_test("drizzle_options");
if (drizzle_options(drizzle) != (DRIZZLE_ALLOCATED | DRIZZLE_NON_BLOCKING))
{
drizzle_test_error("expected options not set");
}
drizzle_test("drizzle_set_options");
drizzle_set_options(drizzle, DRIZZLE_ALLOCATED);
drizzle_test("drizzle_options");
if (drizzle_options(drizzle) != DRIZZLE_ALLOCATED)
{
drizzle_test_error("expected options not set");
}
drizzle_test("drizzle_set_timeout");
drizzle_set_timeout(drizzle, 1234);
drizzle_test("drizzle_timeout");
if (drizzle_timeout(drizzle) != 1234)
{
drizzle_test_error("expected timeout not set");
}
drizzle_test("drizzle_set_verbose");
drizzle_set_verbose(drizzle, DRIZZLE_VERBOSE_CRAZY);
drizzle_test("drizzle_verbose");
if (drizzle_verbose(drizzle) != DRIZZLE_VERBOSE_CRAZY)
{
drizzle_test_error("expected verbose not set");
}
drizzle_test("drizzle_set_log_fn");
drizzle_set_log_fn(drizzle, _log, NULL);
drizzle_test("drizzle_set_event_watch_fn");
drizzle_set_event_watch_fn(drizzle, _event_watch, NULL);
/* Create a listening connection to verify that event_watch_fn gets called. */
listen_con= drizzle_con_create(drizzle, NULL);
assert(listen_con != NULL);
drizzle_con_set_tcp(listen_con, "localhost", DRIZZLE_TEST_PORT);
ret= drizzle_con_listen(listen_con);
assert(ret == DRIZZLE_RETURN_OK);
if (_event_watch_read_bits == 0)
{
drizzle_test_error("event_watch_fn not called to wait for connections");
}
_event_watch_read_bits= 0;
/* Attempt a non-blocking connection. */
drizzle_add_options(drizzle, DRIZZLE_NON_BLOCKING);
con= drizzle_con_add_tcp(drizzle, NULL, "localhost", DRIZZLE_TEST_PORT, "user", "pw", "db",
DRIZZLE_CON_NONE);
assert(con != NULL);
ret= drizzle_con_connect(con);
assert(ret == DRIZZLE_RETURN_IO_WAIT || ret == DRIZZLE_RETURN_COULD_NOT_CONNECT);
if (ret == DRIZZLE_RETURN_IO_WAIT && _event_watch_read_bits == 0 && _event_watch_write_bits == 0)
{
drizzle_test_error("event_watch_fn not called to wait for I/O");
}
drizzle_con_free(con);
_event_watch_read_bits= 0;
_event_watch_write_bits= 0;
drizzle_con_free(listen_con);
drizzle_test("drizzle_free");
drizzle_free(drizzle);
return 0;
}
