greg/libdb
1
0
Fork 0
mirror of https://github.com/berkeleydb/libdb.git synced 2024-11-16 17:16:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
libdb/test/c/suites/TestChannel.c
Gregory Burd eff277ac23 Release 5.2.28 on 6/10/2011
2011-09-13 13:44:24 -04:00

1265 lines
35 KiB
C
Raw Blame History

/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 2011 Oracle and/or its affiliates. All rights reserved.
*/
#include <ctype.h>
#include <stdio.h>
#include <db.h>
#include <assert.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <errno.h>
#ifndef _WIN32
#include <pthread.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/uio.h>
#endif
#include "../cutest/CuTest.h"
#include "../common/test_util.h"
#define MAX_SEGS 10
#define MAX_MSGS 10
#undef LOCK_MUTEX
#undef UNLOCK_MUTEX
#ifdef _WIN32
#define sleep(s) Sleep(1000 * (s))
typedef HANDLE mutex_t;
#define mutex_init(m) \
(((*(m) = CreateMutex(NULL, FALSE, NULL)) != NULL) ? 0 : -1)
#define mutex_lock(m) \
((WaitForSingleObject(*(m), INFINITE) == WAIT_OBJECT_0) ? \
0 : GetLastError())
#define mutex_unlock(m) (ReleaseMutex(*(m)) ? 0 : GetLastError())
#define mutex_destroy(m) (CloseHandle(*(m)) ? 0 : GetLastError())
typedef HANDLE cond_t;
#define cond_init(c) ((*(c) = CreateEvent(NULL, \
TRUE, FALSE, NULL)) == NULL ? GetLastError() : 0)
#define cond_wait(c, m) (SignalObjectAndWait(*(m), *(c), INFINITE, FALSE) == WAIT_OBJECT_0 ? \
0 : GetLastError())
#define cond_wake(c) (SetEvent(*(c)) ? 0 : GetLastError())
#else
typedef pthread_mutex_t mutex_t;
#define mutex_init(m) pthread_mutex_init((m), NULL)
#define mutex_lock(m) pthread_mutex_lock(m)
#define mutex_unlock(m) pthread_mutex_unlock(m)
#define mutex_destroy(m) pthread_mutex_destroy(m)
typedef pthread_cond_t cond_t;
#define cond_init(c) pthread_cond_init((c), NULL)
#define cond_wait(c, m) pthread_cond_wait((c), (m))
#define cond_wake(c) pthread_cond_broadcast(c)
#endif
struct channel_test_globals {
CuTest *test;
mutex_t mtx;
cond_t cond;
};
struct report {
int dbt_count;
DBT dbt[MAX_SEGS];
int msg_count;
char *msg[MAX_MSGS];
int done, ret;
};
struct reports {
mutex_t m;
int count;
struct report rpt[2];
};
struct env_info {
struct report *rpt;
struct reports *rpts;
struct channel_test_globals *g;
int startupdone;
};
struct msginfo {
DB_ENV *dbenv;
int count;
};
typedef int (*PRED) __P((void *));
static int await_condition __P((PRED, void *, long));
static int check_dbt_string __P((DBT *, const char *));
static void clear_rpt __P((DB_ENV *));
static void clear_rpt_int __P((struct report *));
static int env_done __P((void *));
static struct report *get_rpt __P((const DB_ENV *));
static int fortify __P((DB_ENV *, struct channel_test_globals *));
static int has_msgs __P((void *));
static void msg_disp __P((DB_ENV *, DB_CHANNEL *, DBT *, u_int32_t, u_int32_t));
static void msg_disp2 __P((DB_ENV *, DB_CHANNEL *, DBT *, u_int32_t, u_int32_t));
static void msg_disp3 __P((DB_ENV *, DB_CHANNEL *, DBT *, u_int32_t, u_int32_t));
static void msg_disp4 __P((DB_ENV *, DB_CHANNEL *, DBT *, u_int32_t, u_int32_t));
static void msg_disp5 __P((DB_ENV *, DB_CHANNEL *, DBT *, u_int32_t, u_int32_t));
static int mystrcmp __P((char *, const char *));
static void notify __P((DB_ENV *, u_int32_t, void *));
static int is_started __P((void *));
static void td __P((DB_ENV *));
static void test_data_init __P((DBT *, char *));
static void test_zeroes __P((DB_CHANNEL *, DB_ENV *, CuTest *));
static int two_done __P((void *));
#define LOCK_MUTEX(m) do { \
int __ret; \
__ret = mutex_lock(m); \
assert(__ret == 0); \
} while (0)
#define UNLOCK_MUTEX(m) do { \
int __ret; \
__ret = mutex_unlock(m); \
assert(__ret == 0); \
} while (0)
int TestChannelSuiteSetup(CuSuite *suite) {
return (0);
}
int TestChannelSuiteTeardown(CuSuite *suite) {
return (0);
}
int TestChannelTestSetup(CuTest *test) {
struct channel_test_globals *g;
int ret;
if ((g = calloc(1, sizeof(*g))) == NULL)
return (ENOMEM);
if ((ret = mutex_init(&g->mtx)) != 0) {
free(g);
return (ret);
}
if ((ret = cond_init(&g->cond)) != 0) {
mutex_destroy(&g->mtx);
free(g);
return (ret);
}
g->test = test;
test->context = g;
return (0);
}
int TestChannelTestTeardown(CuTest *test) {
struct channel_test_globals *g;
int ret;
g = test->context;
assert(g != NULL);
ret = mutex_destroy(&g->mtx);
free(g);
test->context = NULL;
return (ret);
}
static void
myerrcall(const DB_ENV *dbenv, const char *errpfx, const char *msg) {
struct report *rpt = get_rpt(dbenv);
assert(rpt->msg_count < MAX_MSGS);
assert((rpt->msg[rpt->msg_count++] = strdup(msg)) != NULL);
}
static int
fortify(dbenv, g)
DB_ENV *dbenv;
struct channel_test_globals *g;
{
struct report *rpt;
struct env_info *info;
if ((info = calloc(1, sizeof(*info))) == NULL)
return (ENOMEM);
if ((rpt = calloc(1, sizeof(*rpt))) == NULL) {
free(info);
return (ENOMEM);
}
info->rpt = rpt;
info->rpts = NULL;
info->g = g;
info->startupdone = 0;
dbenv->app_private = info;
return (0);
}
static int
setup(envp1, envp2, envp3, g)
DB_ENV **envp1, **envp2, **envp3;
struct channel_test_globals *g;
{
DB_ENV *dbenv1, *dbenv2, *dbenv3;
DB_SITE *dbsite;
u_int32_t flags;
int ret;
#define CHECK(call) \
do { \
if ((ret = (call)) != 0) { \
fprintf(stderr, "error %d from %s", ret, #call); \
goto err; \
} \
} while (0);
dbenv1 = dbenv2 = dbenv3 = NULL;
CHECK(db_env_create(&dbenv1, 0));
CHECK(fortify(dbenv1, g));
dbenv1->set_errpfx(dbenv1, "ENV1");
dbenv1->set_errcall(dbenv1, myerrcall);
flags = DB_INIT_REP | DB_INIT_LOG | DB_INIT_LOCK | DB_INIT_MPOOL |
DB_INIT_TXN | DB_RECOVER | DB_THREAD | DB_CREATE;
setup_envdir("DIR1", 1);
CHECK(dbenv1->open(dbenv1, "DIR1", flags, 0));
CHECK(dbenv1->rep_set_config(dbenv1, DB_REPMGR_CONF_ELECTIONS, 0));
CHECK(dbenv1->repmgr_site(dbenv1, "localhost", 6000, &dbsite, 0));
CHECK(dbsite->set_config(dbsite, DB_LOCAL_SITE, 1));
CHECK(dbsite->close(dbsite));
CHECK(dbenv1->set_event_notify(dbenv1, notify));
CHECK(dbenv1->repmgr_msg_dispatch(dbenv1, msg_disp, 0));
CHECK(dbenv1->rep_set_timeout(dbenv1,
DB_REP_CONNECTION_RETRY, 3000000));
CHECK(dbenv1->repmgr_start(dbenv1, 2, DB_REP_MASTER));
CHECK(db_env_create(&dbenv2, 0));
CHECK(fortify(dbenv2, g));
dbenv2->set_errpfx(dbenv2, "ENV2");
dbenv2->set_errcall(dbenv2, myerrcall);
setup_envdir("DIR2", 1);
CHECK(dbenv2->open(dbenv2, "DIR2", flags, 0));
CHECK(dbenv2->rep_set_config(dbenv2, DB_REPMGR_CONF_ELECTIONS, 0));
CHECK(dbenv2->repmgr_site(dbenv2, "localhost", 6001, &dbsite, 0));
CHECK(dbsite->set_config(dbsite, DB_LOCAL_SITE, 1));
CHECK(dbsite->close(dbsite));
CHECK(dbenv2->repmgr_site(dbenv2, "localhost", 6000, &dbsite, 0));
CHECK(dbsite->set_config(dbsite, DB_BOOTSTRAP_HELPER, 1));
CHECK(dbsite->close(dbsite));
CHECK(dbenv2->set_event_notify(dbenv2, notify));
CHECK(dbenv2->rep_set_timeout(dbenv2,
DB_REP_CONNECTION_RETRY, 3000000));
CHECK(dbenv2->repmgr_start(dbenv2, 2, DB_REP_CLIENT));
await_condition(is_started, dbenv2, 60);
if (!is_started(dbenv2)) {
dbenv2->errx(dbenv2, "startup done not achieved in 60 seconds");
ret = DB_TIMEOUT;
goto err;
}
CHECK(db_env_create(&dbenv3, 0));
CHECK(fortify(dbenv3, g));
dbenv3->set_errpfx(dbenv3, "ENV3");
dbenv3->set_errcall(dbenv3, myerrcall);
CHECK(dbenv3->repmgr_msg_dispatch(dbenv3, msg_disp2, 0));
setup_envdir("DIR3", 1);
CHECK(dbenv3->open(dbenv3, "DIR3", flags, 0));
CHECK(dbenv3->rep_set_config(dbenv3, DB_REPMGR_CONF_ELECTIONS, 0));
CHECK(dbenv3->repmgr_site(dbenv3, "localhost", 6002, &dbsite, 0));
CHECK(dbsite->set_config(dbsite, DB_LOCAL_SITE, 1));
CHECK(dbsite->close(dbsite));
CHECK(dbenv3->repmgr_site(dbenv3, "localhost", 6000, &dbsite, 0));
CHECK(dbsite->set_config(dbsite, DB_BOOTSTRAP_HELPER, 1));
CHECK(dbsite->close(dbsite));
CHECK(dbenv3->set_event_notify(dbenv3, notify));
CHECK(dbenv3->rep_set_timeout(dbenv3,
DB_REP_CONNECTION_RETRY, 3000000));
CHECK(dbenv3->repmgr_start(dbenv3, 2, DB_REP_CLIENT));
await_condition(is_started, dbenv3, 60);
if (!is_started(dbenv3)) {
dbenv3->errx(dbenv3, "startup done not achieved in 60 seconds");
ret = DB_TIMEOUT;
goto err;
}
*envp1 = dbenv1;
*envp2 = dbenv2;
*envp3 = dbenv3;
return (0);
err:
if (dbenv3 != NULL)
td(dbenv3);
if (dbenv2 != NULL)
td(dbenv2);
if (dbenv1 != NULL)
td(dbenv1);
return (ret);
}
static void
td(dbenv)
DB_ENV *dbenv;
{
struct env_info *info;
dbenv->set_errcall(dbenv, NULL);
dbenv->set_event_notify(dbenv, NULL);
info = dbenv->app_private;
dbenv->close(dbenv, 0);
if (info != NULL) {
clear_rpt_int(info->rpt);
free(info->rpt);
free(info);
}
}
static void
clear_rpt_int(rpt)
struct report *rpt;
{
int i;
for (i = 0; i < rpt->dbt_count; i++)
free(rpt->dbt[i].data);
rpt->dbt_count = 0;
for (i = 0; i < rpt->msg_count; i++)
free(rpt->msg[i]);
rpt->msg_count = 0;
rpt->done = 0;
}
static void
clear_rpt(dbenv)
DB_ENV *dbenv;
{
struct env_info *info;
struct report *rpt;
info = dbenv->app_private;
rpt = info->rpt;
clear_rpt_int(rpt);
}
static int
env_done(ctx)
void *ctx;
{
DB_ENV *dbenv = ctx;
struct report *rpt = get_rpt(dbenv);
return (rpt->done);
}
static void
await_done(dbenv)
DB_ENV *dbenv;
{
await_condition(env_done, dbenv, 60);
assert(env_done(dbenv));
}
static int
has_msgs(ctx)
void *ctx;
{
struct msginfo *inf = ctx;
DB_ENV *dbenv = inf->dbenv;
struct report *rpt = get_rpt(dbenv);
return (rpt->msg_count == inf->count);
}
static struct report *
get_rpt(dbenv)
const DB_ENV *dbenv;
{
struct env_info *info;
if ((info = dbenv->app_private) == NULL)
return (NULL);
return (info->rpt);
}
int TestChannelFeature(CuTest *ct) {
DB_ENV *dbenv1, *dbenv2, *dbenv3;
DB_CHANNEL *ch;
DB_REP_STAT *stats;
DB_SITE *dbsite;
DBT dbt, rdbts[10], resp;
struct channel_test_globals *g;
struct report *rpt;
struct reports rpts;
struct msginfo info;
char *p;
void *pointer, *vp, *buffer;
u_int8_t short_buf[4];
size_t sz;
int done, eid, ret;
#ifdef _WIN32
setvbuf(stdout, NULL, _IONBF, 0);
#endif
printf("this is a test for repmgr channels feature\n");
g = ct->context;
CuAssertTrue(ct, (ret = setup(&dbenv1, &dbenv2, &dbenv3, g) == 0));
/*
* For this first section, we're sending to ENV2. TODO: make that more
* clear, without duplicating the hard-coding of the port.
*/
CuAssertTrue(ct,
(ret = dbenv1->repmgr_site(dbenv1,
"localhost", 6001, &dbsite, 0)) == 0);
CuAssertTrue(ct, (ret = dbsite->get_eid(dbsite, &eid)) == 0);
CuAssertTrue(ct, (ret = dbsite->close(dbsite)) == 0);
CuAssertTrue(ct, (ret = dbenv1->repmgr_channel(dbenv1, eid, &ch, 0)) == 0);
memset(&dbt, 0, sizeof(dbt));
p = "foobar";
dbt.data = p;
dbt.size = (u_int32_t)strlen(p) + 1;
memset(&resp, 0, sizeof(resp));
resp.flags = DB_DBT_MALLOC;
printf("1. send async msg with no msg dispatch in place\n");
clear_rpt(dbenv2);
CuAssertTrue(ct, (ret = ch->send_msg(ch, &dbt, 1, 0)) == 0);
/* Wait til dbenv2 has reported 1 msg. */
info.dbenv = dbenv2;
info.count = 1;
await_condition(has_msgs, &info, 60);
rpt = get_rpt(dbenv2);
CuAssertTrue(ct, rpt->msg_count == 1);
CuAssertTrue(ct, mystrcmp(rpt->msg[0],
"No message dispatch call-back function has been configured") == 0);
printf("2. send request with no msg dispatch in place\n");
clear_rpt(dbenv2);
ret = ch->send_request(ch, &dbt, 1, &resp, 0, 0);
CuAssertTrue(ct, ret == DB_NOSERVER);
if (resp.data != NULL)
free(resp.data);
await_condition(has_msgs, &info, 60);
CuAssertTrue(ct, rpt->msg_count == 1);
CuAssertTrue(ct, mystrcmp(rpt->msg[0],
"No message dispatch call-back function has been configured") == 0);
CuAssertTrue(ct, (ret = dbenv2->repmgr_msg_dispatch(dbenv2, msg_disp, 0)) == 0);
printf("3. send request where recip forgot resp\n");
clear_rpt(dbenv2);
ret = ch->send_request(ch, &dbt, 1, &resp, 0, 0);
CuAssertTrue(ct, ret == DB_KEYEMPTY);
if (resp.data != NULL)
free(resp.data);
await_done(dbenv2);
CuAssertTrue(ct, rpt->msg_count == 1);
CuAssertTrue(ct, mystrcmp(rpt->msg[0],
"Application failed to provide a response") == 0);
printf("4. now with dispatch fn installed, send a simple async msg\n");
clear_rpt(dbenv2);
test_data_init(&dbt, "Mr. Watson -- come here -- I want to see you.");
CuAssertTrue(ct, (ret = ch->send_msg(ch, &dbt, 1, 0)) == 0);
await_done(dbenv2);
CuAssertTrue(ct, rpt->dbt_count == 1);
check_dbt_string(&rpt->dbt[0],
"Mr. Watson -- come here -- I want to see you.");
CuAssertTrue(ct, rpt->msg_count == 0);
printf("5. send a multi-seg request\n");
clear_rpt(dbenv2);
memset(&resp, 0, sizeof(resp));
resp.flags = DB_DBT_MALLOC;
test_data_init(&rdbts[0], "I wish I were a fish");
test_data_init(&rdbts[1], "I wish I were a bass");
test_data_init(&rdbts[2],
"I'd climb up on a slippery rock and slide down on my ... hands and knees");
CuAssertTrue(ct, (ret = ch->send_request(ch, rdbts, 3, &resp, 0, 0)) == 0);
check_dbt_string(&resp, "this is the answer to the request");
if (resp.data)
free(resp.data);
await_done(dbenv2);
CuAssertTrue(ct, rpt->dbt_count == 3);
check_dbt_string(&rpt->dbt[0], "I wish I were a fish");
check_dbt_string(&rpt->dbt[1], "I wish I were a bass");
check_dbt_string(&rpt->dbt[2],
"I'd climb up on a slippery rock and slide down on my ... hands and knees");
CuAssertTrue(ct, rpt->msg_count == 0);
test_zeroes(ch, dbenv2, ct);
printf("7. send request with too-small USERMEM buffer\n");
clear_rpt(dbenv2);
resp.data = short_buf;
resp.ulen = sizeof(short_buf);
resp.flags = DB_DBT_USERMEM;
CuAssertTrue(ct, (ret = ch->send_request(ch, rdbts, 3, &resp, 0, 0)) == DB_BUFFER_SMALL);
await_done(dbenv2);
CuAssertTrue(ct, rpt->msg_count == 1);
CuAssertTrue(ct, mystrcmp(rpt->msg[0],
"originator's USERMEM buffer too small") == 0);
CuAssertTrue(ct, rpt->ret == EINVAL);
#define BUFLEN 20000
buffer = malloc(BUFLEN);
if (buffer == NULL)
return (2);
resp.data = buffer;
resp.ulen = BUFLEN;
resp.flags = DB_DBT_USERMEM;
printf("8. send USERMEM request without necessary DB_MULTIPLE\n");
clear_rpt(dbenv2);
CuAssertTrue(ct, (ret = ch->send_request(ch, rdbts, 2, &resp, 0, 0)) == DB_BUFFER_SMALL);
await_done(dbenv2);
CuAssertTrue(ct, rpt->msg_count == 1);
CuAssertTrue(ct, mystrcmp(rpt->msg[0],
"originator does not accept multi-segment response") == 0);
CuAssertTrue(ct, rpt->ret == EINVAL);
printf("9. send USERMEM request with DB_MULTIPLE\n");
clear_rpt(dbenv2);
CuAssertTrue(ct, (ret = ch->send_request(ch, rdbts, 2, &resp, 0, DB_MULTIPLE)) == 0);
DB_MULTIPLE_INIT(pointer, &resp);
DB_MULTIPLE_NEXT(pointer, &resp, vp, sz);
CuAssertTrue(ct, rpt->ret == 0);
CuAssertTrue(ct, strcmp((char*)vp, "roses are red") == 0);
CuAssertTrue(ct, sz == strlen((char*)vp) + 1);
DB_MULTIPLE_NEXT(pointer, &resp, vp, sz);
CuAssertTrue(ct, strcmp((char*)vp, "violets are blue") == 0);
CuAssertTrue(ct, sz == strlen((char*)vp) + 1);
DB_MULTIPLE_NEXT(pointer, &resp, vp, sz);
CuAssertTrue(ct, pointer == NULL);
ch->close(ch, 0);
/* ------------------------------- */
CuAssertTrue(ct, (ret = dbenv2->repmgr_channel(dbenv2, DB_EID_MASTER, &ch, 0)) == 0);
CuAssertTrue(ct, (ret = dbenv1->repmgr_msg_dispatch(dbenv1, msg_disp2, 0)) == 0);
// do a request to master
// switch masters
// do a request to new master
printf("(now we try a couple of operations on a master channel)\n");
printf("10. send request to original master\n");
rpt = get_rpt(dbenv1);
clear_rpt(dbenv1);
resp.data = buffer;
resp.ulen = BUFLEN;
resp.flags = DB_DBT_USERMEM;
CuAssertTrue(ct, (ret = ch->send_request(ch, rdbts, 1, &resp, 0, 0)) == 0);
check_dbt_string(&resp, "ENV1");
await_done(dbenv1);
CuAssertTrue(ct, rpt->ret == 0);
CuAssertTrue(ct, rpt->dbt_count == 1);
check_dbt_string(&rpt->dbt[0], "I wish I were a fish");
printf("switch master and wait for our client to see the change\n");
((struct env_info *)dbenv2->app_private)->startupdone = 0;
CuAssertTrue(ct, (ret = dbenv1->repmgr_start(dbenv1, 0, DB_REP_CLIENT)) == 0);
sleep(1); /* workaround for 19329 */
for (done = 0; ; ) {
/*
* Become master, and then make sure it really happened.
* Occasionally a race develops, where we're still holding on to
* the msg lockout at env3 at this point, in which case the
* rep_start() call (underlying our repmgr_start() call here) is
* simply dropped on the floor.
*/
CuAssertTrue(ct, (ret = dbenv3->repmgr_start(dbenv3,
0, DB_REP_MASTER)) == 0);
CuAssertTrue(ct, (ret = dbenv3->rep_stat(dbenv3,
&stats, 0)) == 0);
done = stats->st_status == DB_REP_MASTER;
free(stats);
if (done)
break;
sleep(1);
};
/*
* !!!
* Workaround for 19297: wait until verify dance is complete at env2,
* because (just a little bit) later we're going to switch master again,
* to env2. If rep_start(MASTER) at env2 happens while processing
* VERIFY match record, core rep ignores the rep_start() (even though it
* returns 0).
*/
LOCK_MUTEX(&g->mtx);
while (!((struct env_info *)dbenv2->app_private)->startupdone) {
cond_wait(&g->cond, &g->mtx);
}
// TODO: fix these macros so that this ridiculous hack isn't necessary
#ifndef _WIN32
UNLOCK_MUTEX(&g->mtx);
#endif
printf("11. send request which should go to new master (only)\n");
clear_rpt(dbenv1);
clear_rpt(dbenv3);
CuAssertTrue(ct, (ret = ch->send_request(ch, rdbts, 1, &resp, 0, 0)) == 0);
check_dbt_string(&resp, "ENV3");
rpt = get_rpt(dbenv3);
await_done(dbenv3);
CuAssertTrue(ct, rpt->ret == 0);
CuAssertTrue(ct, rpt->dbt_count == 1);
check_dbt_string(&rpt->dbt[0], "I wish I were a fish");
rpt = get_rpt(dbenv1);
CuAssertTrue(ct, !rpt->done); /* old master shouldn't have recvd anything */
printf("switch master again, to ``self''\n");
CuAssertTrue(ct, (ret = dbenv3->repmgr_start(dbenv3, 0, DB_REP_CLIENT)) == 0);
CuAssertTrue(ct, (ret = dbenv2->repmgr_start(dbenv2, 0, DB_REP_MASTER)) == 0);
/* No need to wait for env2 to see that env2 has become master. */
clear_rpt(dbenv1);
clear_rpt(dbenv2);
clear_rpt(dbenv3);
printf("12. send to self, async\n");
CuAssertTrue(ct, (ret = ch->send_msg(ch, &dbt, 1, 0)) == 0);
await_done(dbenv2);
rpt = get_rpt(dbenv2);
CuAssertTrue(ct, rpt->dbt_count == 1);
check_dbt_string(&rpt->dbt[0],
"Mr. Watson -- come here -- I want to see you.");
CuAssertTrue(ct, rpt->msg_count == 0);
printf(" (check that other two sites didn't receive it)\n");
sleep(1);
CuAssertTrue(ct, !get_rpt(dbenv1)->done);
CuAssertTrue(ct, !get_rpt(dbenv3)->done);
printf("13. send-to-self request\n");
clear_rpt(dbenv2);
CuAssertTrue(ct, (ret = ch->send_request(ch, rdbts, 2, &resp, 0, DB_MULTIPLE)) == 0);
DB_MULTIPLE_INIT(pointer, &resp);
DB_MULTIPLE_NEXT(pointer, &resp, vp, sz);
CuAssertTrue(ct, rpt->ret == 0);
CuAssertTrue(ct, strcmp((char*)vp, "roses are red") == 0);
CuAssertTrue(ct, sz == strlen((char*)vp) + 1);
DB_MULTIPLE_NEXT(pointer, &resp, vp, sz);
CuAssertTrue(ct, strcmp((char*)vp, "violets are blue") == 0);
CuAssertTrue(ct, sz == strlen((char*)vp) + 1);
DB_MULTIPLE_NEXT(pointer, &resp, vp, sz);
CuAssertTrue(ct, pointer == NULL);
/*
* re-test the 0-length cases, in the send-to-self context (the
* implementation has a bunch of separate code)
*/
test_zeroes(ch, dbenv2, ct);
ch->close(ch, 0);
/* ---------------------------------------- */
// If you go from env2 to env, we know that it's port 6000. TODO: make this
// more robust by storing it some more structured form.
//
CuAssertTrue(ct, (ret = dbenv1->repmgr_msg_dispatch(dbenv1, msg_disp3, 0)) == 0);
CuAssertTrue(ct,
(ret = dbenv2->repmgr_site(dbenv2,
"localhost", 6000, &dbsite, 0)) == 0);
CuAssertTrue(ct, (ret = dbsite->get_eid(dbsite, &eid)) == 0);
CuAssertTrue(ct, (ret = dbsite->close(dbsite)) == 0);
CuAssertTrue(ct, (ret = dbenv2->repmgr_channel(dbenv2, eid, &ch, 0)) == 0);
printf("14. send request to site that has been shut down\n");
td(dbenv1);
memset(&resp, 0, sizeof(resp));
resp.flags = DB_DBT_MALLOC;
CuAssertTrue(ct, (ret = ch->send_request(ch, rdbts, 2, &resp, 0, 0)) ==
DB_REP_UNAVAIL);
if (resp.data != NULL)
free(resp.data);
// TODO: a much more interesting case is to have the remote site shut
// down while waiting for the response, because that exercises some
// clean-up code. But I guess that requires running in a couple of
// threads.
ch->close(ch, 0);
printf("15. try to connect to a down site\n");
CuAssertTrue(ct, (ret = dbenv2->repmgr_channel(dbenv2, eid, &ch, 0)) == DB_REP_UNAVAIL);
printf("16. try to connect to a non-existent EID\n");
CuAssertTrue(ct, (ret = dbenv2->repmgr_channel(dbenv2, 1732, &ch, 0)) == EINVAL);
printf("17. connect master to self from the start\n");
CuAssertTrue(ct, (ret = dbenv2->repmgr_channel(dbenv2, DB_EID_MASTER, &ch, 0)) == 0);
CuAssertTrue(ct, (ret = dbenv2->repmgr_msg_dispatch(dbenv2, msg_disp2, 0)) == 0);
rpt = get_rpt(dbenv2);
clear_rpt(dbenv2);
resp.data = buffer;
resp.ulen = BUFLEN;
resp.flags = DB_DBT_USERMEM;
CuAssertTrue(ct, (ret = ch->send_request(ch, rdbts, 1, &resp, 0, 0)) == 0);
check_dbt_string(&resp, "ENV2");
await_done(dbenv2);
CuAssertTrue(ct, rpt->ret == 0);
CuAssertTrue(ct, rpt->dbt_count == 1);
check_dbt_string(&rpt->dbt[0], "I wish I were a fish");
ch->close(ch, 0);
/*
* Send an async message from env2 to env3, at which point env3 will
* reply by returning two async messages back to env2.
*/
printf("18. test async replies to (async) messages\n");
CuAssertTrue(ct, (ret = dbenv3->repmgr_msg_dispatch(dbenv3, msg_disp3, 0)) == 0);
CuAssertTrue(ct, (ret = dbenv2->repmgr_msg_dispatch(dbenv2, msg_disp4, 0)) == 0);
CuAssertTrue(ct,
(ret = dbenv2->repmgr_site(dbenv2,
"localhost", 6002, &dbsite, 0)) == 0);
CuAssertTrue(ct, (ret = dbsite->get_eid(dbsite, &eid)) == 0);
CuAssertTrue(ct, (ret = dbsite->close(dbsite)) == 0);
CuAssertTrue(ct, (ret = dbenv2->repmgr_channel(dbenv2, eid, &ch, 0)) == 0);
rpt = get_rpt(dbenv3);
clear_rpt(dbenv3);
((struct env_info *)dbenv2->app_private)->rpts = &rpts;
memset(&rpts, 0, sizeof(rpts));
mutex_init(&rpts.m);
CuAssertTrue(ct, (ret = ch->send_msg(ch, rdbts, 1, 0)) == 0);
await_done(dbenv3);
CuAssertTrue(ct, rpt->ret == 0);
CuAssertTrue(ct, rpt->dbt_count == 1);
check_dbt_string(&rpt->dbt[0], "I wish I were a fish");
CuAssertTrue(ct, await_condition(two_done, dbenv2, 10));
CuAssertTrue(ct, rpts.rpt[0].done);
CuAssertTrue(ct, rpts.rpt[0].dbt_count == 1);
check_dbt_string(&rpts.rpt[0].dbt[0], "roses may be pink");
CuAssertTrue(ct, rpts.rpt[1].done);
CuAssertTrue(ct, rpts.rpt[1].dbt_count == 1);
check_dbt_string(&rpts.rpt[1].dbt[0], "I think");
clear_rpt_int(&rpts.rpt[0]);
clear_rpt_int(&rpts.rpt[1]);
ch->close(ch, 0);
sleep(1); /* wait for "EOF on connection" msg before cleaning, below */
// This kluge disappears when GM fixes that err msg to become an event
printf("19. test illegal calls from the msg disp function\n");
clear_rpt(dbenv3);
CuAssertTrue(ct, (ret = dbenv3->repmgr_msg_dispatch(dbenv3, msg_disp5, 0)) == 0);
CuAssertTrue(ct, (ret = dbenv2->repmgr_channel(dbenv2, eid, &ch, 0)) == 0);
CuAssertTrue(ct, (ret = ch->send_request(ch, rdbts, 1, &resp, 0, 0)) == 0);
await_done(dbenv3);
rpt = get_rpt(dbenv3);
CuAssertTrue(ct, rpt->ret == EINVAL);
CuAssertTrue(ct, rpt->msg_count == 3);
CuAssertTrue(ct, mystrcmp(rpt->msg[0],
"set_timeout() invalid on DB_CHANNEL supplied to msg dispatch function") == 0);
CuAssertTrue(ct, mystrcmp(rpt->msg[1],
"close() invalid on DB_CHANNEL supplied to msg dispatch function") == 0);
CuAssertTrue(ct, mystrcmp(rpt->msg[2],
"send_request() invalid on DB_CHANNEL supplied to msg dispatch function") == 0);
ch->close(ch, 0);
free(buffer);
td(dbenv2);
td(dbenv3);
return (0);
}
static int
two_done(ctx)
void *ctx;
{
DB_ENV *dbenv = ctx;
struct reports *rpts = ((struct env_info *)dbenv->app_private)->rpts;
return (rpts->count == 2 && rpts->rpt[0].done && rpts->rpt[1].done);
}
/* return 1 ("true") for a match, 0 ("false") otherwise */
static int
check_dbt_string(dbt, s)
DBT *dbt;
const char *s;
{
if (dbt->size != strlen(s))
return (0);
if (dbt->size == 0)
return (1);
return (strcmp((char*)dbt->data, s) == 0);
}
static int
is_started(ctx)
void *ctx;
{
DB_ENV *dbenv = ctx;
DB_REP_STAT *st;
u_int32_t ans;
int ret;
if ((ret = dbenv->rep_stat(dbenv, &st, 0)) != 0) {
dbenv->err(dbenv, ret, "rep_stat");
return (0);
}
ans = st->st_startup_complete;
free(st);
return (ans);
}
static int
await_condition(pred, ctx, limit)
PRED pred;
void *ctx;
long limit;
{
#ifndef _WIN32
struct timeval t;
#endif
time_t tim;
tim = time(NULL) + limit;
while (time(NULL) < tim) {
if ((*pred)(ctx))
return (1);
// sleep 1/10th of a second at a time
// (maybe Windows can use select() too, if include Winsock2.h)
#ifdef _WIN32
Sleep(100);
#else
t.tv_sec = 0;
t.tv_usec = 100000;
select(0, NULL, NULL, NULL, &t);
#endif
}
return (0);
}
static void
notify(dbenv, event, unused)
DB_ENV *dbenv;
u_int32_t event;
void *unused;
{
struct channel_test_globals *g;
struct env_info *info;
if (event == DB_EVENT_PANIC) {
fprintf(stderr, "BDB panic");
abort();
} else if (event == DB_EVENT_REP_STARTUPDONE) {
info = dbenv->app_private;
g = info->g;
LOCK_MUTEX(&g->mtx);
info->startupdone = 1;
cond_wake(&g->cond);
UNLOCK_MUTEX(&g->mtx);
}
}
static void
msg_disp(dbenv, ch, request, nseg, flags)
DB_ENV *dbenv;
DB_CHANNEL *ch;
DBT *request;
u_int32_t nseg;
u_int32_t flags;
{
CuTest *ct;
struct report *rpt = get_rpt(dbenv);
DBT answer, mult[3];
char *p;
size_t sz;
u_int32_t i;
int ret;
ct = ((struct env_info *)dbenv->app_private)->g->test;
CuAssertTrue(ct, nseg < MAX_SEGS);
for (i = 0; i < nseg; i++) {
if ((sz = (rpt->dbt[rpt->dbt_count].size = request[i].size)) > 0) {
CuAssertTrue(ct, (rpt->dbt[rpt->dbt_count].data = malloc(sz)) != NULL);
memcpy(rpt->dbt[rpt->dbt_count].data,
request[i].data, sz);
} else
rpt->dbt[rpt->dbt_count].data = NULL;
rpt->dbt_count++;
}
ret = 0;
if (flags & DB_REPMGR_NEED_RESPONSE) {
if (nseg == 2) {
/* Try a multi-segment response. */
memset(&mult, 0, sizeof(mult));
p = "roses are red";
mult[0].data = p;
mult[0].size = (u_int32_t)strlen(p) + 1;
p = "violets are blue";
mult[1].data = p;
mult[1].size = (u_int32_t)strlen(p) + 1;
ret = ch->send_msg(ch, &mult[0], 2, 0);
} else if (nseg == 1) {
// pretend to ``forget'' to respond
} else if (nseg == 4) {
// send a response of zero segments
ret = ch->send_msg(ch, &answer, 0, 0);
} else if (nseg == 5) {
// send a response with a segment of zero length
memset(&answer, 0, sizeof(answer));
answer.size = 0;
ret = ch->send_msg(ch, &answer, 1, 0);
// TODO: we still need to try this with the DB_MULTIPLE approach too
} else if (nseg == 6) {
// patience, ...
/* Try a multi-segment response. */
memset(&mult, 0, sizeof(mult));
p = "roses are red";
mult[0].data = p;
mult[0].size = (u_int32_t)strlen(p) + 1;
p = "violets are blue";
mult[1].size = 0;
mult[2].data = p;
mult[2].size = (u_int32_t)strlen(p) + 1;
ret = ch->send_msg(ch, &mult[0], 3, 0);
} else {
memset(&answer, 0, sizeof(answer));
p = "this is the answer to the request";
answer.data = p;
answer.size = (u_int32_t)strlen(p) + 1;
ret = ch->send_msg(ch, &answer, 1, 0);
}
}
rpt->ret = ret;
rpt->done = 1;
}
static void
msg_disp2(dbenv, ch, request, nseg, flags)
DB_ENV *dbenv;
DB_CHANNEL *ch;
DBT *request;
u_int32_t nseg;
u_int32_t flags;
{
CuTest *ct;
struct report *rpt = get_rpt(dbenv);
DBT answer;
const char *p;
char buf[100];
size_t sz;
u_int32_t i;
int ret;
ct = ((struct env_info *)dbenv->app_private)->g->test;
CuAssertTrue(ct, nseg < MAX_SEGS);
for (i = 0; i < nseg; i++) {
if ((sz = (rpt->dbt[rpt->dbt_count].size = request[i].size)) > 0) {
CuAssertTrue(ct, (rpt->dbt[rpt->dbt_count].data = malloc(sz)) != NULL);
memcpy(rpt->dbt[rpt->dbt_count].data,
request[i].data, sz);
} else
rpt->dbt[rpt->dbt_count].data = NULL;
rpt->dbt_count++;
}
if (flags & DB_REPMGR_NEED_RESPONSE) {
memset(&answer, 0, sizeof(answer));
dbenv->get_errpfx(dbenv, &p);
strncpy(buf, p, sizeof(buf));
answer.data = buf;
answer.size = (u_int32_t)strlen(p) + 1;
if (answer.size > sizeof(buf))
answer.size = sizeof(buf);
ret = ch->send_msg(ch, &answer, 1, 0);
}
rpt->ret = ret;
rpt->done = 1;
}
/* Test async replies to (async) messages. */
static void
msg_disp3(dbenv, ch, request, nseg, flags)
DB_ENV *dbenv;
DB_CHANNEL *ch;
DBT *request;
u_int32_t nseg;
u_int32_t flags;
{
CuTest *ct;
struct report *rpt = get_rpt(dbenv);
DBT answer;
char *p;
size_t sz;
u_int32_t i;
int ret;
ct = ((struct env_info *)dbenv->app_private)->g->test;
CuAssertTrue(ct, nseg < MAX_SEGS);
for (i = 0; i < nseg; i++) {
if ((sz = (rpt->dbt[rpt->dbt_count].size = request[i].size)) > 0) {
CuAssertTrue(ct, (rpt->dbt[rpt->dbt_count].data = malloc(sz)) != NULL);
memcpy(rpt->dbt[rpt->dbt_count].data,
request[i].data, sz);
} else
rpt->dbt[rpt->dbt_count].data = NULL;
rpt->dbt_count++;
}
ret = 0;
// TODO: test that multiple calls to send_msg are not allowed on a request.
CuAssertTrue(ct, !(flags & DB_REPMGR_NEED_RESPONSE));
memset(&answer, 0, sizeof(answer));
p = "roses may be pink";
answer.data = p;
answer.size = (u_int32_t)strlen(p) + 1;
ret = ch->send_msg(ch, &answer, 1, 0);
if (ret == 0) {
p = "I think";
answer.data = p;
answer.size = (u_int32_t)strlen(p) + 1;
ret = ch->send_msg(ch, &answer, 1, 0);
}
rpt->ret = ret;
rpt->done = 1;
}
static void
msg_disp4(dbenv, ch, request, nseg, flags)
DB_ENV *dbenv;
DB_CHANNEL *ch;
DBT *request;
u_int32_t nseg;
u_int32_t flags;
{
CuTest *ct;
struct reports *rpts = ((struct env_info *)dbenv->app_private)->rpts;
struct report *rpt;
size_t sz;
u_int32_t i;
ct = ((struct env_info *)dbenv->app_private)->g->test;
LOCK_MUTEX(&rpts->m);
rpt = &rpts->rpt[rpts->count++];
UNLOCK_MUTEX(&rpts->m);
CuAssertTrue(ct, !(flags & DB_REPMGR_NEED_RESPONSE));
CuAssertTrue(ct, nseg < MAX_SEGS);
for (i = 0; i < nseg; i++) {
if ((sz = (rpt->dbt[rpt->dbt_count].size = request[i].size)) > 0) {
CuAssertTrue(ct, (rpt->dbt[rpt->dbt_count].data = malloc(sz)) != NULL);
memcpy(rpt->dbt[rpt->dbt_count].data,
request[i].data, sz);
} else
rpt->dbt[rpt->dbt_count].data = NULL;
rpt->dbt_count++;
}
rpt->done = 1;
}
static void
msg_disp5(dbenv, ch, request, nseg, flags)
DB_ENV *dbenv;
DB_CHANNEL *ch;
DBT *request;
u_int32_t nseg;
u_int32_t flags;
{
struct report *rpt = get_rpt(dbenv);
DBT answer;
u_int8_t buf[100];
char *p;
int ret;
memset(&answer, 0, sizeof(answer));
answer.flags = DB_DBT_USERMEM;
answer.ulen = sizeof(buf);
answer.data = buf;
if ((ret = ch->set_timeout(ch, 45000000)) != EINVAL ||
(ret = ch->close(ch, 0)) != EINVAL)
rpt->ret = ret;
else
rpt->ret = ch->send_request(ch, request, nseg, &answer, 0, 0);
memset(&answer, 0, sizeof(answer));
p = "roses may be pink";
answer.data = p;
answer.size = (u_int32_t)strlen(p) + 1;
ret = ch->send_msg(ch, &answer, 1, 0);
rpt->done = 1;
}
static void
test_data_init(dbt, data)
DBT *dbt;
char *data;
{
memset(dbt, 0, sizeof(*dbt));
dbt->data = data;
dbt->size = (u_int32_t)strlen(data) + 1;
}
static void
test_zeroes(ch, dest, ct)
DB_CHANNEL *ch;
DB_ENV *dest; /* destination env handle */
CuTest *ct;
{
DBT resp;
DBT rdbts[6];
struct report *rpt;
void *pointer, *vp;
size_t sz;
int i, ret;
memset(&resp, 0, sizeof(resp));
resp.flags = DB_DBT_MALLOC;
#define DATA0 "Dear kindly judge, your honor"
#define DATA1 "my parents treat me rough"
#define DATA2 "with all their marijuana"
#define DATA3 "they won't give me a puff"
#define DATA4 "The didn't wanna have me, but somehow I was had"
#define DATA5 "Leapin' lizards, that's why I'm so bad!"
#undef ADD_TEST_DATA
#define ADD_TEST_DATA(x) do { test_data_init(&rdbts[i++], (x)); } while (0);
i = 0;
ADD_TEST_DATA(DATA0);
ADD_TEST_DATA(DATA1);
ADD_TEST_DATA(DATA2);
ADD_TEST_DATA(DATA3);
ADD_TEST_DATA(DATA4);
ADD_TEST_DATA(DATA5);
rpt = get_rpt(dest);
printf("6. send zero-segment request\n");
clear_rpt(dest);
CuAssertTrue(ct, (ret = ch->send_request(ch, rdbts, 0, &resp, 0, 0)) == 0);
CuAssertTrue(ct, rpt->dbt_count == 0);
CuAssertTrue(ct, rpt->msg_count == 0);
check_dbt_string(&resp, "this is the answer to the request");
if (resp.data)
free(resp.data);
printf("6.a) send request with a zero-length segment (now why would anyone want to do that?)\n");
clear_rpt(dest);
rdbts[1].size = 0;
CuAssertTrue(ct, (ret = ch->send_request(ch, rdbts, 3, &resp, 0, 0)) == 0);
await_done(dest);
CuAssertTrue(ct, rpt->dbt_count == 3);
check_dbt_string(&rpt->dbt[0], DATA0);
check_dbt_string(&rpt->dbt[1], "");
check_dbt_string(&rpt->dbt[2], DATA2);
CuAssertTrue(ct, rpt->msg_count == 0);
check_dbt_string(&resp, "this is the answer to the request");
if (resp.data)
free(resp.data);
i = 1; ADD_TEST_DATA(DATA1); /* restore perturbed test data */
printf("6.b) get a zero-length response\n");
clear_rpt(dest);
CuAssertTrue(ct, (ret = ch->send_request(ch, rdbts, 4, &resp, 0, 0)) == 0);
await_done(dest);
CuAssertTrue(ct, rpt->dbt_count == 4);
CuAssertTrue(ct, rpt->msg_count == 0);
CuAssertTrue(ct, rpt->ret == 0);
CuAssertTrue(ct, resp.size == 0);
if (resp.data)
free(resp.data);
printf("6.c) get a zero-length response (alternate version)\n");
clear_rpt(dest);
CuAssertTrue(ct, (ret = ch->send_request(ch, rdbts, 5, &resp, 0, 0)) == 0);
await_done(dest);
CuAssertTrue(ct, rpt->dbt_count == 5);
CuAssertTrue(ct, rpt->msg_count == 0);
CuAssertTrue(ct, rpt->ret == 0);
CuAssertTrue(ct, resp.size == 0);
if (resp.data)
free(resp.data);
printf("6.d) get a zero-length response (DB_MULTIPLE, zero segments)\n");
clear_rpt(dest);
CuAssertTrue(ct, (ret = ch->send_request(ch, rdbts, 4, &resp, 0, DB_MULTIPLE)) == 0);
await_done(dest);
CuAssertTrue(ct, rpt->msg_count == 0);
CuAssertTrue(ct, rpt->ret == 0);
DB_MULTIPLE_INIT(pointer, &resp);
DB_MULTIPLE_NEXT(pointer, &resp, vp, sz);
CuAssertTrue(ct, pointer == NULL);
if (resp.data)
free(resp.data);
printf("6.e) get a zero-length response (DB_MULTIPLE, a zero-length segment)\n");
clear_rpt(dest);
CuAssertTrue(ct, (ret = ch->send_request(ch, rdbts, 5, &resp, 0, DB_MULTIPLE)) == 0);
await_done(dest);
CuAssertTrue(ct, rpt->msg_count == 0);
CuAssertTrue(ct, rpt->ret == 0);
DB_MULTIPLE_INIT(pointer, &resp);
DB_MULTIPLE_NEXT(pointer, &resp, vp, sz);
CuAssertTrue(ct, sz == 0);
DB_MULTIPLE_NEXT(pointer, &resp, vp, sz);
CuAssertTrue(ct, pointer == NULL);
if (resp.data)
free(resp.data);
printf("6.f) get a zero-length response (DB_MULTIPLE, a zero-length segment in the middle)\n");
clear_rpt(dest);
CuAssertTrue(ct, (ret = ch->send_request(ch, rdbts, 6, &resp, 0, DB_MULTIPLE)) == 0);
await_done(dest);
CuAssertTrue(ct, rpt->msg_count == 0);
CuAssertTrue(ct, rpt->ret == 0);
DB_MULTIPLE_INIT(pointer, &resp);
DB_MULTIPLE_NEXT(pointer, &resp, vp, sz);
CuAssertTrue(ct, rpt->ret == 0);
CuAssertTrue(ct, strcmp((char*)vp, "roses are red") == 0);
CuAssertTrue(ct, sz == strlen((char*)vp) + 1);
DB_MULTIPLE_NEXT(pointer, &resp, vp, sz);
CuAssertTrue(ct, sz == 0);
DB_MULTIPLE_NEXT(pointer, &resp, vp, sz);
CuAssertTrue(ct, strcmp((char*)vp, "violets are blue") == 0);
CuAssertTrue(ct, sz == strlen((char*)vp) + 1);
DB_MULTIPLE_NEXT(pointer, &resp, vp, sz);
CuAssertTrue(ct, pointer == NULL);
if (resp.data)
free(resp.data);
}
/*
* Compare, but skip over BDB error msg number at beginning of `actual'.
*/
static int
mystrcmp(actual, expected)
char *actual;
const char *expected;
{
char *p;
for (p = actual; *p != '\0' && !isspace(*p); p++)
;
for (; *p != '\0' && isspace(*p); p++)
;
return (strcmp(p, expected));
}
Reference in a new issue View git blame Copy permalink