faststep 0.0.8.1 → 0.1.0.beta1

data/ext/faststep/connection.c

@@ -43,12 +43,12 @@ static VALUE faststep_connection_new(int argc, VALUE* argv, VALUE class) {
 }
 
 static VALUE faststep_connection_connect(VALUE self) {
-  mongo_connection_options* options = (mongo_connection_options*)bson_malloc(sizeof(mongo_connection_options));
+  mongo_host_port* host_port = (mongo_host_port*)bson_malloc(sizeof(mongo_host_port));
 
-  strcpy(options->host, RSTRING_PTR(rb_iv_get(self, "@host")));
-  options->port = NUM2INT(rb_iv_get(self, "@port"));
+  strcpy(host_port->host, RSTRING_PTR(rb_iv_get(self, "@host")));
+  host_port->port = NUM2INT(rb_iv_get(self, "@port"));
 
-  _faststep_connect_or_raise(GetFaststepConnection(self), options);
+  _faststep_connect_or_raise(GetFaststepConnection(self), host_port);
 
   return Qnil;
 }
@@ -67,8 +67,8 @@ static VALUE faststep_connection_master(const VALUE self) {
   return bool_to_ruby(mongo_cmd_ismaster(GetFaststepConnection(self), NULL));
 }
 
-static void _faststep_connect_or_raise(mongo_connection* conn, mongo_connection_options* options) {
-  mongo_connect(conn, options);
+static void _faststep_connect_or_raise(mongo_connection* conn, mongo_host_port* host_port) {
+  mongo_connect(conn, host_port->host, host_port->port);
 
   if(conn->connected == 0) {
     mongo_destroy(conn);

data/ext/faststep/connection.h

@@ -13,5 +13,5 @@ static VALUE faststep_connection_master(const VALUE);
 
 mongo_connection* GetFaststepConnection(const VALUE);
 
-static void _faststep_connect_or_raise(mongo_connection*, mongo_connection_options*);
+static void _faststep_connect_or_raise(mongo_connection*, mongo_host_port*);
 #endif

data/ext/faststep/cursor.c

@@ -58,7 +58,7 @@ static VALUE faststep_cursor_each(const VALUE self) {
   fs_cursor->cursor      = _faststep_build_mongo_cursor(self);
   fs_cursor->initialized = 1;
 
-  while(mongo_cursor_next(fs_cursor->cursor)) {
+  while(MONGO_OK == mongo_cursor_next(fs_cursor->cursor)) {
     rb_yield(ruby_hash_from_bson(&fs_cursor->cursor->current));
   }
 }

data/ext/faststep/encoding.c

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2009-2010 10gen, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Portions Copyright 2001 Unicode, Inc.
+ *
+ * Disclaimer
+ *
+ * This source code is provided as is by Unicode, Inc. No claims are
+ * made as to fitness for any particular purpose. No warranties of any
+ * kind are expressed or implied. The recipient agrees to determine
+ * applicability of information provided. If this file has been
+ * purchased on magnetic or optical media from Unicode, Inc., the
+ * sole remedy for any claim will be exchange of defective media
+ * within 90 days of receipt.
+ *
+ * Limitations on Rights to Redistribute This Code
+ *
+ * Unicode, Inc. hereby grants the right to freely use the information
+ * supplied in this file in the creation of products supporting the
+ * Unicode Standard, and to make copies of this file in any form
+ * for internal or external distribution as long as this notice
+ * remains attached.
+ */
+
+
+#include "bson.h"
+#include "encoding.h"
+
+/*
+ * Index into the table below with the first byte of a UTF-8 sequence to
+ * get the number of trailing bytes that are supposed to follow it.
+ */
+static const char trailingBytesForUTF8[256] = {
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+    2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
+};
+
+/* --------------------------------------------------------------------- */
+
+/*
+ * Utility routine to tell whether a sequence of bytes is legal UTF-8.
+ * This must be called with the length pre-determined by the first byte.
+ * The length can be set by:
+ *  length = trailingBytesForUTF8[*source]+1;
+ * and the sequence is illegal right away if there aren't that many bytes
+ * available.
+ * If presented with a length > 4, this returns 0.  The Unicode
+ * definition of UTF-8 goes up to 4-byte sequences.
+ */
+static int isLegalUTF8(const unsigned char* source, int length) {
+    unsigned char a;
+    const unsigned char* srcptr = source + length;
+    switch (length) {
+    default: return 0;
+        /* Everything else falls through when "true"... */
+    case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return 0;
+    case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return 0;
+    case 2: if ((a = (*--srcptr)) > 0xBF) return 0;
+        switch (*source) {
+            /* no fall-through in this inner switch */
+            case 0xE0: if (a < 0xA0) return 0; break;
+            case 0xF0: if (a < 0x90) return 0; break;
+            case 0xF4: if (a > 0x8F) return 0; break;
+            default:  if (a < 0x80) return 0;
+        }
+        case 1: if (*source >= 0x80 && *source < 0xC2) return 0;
+        if (*source > 0xF4) return 0;
+    }
+    return 1;
+}
+
+static int bson_validate_string( bson_buffer* b, const unsigned char* string,
+    const int length, const char check_utf8, const char check_dot,
+    const char check_dollar) {
+
+    int position = 0;
+    int sequence_length = 1;
+
+    if( check_dollar && string[0] == '$' ) {
+        b->err |= BSON_FIELD_INIT_DOLLAR;
+    }
+
+    while (position < length) {
+        if (check_dot && *(string + position) == '.') {
+            b->err |= BSON_FIELD_HAS_DOT;
+        }
+
+        if (check_utf8) {
+            sequence_length = trailingBytesForUTF8[*(string + position)] + 1;
+            if ((position + sequence_length) > length) {
+                b->err |= BSON_NOT_UTF8;
+                return BSON_ERROR;
+            }
+            if (!isLegalUTF8(string + position, sequence_length)) {
+                b->err |= BSON_NOT_UTF8;
+                return BSON_ERROR;
+            }
+        }
+        position += sequence_length;
+    }
+
+    return BSON_OK;
+}
+
+
+int bson_check_string( bson_buffer* b, const unsigned char* string,
+    const int length ) {
+
+    return bson_validate_string( b, string, length, 1, 0, 0 );
+}
+
+int bson_check_field_name( bson_buffer* b, const unsigned char* string,
+    const int length ) {
+
+    return bson_validate_string( b, string, length, 1, 1, 1 );
+}

data/ext/faststep/encoding.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2010 10gen, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _BSON_ENCODING_H_
+#define _BSON_ENCODING_H_
+
+MONGO_EXTERN_C_START
+
+/**
+ * Check that a field name is valid UTF8, does not start with a '$',
+ * and contains no '.' characters. Set buffer bit field appropriately.
+ * Note that we don't need to check for '\0' because we're using
+ * strlen(3), which stops at '\0'.
+ *
+ * @param b The bson_buffer to which field name will be appended.
+ * @param string The field name as char*.
+ * @param length The length of the field name.
+ *
+ * @return BSON_OK if valid UTF8 and BSON_ERROR if not. All BSON strings must be
+ *     valid UTF8. This function will also check whether the string
+ *     contains '.' or starts with '$', since the validity of this depends on context.
+ *     Set the value of b->err appropriately.
+ */
+int bson_check_field_name( bson_buffer* b, const unsigned char* string,
+    const int length );
+
+/**
+ * Check that a string is valid UTF8. Sets the buffer bit field appropriately.
+ *
+ * @param b The bson_buffer to which string will be appended.
+ * @param string The string to check.
+ * @param length The length of the string.
+ *
+ * @return BSON_OK if valid UTF-8; otherwise, BSON_ERROR.
+ *     Sets b->err on error.
+ */
+bson_bool_t bson_check_string( bson_buffer* b, const unsigned char* string,
+    const int length );
+
+MONGO_EXTERN_C_END
+#endif

data/ext/faststep/gridfs.c

@@ -103,7 +103,7 @@ int gridfs_init(mongo_connection * client, const char * dbname,
   bson_append_int(&bb, "filename", 1);
   bson_from_buffer(&b, &bb);
   options = 0;
-  success = mongo_create_index(gfs->client, gfs->files_ns, &b, options, &out);
+  success = (mongo_create_index(gfs->client, gfs->files_ns, &b, options, &out) == MONGO_OK);
   bson_destroy(&b);
   if (!success) {
     free((char*)gfs->dbname);
@@ -118,7 +118,7 @@ int gridfs_init(mongo_connection * client, const char * dbname,
   bson_append_int(&bb, "n", 1);
   bson_from_buffer(&b, &bb);
   options = MONGO_INDEX_UNIQUE;
-  success = mongo_create_index(gfs->client, gfs->chunks_ns, &b, options, &out);
+  success = (mongo_create_index(gfs->client, gfs->chunks_ns, &b, options, &out) == MONGO_OK);
   bson_destroy(&b);
   if (!success) {
     free((char*)gfs->dbname);
@@ -160,8 +160,7 @@ static bson gridfs_insert_file( gridfs* gfs, const char* name,
   bson_append_oid(&buf, "filemd5", &id);
   bson_append_string(&buf, "root", gfs->prefix);
   bson_from_buffer(&command, &buf);
-  assert(mongo_run_command(gfs->client, gfs->dbname,
-         &command, &res));
+  assert(mongo_run_command(gfs->client, gfs->dbname, &command, &res) == MONGO_OK);
   bson_destroy(&command);
 
   /* Create and insert BSON for file metadata */
@@ -325,6 +324,7 @@ bson gridfile_writer_done( gridfile* gfile )
     oChunk = chunk_new(gfile->id, gfile->chunk_num, gfile->pending_data, gfile->pending_len);
     mongo_insert(gfile->gfs->client, gfile->gfs->chunks_ns, oChunk);
     chunk_free(oChunk);
+    free(gfile->pending_data);
     gfile->length += gfile->pending_len;
   }
 
@@ -399,7 +399,7 @@ void gridfs_remove_filename(gridfs* gfs, const char* filename )
   bson_destroy(&query);
 
   /* Remove each file and it's chunks from files named filename */
-  while (mongo_cursor_next(files)) {
+  while (mongo_cursor_next(files) == MONGO_OK) {
     file = files->current;
     bson_find(&it, &file, "_id");
     id = *bson_iterator_oid(&it);
@@ -444,7 +444,7 @@ int gridfs_find_query(gridfs* gfs, bson* query,
 
 
   i = (mongo_find_one(gfs->client, gfs->files_ns,
-         &finalQuery, NULL, &out));
+         &finalQuery, NULL, &out) == MONGO_OK);
   bson_destroy(&uploadDate);
   bson_destroy(&finalQuery);
   if (!i)
@@ -658,7 +658,7 @@ bson gridfile_get_chunk(gridfile* gfile, int n)
 
   assert(mongo_find_one(gfile->gfs->client,
       gfile->gfs->chunks_ns,
-      &query, NULL, &out));
+      &query, NULL, &out) == MONGO_OK);
   return out;
 }
 
@@ -719,7 +719,6 @@ gridfs_offset gridfile_write_file(gridfile* gfile, FILE *stream)
   const int num = gridfile_get_numchunks( gfile );
 
   for ( i=0; i<num; i++ ){
-    printf("N: %d", i);
     chunk = gridfile_get_chunk( gfile, i );
     bson_find( &it, &chunk, "data" );
     len = bson_iterator_bin_len( &it );

data/ext/faststep/gridfs.h

@@ -1,3 +1,7 @@
+/**
+ * @file gridfs.h
+ * @brief GridFS Declarations
+ */
 /*--------------------------------------------------------------------*/
 /* gridfs.h                                                           */
 /* Author: Christopher Triolo                                         */
@@ -82,7 +86,8 @@ void gridfs_destroy( gridfs* gfs );
  *
  *  @return - 1 if successful, 0 otherwise
  */
-void gridfile_writer_init( gridfile* gfile, gridfs* gfs, const char* remote_name, const char* content_type );
+void gridfile_writer_init( gridfile* gfile, gridfs* gfs, const char* remote_name,
+    const char* content_type );
 
 /** Write to a GridFS file incrementally. You can call this function any number
  *  of times with a new buffer each time. This allows you to effectively
@@ -90,7 +95,8 @@ void gridfile_writer_init( gridfile* gfile, gridfs* gfs, const char* remote_name
  *
  *  @return - 1 if successful, 0 otherwise
  */
-void gridfile_write_buffer( gridfile* gfile, const char* data, gridfs_offset length );
+void gridfile_write_buffer( gridfile* gfile, const char* data,
+    gridfs_offset length );
 
 /** Signal that writing of this gridfile is complete by
  *  writing any buffered chunks along with the entry in the

data/ext/faststep/md5.h

@@ -1,3 +1,5 @@
+/** @file md5.h */
+
 /*
   Copyright (C) 1999, 2002 Aladdin Enterprises.  All rights reserved.