350 lines
8.8 KiB
C
350 lines
8.8 KiB
C
#include "status.h"
|
|
#include "serve.h"
|
|
#include "ioutil.h"
|
|
#include "util.h"
|
|
#include "bitset.h"
|
|
|
|
#include <check.h>
|
|
|
|
struct server *mock_server(void)
|
|
{
|
|
struct server *out = xmalloc(sizeof(struct server));
|
|
out->l_start_mirror = flexthread_mutex_create();
|
|
out->nbd_client = xmalloc(sizeof(struct client_tbl_entry) * 4);
|
|
out->max_nbd_clients = 4;
|
|
out->size = 65536;
|
|
|
|
out->allocation_map = bitset_alloc(65536, 4096);
|
|
|
|
return out;
|
|
}
|
|
|
|
struct server *mock_mirroring_server(void)
|
|
{
|
|
struct server *out = mock_server();
|
|
out->mirror = xmalloc(sizeof(struct mirror));
|
|
out->mirror_super = xmalloc(sizeof(struct mirror_super));
|
|
return out;
|
|
}
|
|
|
|
void destroy_mock_server(struct server *serve)
|
|
{
|
|
if (NULL != serve->mirror) {
|
|
free(serve->mirror);
|
|
}
|
|
|
|
if (NULL != serve->mirror_super) {
|
|
free(serve->mirror_super);
|
|
}
|
|
|
|
flexthread_mutex_destroy(serve->l_start_mirror);
|
|
|
|
bitset_free(serve->allocation_map);
|
|
free(serve->nbd_client);
|
|
free(serve);
|
|
}
|
|
|
|
START_TEST(test_status_create)
|
|
{
|
|
struct server *server = mock_server();
|
|
struct status *status = status_create(server);
|
|
|
|
fail_if(NULL == status, "Status wasn't allocated");
|
|
status_destroy(status);
|
|
destroy_mock_server(server);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_gets_has_control)
|
|
{
|
|
struct server *server = mock_server();
|
|
server->success = 1;
|
|
|
|
struct status *status = status_create(server);
|
|
|
|
fail_unless(status->has_control == 1, "has_control wasn't copied");
|
|
status_destroy(status);
|
|
destroy_mock_server(server);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_gets_is_mirroring)
|
|
{
|
|
struct server *server = mock_server();
|
|
struct status *status = status_create(server);
|
|
|
|
fail_if(status->is_mirroring, "is_mirroring was set");
|
|
status_destroy(status);
|
|
destroy_mock_server(server);
|
|
|
|
server = mock_mirroring_server();
|
|
status = status_create(server);
|
|
|
|
fail_unless(status->is_mirroring, "is_mirroring wasn't set");
|
|
status_destroy(status);
|
|
destroy_mock_server(server);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_gets_clients_allowed)
|
|
{
|
|
struct server *server = mock_server();
|
|
struct status *status = status_create(server);
|
|
|
|
fail_if(status->clients_allowed, "clients_allowed was set");
|
|
status_destroy(status);
|
|
|
|
server->allow_new_clients = 1;
|
|
status = status_create(server);
|
|
|
|
fail_unless(status->clients_allowed, "clients_allowed was not set");
|
|
status_destroy(status);
|
|
destroy_mock_server(server);
|
|
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_gets_pid)
|
|
{
|
|
struct server *server = mock_server();
|
|
struct status *status = status_create(server);
|
|
|
|
fail_unless(getpid() == status->pid, "Pid wasn't gathered");
|
|
|
|
status_destroy(status);
|
|
destroy_mock_server(server);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_gets_size)
|
|
{
|
|
struct server *server = mock_server();
|
|
server->size = 1024;
|
|
|
|
struct status *status = status_create(server);
|
|
|
|
fail_unless(1024 == status->size, "Size wasn't gathered");
|
|
|
|
status_destroy(status);
|
|
destroy_mock_server(server);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_gets_migration_statistics)
|
|
{
|
|
struct server *server = mock_mirroring_server();
|
|
server->mirror->all_dirty = 16384;
|
|
server->mirror->max_bytes_per_second = 32768;
|
|
server->mirror->offset = 0;
|
|
|
|
/* we have a bit of a time dependency here */
|
|
server->mirror->migration_started = monotonic_time_ms();
|
|
|
|
struct status *status = status_create(server);
|
|
|
|
fail_unless(0 == status->migration_duration ||
|
|
1 == status->migration_duration ||
|
|
2 == status->migration_duration,
|
|
"migration_duration is unreasonable!");
|
|
|
|
fail_unless(16384 / (status->migration_duration + 1) ==
|
|
status->migration_speed,
|
|
"migration_speed not calculated correctly");
|
|
|
|
fail_unless(32768 == status->migration_speed_limit,
|
|
"migration_speed_limit not read");
|
|
|
|
// ( size / current_bps ) + 1 happens to be 3 for this test
|
|
fail_unless(3 == status->migration_seconds_left,
|
|
"migration_seconds_left not gathered");
|
|
|
|
status_destroy(status);
|
|
destroy_mock_server(server);
|
|
}
|
|
|
|
END_TEST
|
|
#define RENDER_TEST_SETUP \
|
|
struct status status; \
|
|
int fds[2]; \
|
|
pipe( fds );
|
|
void fail_unless_rendered(int fd, char *fragment)
|
|
{
|
|
char buf[1024] = { 0 };
|
|
char emsg[1024] = { 0 };
|
|
char *found = NULL;
|
|
|
|
sprintf(emsg, "Fragment: %s not found", fragment);
|
|
|
|
fail_unless(read_until_newline(fd, buf, 1024) > 0, "Couldn't read");
|
|
found = strstr(buf, fragment);
|
|
fail_if(NULL == found, emsg);
|
|
|
|
return;
|
|
}
|
|
|
|
void fail_if_rendered(int fd, char *fragment)
|
|
{
|
|
char buf[1024] = { 0 };
|
|
char emsg[1024] = { 0 };
|
|
char *found = NULL;
|
|
|
|
sprintf(emsg, "Fragment: %s found", fragment);
|
|
|
|
fail_unless(read_until_newline(fd, buf, 1024) > 0, "Couldn't read");
|
|
found = strstr(buf, fragment);
|
|
fail_unless(NULL == found, emsg);
|
|
|
|
return;
|
|
}
|
|
|
|
START_TEST(test_renders_has_control)
|
|
{
|
|
RENDER_TEST_SETUP status.has_control = 1;
|
|
status_write(&status, fds[1]);
|
|
fail_unless_rendered(fds[0], "has_control=true");
|
|
|
|
status.has_control = 0;
|
|
status_write(&status, fds[1]);
|
|
fail_unless_rendered(fds[0], "has_control=false");
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_renders_is_mirroring)
|
|
{
|
|
RENDER_TEST_SETUP status.is_mirroring = 1;
|
|
status_write(&status, fds[1]);
|
|
fail_unless_rendered(fds[0], "is_mirroring=true");
|
|
|
|
status.is_mirroring = 0;
|
|
status_write(&status, fds[1]);
|
|
fail_unless_rendered(fds[0], "is_mirroring=false");
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_renders_clients_allowed)
|
|
{
|
|
RENDER_TEST_SETUP status.clients_allowed = 1;
|
|
status_write(&status, fds[1]);
|
|
fail_unless_rendered(fds[0], "clients_allowed=true");
|
|
|
|
status.clients_allowed = 0;
|
|
status_write(&status, fds[1]);
|
|
fail_unless_rendered(fds[0], "clients_allowed=false");
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_renders_num_clients)
|
|
{
|
|
RENDER_TEST_SETUP status.num_clients = 0;
|
|
status_write(&status, fds[1]);
|
|
fail_unless_rendered(fds[0], "num_clients=0");
|
|
|
|
status.num_clients = 4000;
|
|
status_write(&status, fds[1]);
|
|
fail_unless_rendered(fds[0], "num_clients=4000");
|
|
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_renders_pid)
|
|
{
|
|
RENDER_TEST_SETUP status.pid = 42;
|
|
status_write(&status, fds[1]);
|
|
fail_unless_rendered(fds[0], "pid=42");
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_renders_size)
|
|
{
|
|
RENDER_TEST_SETUP status.size = ((uint64_t) 1 << 33);
|
|
status_write(&status, fds[1]);
|
|
fail_unless_rendered(fds[0], "size=8589934592");
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_renders_migration_statistics)
|
|
{
|
|
RENDER_TEST_SETUP status.is_mirroring = 0;
|
|
status.migration_duration = 8;
|
|
status.migration_speed = 40000000;
|
|
status.migration_speed_limit = 40000001;
|
|
status.migration_seconds_left = 1;
|
|
status.migration_bytes_left = 5000;
|
|
|
|
status_write(&status, fds[1]);
|
|
fail_if_rendered(fds[0], "migration_duration");
|
|
|
|
status_write(&status, fds[1]);
|
|
fail_if_rendered(fds[0], "migration_speed");
|
|
|
|
status_write(&status, fds[1]);
|
|
fail_if_rendered(fds[0], "migration_speed_limit");
|
|
|
|
status_write(&status, fds[1]);
|
|
fail_if_rendered(fds[0], "migration_seconds_left");
|
|
|
|
status.is_mirroring = 1;
|
|
|
|
status_write(&status, fds[1]);
|
|
fail_unless_rendered(fds[0], "migration_duration=8");
|
|
|
|
status_write(&status, fds[1]);
|
|
fail_unless_rendered(fds[0], "migration_speed=40000000");
|
|
|
|
status_write(&status, fds[1]);
|
|
fail_unless_rendered(fds[0], "migration_speed_limit=40000001");
|
|
|
|
status_write(&status, fds[1]);
|
|
fail_unless_rendered(fds[0], "migration_seconds_left=1");
|
|
|
|
status_write(&status, fds[1]);
|
|
fail_unless_rendered(fds[0], "migration_bytes_left=5000");
|
|
|
|
status.migration_speed_limit = UINT64_MAX;
|
|
|
|
status_write(&status, fds[1]);
|
|
fail_if_rendered(fds[0], "migration_speed_limit");
|
|
}
|
|
END_TEST
|
|
|
|
Suite * status_suite(void)
|
|
{
|
|
Suite *s = suite_create("status");
|
|
TCase *tc_create = tcase_create("create");
|
|
TCase *tc_render = tcase_create("render");
|
|
|
|
tcase_add_test(tc_create, test_status_create);
|
|
tcase_add_test(tc_create, test_gets_has_control);
|
|
tcase_add_test(tc_create, test_gets_is_mirroring);
|
|
tcase_add_test(tc_create, test_gets_clients_allowed);
|
|
tcase_add_test(tc_create, test_gets_pid);
|
|
tcase_add_test(tc_create, test_gets_size);
|
|
tcase_add_test(tc_create, test_gets_migration_statistics);
|
|
|
|
|
|
tcase_add_test(tc_render, test_renders_has_control);
|
|
tcase_add_test(tc_render, test_renders_is_mirroring);
|
|
tcase_add_test(tc_render, test_renders_clients_allowed);
|
|
tcase_add_test(tc_render, test_renders_num_clients);
|
|
tcase_add_test(tc_render, test_renders_pid);
|
|
tcase_add_test(tc_render, test_renders_size);
|
|
tcase_add_test(tc_render, test_renders_migration_statistics);
|
|
|
|
suite_add_tcase(s, tc_create);
|
|
suite_add_tcase(s, tc_render);
|
|
|
|
return s;
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
int number_failed;
|
|
|
|
Suite *s = status_suite();
|
|
SRunner *sr = srunner_create(s);
|
|
srunner_run_all(sr, CK_NORMAL);
|
|
number_failed = srunner_ntests_failed(sr);
|
|
srunner_free(sr);
|
|
return (number_failed == 0) ? 0 : 1;
|
|
}
|