mrb_value mrb_mongo_collection_update(mrb_state *mrb, mrb_value self) {
mrb_mongo_collection_data *data = DATA_PTR(self);
mrb_value selector_hash, update_hash;
mrb_bool upsert;
bson_t *selector, *update;
bson_error_t error;
mongoc_update_flags_t flags;
flags = MONGOC_UPDATE_MULTI_UPDATE;
mrb_get_args(mrb, "HH|b", &selector_hash, &update_hash, &upsert);
if (!mrb_hash_p(selector_hash)) {
selector_hash = mrb_hash_new(mrb);
}
if (upsert) flags = flags | MONGOC_UPDATE_UPSERT;
selector = bson_new();
update = bson_new();
mrb_hash_to_bson(mrb, selector_hash, selector);
mrb_hash_to_bson(mrb, update_hash, update);
if (!mongoc_collection_update(data->collection, flags, selector, update, NULL, &error)) {
bson_destroy(selector);
bson_destroy(update);
mrb_raise(mrb, E_RUNTIME_ERROR, error.message);
}
bson_destroy(selector);
bson_destroy(update);
return mrb_nil_value();
}
bool rubyval_to_ccvaluemapintkey(mrb_state* mrb, mrb_value arg, cocos2d::ValueMapIntKey* ret, const char* funcName)
{
if (! mrb_hash_p(arg)) {
return false;
}
mrb_value key_arr = mrb_hash_keys(mrb, arg);
mrb_int len = mrb_ary_len(mrb, key_arr);
ValueMapIntKey& dict = *ret;
for (mrb_int i = 0; i < len; i++) {
mrb_value hk = mrb_ary_ref(mrb, key_arr, i);
mrb_value hv = mrb_hash_get(mrb, arg, hk);
int int_key = 0;
if (mrb_string_p(hk)) {
char *kstr = mrb_str_to_cstr(mrb, hk);
int_key = atoi(kstr);
} else if (mrb_symbol_p(hk)) {
mrb_sym sym = mrb_symbol(hk);
const char* kstr = mrb_sym2name(mrb, sym);
int_key = atoi(kstr);
} else {
return false;
}
Value val;
if (! rubyval_to_ccvalue(mrb, hv, &val)) {
return false;
}
dict[int_key] = val;
}
return true;
}
bool rubyval_to_dictionary(mrb_state* mrb, mrb_value arg, __Dictionary** outValue, const char* funcName)
{
if (! mrb_hash_p(arg)) {
return false;
}
mrb_value key_arr = mrb_hash_keys(mrb, arg);
mrb_int len = mrb_ary_len(mrb, key_arr);
__Dictionary* dic = __Dictionary::create();
for (mrb_int i = 0; i < len; i++) {
mrb_value hk = mrb_ary_ref(mrb, key_arr, i);
mrb_value hv = mrb_hash_get(mrb, arg, hk);
if (mrb_string_p(hk)) {
char *kstr = mrb_str_to_cstr(mrb, hk);
Ref* ref = to_ref_value(mrb, hv);
dic->setObject(ref, std::string(kstr));
} else if (mrb_symbol_p(hk)) {
mrb_sym sym = mrb_symbol(hk);
const char* kstr = mrb_sym2name(mrb, sym);
Ref* ref = to_ref_value(mrb, hv);
dic->setObject(ref, std::string(kstr));
} else {
CCASSERT(false, "not supported key value type");
}
}
*outValue = dic;
return true;
}
static mrb_value
hash_equal(mrb_state *mrb, mrb_value hash1, mrb_value hash2, mrb_bool eql)
{
khash_t(ht) *h1, *h2;
mrb_bool eq;
if (mrb_obj_equal(mrb, hash1, hash2)) return mrb_true_value();
if (!mrb_hash_p(hash2)) {
if (!mrb_respond_to(mrb, hash2, mrb_intern_lit(mrb, "to_hash"))) {
return mrb_false_value();
}
else {
if (eql) {
eq = mrb_eql(mrb, hash2, hash1);
}
else {
eq = mrb_equal(mrb, hash2, hash1);
}
return mrb_bool_value(eq);
}
}
h1 = RHASH_TBL(hash1);
h2 = RHASH_TBL(hash2);
if (!h1) {
return mrb_bool_value(!h2);
}
if (!h2) return mrb_false_value();
if (kh_size(h1) != kh_size(h2)) return mrb_false_value();
else {
khiter_t k1, k2;
mrb_value key;
for (k1 = kh_begin(h1); k1 != kh_end(h1); k1++) {
if (!kh_exist(h1, k1)) continue;
key = kh_key(h1,k1);
k2 = kh_get(ht, mrb, h2, key);
if (k2 != kh_end(h2)) {
if (eql)
eq = mrb_eql(mrb, kh_value(h1,k1), kh_value(h2,k2));
else
eq = mrb_equal(mrb, kh_value(h1,k1), kh_value(h2,k2));
if (eq) {
continue; /* next key */
}
}
return mrb_false_value();
}
}
return mrb_true_value();
}
mrb_value mrb_mongo_collection_query(mrb_state *mrb, mrb_value self) {
mrb_value hash_query, query;
mrb_value query_params[2];
mrb_get_args(mrb, "|H", &hash_query);
if (!mrb_hash_p(hash_query)) {
hash_query = mrb_hash_new(mrb);
}
struct RClass *_class_mongo = mrb_module_get(mrb, "Mongo");
struct RClass *_class_mongo_query = mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(_class_mongo), mrb_intern_lit(mrb, "Query")));
query_params[0] = self;
query_params[1] = hash_query;
query = mrb_obj_new(mrb, _class_mongo_query, 2, query_params);
return query;
}
mrb_value mrb_mongo_collection_drop(mrb_state *mrb, mrb_value self) {
mrb_mongo_collection_data *data = DATA_PTR(self);
mrb_value drop_hash;
bson_t *doc;
bson_error_t error;
mrb_get_args(mrb, "|H", &drop_hash);
if (!mrb_hash_p(drop_hash)) {
drop_hash = mrb_hash_new(mrb);
}
doc = bson_new();
mrb_hash_to_bson(mrb, drop_hash, doc);
if (!mongoc_collection_remove(data->collection, MONGOC_REMOVE_NONE, doc, NULL, &error)) {
bson_destroy(doc);
mrb_raise(mrb, E_RUNTIME_ERROR, error.message);
}
return mrb_nil_value();
}
static mrb_value http_request_method(mrb_state *mrb, mrb_value self)
{
h2o_mruby_generator_t *generator;
struct st_h2o_mruby_http_request_context_t *ctx;
const char *arg_url;
mrb_int arg_url_len;
mrb_value arg_hash;
h2o_iovec_t method;
h2o_url_t url;
/* parse args */
arg_hash = mrb_nil_value();
mrb_get_args(mrb, "s|H", &arg_url, &arg_url_len, &arg_hash);
/* precond check */
if ((generator = h2o_mruby_current_generator) == NULL || generator->req == NULL)
mrb_exc_raise(mrb, create_downstream_closed_exception(mrb));
/* allocate context and initialize */
ctx = h2o_mem_alloc_shared(&generator->req->pool, sizeof(*ctx), on_dispose);
memset(ctx, 0, sizeof(*ctx));
ctx->generator = generator;
ctx->receiver = mrb_nil_value();
h2o_buffer_init(&ctx->req.buf, &h2o_socket_buffer_prototype);
h2o_buffer_init(&ctx->resp.after_closed, &h2o_socket_buffer_prototype);
ctx->refs.request = mrb_nil_value();
ctx->refs.input_stream = mrb_nil_value();
/* uri */
if (h2o_url_parse(arg_url, arg_url_len, &url) != 0)
mrb_raise(mrb, E_ARGUMENT_ERROR, "invaild URL");
/* method */
method = h2o_iovec_init(H2O_STRLIT("GET"));
if (mrb_hash_p(arg_hash)) {
mrb_value t = mrb_hash_get(mrb, arg_hash, mrb_symbol_value(generator->ctx->symbols.sym_method));
if (!mrb_nil_p(t)) {
t = mrb_str_to_str(mrb, t);
method = h2o_iovec_init(RSTRING_PTR(t), RSTRING_LEN(t));
}
}
/* start building the request */
h2o_buffer_reserve(&ctx->req.buf, method.len + 1);
append_to_buffer(&ctx->req.buf, method.base, method.len);
append_to_buffer(&ctx->req.buf, H2O_STRLIT(" "));
h2o_buffer_reserve(&ctx->req.buf,
url.path.len + url.authority.len + sizeof(" HTTP/1.1\r\nConnection: close\r\nHost: \r\n") - 1);
append_to_buffer(&ctx->req.buf, url.path.base, url.path.len);
append_to_buffer(&ctx->req.buf, H2O_STRLIT(" HTTP/1.1\r\nConnection: close\r\nHost: "));
append_to_buffer(&ctx->req.buf, url.authority.base, url.authority.len);
append_to_buffer(&ctx->req.buf, H2O_STRLIT("\r\n"));
/* headers */
if (mrb_hash_p(arg_hash)) {
mrb_value headers = mrb_hash_get(mrb, arg_hash, mrb_symbol_value(generator->ctx->symbols.sym_headers));
if (!mrb_nil_p(headers)) {
if (h2o_mruby_iterate_headers(generator->ctx, headers, flatten_request_header, ctx) != 0) {
mrb_value exc = mrb_obj_value(mrb->exc);
mrb->exc = NULL;
mrb_exc_raise(mrb, exc);
}
}
}
/* body */
if (mrb_hash_p(arg_hash)) {
mrb_value body = mrb_hash_get(mrb, arg_hash, mrb_symbol_value(generator->ctx->symbols.sym_body));
if (!mrb_nil_p(body)) {
if (mrb_obj_eq(mrb, body, generator->rack_input)) {
/* fast path */
mrb_int pos;
mrb_input_stream_get_data(mrb, body, NULL, NULL, &pos, NULL, NULL);
ctx->req.body = generator->req->entity;
ctx->req.body.base += pos;
ctx->req.body.len -= pos;
} else {
if (!mrb_string_p(body)) {
body = mrb_funcall(mrb, body, "read", 0);
if (!mrb_string_p(body))
mrb_raise(mrb, E_ARGUMENT_ERROR, "body.read did not return string");
}
ctx->req.body = h2o_strdup(&ctx->generator->req->pool, RSTRING_PTR(body), RSTRING_LEN(body));
}
if (!ctx->req.has_transfer_encoding) {
char buf[64];
size_t l = (size_t)sprintf(buf, "content-length: %zu\r\n", ctx->req.body.len);
h2o_buffer_reserve(&ctx->req.buf, l);
append_to_buffer(&ctx->req.buf, buf, l);
}
}
}
h2o_buffer_reserve(&ctx->req.buf, 2);
append_to_buffer(&ctx->req.buf, H2O_STRLIT("\r\n"));
/* build request and connect */
h2o_http1client_connect(&ctx->client, ctx, &generator->req->conn->ctx->proxy.client_ctx, url.host, h2o_url_get_port(&url),
on_connect);
ctx->refs.request = h2o_mruby_create_data_instance(mrb, mrb_ary_entry(generator->ctx->constants, H2O_MRUBY_HTTP_REQUEST_CLASS),
ctx, &request_type);
return ctx->refs.request;
}