/* * Interface between MongoDB based on NSF (Next Scripting * Framework) * * This implementation provides a low level interface based on tagged elements * to force / preserve the datatypes of MongoDB when converting into Tcl. * * This code serves as well as an example how to use the source code generator * of NSF. The example shows how to use the source code generator from NSF to * generate a C interface. * * -gustaf neumann March 27, 2011 * * Copyright (C) 2011-2018 Gustaf Neumann */ #include #include #include #include "bson.h" #include "mongoc.h" #include #include #include #define USE_CLIENT_POOL 1 /* * Define the counters to generate nice symbols for pointer converter */ static int gridfileCount = 0; static int gridfsCount = 0; static int mongoClientCount = 0; static int mongoCollectionCount = 0; static int mongoCursorCount = 0; #if defined(USE_CLIENT_POOL) static NsfMutex poolMutex = 0; static mongoc_client_pool_t *mongoClientPool = NULL; static int mongoClientPoolRefCount = 0; static mongoc_uri_t *mongoUri = NULL; #endif typedef enum { NSF_BSON_ARRAY, NSF_BSON_BINARY, NSF_BSON_BOOL, NSF_BSON_INT32, NSF_BSON_INT64, NSF_BSON_DATE_TIME, NSF_BSON_DECIMAL128, NSF_BSON_DOCUMENT, NSF_BSON_DOUBLE, NSF_BSON_MINKEY, NSF_BSON_MAXKEY, NSF_BSON_NULL, NSF_BSON_OID, NSF_BSON_REGEX, NSF_BSON_STRING, NSF_BSON_TIMESTAMP, NSF_BSON_UNKNOWN } nsfMongoTypes; static const char * NsfMongoGlobalStrings[] = { "array", "binary", "boolean", "int32", "int64", "datetime", "decimal128", "document", "double", "minkey", "maxkey", "null", "oid", "regex", "string", "timestamp", "unknown", NULL }; static Tcl_Obj **NsfMongoGlobalObjs = NULL; static Tcl_Obj *BsonToList(Tcl_Interp *interp, const bson_t *data , int depth); static bson_type_t BsonTagToType(Tcl_Interp *interp, const char *tag); extern Tcl_PackageInitProc Nsfmongo_SafeInit; extern Tcl_PackageInitProc Nsfmongo_Init; static Tcl_ExitProc Nsfmongo_Exit; static Tcl_ExitProc Nsfmongo_ThreadExit; Nsf_TypeConverter Nsf_ConvertTo_Boolean; Nsf_TypeConverter Nsf_ConvertTo_Class; Nsf_TypeConverter Nsf_ConvertTo_Int32; Nsf_TypeConverter Nsf_ConvertTo_Integer; Nsf_TypeConverter Nsf_ConvertTo_Object; Nsf_TypeConverter Nsf_ConvertTo_Pointer; Nsf_TypeConverter Nsf_ConvertTo_String; Nsf_TypeConverter Nsf_ConvertTo_Tclobj; /*********************************************************************** * The following definitions should not be here, but they are included * to get compilation going for the time being. ***********************************************************************/ typedef void *NsfObject; #define PARSE_CONTEXT_PREALLOC 20 typedef struct { ClientData *clientData; /* 4 members pointer to the actual parse context data */ Tcl_Obj **objv; Tcl_Obj **full_objv; /* contains method as well */ unsigned int *flags; ClientData clientData_static[PARSE_CONTEXT_PREALLOC]; /* 3 members preallocated parse context data */ Tcl_Obj *objv_static[PARSE_CONTEXT_PREALLOC+1]; unsigned int flags_static[PARSE_CONTEXT_PREALLOC+1]; unsigned int status; int lastObjc; /* points to the first "unprocessed" argument */ int objc; NsfObject *object; int varArgs; /* does the parameter end with some kind of "args" */ } ParseContext; #define nr_elements(arr) ((int) (sizeof(arr) / sizeof(arr[0]))) #define ObjStr(obj) (obj)->bytes ? (obj)->bytes : Tcl_GetString(obj) #ifdef UNUSED #elif defined(__GNUC__) # define UNUSED(x) UNUSED_ ## x __attribute__((unused)) #elif defined(__LCLINT__) # define UNUSED(x) /*@unused@*/ x #else # define UNUSED(x) x #endif #if defined(HAVE_STDINT_H) # define HAVE_INTPTR_T # define HAVE_UINTPTR_T #endif #if !defined(INT2PTR) && !defined(PTR2INT) # if defined(HAVE_INTPTR_T) || defined(intptr_t) # define INT2PTR(p) ((void *)(intptr_t)(p)) # define PTR2INT(p) ((int)(intptr_t)(p)) # else # define INT2PTR(p) ((void *)(p)) # define PTR2INT(p) ((int)(p)) # endif #endif #if !defined(UINT2PTR) && !defined(PTR2UINT) # if defined(HAVE_UINTPTR_T) || defined(uintptr_t) # define UINT2PTR(p) ((void *)(uintptr_t)(p)) # define PTR2UINT(p) ((unsigned int)(uintptr_t)(p)) # else # define UINT2PTR(p) ((void *)(p)) # define PTR2UINT(p) ((unsigned int)(p)) # endif #endif static int ArgumentParse(Tcl_Interp *interp, int objc, Tcl_Obj *const objv[], NsfObject *obj, Tcl_Obj *procName, Nsf_Param const *paramPtr, int nrParameters, int serial, unsigned int processFlags, ParseContext *pc) { return Nsf_ArgumentParse(interp, objc, objv, (Nsf_Object *)obj, procName, paramPtr, nrParameters, serial, processFlags, (Nsf_ParseContext *)pc); } /*********************************************************************** * Include the generated mongo db API. ***********************************************************************/ #include "mongoAPI.h" /*********************************************************************** * Helper functions ***********************************************************************/ /* *---------------------------------------------------------------------- * * BsonToList -- * * Convert a bson_t structure to a tagged list. Each value field is * preceded by a tag denoting its bson type. * * Results: * Tagged list. * * Side effects: * None. * *---------------------------------------------------------------------- */ Tcl_Obj * BsonToList(Tcl_Interp *interp, const bson_t *data , int depth) { bson_iter_t i; char oidhex[25]; Tcl_Obj *resultObj, *elemObj; bson_iter_init( &i , data ); resultObj = Tcl_NewListObj(0, NULL); while ( bson_iter_next( &i ) ){ bson_type_t t = bson_iter_type( &i ); nsfMongoTypes tag; const char *key; if ( t == 0 ) break; key = bson_iter_key( &i ); /*fprintf(stderr, "BsonToList: key %s t %d string %d\n", key, t, bson_string);*/ switch ( t ){ case BSON_TYPE_INT32: tag = NSF_BSON_INT32; elemObj = Tcl_NewIntObj(bson_iter_int32( &i )); break; case BSON_TYPE_INT64: tag = NSF_BSON_INT64; elemObj = Tcl_NewLongObj(bson_iter_int64( &i )); break; case BSON_TYPE_DATE_TIME: tag = NSF_BSON_DATE_TIME; elemObj = Tcl_NewLongObj(bson_iter_date_time( &i )); break; case BSON_TYPE_DOUBLE: tag = NSF_BSON_DOUBLE; elemObj = Tcl_NewDoubleObj(bson_iter_double( &i )); break; case BSON_TYPE_BOOL: tag = NSF_BSON_BOOL; elemObj = Tcl_NewBooleanObj(bson_iter_bool( &i )); break; case BSON_TYPE_REGEX: { const char *options = NULL, *regex; tag = NSF_BSON_REGEX; regex = bson_iter_regex( &i, &options ); elemObj = Tcl_NewListObj(0, NULL); Tcl_ListObjAppendElement(interp, elemObj, Tcl_NewStringObj(regex, -1)); Tcl_ListObjAppendElement(interp, elemObj, Tcl_NewStringObj(options, -1)); break; } case BSON_TYPE_UTF8: { uint32_t utf8_len; const char *string = bson_iter_utf8( &i, &utf8_len); /*fprintf(stderr, "append UTF8: <%s> %d\n", string, utf8_len);*/ tag = NSF_BSON_STRING; elemObj = Tcl_NewStringObj(string, (int)utf8_len); break; } case BSON_TYPE_MINKEY: tag = NSF_BSON_MINKEY; elemObj = Tcl_NewStringObj("null", 4); break; case BSON_TYPE_MAXKEY: tag = NSF_BSON_MAXKEY; elemObj = Tcl_NewStringObj("null", 4); break; case BSON_TYPE_NULL: tag = NSF_BSON_NULL; elemObj = Tcl_NewStringObj("null", 4); break; case BSON_TYPE_OID: { tag = NSF_BSON_OID; bson_oid_to_string(bson_iter_oid(&i), oidhex); elemObj = Tcl_NewStringObj(oidhex, -1); break; } case BSON_TYPE_TIMESTAMP: { uint32_t timestamp, increment; tag = NSF_BSON_TIMESTAMP; bson_iter_timestamp( &i, ×tamp, &increment ); elemObj = Tcl_NewListObj(0, NULL); Tcl_ListObjAppendElement(interp, elemObj, Tcl_NewLongObj((long)timestamp)); Tcl_ListObjAppendElement(interp, elemObj, Tcl_NewLongObj((long)increment)); break; } case BSON_TYPE_DOCUMENT: { const uint8_t *docbuf = NULL; uint32_t doclen = 0; bson_t b; tag = NSF_BSON_DOCUMENT; bson_iter_document(&i, &doclen, &docbuf); bson_init_static(&b, docbuf, doclen); elemObj = BsonToList(interp, &b , depth + 1 ); break; } case BSON_TYPE_ARRAY: { const uint8_t *docbuf = NULL; uint32_t doclen = 0; bson_t b; tag = NSF_BSON_ARRAY; bson_iter_array(&i, &doclen, &docbuf); bson_init_static(&b, docbuf, doclen); elemObj = BsonToList(interp, &b , depth + 1 ); break; } case BSON_TYPE_DECIMAL128: { bson_decimal128_t decimal128; char string[BSON_DECIMAL128_STRING]; tag = NSF_BSON_DECIMAL128; bson_iter_decimal128( &i, &decimal128); bson_decimal128_to_string(&decimal128, string); elemObj = Tcl_NewStringObj(string, -1); break; } case BSON_TYPE_BINARY: { uint32_t length; const uint8_t *bytes; tag = NSF_BSON_BINARY; bson_iter_binary( &i, NULL /* subtype_t */, &length, &bytes); elemObj = Tcl_NewByteArrayObj(bytes, (int)length); break; } case BSON_TYPE_CODE: /* fall through */ case BSON_TYPE_CODEWSCOPE: /* fall through */ case BSON_TYPE_DBPOINTER: /* fall through */ case BSON_TYPE_EOD: /* fall through */ case BSON_TYPE_SYMBOL: /* fall through */ case BSON_TYPE_UNDEFINED: /* fall through */ default: tag = NSF_BSON_UNKNOWN; elemObj = Tcl_NewStringObj("", 0); NsfLog(interp, NSF_LOG_WARN, "BsonToList: unknown type %d", t); } Tcl_ListObjAppendElement(interp, resultObj, Tcl_NewStringObj(key, -1)); Tcl_ListObjAppendElement(interp, resultObj, NsfMongoGlobalObjs[tag]); Tcl_ListObjAppendElement(interp, resultObj, elemObj); } return resultObj; } /* *---------------------------------------------------------------------- * * BsonTagToType -- * * Convert a bson tag string to a bson_type. For the time being * we compare as little as possible characters. In the future we * might want to cache the bson tag in the Tcl_obj, maybe we can * use Tcl_GetIndexFromObj(); * * Results: * bson_type. * * Side effects: * None. * *---------------------------------------------------------------------- */ bson_type_t BsonTagToType(Tcl_Interp *interp, const char *tag) { char firstChar = *tag; switch (firstChar) { case 'a': /* array */ return BSON_TYPE_ARRAY; case 'b': /* bool */ return BSON_TYPE_BOOL; case 'd': if (*(tag + 1) == 'a') /* date */ return BSON_TYPE_DATE_TIME; if (*(tag + 1) == 'o' && *(tag + 2) == 'c') /* document */ return BSON_TYPE_DOCUMENT; if (*(tag + 1) == 'o' && *(tag + 2) == 'u') /* double */ return BSON_TYPE_DOUBLE; break; case 'i': /* int32|64 */ if (*(tag + 1) == 'n' && *(tag + 2) == 't' && *(tag + 3) == '3') return BSON_TYPE_INT32; if (*(tag + 1) == 'n' && *(tag + 2) == 't' && *(tag + 3) == '6') return BSON_TYPE_INT64; if (*(tag + 1) == 'n' && *(tag + 2) == 't') return BSON_TYPE_INT32; break; case 'm': if (*(tag + 1) == 'i') /* minkey */ return BSON_TYPE_MINKEY; if (*(tag + 1) == 'a') /* maxkey */ return BSON_TYPE_MAXKEY; break; case 'n': /* null */ return BSON_TYPE_NULL; case 'o': if (*(tag + 1) == 'i') /* oid */ return BSON_TYPE_OID; break; case 'r': /* regex */ return BSON_TYPE_REGEX; case 's': /* string */ return BSON_TYPE_UTF8; case 't': /* timestamp */ return BSON_TYPE_TIMESTAMP; } NsfLog(interp, NSF_LOG_WARN, "BsonTagToType: Treat unknown tag '%s' as string", tag); return BSON_TYPE_UTF8; } /* *---------------------------------------------------------------------- * * BsonAppend -- * * append a tagged element to a bson buffer. * * Results: * Tcl result code. * * Side effects: * Value appended to bson buffer. * *---------------------------------------------------------------------- */ static int BsonAppend(Tcl_Interp *interp, bson_t *bbPtr, const char *name, const char *tag, Tcl_Obj *value) { int result = TCL_OK; bson_type_t t = BsonTagToType(interp, tag); int keyLength = (int)strlen(name); /*fprintf(stderr, "BsonAppend: add name %s tag %s value '%s'\n", name, tag, ObjStr(value));*/ switch ( t ){ case BSON_TYPE_UTF8: { const char* string = ObjStr(value); bson_append_utf8(bbPtr, name, keyLength, string, (int)strlen(string)); break; } case BSON_TYPE_INT32: { int32_t v; result = Tcl_GetIntFromObj(interp, value, &v); if (result != TCL_OK) break; bson_append_int32(bbPtr, name, keyLength, v); break; } case BSON_TYPE_DOUBLE: { double v; result = Tcl_GetDoubleFromObj(interp, value, &v); if (result != TCL_OK) break; bson_append_double(bbPtr, name, keyLength, v); break; } case BSON_TYPE_BOOL: { int v; result = Tcl_GetBooleanFromObj(interp, value, &v); if (result != TCL_OK) break; bson_append_bool(bbPtr, name, keyLength, v); break; } case BSON_TYPE_INT64: { long v; result = Tcl_GetLongFromObj(interp, value, &v); if (result != TCL_OK) break; bson_append_int64(bbPtr, name, keyLength, v); break; } case BSON_TYPE_MAXKEY: bson_append_maxkey(bbPtr, name, keyLength); break; case BSON_TYPE_MINKEY: bson_append_minkey(bbPtr, name, keyLength); break; case BSON_TYPE_NULL: { bson_append_null(bbPtr, name, keyLength); break; } case BSON_TYPE_OID: { bson_oid_t v; bson_oid_init_from_string(&v, ObjStr(value)); bson_append_oid(bbPtr, name, keyLength, &v); break; } case BSON_TYPE_REGEX: { int objc = 0; Tcl_Obj **objv; result = Tcl_ListObjGetElements(interp, value, &objc, &objv); if (result != TCL_OK || objc != 2) { return NsfPrintError(interp, "invalid regexp representation: %s", ObjStr(value)); } bson_append_regex(bbPtr, name, keyLength, ObjStr(objv[0]), ObjStr(objv[1])); break; } case BSON_TYPE_DATE_TIME: { long v; result = Tcl_GetLongFromObj(interp, value, &v); if (result != TCL_OK) break; bson_append_date_time(bbPtr, name, keyLength, v); break; } case BSON_TYPE_TIMESTAMP: { int timestamp = 0, increment = 0, objc = 0; Tcl_Obj **objv; result = Tcl_ListObjGetElements(interp, value, &objc, &objv); if (result != TCL_OK || objc != 2) { return NsfPrintError(interp, "invalid timestamp: %s", ObjStr(value)); } else { result = Tcl_GetIntFromObj(interp, objv[0], ×tamp); if (result == TCL_OK) { result = Tcl_GetIntFromObj(interp, objv[1], &increment); } if (result == TCL_OK) { bson_append_timestamp(bbPtr, name, keyLength, (uint32_t)timestamp, (uint32_t)increment); } } break; } case BSON_TYPE_DOCUMENT: case BSON_TYPE_ARRAY: { int i, objc; Tcl_Obj **objv; bson_t child, *childPtr = &child; result = Tcl_ListObjGetElements(interp, value, &objc, &objv); if (result != TCL_OK || ((objc % 3) != 0)) { return NsfPrintError(interp, "invalid %s value contain multiple of 3 elements %s", tag, ObjStr(value)); } if (t == BSON_TYPE_DOCUMENT) { bson_append_document_begin(bbPtr, name, keyLength, childPtr); } else { bson_append_array_begin(bbPtr, name, keyLength, childPtr); } for (i = 0; i< objc; i += 3) { /*fprintf(stderr, "value %s, i %d, [0]: %s, [1]: %s, [2]: %s\n", ObjStr(value), i, ObjStr(objv[i]), ObjStr(objv[i+1]), ObjStr(objv[i+2]));*/ result = BsonAppend(interp, childPtr, ObjStr(objv[i]), ObjStr(objv[i+1]), objv[i+2]); if (result != TCL_OK) break; } if (t == BSON_TYPE_DOCUMENT) { bson_append_document_end(bbPtr, childPtr); } else { bson_append_array_end(bbPtr, childPtr); } break; } case BSON_TYPE_DECIMAL128: { bson_decimal128_t decimal128; bson_decimal128_from_string(ObjStr(value), &decimal128); bson_append_decimal128(bbPtr, name, keyLength, &decimal128); break; } case BSON_TYPE_BINARY: { int length; const uint8_t *data = Tcl_GetByteArrayFromObj(value, &length); bson_append_binary(bbPtr, name, keyLength, 0x00 /*bson_subtype_t*/, data, (uint32_t)length); break; } case BSON_TYPE_DBPOINTER: case BSON_TYPE_CODE: case BSON_TYPE_SYMBOL: case BSON_TYPE_CODEWSCOPE: return NsfPrintError(interp, "tag %s not handled yet", tag); break; case BSON_TYPE_UNDEFINED: case BSON_TYPE_EOD: break; /* no default here, to get the warning to the compilation log for the time being */ } return result; } /* *---------------------------------------------------------------------- * * BsonAppendObjv -- * * Append all elements of objv to an uninitialized bson buffer. * * Results: * Tcl result code. * * Side effects: * Value appended to bson buffer. * *---------------------------------------------------------------------- */ static int BsonAppendObjv(Tcl_Interp *interp, bson_t *bPtr, int objc, Tcl_Obj **objv) { int i, result = TCL_OK; bson_init(bPtr); for (i = 0; i < objc; i += 3) { char *name = ObjStr(objv[i]); char *tag = ObjStr(objv[i+1]); Tcl_Obj *value = objv[i+2]; /*fprintf(stderr, "adding pair '%s' (%s) '%s'\n", name, tag, ObjStr(value));*/ result = BsonAppend(interp, bPtr, name, tag, value); if (result != TCL_OK) { break; } } return result; } /*********************************************************************** * Define the API functions ***********************************************************************/ /* cmd json::generate NsfMongoJsonGenerate { {-argName "list" -required 1 -type tclobj} } */ static int NsfMongoJsonGenerate(Tcl_Interp *interp, Tcl_Obj *listObj) { bson_t list, *listPtr = &list; size_t length; int result, objc; Tcl_Obj **objv; result = Tcl_ListObjGetElements(interp, listObj, &objc, &objv); if (result != TCL_OK || ((objc % 3) != 0)) { return NsfPrintError(interp, "%s: must contain a multiple of 3 elements", ObjStr(listObj)); } result = BsonAppendObjv(interp, listPtr, objc, objv); if (result == TCL_OK) { char *jsonString; jsonString = bson_as_json(listPtr, &length); if (jsonString != NULL) { Tcl_SetObjResult(interp, Tcl_NewStringObj(jsonString, (int)length)); bson_free(jsonString); } else { result = NsfPrintError(interp, "invalid bson string: %s", ObjStr(listObj)); } bson_destroy( listPtr ); } return result; } /* cmd json::parse NsfMongoJsonParse { {-argName "json" -required 1 -type tclobj} } */ static int NsfMongoJsonParse(Tcl_Interp *interp, Tcl_Obj *jsonObj) { bson_t bson, *bsonPtr = &bson; const char *jsonString; int result, jsonLength; bson_error_t bsonError; jsonString = Tcl_GetStringFromObj(jsonObj, &jsonLength); if (bson_init_from_json (bsonPtr, jsonString,jsonLength, &bsonError) == true) { Tcl_SetObjResult(interp, BsonToList(interp, bsonPtr, 0)); bson_destroy( bsonPtr ); result = TCL_OK; } else { result = NsfPrintError(interp, "mongo::json::parse: error: %s", bsonError.message); } return result; } /* cmd close NsfMongoClose { {-argName "conn" -required 1 -type mongoc_client_t -withObj 1} } */ static int NsfMongoClose(Tcl_Interp *UNUSED(interp), mongoc_client_t *connPtr, Tcl_Obj *connObj) { #if defined(USE_CLIENT_POOL) mongoc_client_pool_push(mongoClientPool, connPtr); #else mongoc_client_destroy(connPtr); #endif Nsf_PointerDelete(ObjStr(connObj), connPtr, 0); return TCL_OK; } /* cmd connect NsfMongoConnect { {-argName "-uri" -required 0 -nrargs 1} } */ static int NsfMongoConnect(Tcl_Interp *interp, const char *uri) { char channelName[80]; mongoc_client_t *clientPtr; if (uri == NULL) { uri = "mongodb://127.0.0.1:27017/"; } #if defined(USE_CLIENT_POOL) NsfMutexLock(&poolMutex); if (mongoClientPool == NULL) { mongoUri = mongoc_uri_new(uri); NsfLog(interp, NSF_LOG_NOTICE, "nsf::mongo::connect: creating pool with uri %s", uri); mongoClientPool = mongoc_client_pool_new(mongoUri); } NsfMutexUnlock(&poolMutex); clientPtr = mongoc_client_pool_pop(mongoClientPool); #else clientPtr = mongoc_client_new(uri); #endif if (clientPtr == NULL) { return NsfPrintError(interp, "failed to parse Mongo URI"); } /* * Make an entry in the symbol table and return entry name it as * result. */ if (Nsf_PointerAdd(interp, channelName, 80u, "mongoc_client_t", clientPtr) != TCL_OK) { mongoc_client_destroy(clientPtr); return TCL_ERROR; } Tcl_SetObjResult(interp, Tcl_NewStringObj(channelName, -1)); return TCL_OK; } /* cmd run NsfMongoRunCmd { {-argName "-nocomplain" -required 0 -nrargs 0} {-argName "conn" -required 1 -type mongoc_client_t} {-argName "db" -required 1} {-argName "cmd" -required 1 -type tclobj} } */ static int NsfMongoRunCmd(Tcl_Interp *interp, int withNocomplain, mongoc_client_t *clientPtr, const char *db, Tcl_Obj *cmdObj) { bson_t cmd, *cmdPtr = &cmd, reply, *replyPtr = &reply; mongoc_read_prefs_t *readPrefsPtr = NULL; /* TODO: not used */ bson_error_t bsonError; int result, objc; Tcl_Obj **objv; result = Tcl_ListObjGetElements(interp, cmdObj, &objc, &objv); if (result != TCL_OK || ((objc % 3) != 0)) { return NsfPrintError(interp, "%s: must contain a multiple of 3 elements", ObjStr(cmdObj)); } BsonAppendObjv(interp, cmdPtr, objc, objv); /*mongo_clear_errors( connPtr );*/ result = mongoc_client_command_simple( clientPtr, db, cmdPtr, readPrefsPtr, replyPtr, &bsonError); bson_destroy( cmdPtr ); if (withNocomplain == 0 && result == 0) { return NsfPrintError(interp, "mongo::run: command '%s' returned error: %s", ObjStr(cmdObj), bsonError.message); } Tcl_SetObjResult(interp, BsonToList(interp, replyPtr, 0)); bson_destroy(replyPtr); return TCL_OK; } /* cmd status NsfMongoStatus { {-argName "conn" -required 1 -type mongoc_client_t -withObj 1} } */ static int NsfMongoStatus(Tcl_Interp *interp, mongoc_client_t *clientPtr, Tcl_Obj *UNUSED(clientObj)) { mongoc_read_prefs_t *readPrefs = NULL; /* TODO: not handled */ bson_t reply, *replyPtr = &reply; bson_error_t bsonError; int result = TCL_OK; bson_t cmd = BSON_INITIALIZER; bool ret; BSON_APPEND_INT32(&cmd, "serverStatus", 1); ret = mongoc_client_command_simple(clientPtr, "admin", &cmd, readPrefs, replyPtr, &bsonError); bson_destroy(&cmd); if (likely(ret != 0)) { Tcl_SetObjResult(interp, BsonToList(interp, replyPtr, 0)); } else { result = NsfPrintError(interp, "mongo::status: error: %s", bsonError.message); } bson_destroy(replyPtr); return result; } /* cmd collection::open NsfCollectionOpen { {-argName "conn" -required 1 -type mongoc_client_t} {-argName "dbname" -required 1} {-argName "collectionname" -required 1} } */ int NsfCollectionOpen(Tcl_Interp *interp, mongoc_client_t *clientPtr, const char *dbName, const char *collectionName) { int result = TCL_ERROR; mongoc_collection_t *collectionPtr; collectionPtr = mongoc_client_get_collection(clientPtr, dbName, collectionName); if (collectionPtr != NULL) { char buffer[80]; if (Nsf_PointerAdd(interp, buffer, 80u, "mongoc_collection_t", collectionPtr) == TCL_OK) { Tcl_SetObjResult(interp, Tcl_NewStringObj(buffer, -1)); result = TCL_OK; } else { mongoc_collection_destroy(collectionPtr); result = TCL_ERROR; } } if (collectionPtr == NULL) { result = NsfPrintError(interp, "collection::open: could not open collection: %s.%s", dbName, collectionName); } return result; } /* cmd collection::close NsfCollectionClose { {-argName "collection" -required 1 -type mongoc_collection_t -withObj 1} } */ static int NsfCollectionClose(Tcl_Interp *UNUSED(interp), mongoc_collection_t *collectionPtr, Tcl_Obj *clientObj) { mongoc_collection_destroy(collectionPtr); Nsf_PointerDelete(ObjStr(clientObj), collectionPtr, 0); return TCL_OK; } /* cmd collection::count NsfMongoCollectionCount { {-argName "collection" -required 1 -type mongoc_collection_t} {-argName "query" -required 1 -type tclobj} } */ static int NsfMongoCollectionCount(Tcl_Interp *interp, mongoc_collection_t *collectionPtr, Tcl_Obj *queryObj) { int objc, result; int64_t count; Tcl_Obj **objv; bson_t query, *queryPtr = &query; bson_error_t bsonError; /*bson_t* opts = BCON_NEW("skip", BCON_INT64(5));*/ result = Tcl_ListObjGetElements(interp, queryObj, &objc, &objv); if (result != TCL_OK || ((objc % 3) != 0)) { return NsfPrintError(interp, "%s: must contain a multiple of 3 elements", ObjStr(queryObj)); } BsonAppendObjv(interp, queryPtr, objc, objv); count = mongoc_collection_count_documents(collectionPtr, queryPtr, NULL /* opts */, NULL /* read preferences */, NULL /* replyPtr */, &bsonError); if (count == -1) { bson_destroy( queryPtr ); return NsfPrintError(interp, "mongo::collection::count: error: %s", bsonError.message); } bson_destroy( queryPtr ); Tcl_SetObjResult(interp, Tcl_NewWideIntObj((Tcl_WideInt)count)); return TCL_OK; } /* cmd "collection::delete" NsfMongoCollectionDelete { {-argName "collection" -required 1 -type mongoc_collection_t} {-argName "condition" -required 1 -type tclobj} } */ static int NsfMongoCollectionDelete(Tcl_Interp *interp, mongoc_collection_t *collectionPtr, Tcl_Obj *conditionObj) { int objc, result, success; Tcl_Obj **objv; bson_t query, *queryPtr = &query; bson_error_t bsonError; mongoc_remove_flags_t removeFlags = 0; /* TODO: not handled */ /* MONGOC_DELETE_SINGLE_REMOVE = 1 << 0,**/ const mongoc_write_concern_t *writeConcern = NULL; /* TODO: not handled yet */ result = Tcl_ListObjGetElements(interp, conditionObj, &objc, &objv); if (result != TCL_OK || ((objc % 3) != 0)) { return NsfPrintError(interp, "%s: must contain a multiple of 3 elements", ObjStr(conditionObj)); } BsonAppendObjv(interp, queryPtr, objc, objv); success = mongoc_collection_remove(collectionPtr, removeFlags, queryPtr, writeConcern, &bsonError); if (success == 0) { result = NsfPrintError(interp, "mongo::collection::delete: error: %s", bsonError.message); } bson_destroy(queryPtr); return result; } /* cmd "collection::index" NsfMongoCollectionIndex { {-argName "collection" -required 1 -type mongoc_collection_t} {-argName "attributes" -required 1 -type tclobj} {-argName "-name" -required 0 -nrargs 1} {-argName "-background" -required 0 -nrargs 0} {-argName "-dropdups" -required 0 -nrargs 0} {-argName "-sparse" -required 0 -nrargs 0} {-argName "-ttl" -required 0 -nrargs 1 -type int32} {-argName "-unique" -required 0 -nrargs 0} } */ static int NsfMongoCollectionIndex(Tcl_Interp *interp, mongoc_collection_t *collectionPtr, Tcl_Obj *attributesObj, const char *withName, int withBackground, int withDropdups, int withSparse, int withTtl, int withUnique) { int objc, result, success = 0; Tcl_Obj **objv; bson_t keys, *keysPtr = &keys; bson_error_t bsonError; mongoc_index_opt_t options; bson_t *create_indexes; char *index_name; const char *collection_name; result = Tcl_ListObjGetElements(interp, attributesObj, &objc, &objv); if (result != TCL_OK || ((objc % 3) != 0)) { return NsfPrintError(interp, "%s: must contain a multiple of 3 elements", ObjStr(attributesObj)); } BsonAppendObjv(interp, keysPtr, objc, objv); index_name = mongoc_collection_keys_to_index_string(keysPtr); collection_name = mongoc_collection_get_name(collectionPtr); create_indexes = BCON_NEW("createIndexes", BCON_UTF8(collection_name), "indexes", "[", "{", "key", BCON_DOCUMENT(keysPtr), "name", BCON_UTF8(index_name), "}", "]"); mongoc_index_opt_init(&options); if (withBackground != 0) {options.background = 1;} if (withDropdups != 0) {options.drop_dups = 1;} if (withSparse != 0) {options.sparse = 1;} if (withUnique != 0) {options.unique = 1;} if (withTtl != 0) {options.expire_after_seconds = withTtl;} if (withName != 0) {options.name = withName;} /* TODO: not handled: is_initialized, v, weights, default_language, language_override, padding */ success = mongoc_collection_write_command_with_opts( collectionPtr, create_indexes, NULL /* opts */, NULL /*&reply*/, &bsonError); bson_destroy(keysPtr); bson_free(index_name); bson_destroy(create_indexes); Tcl_SetObjResult(interp, Tcl_NewBooleanObj(success)); return TCL_OK; } /* cmd "collection::insert" NsfMongoCollectionInsert { {-argName "collection" -required 1 -type mongoc_collection_t} {-argName "values" -required 1 -type tclobj} } */ static int NsfMongoCollectionInsert(Tcl_Interp *interp, mongoc_collection_t *collectionPtr, Tcl_Obj *valuesObj) { int i, objc, result, success; Tcl_Obj **objv; bson_t bson, *bsonPtr = &bson; bson_oid_t oid; bson_error_t bsonError; mongoc_insert_flags_t insertFlags = MONGOC_INSERT_NO_VALIDATE; /* otherwise, we can't insert a DBRef */ /* TODO: insertFlags not handled: MONGOC_INSERT_NONE = 0, MONGOC_INSERT_CONTINUE_ON_ERROR = 1 << 0, MONGOC_INSERT_NO_VALIDATE = 1 << 31, */ const mongoc_write_concern_t *writeConcern = NULL; /* TODO: not handled yet */ result = Tcl_ListObjGetElements(interp, valuesObj, &objc, &objv); if (result != TCL_OK || ((objc % 3) != 0)) { return NsfPrintError(interp, "%s: must contain a multiple of 3 elements", ObjStr(valuesObj)); } bson_init(bsonPtr); bson_oid_init(&oid, NULL); bson_append_oid(bsonPtr, "_id", 3, &oid); for (i = 0; i < objc; i += 3) { const char *name = ObjStr(objv[i]); const char *tag = ObjStr(objv[i+1]); Tcl_Obj *value = objv[i+2]; /*fprintf(stderr, "adding pair '%s' (%s) '%s'\n", name, tag, ObjStr(value));*/ BsonAppend(interp, bsonPtr, name, tag, value); } success = mongoc_collection_insert(collectionPtr, insertFlags, bsonPtr, writeConcern, &bsonError); if (success == 0) { result = NsfPrintError(interp, "mongo::collection::insert: error: %s", bsonError.message); } else { Tcl_SetObjResult(interp, BsonToList(interp, bsonPtr, 0)); } bson_destroy(bsonPtr); return result; } /* cmd collection::query NsfMongoCollectionQuery { {-argName "collection" -required 1 -type mongoc_collection_t} {-argName "filter" -required 1 -type tclobj} {-argName "-opts" -required 0 -nrargs 1 -type tclobj} } */ static int NsfMongoCollectionQuery(Tcl_Interp *interp, mongoc_collection_t *collectionPtr, Tcl_Obj *filterObj, Tcl_Obj *withOptsObj) { int objc1, objc2 = 0, result; Tcl_Obj **objv1, **objv2 = NULL, *resultObj; mongoc_cursor_t *cursor; bson_t filter, *const filterPtr = &filter; bson_t opts, *const optsPtr = &opts; const bson_t *nextPtr; mongoc_read_prefs_t *readPrefsPtr = NULL; /* TODO: not handled */ /*fprintf(stderr, "NsfMongoQuery: namespace %s withLimit %d withSkip %d\n", namespace, withLimit, withSkip);*/ result = Tcl_ListObjGetElements(interp, filterObj, &objc1, &objv1); if (result != TCL_OK || ((objc1 % 3) != 0)) { return NsfPrintError(interp, "%s: must contain a multiple of 3 elements", ObjStr(filterObj)); } if (withOptsObj != NULL) { result = Tcl_ListObjGetElements(interp, withOptsObj, &objc2, &objv2); if (result != TCL_OK || ((objc2 % 3) != 0)) { return NsfPrintError(interp, "%s: must contain a multiple of 3 elements", ObjStr(withOptsObj)); } } else { objc2 = 0; } BsonAppendObjv(interp, filterPtr, objc1, objv1); BsonAppendObjv(interp, optsPtr, objc2, objv2); resultObj = Tcl_NewListObj(0, NULL); cursor = mongoc_collection_find_with_opts( collectionPtr, filterPtr, optsPtr, readPrefsPtr); while( mongoc_cursor_next( cursor, &nextPtr ) == 1 ) { Tcl_ListObjAppendElement(interp, resultObj, BsonToList(interp, nextPtr, 0)); } mongoc_cursor_destroy( cursor ); bson_destroy( filterPtr ); bson_destroy( optsPtr ); Tcl_SetObjResult(interp, resultObj); return TCL_OK; } /* cmd "collection::stats" NsfMongoCollectionStats { {-argName "collection" -required 1 -type mongoc_collection_t} {-argName "-options" -required 0 -type tclobj} } */ static int NsfMongoCollectionStats(Tcl_Interp *interp, mongoc_collection_t *collectionPtr, Tcl_Obj *optionsObj) { int objc = 0, success, result; Tcl_Obj **objv = NULL; bson_t options, *optionsPtr = NULL; bson_t stats, *statsPtr = &stats; bson_t cmd = BSON_INITIALIZER; bson_iter_t iter; bson_error_t bsonError; if (optionsObj != NULL) { result = Tcl_ListObjGetElements(interp, optionsObj, &objc, &objv); if (result != TCL_OK || ((objc % 3) != 0)) { return NsfPrintError(interp, "%s: must contain a multiple of 3 elements", ObjStr(optionsObj)); } optionsPtr = &options; BsonAppendObjv(interp, optionsPtr, objc, objv); } if (optionsPtr != NULL && bson_iter_init_find(&iter, optionsPtr, "scale") && !BSON_ITER_HOLDS_INT32 (&iter)) { bson_set_error(&bsonError, MONGOC_ERROR_BSON, MONGOC_ERROR_BSON_INVALID, "'scale' must be an int32 value."); success = 0; } else { BSON_APPEND_UTF8(&cmd, "collStats", mongoc_collection_get_name(collectionPtr)); if (optionsPtr != NULL) { bson_concat(&cmd, optionsPtr); } success = mongoc_collection_command_simple(collectionPtr, &cmd, mongoc_collection_get_read_prefs(collectionPtr), statsPtr, &bsonError); bson_destroy(&cmd); } if (optionsPtr != NULL) { bson_destroy(optionsPtr); } if (success != 0) { Tcl_SetObjResult(interp, BsonToList(interp, statsPtr, 0)); bson_destroy(statsPtr); result = TCL_OK; } else { result = NsfPrintError(interp, "mongo::collection::stats: error: %s", bsonError.message); } return result; } /* cmd "collection::update" NsfMongoCollectionUpdate { {-argName "collection" -required 1 -type mongoc_collection_t} {-argName "cond" -required 1 -type tclobj} {-argName "values" -required 1 -type tclobj} {-argName "-upsert" -required 0 -nrargs 0} {-argName "-all" -required 0 -nrargs 0} } */ static int NsfMongoCollectionUpdate(Tcl_Interp *interp, mongoc_collection_t *collectionPtr, Tcl_Obj *conditionObj, Tcl_Obj *valuesObj, int withUpsert, int withAll) { const mongoc_write_concern_t *writeConcern = NULL; /* TODO: not handled yet */ mongoc_update_flags_t updateFlags = MONGOC_UPDATE_NO_VALIDATE; /* for dbrefs */ bson_error_t bsonError; bson_t cond, *condPtr = &cond, values, *valuesPtr = &values; int objc, result, success; Tcl_Obj **objv; result = Tcl_ListObjGetElements(interp, conditionObj, &objc, &objv); if (result != TCL_OK || ((objc % 3) != 0)) { return NsfPrintError(interp, "%s: must contain a multiple of 3 elements", ObjStr(conditionObj)); } BsonAppendObjv(interp, condPtr, objc, objv); result = Tcl_ListObjGetElements(interp, valuesObj, &objc, &objv); if (result != TCL_OK || ((objc % 3) != 0)) { bson_destroy(condPtr); return NsfPrintError(interp, "%s: must contain a multiple of 3 elements", ObjStr(valuesObj)); } BsonAppendObjv(interp, valuesPtr, objc, objv); if (withUpsert != 0) {updateFlags |= MONGOC_UPDATE_UPSERT;} if (withAll != 0) {updateFlags |= MONGOC_UPDATE_MULTI_UPDATE;} success = mongoc_collection_update(collectionPtr, updateFlags, condPtr, valuesPtr, writeConcern, &bsonError); if (success == 0) { result = NsfPrintError(interp, "mongo::collection::delete: error: %s", bsonError.message); } return result; } /*********************************************************************** * Cursor interface ***********************************************************************/ /* cmd cursor::aggregate NsfMongoCursorAggregate { {-argName "collection" -required 1 -type mongoc_collection_t} {-argName "pipeline" -required 1 -type tclobj} {-argName "options" -required 1 -type tclobj} {-argName "-tailable" -required 0 -nrargs 0} {-argName "-awaitdata" -required 0 -nrargs 0} } */ static int NsfMongoCursorAggregate(Tcl_Interp *interp, mongoc_collection_t *collectionPtr, Tcl_Obj *pipelineObj, Tcl_Obj *optionsObj, int withTailable, int withAwaitdata) { int objc1, objc2, result; mongoc_query_flags_t queryFlags = 0; Tcl_Obj **objv1, **objv2 = NULL; mongoc_cursor_t *cursor; bson_t pipeline, *pipelinePtr = &pipeline; bson_t options, *optionsPtr = &options; mongoc_read_prefs_t *readPrefsPtr = NULL; /* TODO: not used */ result = Tcl_ListObjGetElements(interp, pipelineObj, &objc1, &objv1); if (result != TCL_OK || ((objc1 % 3) != 0)) { return NsfPrintError(interp, "%s: must contain a multiple of 3 elements", ObjStr(pipelineObj)); } result = Tcl_ListObjGetElements(interp, optionsObj, &objc2, &objv2); if (result != TCL_OK || ((objc2 % 3) != 0)) { return NsfPrintError(interp, "%s: must contain a multiple of 3 elements", ObjStr(optionsObj)); } BsonAppendObjv(interp, pipelinePtr, objc1, objv1); BsonAppendObjv(interp, optionsPtr, objc2, objv2); /* * The last field of mongo_find is options, semantics are described here * https://www.mongodb.org/display/DOCS/Mongo+Wire+Protocol#MongoWireProtocol-OPQUERY */ if (withTailable != 0) { queryFlags |= MONGOC_QUERY_TAILABLE_CURSOR; } if (withAwaitdata != 0) { queryFlags |= MONGOC_QUERY_AWAIT_DATA; } /* TODO: query flags: MONGOC_QUERY_SLAVE_OK = 1 << 2, MONGOC_QUERY_OPLOG_REPLAY = 1 << 3, MONGOC_QUERY_NO_CURSOR_TIMEOUT = 1 << 4, MONGOC_QUERY_EXHAUST = 1 << 6, MONGOC_QUERY_PARTIAL = 1 << 7, */ cursor = mongoc_collection_aggregate(collectionPtr, queryFlags, pipelinePtr, optionsPtr, readPrefsPtr); if (cursor != NULL) { char buffer[80]; if (Nsf_PointerAdd(interp, buffer, 80u, "mongoc_cursor_t", cursor) == TCL_OK) { Tcl_SetObjResult(interp, Tcl_NewStringObj(buffer, -1)); } else { mongoc_cursor_destroy( cursor ); result = TCL_ERROR; } } else { Tcl_ResetResult(interp); } bson_destroy( pipelinePtr ); bson_destroy( optionsPtr ); return result; } /* cmd cursor::find NsfMongoCursorFind { {-argName "collection" -required 1 -type mongoc_collection_t} {-argName "filter" -required 1 -type tclobj} {-argName "-opts" -required 0 -nrargs 1 -type tclobj} } */ static int NsfMongoCursorFind(Tcl_Interp *interp, mongoc_collection_t *collectionPtr, Tcl_Obj *filterObj, Tcl_Obj *withOptsObj) { int objc1, objc2 = 0, result; Tcl_Obj **objv1, **objv2 = NULL; mongoc_cursor_t *cursor; bson_t filter, *filterPtr = &filter; bson_t opts, *optsPtr = &opts; mongoc_read_prefs_t *readPrefsPtr = NULL; /* TODO: not used */ /*fprintf(stderr, "NsfMongoQuery: namespace %s withLimit %d withSkip %d\n", namespace, withLimit, withSkip);*/ result = Tcl_ListObjGetElements(interp, filterObj, &objc1, &objv1); if (result != TCL_OK || ((objc1 % 3) != 0)) { return NsfPrintError(interp, "%s: must contain a multiple of 3 elements", ObjStr(filterObj)); } if (withOptsObj != NULL) { result = Tcl_ListObjGetElements(interp, withOptsObj, &objc2, &objv2); if (result != TCL_OK || ((objc2 % 3) != 0)) { return NsfPrintError(interp, "%s: must contain a multiple of 3 elements", ObjStr(withOptsObj)); } } BsonAppendObjv(interp, filterPtr, objc1, objv1); BsonAppendObjv(interp, optsPtr, objc2, objv2); cursor = mongoc_collection_find_with_opts( collectionPtr, filterPtr, optsPtr, readPrefsPtr); if (cursor != NULL) { char buffer[80]; if (Nsf_PointerAdd(interp, buffer, 80u, "mongoc_cursor_t", cursor) == TCL_OK) { Tcl_SetObjResult(interp, Tcl_NewStringObj(buffer, -1)); } else { mongoc_cursor_destroy( cursor ); result = TCL_ERROR; } } else { Tcl_ResetResult(interp); } bson_destroy( filterPtr ); bson_destroy( optsPtr ); return result; } /* cmd cursor::next NsfMongoCursorNext { {-argName "cursor" -required 1 -type mongoc_cursor_t} } */ static int NsfMongoCursorNext(Tcl_Interp *interp, mongoc_cursor_t *cursor) { int result; const bson_t *nextPtr; result = mongoc_cursor_next( cursor, &nextPtr ); if (result == 1) { Tcl_SetObjResult(interp, BsonToList(interp, nextPtr, 0)); } return TCL_OK; } /* cmd cursor::close NsfMongoCursorClose { {-argName "cursor" -required 1 -type mongoc_cursor_t -withObj 1} } */ static int NsfMongoCursorClose(Tcl_Interp *UNUSED(interp), mongoc_cursor_t *cursor, Tcl_Obj *cursorObj) { mongoc_cursor_destroy( cursor ); Nsf_PointerDelete(ObjStr(cursorObj), cursor, 0); return TCL_OK; } /*********************************************************************** * GridFS interface ***********************************************************************/ /* cmd gridfs::close NsfMongoGridFSClose { {-argName "gfs" -required 1 -type mongoc_gridfs_t -withObj 1} } */ static int NsfMongoGridFSClose(Tcl_Interp *UNUSED(interp), mongoc_gridfs_t *gridfsPtr, Tcl_Obj *gridfsObj) { mongoc_gridfs_destroy(gridfsPtr); Nsf_PointerDelete(ObjStr(gridfsObj), gridfsPtr, 0); return TCL_OK; } /* cmd gridfs::open NsfMongoGridFSOpen { {-argName "conn" -required 1 -type mongoc_client_t} {-argName "dbname" -required 1} {-argName "prefix" -required 1} } */ static int NsfMongoGridFSOpen(Tcl_Interp *interp, mongoc_client_t *clientPtr, const char *dbname, const char *prefix) { char buffer[80]; int result = TCL_OK; bson_error_t bsonError; mongoc_gridfs_t *gfsPtr; gfsPtr = mongoc_client_get_gridfs(clientPtr, dbname, prefix, &bsonError); if (gfsPtr == NULL) { result = NsfPrintError(interp, "mongo::gridfs::open: error: %s", bsonError.message); } if (Nsf_PointerAdd(interp, buffer, 80u, "mongoc_gridfs_t", gfsPtr) == TCL_OK) { Tcl_SetObjResult(interp, Tcl_NewStringObj(buffer, -1)); } else { mongoc_gridfs_destroy(gfsPtr); result = TCL_ERROR; } return result; } /*********************************************************************** * GridFile interface operating on GridFS ***********************************************************************/ #define MONGOC_GRIDFS_READ_CHUNK 4096*4 /* cmd gridfile::create NsfMongoGridFileCreate { {-argName "-source" -required 1 -typeName "gridfilesource" -type "file|string"} {-argName "gfs" -required 1 -type mongoc_gridfs_t} {-argName "value" -required 1} {-argName "name" -required 1} {-argName "contenttype" -required 1} {-argName "-metadata" -required 0 -nrags 1 -type tclobj} } */ static int NsfMongoGridFileCreate(Tcl_Interp *interp, GridfilesourceIdx_t withSource, mongoc_gridfs_t *gridfsPtr, const char *value, const char *name, const char *contenttype, Tcl_Obj *withMetadata ) { int result = TCL_OK; mongoc_gridfs_file_opt_t fileOpts ; mongoc_gridfs_file_t *gridFile; bson_t bsonMetaData, *bsonMetaDataPtr = &bsonMetaData; memset(&fileOpts, 0, sizeof(fileOpts)); if (withSource == GridfilesourceNULL) { withSource = GridfilesourceFileIdx; } if (withMetadata != NULL) { Tcl_Obj **objv; int objc; result = Tcl_ListObjGetElements(interp, withMetadata, &objc, &objv); if (result != TCL_OK || ((objc % 3) != 0)) { return NsfPrintError(interp, "%s: must contain a multiple of 3 elements", ObjStr(withMetadata)); } BsonAppendObjv(interp, bsonMetaDataPtr, objc, objv); fileOpts.metadata = bsonMetaDataPtr; } fileOpts.filename = name; fileOpts.content_type = contenttype; /* const char *md5; const bson_t *aliases; uint32_t chunk_size; */ gridFile = mongoc_gridfs_create_file(gridfsPtr, &fileOpts); if (withSource == GridfilesourceFileIdx) { uint8_t buf[MONGOC_GRIDFS_READ_CHUNK]; mongoc_iovec_t iov = { buf, 0 }; int fd = open(value, O_RDONLY); if (fd < 1) { mongoc_gridfs_file_destroy(gridFile); return NsfPrintError(interp, "nsf::gridfile::create: cannot open file '%s' for reading", value); } for (;; ) { ssize_t n = read(fd, iov.iov_base, MONGOC_GRIDFS_READ_CHUNK); if (n > 0) { iov.iov_len = (size_t)n; n = mongoc_gridfs_file_writev(gridFile, &iov, 1, 0); if ((size_t)n != iov.iov_len) { NsfLog(interp, NSF_LOG_WARN, "mongodb: write of %d bytes returned %d", iov.iov_len, n); } } else if (n == 0) { break; } else { result = TCL_ERROR; break; } } close(fd); } else { mongoc_iovec_t iov = { (char *)value, strlen(value) }; mongoc_gridfs_file_writev(gridFile, &iov, 1, 0); } if (result == TCL_OK) { mongoc_gridfs_file_save(gridFile); } mongoc_gridfs_file_destroy(gridFile); Tcl_SetObjResult(interp, Tcl_NewIntObj(result == TCL_OK)); return result; } /* cmd "gridfile::delete" NsfMongoGridFileDelete { {-argName "gfs" -required 1 -type mongoc_gridfs_t} {-argName "query" -required 1 -type tclobj} } */ static int NsfMongoGridFileDelete(Tcl_Interp *interp, mongoc_gridfs_t *gridfsPtr, Tcl_Obj *queryObj) { bson_t query, *queryPtr = &query; mongoc_cursor_t *files; const bson_t *nextPtr; bson_iter_t it; Tcl_Obj **objv; int objc, result; mongoc_read_prefs_t *readPrefsPtr = NULL; /* TODO: not handled */ result = Tcl_ListObjGetElements(interp, queryObj, &objc, &objv); if (result != TCL_OK || ((objc % 3) != 0)) { return NsfPrintError(interp, "%s: must contain a multiple of 3 elements", ObjStr(queryObj)); } BsonAppendObjv(interp, queryPtr, objc, objv); files = mongoc_collection_find_with_opts( mongoc_gridfs_get_files(gridfsPtr), queryPtr, NULL, readPrefsPtr); bson_destroy(queryPtr); /* * Files should be a valid cursor even if the file doesn't exist. */ if ( files == NULL ) { return NsfPrintError(interp, "gridfs::remove_file: invalid cursor for files"); } /* * Remove each file and it's chunks from files named filename. */ while (mongoc_cursor_next(files, &nextPtr)) { bson_t bson, *bsonPtr = &bson; bson_error_t bsonError; bson_oid_t id; bson_iter_init_find(&it, nextPtr, "_id"); id = *bson_iter_oid(&it); /* * Remove the file with the specified id. */ bson_init(bsonPtr); bson_append_oid(bsonPtr, "_id", 3, &id); mongoc_collection_remove(mongoc_gridfs_get_files(gridfsPtr), 0, bsonPtr, NULL, &bsonError); bson_destroy(bsonPtr); /* * Remove all chunks from the file with the specified id. */ bson_init(bsonPtr); bson_append_oid(bsonPtr, "files_id", 8, &id); mongoc_collection_remove(mongoc_gridfs_get_chunks(gridfsPtr), 0, bsonPtr, NULL, &bsonError); bson_destroy(bsonPtr); } mongoc_cursor_destroy(files); return TCL_OK; } /* cmd gridfile::open NsfMongoGridFileOpen { {-argName "gfs" -required 1 -type mongoc_gridfs_t} {-argName "filter" -required 1 -type tclobj} } */ static int NsfMongoGridFileOpen(Tcl_Interp *interp, mongoc_gridfs_t *gridfsPtr, Tcl_Obj *filterObj) { mongoc_gridfs_file_t* gridFilePtr; bson_error_t bsonError; bson_t filter, *filterPtr = &filter; int result, objc; Tcl_Obj **objv; /*fprintf(stderr, "NsfMongoFilter: namespace %s withLimit %d withSkip %d\n", namespace, withLimit, withSkip);*/ result = Tcl_ListObjGetElements(interp, filterObj, &objc, &objv); if (result != TCL_OK || ((objc % 3) != 0)) { return NsfPrintError(interp, "%s: must contain a multiple of 3 elements", ObjStr(filterObj)); } BsonAppendObjv(interp, filterPtr, objc, objv); gridFilePtr = mongoc_gridfs_find_one_with_opts(gridfsPtr, filterPtr, NULL, &bsonError); if (gridFilePtr != NULL) { char buffer[80]; if (Nsf_PointerAdd(interp, buffer, 80u, "mongoc_gridfs_file_t", gridFilePtr) == TCL_OK) { Tcl_SetObjResult(interp, Tcl_NewStringObj(buffer, -1)); } else { mongoc_gridfs_file_destroy(gridFilePtr); result = TCL_ERROR; } } else { Tcl_ResetResult(interp); } bson_destroy(filterPtr); return result; } /*********************************************************************** * GridFile interface * * Currently offsets and sizes are limited to 32bit integers, we should * relax this later. ***********************************************************************/ /* cmd gridfile::close NsfMongoGridFileClose { {-argName "gridfile" -required 1 -type mongoc_gridfs_file_t -withObj 1} } */ static int NsfMongoGridFileClose(Tcl_Interp *UNUSED(interp), mongoc_gridfs_file_t* gridFilePtr, Tcl_Obj *gridFileObj) { mongoc_gridfs_file_destroy(gridFilePtr); Nsf_PointerDelete(ObjStr(gridFileObj), gridFilePtr, 0); return TCL_OK; } /* cmd gridfile::get_contentlength NsfMongoGridFileGetContentlength { {-argName "gridfile" -required 1 -type mongoc_gridfs_file_t} } */ static int NsfMongoGridFileGetContentlength(Tcl_Interp *interp, mongoc_gridfs_file_t* gridFilePtr) { int64_t len; len = mongoc_gridfs_file_get_length(gridFilePtr); Tcl_SetObjResult(interp, Tcl_NewLongObj(len)); return TCL_OK; } /* cmd gridfile::get_contenttype NsfMongoGridFileGetContentType { {-argName "gridfile" -required 1 -type mongoc_gridfs_file_t} } */ static int NsfMongoGridFileGetContentType(Tcl_Interp *interp, mongoc_gridfs_file_t* gridFilePtr) { Tcl_SetObjResult(interp, Tcl_NewStringObj(mongoc_gridfs_file_get_content_type(gridFilePtr), -1)); return TCL_OK; } /* cmd gridfile::get_metadata NsfMongoGridFileGetMetaData { {-argName "gridfile" -required 1 -type mongoc_gridfs_file_t} } */ static int NsfMongoGridFileGetMetaData(Tcl_Interp *interp, mongoc_gridfs_file_t* gridFilePtr) { const bson_t *metaDataPtr = mongoc_gridfs_file_get_metadata(gridFilePtr); if (metaDataPtr != NULL) { Tcl_SetObjResult(interp, BsonToList(interp, metaDataPtr, 0)); } return TCL_OK; } /* cmd gridfile::read NsfMongoGridFileRead { {-argName "gridfile" -required 1 -type mongoc_gridfs_file_t} {-argName "size" -required 1 -type int} } */ static int NsfMongoGridFileRead(Tcl_Interp *interp, mongoc_gridfs_file_t *gridFilePtr, int size) { ssize_t readSize; Tcl_Obj *resultObj = Tcl_NewByteArrayObj(NULL, size); mongoc_iovec_t iov = { NULL, (size_t)size }; assert(size > 0); iov.iov_base = Tcl_SetByteArrayLength(resultObj, size); readSize = mongoc_gridfs_file_readv(gridFilePtr, &iov, 1, 0 /* min_bytes */, 0 /* timeout_msec */); /*fprintf(stderr, "NsfMongoGridFileRead want %d got %d\n", size, readSize);*/ Tcl_SetByteArrayLength(resultObj, (int)readSize); Tcl_SetObjResult(interp, resultObj); return TCL_OK; } /* cmd "gridfile::seek" NsfMongoGridFileSeek { {-argName "gridfile" -required 1 -type mongoc_gridfs_file_t} {-argName "offset" -required 1 -type int32} } */ static int NsfMongoGridFileSeek(Tcl_Interp *UNUSED(interp), mongoc_gridfs_file_t *gridFilePtr, int offset) { int result; /* * TODO: whence SEEK_SET, SEEK_CUR or SEEK_END; implementation of SEEK_END looks incorrect */ result = mongoc_gridfs_file_seek(gridFilePtr, offset, SEEK_SET); return result < 0 ? TCL_ERROR : TCL_OK; } /*********************************************************************** * Finally, provide the necessary Tcl package interface. ***********************************************************************/ static void Nsfmongo_ThreadExit(ClientData UNUSED(clientData)) { /* * The exit might happen at a time, when Tcl is already shut down. * We can't reliably call NsfLog. */ fprintf(stderr, "+++ Nsfmongo_ThreadExit\n"); #if defined(USE_CLIENT_POOL) NsfMutexLock(&poolMutex); mongoClientPoolRefCount --; if (mongoClientPool != NULL) { /*fprintf(stderr, "========= Nsfmongo_ThreadExit mongoClientPoolRefCount %d\n", mongoClientPoolRefCount);*/ if (mongoClientPoolRefCount < 1) { mongoc_client_pool_destroy(mongoClientPool); mongoClientPool = NULL; mongoc_uri_destroy(mongoUri); mongoUri = NULL; } } NsfMutexUnlock(&poolMutex); #endif } static void Nsfmongo_Exit(ClientData clientData) { /* * The exit might happen at a time, when Tcl is already shut down. * We can't reliably call NsfLog. * * Tcl_Interp *interp = (Tcl_Interp *)clientData; * NsfLog(interp,NSF_LOG_NOTICE, "Nsfmongo Exit"); */ fprintf(stderr, "+++ Nsfmongo_Exit\n"); #if defined(TCL_THREADS) Tcl_DeleteThreadExitHandler(Nsfmongo_ThreadExit, clientData); #endif Tcl_Release(clientData); /* * Release the state of mongo-c-driver explicitly. */ mongoc_cleanup(); } extern int Nsfmongo_Init(Tcl_Interp * interp) { int i; static NsfMutex initMutex = 0; #ifdef USE_TCL_STUBS if (Tcl_InitStubs(interp, TCL_VERSION, 0) == NULL) { return TCL_ERROR; } # ifdef USE_NSF_STUBS if (Nsf_InitStubs(interp, "2.0", 0) == NULL) { return TCL_ERROR; } # endif #else if (Tcl_PkgRequire(interp, "Tcl", TCL_VERSION, 0) == NULL) { return TCL_ERROR; } #endif Tcl_PkgProvide(interp, "nsf::mongo", PACKAGE_VERSION); #ifdef PACKAGE_REQUIRE_FROM_SLAVE_INTERP_WORKS_NOW if (Tcl_PkgRequire(interp, "nsf", PACKAGE_VERSION, 0) == NULL) { return TCL_ERROR; } #endif Tcl_Preserve(interp); #if defined(TCL_THREADS) Tcl_CreateThreadExitHandler(Nsfmongo_ThreadExit, interp); #endif Tcl_CreateExitHandler(Nsfmongo_Exit, interp); #if defined(USE_CLIENT_POOL) NsfMutexLock(&poolMutex); mongoClientPoolRefCount ++; NsfMutexUnlock(&poolMutex); #endif /* * Register global mongo Tcl_Objs once. */ NsfMutexLock(&initMutex); if (NsfMongoGlobalObjs == NULL) { NsfMongoGlobalObjs = (Tcl_Obj **)ckalloc(sizeof(Tcl_Obj*)*nr_elements(NsfMongoGlobalStrings)); for (i = 0; i < nr_elements(NsfMongoGlobalStrings); i++) { NsfMongoGlobalObjs[i] = Tcl_NewStringObj(NsfMongoGlobalStrings[i], -1); Tcl_IncrRefCount(NsfMongoGlobalObjs[i]); } /* * Initializing state of mongo-c-driver explicitly. */ mongoc_init(); } NsfMutexUnlock(&initMutex); Nsf_EnumerationTypeRegister(interp, enumeratorConverterEntries); Nsf_CmdDefinitionRegister(interp, method_definitions); /* * Register the pointer converter. */ Nsf_PointerTypeRegister(interp, "mongoc_client_t", &mongoClientCount); Nsf_PointerTypeRegister(interp, "mongoc_collection_t", &mongoCollectionCount); Nsf_PointerTypeRegister(interp, "mongoc_cursor_t", &mongoCursorCount); Nsf_PointerTypeRegister(interp, "mongoc_gridfs_file_t", &gridfileCount); Nsf_PointerTypeRegister(interp, "mongoc_gridfs_t", &gridfsCount); for (i=0; i < nr_elements(method_command_namespace_names); i++) { Tcl_CreateNamespace(interp, method_command_namespace_names[i], 0, (Tcl_NamespaceDeleteProc *)NULL); } /* * Create all method commands (will use the namespaces above) */ for (i = 0; i < nr_elements(method_definitions)-1; i++) { Tcl_CreateObjCommand(interp, method_definitions[i].methodName, method_definitions[i].proc, 0, 0); } Tcl_SetIntObj(Tcl_GetObjResult(interp), 1); return TCL_OK; } extern int Nsfmongo_SafeInit( Tcl_Interp *interp) { return Nsfmongo_Init(interp); } /* * Local Variables: * mode: c * c-basic-offset: 2 * fill-column: 78 * indent-tabs-mode: nil * End: */