static int
process_message(SoupMessage *msg)
{
struct request *req;
char *data;
GTimer *timer;
gulong microsecs;
timer = g_timer_new();
g_timer_start(timer);
req = request_new(msg->request_body->data);
if (!req)
return 1;
data = request_response(req);
if (!data)
return 1;
request_destroy(req);
soup_message_set_response(msg, "application/json",
SOUP_MEMORY_TAKE, data, strlen(data));
soup_message_set_status(msg, SOUP_STATUS_OK);
g_timer_stop(timer);
g_print("Time elapsed: %f\n", g_timer_elapsed(timer, µsecs));
g_timer_destroy(timer);
return 0;
}
static command_status_t domain_export(COMMAND_ARGS)
{
xmlDocPtr doc;
request_t *req;
xmlNodePtr root;
bool request_success;
domain_record_argument_t *args;
USED(mainopts);
args = (domain_record_argument_t *) arg;
assert(NULL != args->domain);
req = request_new(REQUEST_FLAG_SIGN, HTTP_GET, NULL, error, API_BASE_URL "/domain/zone/%s/export", args->domain);
REQUEST_XML_RESPONSE_WANTED(req); // we ask XML instead of JSON else we have to parse invalid json document or to unescape characters
if ((request_success = request_execute(req, RESPONSE_XML, (void **) &doc, error))) {
if (NULL != (root = xmlDocGetRootElement(doc))) {
xmlChar *content;
content = xmlNodeGetContent(root);
puts((const char *) content);
xmlFree(content);
}
request_success = NULL != root;
xmlFreeDoc(doc);
}
request_destroy(req);
return request_success ? COMMAND_SUCCESS : COMMAND_FAILURE;
}
static void
test_teardown(void)
{
buf_destroy(&buf);
response_destroy(&rsp);
request_destroy(&req);
}
static command_status_t dnssec_status(COMMAND_ARGS)
{
request_t *req;
bool request_success;
json_document_t *doc;
domain_record_argument_t *args;
USED(mainopts);
args = (domain_record_argument_t *) arg;
assert(NULL != args->domain);
req = request_new(REQUEST_FLAG_SIGN, HTTP_GET, NULL, error, API_BASE_URL "/domain/zone/%s/dnssec", args->domain);
request_success = request_execute(req, RESPONSE_JSON, (void **) &doc, error);
request_destroy(req);
if (request_success) {
json_value_t root, v;
root = json_document_get_root(doc);
#if 0
// for translations, do not remove
_("enabled")
_("disabled")
_("enableInProgress")
_("disableInProgress")
#endif
json_object_get_property(root, "status", &v);
puts(_(json_get_string(v)));
json_document_destroy(doc);
}
return request_success ? COMMAND_SUCCESS : COMMAND_FAILURE;
}
request_t *
mock_server_receives_query (mock_server_t *server,
const char *ns,
mongoc_query_flags_t flags,
uint32_t skip,
uint32_t n_return,
const char *query_json,
const char *fields_json)
{
request_t *request;
request = mock_server_receives_request (server);
if (request && !request_matches_query (request,
ns,
flags,
skip,
n_return,
query_json,
fields_json,
false)) {
request_destroy (request);
return NULL;
}
return request;
}
request_t *
mock_server_receives_query (mock_server_t *server,
const char *ns,
mongoc_query_flags_t flags,
uint32_t skip,
uint32_t n_return,
const char *query_json,
const char *fields_json)
{
sync_queue_t *q;
request_t *request;
q = mock_server_get_queue (server);
request = (request_t *) q_get (q, server->request_timeout_msec);
if (request && !request_matches_query (request,
ns,
flags,
skip,
n_return,
query_json,
fields_json,
false)) {
request_destroy (request);
return NULL;
}
return request;
}
/**
* proposer_ack_request - Dispatch a request as a decree.
*/
int
proposer_ack_request(struct paxos_header *hdr, msgpack_object *o)
{
struct paxos_request *req;
struct paxos_acceptor *acc;
// Allocate a request and unpack into it.
req = g_malloc0(sizeof(*req));
paxos_request_unpack(req, o);
// The requester overloads ph_inst to the ID of the acceptor it believes
// to be the proposer. If the requester has a live connection to us but
// thinks that a lower-ranked acceptor is the proposer, kill them for
// having inconsistent state.
//
// It is possible that a higher-ranked acceptor is identified as the
// proposer. This should occur only in the case that we are preparing but
// have lost our connection to the true proposer; in this case we will defer
// our decree until after our prepare. If we indeed are not the proposer,
// our prepare will fail, and we will be redirected at that point.
if (hdr->ph_inum > pax->self_id) {
acc = acceptor_find(&pax->alist, req->pr_val.pv_reqid.id);
request_destroy(req);
return proposer_decree_part(acc, 1);
}
// Add it to the request cache if needed.
if (request_needs_cached(req->pr_val.pv_dkind)) {
request_insert(&pax->rcache, req);
}
return proposer_decree_request(req);
}
static command_status_t fetch_domains(domain_set_t *ds, bool force, error_t **error)
{
if (!ds->uptodate || force) {
request_t *req;
bool request_success;
json_document_t *doc;
req = request_new(REQUEST_FLAG_SIGN, HTTP_GET, NULL, error, API_BASE_URL "/domain");
request_success = request_execute(req, RESPONSE_JSON, (void **) &doc, error);
request_destroy(req);
if (request_success) {
Iterator it;
json_value_t root;
root = json_document_get_root(doc);
hashtable_clear(ds->domains);
json_array_to_iterator(&it, root);
for (iterator_first(&it); iterator_is_valid(&it); iterator_next(&it)) {
json_value_t v;
v = (json_value_t) iterator_current(&it, NULL);
hashtable_put(ds->domains, 0, json_get_string(v), domain_new(), NULL); // ds->domains has strdup as key_duper, don't need to strdup it ourself
}
iterator_close(&it);
ds->uptodate = TRUE;
json_document_destroy(doc);
} else {
return COMMAND_FAILURE;
}
}
return COMMAND_SUCCESS;
}
void request_api_deinitialize()
{
pthread_mutex_destroy(&requestStackMutexG);
while (requestStackCountG--) {
request_destroy(requestStackG[requestStackCountG]);
}
}
static bool
hangup (request_t *request,
void *ctx)
{
mock_server_hangs_up (request);
request_destroy (request);
return true;
}
static bool get_domain_records(const char *domain, domain_t **d, bool force, error_t **error)
{
domain_set_t *ds;
bool request_success;
*d = NULL;
FETCH_ACCOUNT_DOMAINS(ds);
request_success = TRUE;
// TODO: hashtable_clear((*d)->records) if force
if (!hashtable_get(ds->domains, domain, d) || !(*d)->uptodate || force) {
request_t *req;
json_document_t *doc;
if (NULL == *d) {
*d = domain_new();
hashtable_put(ds->domains, 0, domain, *d, NULL);
}
req = request_new(REQUEST_FLAG_SIGN, HTTP_GET, NULL, error, API_BASE_URL "/domain/zone/%s/record", domain);
request_success = request_execute(req, RESPONSE_JSON, (void **) &doc, error);
request_destroy(req);
// result
if (request_success) {
Iterator it;
json_value_t root;
root = json_document_get_root(doc);
json_array_to_iterator(&it, root);
for (iterator_first(&it); request_success && iterator_is_valid(&it); iterator_next(&it)) {
json_value_t v;
json_document_t *doc;
v = (json_value_t) iterator_current(&it, NULL);
req = request_new(REQUEST_FLAG_SIGN, HTTP_GET, NULL, error, API_BASE_URL "/domain/zone/%s/record/%u", domain, json_get_integer(v));
request_success = request_execute(req, RESPONSE_JSON, (void **) &doc, error);
request_destroy(req);
// result
parse_record((*d)->records, doc);
}
iterator_close(&it);
json_document_destroy(doc);
(*d)->uptodate = TRUE;
}
}
return request_success ? COMMAND_SUCCESS : COMMAND_FAILURE;
}
static void
_test_find_command (const mongoc_uri_t *uri,
mock_server_t *server,
const char *query_in,
mongoc_read_prefs_t *read_prefs,
mongoc_query_flags_t expected_find_cmd_query_flags,
const char *expected_find_cmd)
{
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_t b = BSON_INITIALIZER;
future_t *future;
request_t *request;
client = mongoc_client_new_from_uri (uri);
collection = mongoc_client_get_collection (client, "test", "test");
mongoc_collection_set_read_prefs (collection, read_prefs);
cursor = mongoc_collection_find (collection,
MONGOC_QUERY_NONE,
0,
1,
0,
tmp_bson (query_in),
NULL,
read_prefs);
future = future_cursor_next (cursor, &doc);
request = mock_server_receives_command (
server,
"test",
expected_find_cmd_query_flags,
expected_find_cmd);
mock_server_replies (request,
MONGOC_REPLY_NONE, /* flags */
0, /* cursorId */
0, /* startingFrom */
1, /* numberReturned */
"{'ok': 1,"
" 'cursor': {"
" 'id': 0,"
" 'ns': 'db.collection',"
" 'firstBatch': [{'a': 1}]}}");
/* mongoc_cursor_next returned true */
assert (future_get_bool (future));
request_destroy (request);
future_destroy (future);
mongoc_cursor_destroy (cursor);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
bson_destroy (&b);
}
/* direct connection to a secondary requires read pref primaryPreferred to
* avoid "not master" error from server */
static void
_test_op_msg_direct_connection (bool is_mongos,
test_op_msg_direct_fn_t fn,
const char *expected_cmd)
{
mock_server_t *server;
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_read_prefs_t *prefs = NULL;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_t *cmd;
future_t *future;
request_t *request;
const char *reply;
int i;
if (is_mongos) {
server = mock_mongos_new (WIRE_VERSION_OP_MSG);
} else {
server = mock_server_with_autoismaster (WIRE_VERSION_OP_MSG);
}
mock_server_auto_endsessions (server);
mock_server_run (server);
client = mongoc_client_new_from_uri (mock_server_get_uri (server));
collection = mongoc_client_get_collection (client, "db", "collection");
for (i = 0; i < 2; i++) {
if (i == 1) {
/* user-supplied read preference primary makes no difference */
prefs = mongoc_read_prefs_new (MONGOC_READ_PRIMARY);
}
cursor = fn (collection, prefs);
future = future_cursor_next (cursor, &doc);
cmd = tmp_bson (expected_cmd);
request = mock_server_receives_msg (server, 0, cmd);
reply = "{'ok': 1,"
" 'cursor': {"
" 'id': 0,"
" 'ns': 'db.collection',"
" 'firstBatch': [{'a': 1}]}}";
mock_server_replies_simple (request, reply);
BSON_ASSERT (future_get_bool (future));
future_destroy (future);
request_destroy (request);
mongoc_cursor_destroy (cursor);
mongoc_read_prefs_destroy (prefs); /* null ok */
}
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
mock_server_destroy (server);
}
static void
do_server_request(struct server *sv, int connfd)
{
int ret;
struct request *rq;
struct file_data *data;
data = file_data_init();
rq = request_init(connfd, data);
if (!rq) {
file_data_free(data);
return;
}
if(cache_active ==1){
pthread_mutex_lock( &conditionMutex);
struct hash_node *cache_stored;
cache_stored= cache_lookup(data->file_name);
if(cache_stored!=NULL){ // check if it populated in the cache{
data->file_buf = Malloc(cache_stored->data->file_size);
strncpy(data->file_buf, cache_stored->data->file_buf, cache_stored->data->file_size);
data->file_size =cache_stored->data->file_size;
}
else{
/* reads file,
* fills data->file_buf with the file contents,
* data->file_size with file size. */
pthread_mutex_unlock( &conditionMutex );
ret = request_readfile(rq);
pthread_mutex_lock( &conditionMutex );
// need to renew the cache
if(data->file_size<max_cache){
if(data->file_size <=(max_cache-cache_current_size) ){
cache_insert(data);
}
else{
cache_evict(data->file_size);
cache_insert(data);
}
}
}
pthread_mutex_unlock( &conditionMutex );
}
else{
ret = request_readfile(rq);
if (!ret)
goto out;
}
/* sends file to client */
request_sendfile(rq);
out:
request_destroy(rq);
file_data_free(data);
}
// ./ovh domain domain.ext record toto add www type CNAME
// TODO: ttl (optionnal)
static command_status_t record_add(COMMAND_ARGS)
{
bool request_success;
json_document_t *doc;
domain_record_argument_t *args;
USED(mainopts);
args = (domain_record_argument_t *) arg;
assert(NULL != args->domain);
assert(NULL != args->record);
{
json_document_t *reqdoc;
// data
{
json_value_t root;
reqdoc = json_document_new();
root = json_object();
json_object_set_property(root, "target", json_string(args->value));
json_object_set_property(root, "fieldType", json_string(domain_record_types[args->type]));
// if ('\0' != *subdomain)
json_object_set_property(root, "subDomain", json_string(args->record));
json_document_set_root(reqdoc, root);
}
// request
{
request_t *req;
req = request_new(REQUEST_FLAG_SIGN | REQUEST_FLAG_JSON, HTTP_POST, reqdoc, error, API_BASE_URL "/domain/zone/%s/record", args->domain);
request_success = request_execute(req, RESPONSE_JSON, (void **) &doc, error);
request_destroy(req);
json_document_destroy(reqdoc);
}
}
// result
if (request_success) {
domain_t *d;
ht_hash_t h;
domain_set_t *ds;
d = NULL;
ds = NULL;
account_current_get_data(MODULE_NAME, (void **) &ds);
assert(NULL != ds);
h = hashtable_hash(ds->domains, args->domain);
if (!hashtable_quick_get(ds->domains, h, args->domain, &d)) {
d = domain_new();
hashtable_quick_put(ds->domains, 0, h, args->domain, d, NULL);
}
parse_record(d->records, doc);
ask_for_refresh(RELAY_COMMAND_ARGS);
}
return request_success ? COMMAND_SUCCESS : COMMAND_FAILURE;
}
static command_status_t record_delete(COMMAND_ARGS)
{
domain_t *d;
record_t *match;
bool request_success;
domain_record_argument_t *args;
args = (domain_record_argument_t *) arg;
assert(NULL != args->domain);
assert(NULL != args->record);
if ((request_success = (COMMAND_SUCCESS == get_domain_records(args->domain, &d, FALSE, error)))) {
#if 0
// what was the goal? If true, it is more the domain which does not exist!
if (!hashtable_get(domains, argv[0], &d)) {
error_set(error, WARN, "Domain '%s' doesn't have any record named '%s'\n", argv[0], argv[3]);
return COMMAND_FAILURE;
}
#endif
{
size_t matches;
matches = find_record(d->records, args->record, &match);
switch (matches) {
case 1:
{
if (!confirm(mainopts, _("Confirm deletion of '%s.%s'"), match->name, args->domain)) {
return COMMAND_SUCCESS; // yeah, success because user canceled it
}
break;
}
case 0:
error_set(error, INFO, "No record match '%s'", args->record);
return COMMAND_SUCCESS;
default:
error_set(error, WARN, "Abort, more than one record match '%s'", args->record);
return COMMAND_FAILURE;
}
}
{
request_t *req;
// request
req = request_new(REQUEST_FLAG_SIGN, HTTP_DELETE, NULL, error, API_BASE_URL "/domain/zone/%s/record/%" PRIu32, args->domain, match->id);
request_success = request_execute(req, RESPONSE_IGNORE, NULL, error);
request_destroy(req);
// result
if (request_success) {
hashtable_quick_delete(d->records, match->id, NULL, TRUE);
ask_for_refresh(RELAY_COMMAND_ARGS);
}
}
}
return request_success ? COMMAND_SUCCESS : COMMAND_FAILURE;
}
static bool
responder (request_t *request, void *data)
{
if (!strcmp (request->command_name, "foo")) {
mock_server_replies_simple (request, "{'ok': 1}");
request_destroy (request);
return true;
}
return false;
}
/* test that we add readConcern only inside $query, not outside it too */
static void
test_mongos_read_concern (void)
{
mock_server_t *server;
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_read_prefs_t *prefs;
mongoc_cursor_t *cursor;
const bson_t *doc;
future_t *future;
request_t *request;
server = mock_mongos_new (WIRE_VERSION_READ_CONCERN);
mock_server_run (server);
client = mongoc_client_new_from_uri (mock_server_get_uri (server));
collection = mongoc_client_get_collection (client, "test", "test");
prefs = mongoc_read_prefs_new (MONGOC_READ_SECONDARY);
cursor = mongoc_collection_find_with_opts (
collection,
tmp_bson ("{'a': 1}"),
tmp_bson ("{'readConcern': {'level': 'foo'}}"),
prefs);
future = future_cursor_next (cursor, &doc);
request = mock_server_receives_command (
server,
"test",
MONGOC_QUERY_SLAVE_OK,
"{"
" '$query': {"
" 'find': 'test', 'filter': {}, 'readConcern': {'level': 'foo'}"
" },"
" '$readPreference': {"
" 'mode': 'secondary'"
" },"
" 'readConcern': {'$exists': false}"
"}");
mock_server_replies_to_find (
request, MONGOC_QUERY_SLAVE_OK, 0, 1, "db.collection", "{}", true);
/* mongoc_cursor_next returned true */
BSON_ASSERT (future_get_bool (future));
request_destroy (request);
future_destroy (future);
mongoc_cursor_destroy (cursor);
mongoc_read_prefs_destroy (prefs);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
mock_server_destroy (server);
}
request_t *mock_server_receives_kill_cursors (mock_server_t *server,
int64_t cursor_id)
{
request_t *request;
request = mock_server_receives_request (server);
if (request && !request_matches_kill_cursors (request, cursor_id)) {
request_destroy (request);
return NULL;
}
return request;
}
static void
_test_op_query (const mongoc_uri_t *uri,
mock_server_t *server,
const char *query_in,
mongoc_read_prefs_t *read_prefs,
mongoc_query_flags_t expected_query_flags,
const char *expected_query)
{
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_t b = BSON_INITIALIZER;
future_t *future;
request_t *request;
client = mongoc_client_new_from_uri (uri);
collection = mongoc_client_get_collection (client, "test", "test");
cursor = mongoc_collection_find (collection,
MONGOC_QUERY_NONE,
0,
1,
0,
tmp_bson (query_in),
NULL,
read_prefs);
future = future_cursor_next (cursor, &doc);
request = mock_server_receives_query (
server, "test.test", expected_query_flags, 0, 1, expected_query, NULL);
mock_server_replies (request,
MONGOC_REPLY_NONE, /* flags */
0, /* cursorId */
0, /* startingFrom */
1, /* numberReturned */
"{'a': 1}");
/* mongoc_cursor_next returned true */
BSON_ASSERT (future_get_bool (future));
request_destroy (request);
future_destroy (future);
mongoc_cursor_destroy (cursor);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
bson_destroy (&b);
}
static command_status_t domain_check(COMMAND_ARGS)
{
bool success;
domain_set_t *ds;
USED(arg);
USED(mainopts);
FETCH_ACCOUNT_DOMAINS(ds);
// populate
if ((success = (COMMAND_SUCCESS == fetch_domains(ds, FALSE, error)))) {
time_t now;
Iterator it;
now = time(NULL);
hashtable_to_iterator(&it, ds->domains);
for (iterator_first(&it); success && iterator_is_valid(&it); iterator_next(&it)) {
request_t *req;
json_document_t *doc;
const char *domain_name;
iterator_current(&it, (void **) &domain_name);
// request
req = request_new(REQUEST_FLAG_SIGN, HTTP_GET, NULL, error, API_BASE_URL "/domain/%s/serviceInfos", domain_name);
success = request_execute(req, RESPONSE_JSON, (void **) &doc, error);
request_destroy(req);
// response
if (success) {
time_t domain_expiration;
json_value_t root, expiration;
root = json_document_get_root(doc);
if (json_object_get_property(root, "expiration", &expiration)) {
if (date_parse_to_timestamp(json_get_string(expiration), NULL, &domain_expiration)) {
int diff_days;
diff_days = date_diff_in_days(domain_expiration, now);
if (diff_days > 0 && diff_days < 3000) {
printf("%s expires in %d days\n", domain_name, diff_days);
}
}
}
json_document_destroy(doc);
}
}
iterator_close(&it);
}
return success ? COMMAND_SUCCESS : COMMAND_FAILURE;
}
static command_status_t domain_refresh(COMMAND_ARGS)
{
request_t *req;
bool request_success;
domain_record_argument_t *args;
USED(mainopts);
args = (domain_record_argument_t *) arg;
assert(NULL != args->domain);
req = request_new(REQUEST_FLAG_SIGN, HTTP_POST, NULL, error, API_BASE_URL "/domain/zone/%s/refresh", args->domain);
request_success = request_execute(req, RESPONSE_IGNORE, NULL, error); // Response is void
request_destroy(req);
return request_success ? COMMAND_SUCCESS : COMMAND_FAILURE;
}
static void
_test_command_simple (const mongoc_uri_t *uri,
mock_server_t *server,
const char *command,
mongoc_read_prefs_t *read_prefs,
mongoc_query_flags_t expected_query_flags,
const char *expected_query)
{
mongoc_client_t *client;
mongoc_collection_t *collection;
bson_t b = BSON_INITIALIZER;
future_t *future;
request_t *request;
client = mongoc_client_new_from_uri (uri);
collection = mongoc_client_get_collection (client, "test", "test");
mongoc_collection_set_read_prefs (collection, read_prefs);
future = future_client_command_simple (client,
"test",
tmp_bson (command),
read_prefs,
NULL,
NULL);
request = mock_server_receives_command (
server,
"test",
expected_query_flags,
expected_query);
mock_server_replies (request,
MONGOC_REPLY_NONE, /* flags */
0, /* cursorId */
0, /* startingFrom */
1, /* numberReturned */
"{'ok': 1}");
/* mongoc_cursor_next returned true */
assert (future_get_bool (future));
request_destroy (request);
future_destroy (future);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
bson_destroy (&b);
}
request_t *mock_server_receives_kill_cursors (mock_server_t *server,
int64_t cursor_id)
{
sync_queue_t *q;
request_t *request;
q = mock_server_get_queue (server);
request = (request_t *) q_get (q, server->request_timeout_msec);
if (request && !request_matches_kill_cursors (request, cursor_id)) {
request_destroy (request);
return NULL;
}
return request;
}
static void
_test_op_msg (const mongoc_uri_t *uri,
mock_server_t *server,
const char *query_in,
mongoc_read_prefs_t *read_prefs,
const char *expected_op_msg)
{
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_t b = BSON_INITIALIZER;
future_t *future;
request_t *request;
client = mongoc_client_new_from_uri (uri);
collection = mongoc_client_get_collection (client, "test", "test");
cursor = mongoc_collection_find (collection,
MONGOC_QUERY_NONE,
0,
1,
0,
tmp_bson (query_in),
NULL,
read_prefs);
future = future_cursor_next (cursor, &doc);
request = mock_server_receives_msg (server, 0, tmp_bson (expected_op_msg));
mock_server_replies_simple (request,
"{'ok': 1,"
" 'cursor': {"
" 'id': 0,"
" 'ns': 'db.collection',"
" 'firstBatch': [{'a': 1}]}}");
/* mongoc_cursor_next returned true */
BSON_ASSERT (future_get_bool (future));
request_destroy (request);
future_destroy (future);
mongoc_cursor_destroy (cursor);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
bson_destroy (&b);
}
static bool
auto_ismaster (request_t *request,
void *data)
{
const char *response_json = (const char *) data;
char *quotes_replaced;
bson_t response;
bson_error_t error;
if (!request->is_command || strcasecmp (request->command_name, "ismaster")) {
return false;
}
quotes_replaced = single_quotes_to_double (response_json);
if (!bson_init_from_json (&response, quotes_replaced, -1, &error)) {
fprintf (stderr, "%s\n", error.message);
fflush (stderr);
abort ();
}
if (mock_server_get_rand_delay (request->server)) {
_mongoc_usleep ((int64_t) (rand () % 10) * 1000);
}
if (mock_server_get_verbose (request->server)) {
printf ("%5.2f %hu <- %hu \t%s\n",
mock_server_get_uptime_sec (request->server),
request->client_port,
mock_server_get_port (request->server),
quotes_replaced);
fflush (stdout);
}
mock_server_reply_simple (request->server,
request->client,
&request->request_rpc,
MONGOC_REPLY_NONE,
&response,
0);
bson_destroy (&response);
bson_free (quotes_replaced);
request_destroy (request);
return true;
}
static void request_release(Request *request)
{
pthread_mutex_lock(&requestStackMutexG);
// If the request stack is full, destroy this one
if (requestStackCountG == REQUEST_STACK_SIZE) {
pthread_mutex_unlock(&requestStackMutexG);
request_destroy(request);
}
// Else put this one at the front of the request stack; we do this because
// we want the most-recently-used curl handle to be re-used on the next
// request, to maximize our chances of re-using a TCP connection before it
// times out
else {
requestStackG[requestStackCountG++] = request;
pthread_mutex_unlock(&requestStackMutexG);
}
}
static command_status_t dnssec_enable_disable(COMMAND_ARGS)
{
request_t *req;
bool request_success;
domain_record_argument_t *args;
USED(mainopts);
args = (domain_record_argument_t *) arg;
assert(NULL != args->domain);
if (args->on_off) {
req = request_new(REQUEST_FLAG_SIGN, HTTP_POST, NULL, error, API_BASE_URL "/domain/zone/%s/dnssec", args->domain);
} else {
req = request_new(REQUEST_FLAG_SIGN, HTTP_DELETE, NULL, error, API_BASE_URL "/domain/zone/%s/dnssec", args->domain);
}
request_success = request_execute(req, RESPONSE_IGNORE, NULL, error);
request_destroy(req);
return request_success ? COMMAND_SUCCESS : COMMAND_FAILURE;
}
static void
test_exhaust (void)
{
mock_server_t *server;
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_cursor_t *cursor;
request_t *request;
future_t *future;
const bson_t *doc;
bson_error_t error;
server = mock_server_with_autoismaster (WIRE_VERSION_FIND_CMD);
mock_server_run (server);
client = mongoc_client_new_from_uri (mock_server_get_uri (server));
collection = mongoc_client_get_collection (client, "db", "collection");
cursor = mongoc_collection_find_with_opts (collection,
tmp_bson (NULL),
NULL,
tmp_bson ("{'exhaust': true}"));
future = future_cursor_next (cursor, &doc);
/* Find, getMore and killCursors commands spec: "The find command does not
* support the exhaust flag from OP_QUERY. Drivers that support exhaust MUST
* fallback to existing OP_QUERY wire protocol messages."
*/
request = mock_server_receives_request (server);
mock_server_replies_to_find (
request, MONGOC_QUERY_SLAVE_OK | MONGOC_QUERY_EXHAUST,
0, 0, "db.collection", "{}", false /* is_command */);
ASSERT (future_get_bool (future));
ASSERT_OR_PRINT (!mongoc_cursor_error (cursor, &error), error);
request_destroy (request);
future_destroy (future);
mongoc_cursor_destroy (cursor);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
mock_server_destroy (server);
}
request_t *
mock_server_receives_bulk_insert (mock_server_t *server,
const char *ns,
mongoc_insert_flags_t flags,
int n)
{
request_t *request;
request = mock_server_receives_request (server);
if (request && !request_matches_bulk_insert (request,
ns,
flags,
n)) {
request_destroy (request);
return NULL;
}
return request;
}