Array HHVM_METHOD(MongoDBDriverWriteConcern, __debugInfo)
{
MongoDBDriverWriteConcernData* data = Native::data<MongoDBDriverWriteConcernData>(this_);
const char *wtag = mongoc_write_concern_get_wtag(data->m_write_concern);
const int32_t w = mongoc_write_concern_get_w(data->m_write_concern);
Array retval = Array::Create();
if (wtag) {
retval.set(s_MongoDriverWriteConcern_w, (char*)wtag);
} else if (mongoc_write_concern_get_wmajority(data->m_write_concern)) {
retval.set(s_MongoDriverWriteConcern_w, "majority");
} else if (w != MONGOC_WRITE_CONCERN_W_DEFAULT) {
retval.set(s_MongoDriverWriteConcern_w, w);
}
retval.set(s_MongoDriverWriteConcern_wmajority, mongoc_write_concern_get_wmajority(data->m_write_concern));
retval.set(s_MongoDriverWriteConcern_wtimeout, mongoc_write_concern_get_wtimeout(data->m_write_concern));
if (data->m_write_concern->fsync_ != MONGOC_WRITE_CONCERN_FSYNC_DEFAULT) {
retval.set(s_MongoDriverWriteConcern_fsync, mongoc_write_concern_get_fsync(data->m_write_concern));
} else {
retval.set(s_MongoDriverWriteConcern_fsync, Variant());
}
if (data->m_write_concern->journal != MONGOC_WRITE_CONCERN_JOURNAL_DEFAULT) {
retval.set(s_MongoDriverWriteConcern_journal, mongoc_write_concern_get_journal(data->m_write_concern));
} else {
retval.set(s_MongoDriverWriteConcern_journal, Variant());
}
return retval;
}
/* {{{ proto string|integer|null MongoDB\Driver\WriteConcern::getW()
Returns the WriteConcern "w" option */
static PHP_METHOD(WriteConcern, getW)
{
php_phongo_writeconcern_t *intern;
const char *wtag;
SUPPRESS_UNUSED_WARNING(return_value_ptr) SUPPRESS_UNUSED_WARNING(return_value_used)
intern = Z_WRITECONCERN_OBJ_P(getThis());
if (zend_parse_parameters_none() == FAILURE) {
return;
}
wtag = mongoc_write_concern_get_wtag(intern->write_concern);
if (wtag) {
PHONGO_RETURN_STRING(wtag);
}
if (mongoc_write_concern_get_wmajority(intern->write_concern)) {
PHONGO_RETURN_STRING(PHONGO_WRITE_CONCERN_W_MAJORITY);
}
if (mongoc_write_concern_get_w(intern->write_concern) != MONGOC_WRITE_CONCERN_W_DEFAULT) {
RETURN_LONG(mongoc_write_concern_get_w(intern->write_concern));
}
RETURN_NULL();
} /* }}} */
static void
test_mongoc_uri_write_concern (void)
{
const mongoc_write_concern_t *wr;
mongoc_uri_t *uri;
const write_concern_test *t;
int i;
static const write_concern_test tests [] = {
{ "mongodb://localhost/?safe=false", true, MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED },
{ "mongodb://localhost/?safe=true", true, 1 },
{ "mongodb://localhost/?w=-1", true, MONGOC_WRITE_CONCERN_W_ERRORS_IGNORED },
{ "mongodb://localhost/?w=0", true, MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED },
{ "mongodb://localhost/?w=1", true, 1 },
{ "mongodb://localhost/?w=2", true, 2 },
{ "mongodb://localhost/?w=majority", true, MONGOC_WRITE_CONCERN_W_MAJORITY },
{ "mongodb://localhost/?w=10", true, 10 },
{ "mongodb://localhost/?w=", true, MONGOC_WRITE_CONCERN_W_DEFAULT },
{ "mongodb://localhost/?w=mytag", true, MONGOC_WRITE_CONCERN_W_TAG, "mytag" },
{ "mongodb://localhost/?w=mytag&safe=false", true, MONGOC_WRITE_CONCERN_W_TAG, "mytag" },
{ "mongodb://localhost/?w=1&safe=false", true, 1 },
{ "mongodb://localhost/?journal=true", true, MONGOC_WRITE_CONCERN_W_DEFAULT },
{ "mongodb://localhost/?w=0&journal=true", false, MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED },
{ "mongodb://localhost/?w=-1&journal=true", false, MONGOC_WRITE_CONCERN_W_ERRORS_IGNORED },
{ "mongodb://localhost/?w=1&journal=true", true, 1 },
{ NULL }
};
/* Suppress warnings from two invalid URIs ("journal" and "w" conflict) */
suppress_one_message();
suppress_one_message();
for (i = 0; tests [i].uri; i++) {
t = &tests [i];
uri = mongoc_uri_new (t->uri);
if (t->parses) {
assert (uri);
} else {
assert (!uri);
continue;
}
wr = mongoc_uri_get_write_concern (uri);
assert (wr);
assert (t->w == mongoc_write_concern_get_w (wr));
if (t->wtag) {
assert (0 == strcmp (t->wtag, mongoc_write_concern_get_wtag (wr)));
}
mongoc_uri_destroy (uri);
}
}
static bool hippo_mongo_driver_manager_apply_wc(mongoc_uri_t *uri, const Array options)
{
int32_t wtimeoutms;
mongoc_write_concern_t *new_wc;
const mongoc_write_concern_t *old_wc;
if (!(old_wc = mongoc_uri_get_write_concern(uri))) {
throw MongoDriver::Utils::throwRunTimeException("mongoc_uri_t does not have a write concern");
return false;
}
if (options.size() == 0) {
return true;
}
if (
!options.exists(s_MongoDBDriverManager_journal) &&
!options.exists(s_MongoDBDriverManager_safe) &&
!options.exists(s_MongoDBDriverManager_w) &&
!options.exists(s_MongoDBDriverManager_wtimeoutms)
) {
return true;
}
wtimeoutms = mongoc_write_concern_get_wtimeout(old_wc);
new_wc = mongoc_write_concern_copy(old_wc);
if (options.exists(s_MongoDBDriverManager_safe) && options[s_MongoDBDriverManager_safe].isBoolean()) {
mongoc_write_concern_set_w(new_wc, options[s_MongoDBDriverManager_safe].toBoolean() ? 1 : MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED);
}
if (options.exists(s_MongoDBDriverManager_wtimeoutms) && options[s_MongoDBDriverManager_wtimeoutms].isInteger()) {
wtimeoutms = (int32_t) options[s_MongoDBDriverManager_wtimeoutms].toInt64();
}
if (options.exists(s_MongoDBDriverManager_journal) && options[s_MongoDBDriverManager_journal].isBoolean()) {
mongoc_write_concern_set_journal(new_wc, !!options[s_MongoDBDriverManager_journal].toBoolean());
}
if (options.exists(s_MongoDBDriverManager_w)) {
if (options[s_MongoDBDriverManager_w].isInteger()) {
int32_t value = (int32_t) options[s_MongoDBDriverManager_w].toInt64();
switch (value) {
case MONGOC_WRITE_CONCERN_W_ERRORS_IGNORED:
case MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED:
mongoc_write_concern_set_w(new_wc, value);
break;
default:
if (value > 0) {
mongoc_write_concern_set_w(new_wc, value);
break;
}
throw MongoDriver::Utils::throwInvalidArgumentException("Unsupported w value: " + Variant(value).toString());
mongoc_write_concern_destroy(new_wc);
return false;
}
} else if (options[s_MongoDBDriverManager_w].isString()) {
const char *str = options[s_MongoDBDriverManager_w].toString().c_str();
if (0 == strcasecmp("majority", str)) {
mongoc_write_concern_set_wmajority(new_wc, wtimeoutms);
} else {
mongoc_write_concern_set_wtag(new_wc, str);
}
}
}
/* Only set wtimeout if it's still applicable; otherwise, clear it. */
if (mongoc_write_concern_get_w(new_wc) > 1 ||
mongoc_write_concern_get_wmajority(new_wc) ||
mongoc_write_concern_get_wtag(new_wc)) {
mongoc_write_concern_set_wtimeout(new_wc, wtimeoutms);
} else {
mongoc_write_concern_set_wtimeout(new_wc, 0);
}
if (mongoc_write_concern_get_journal(new_wc)) {
int32_t w = mongoc_write_concern_get_w(new_wc);
if (w == MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED || w == MONGOC_WRITE_CONCERN_W_ERRORS_IGNORED) {
throw MongoDriver::Utils::throwInvalidArgumentException("Journal conflicts with w value: " + Variant(w).toString());
mongoc_write_concern_destroy(new_wc);
return false;
}
}
/* This may be redundant in light of the last check (unacknowledged w with
* journal), but we'll check anyway in case additional validation is
* implemented. */
if (!mongoc_write_concern_is_valid(new_wc)) {
throw MongoDriver::Utils::throwInvalidArgumentException("Write concern is not valid");
mongoc_write_concern_destroy(new_wc);
return false;
}
mongoc_uri_set_write_concern(uri, new_wc);
mongoc_write_concern_destroy(new_wc);
return true;
}
