mongodb: Update yaml

code clean up

driver-mongodb/src/main/java/io/nosqlbench/driver/mongodb/MongoAction.java

@@ -6,8 +6,6 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import com.codahale.metrics.Timer;
-import com.mongodb.ReadPreference;
-import com.mongodb.client.MongoDatabase;
 import io.nosqlbench.engine.api.activityapi.core.SyncAction;
 import io.nosqlbench.engine.api.activityapi.planning.OpSequence;
 import org.bson.Document;
@@ -51,12 +49,9 @@ public class MongoAction implements SyncAction {
             activity.triesHisto.update(i);
 
             try (Timer.Context resultTime = activity.resultTimer.time()) {
-                MongoDatabase database = activity.getDatabase();
-                ReadPreference readPreference = rms.getReadPreference();
-
                 // assuming the commands are one of these in the doc:
                 // https://docs.mongodb.com/manual/reference/command/nav-crud/
-                Document resultDoc = database.runCommand(queryBson, readPreference);
+                Document resultDoc = activity.getDatabase().runCommand(queryBson, rms.getReadPreference());
 
                 long resultNanos = System.nanoTime() - nanoStartTime;
 

driver-mongodb/src/main/java/io/nosqlbench/driver/mongodb/MongoActivity.java

@@ -10,6 +10,8 @@ import org.slf4j.LoggerFactory;
 
 import com.codahale.metrics.Histogram;
 import com.codahale.metrics.Timer;
+import com.mongodb.ConnectionString;
+import com.mongodb.MongoClientSettings;
 import com.mongodb.client.MongoClient;
 import com.mongodb.client.MongoClients;
 import com.mongodb.client.MongoDatabase;
@@ -26,6 +28,12 @@ import io.nosqlbench.engine.api.activityimpl.SimpleActivity;
 import io.nosqlbench.engine.api.metrics.ActivityMetrics;
 import io.nosqlbench.engine.api.templating.StrInterpolator;
 import io.nosqlbench.engine.api.util.TagFilter;
+import org.bson.UuidRepresentation;
+import org.bson.codecs.UuidCodec;
+import org.bson.codecs.configuration.CodecRegistry;
+
+import static org.bson.codecs.configuration.CodecRegistries.fromCodecs;
+import static org.bson.codecs.configuration.CodecRegistries.fromRegistries;
 
 public class MongoActivity extends SimpleActivity implements ActivityDefObserver {
 
@@ -45,8 +53,8 @@ public class MongoActivity extends SimpleActivity implements ActivityDefObserver
     Timer bindTimer;
     Timer resultTimer;
     Timer resultSuccessTimer;
-    Histogram resultSetSizeHisto;
     Histogram triesHisto;
+    Histogram resultSetSizeHisto;
 
     public MongoActivity(ActivityDef activityDef) {
         super(activityDef);
@@ -74,7 +82,7 @@ public class MongoActivity extends SimpleActivity implements ActivityDefObserver
         opSequence = initOpSequencer();
         setDefaultsFromOpSequence(opSequence);
 
-        client = MongoClients.create(connectionString);
+        client = createMongoClient(connectionString);
         mongoDatabase = client.getDatabase(databaseName);
         showQuery = activityDef.getParams().getOptionalBoolean("showquery")
                                .orElse(false);
@@ -111,6 +119,9 @@ public class MongoActivity extends SimpleActivity implements ActivityDefObserver
         stmtsDocList.getStmts().stream().map(tagFilter::matchesTaggedResult).forEach(r -> logger.info(r.getLog()));
 
         List<OpTemplate> stmts = stmtsDocList.getStmts(tagfilter);
+        if (stmts.isEmpty()) {
+            logger.error("No statements found for this activity");
+        } else {
             for (OpTemplate stmt : stmts) {
                 ParsedStmt parsed = stmt.getParsed().orError();
                 String statement = parsed.getPositionalStatement(Function.identity());
@@ -118,10 +129,22 @@ public class MongoActivity extends SimpleActivity implements ActivityDefObserver
 
                 sequencer.addOp(new ReadyMongoStatement(stmt), stmt.getParamOrDefault("ratio",1));
             }
+        }
 
         return sequencer.resolve();
     }
 
+    MongoClient createMongoClient(String connectionString) {
+        CodecRegistry codecRegistry = fromRegistries(fromCodecs(new UuidCodec(UuidRepresentation.STANDARD)),
+                                                     MongoClientSettings.getDefaultCodecRegistry());
+        MongoClientSettings settings = MongoClientSettings.builder()
+                                                          .applyConnectionString(new ConnectionString(connectionString))
+                                                          .codecRegistry(codecRegistry)
+                                                          .uuidRepresentation(UuidRepresentation.STANDARD)
+                                                          .build();
+        return MongoClients.create(settings);
+    }
+
     protected MongoDatabase getDatabase() {
         return mongoDatabase;
     }

driver-mongodb/src/main/java/io/nosqlbench/driver/mongodb/MongoActivityType.java

@@ -28,8 +28,7 @@ public class MongoActivityType implements ActivityType<MongoActivity> {
 
         private final MongoActivity activity;
 
-        public MongoActionDispenser(MongoActivity activity)
+        public MongoActionDispenser(MongoActivity activity) {
-        {
             this.activity = activity;
         }
 

driver-mongodb/src/main/java/io/nosqlbench/driver/mongodb/ReadyMongoStatement.java

@@ -11,8 +11,8 @@ import org.bson.conversions.Bson;
 
 public class ReadyMongoStatement {
 
-    private StringBindings bindings;
+    private final StringBindings bindings;
-    private ReadPreference readPreference;
+    private final ReadPreference readPreference;
 
     public ReadyMongoStatement(OpTemplate stmtDef) {
         ParsedTemplate paramTemplate = new ParsedTemplate(stmtDef.getStmt(), stmtDef.getBindings());

driver-mongodb/src/main/resources/activities/mongodb-basic-uuid.yaml

@@ -0,0 +1,80 @@
+# nb -v run driver=mongodb yaml=mongodb-basic-uuid connection=mongodb://127.0.0.1 database=testdb tags=phase:rampup
+description: An exmaple of a basic mongo insert and find with UUID
+
+scenarios:
+  default:
+    - run driver=mongodb tags==phase:rampup cycles===TEMPLATE(rampup-cycles,100000000) threads=auto
+    - run driver=mongodb tags==phase:main cycles===TEMPLATE(main-cycles,100000000) threads=auto
+bindings:
+  seq_uuid: Mod(<<uuidCount:100000000>>L); ToHashedUUID() -> java.util.UUID; ToString() -> String
+  rw_uuid: <<uuidDist:Uniform(0,100000000)->long>>; ToHashedUUID() -> java.util.UUID; ToString() -> String
+  seq_key: Mod(<<keyCount:1000000>>L); ToInt()
+  seq_value: Mod(<<valueCount:1000000000>>L); <<valueSizeDist:Hash()>>; ToLong()
+  rw_key: <<keyDist:Uniform(0,1000000)->long>>; ToInt()
+  rw_value: <<valDist:Uniform(0,1000000000)->long>>; <<valueSizeDist:Hash()>>; ToLong()
+
+blocks:
+  - name: rampup
+    tags:
+      phase: rampup
+    statements:
+      - rampup-insert: |
+          {
+            insert: "<<collection:keyvalueuuid>>",
+            documents: [ { _id: UUID("{seq_uuid}"),
+                           key: {seq_key},
+                           value: NumberLong({seq_value}) } ]
+          }
+        params:
+          readPreference: primary
+        tags:
+          name: rampup-insert
+  - name: verify
+    tags:
+      phase: verify
+      type: read
+    params:
+      cl: <<read_cl:LOCAL_QUORUM>>
+    statements:
+      - verify-find: |
+          {
+            find: "<<collection:keyvalueuuid>>",
+            filter: { _id: UUID("{seq_uuid}") }
+          }
+        verify-fields: _id->seq_uuid, key->seq_key, value->seq_value
+        tags:
+          name: verify
+  - name: main-read
+    tags:
+      phase: main
+      type: read
+    params:
+      ratio: <<read_ratio:1>>
+    statements:
+      - main-find: |
+          {
+            find: "<<collection:keyvalueuuid>>",
+            filter: { _id: UUID("{rw_uuid}") }
+          }
+        params:
+          readPreference: primary
+        tags:
+          name: main-find
+  - name: main-write
+    tags:
+      phase: main
+      type: write
+    params:
+      ratio: <<write_ratio:1>>
+    statements:
+      - main-insert: |
+          {
+            insert: "<<collection:keyvalueuuid>>",
+            documents: [ { _id: UUID("{rw_uuid}")
+                           key: {rw_key},
+                           value: NumberLong({rw_value}) } ]
+          }
+        params:
+          readPreference: primary
+        tags:
+          name: main-insert

driver-mongodb/src/main/resources/activities/mongodb-basic.yaml

@@ -1,15 +1,15 @@
-# nb -v run driver=mongodb yaml=mongodb-basic connection=mongodb://127.0.0.1 database=testdb tags=phase:rampup
+# nb -v run driver=mongodb yaml=mongodb-basic connection=mongodb://127.0.0.1 database=testdb tags=phase:rampup cycles=1M
 description: An exmaple of a basic mongo insert and find.
 
 scenarios:
   default:
-    - run driver=mongodb tags==phase:rampup cycles===TEMPLATE(rampup-cycles,10000000) threads=auto
+    - run driver=mongodb tags==phase:rampup cycles===TEMPLATE(rampup-cycles,1000000) threads=auto
-    - run driver=mongodb tags==phase:main cycles===TEMPLATE(main-cycles,10000000) threads=auto
+    - run driver=mongodb tags==phase:main cycles===TEMPLATE(main-cycles,1000000) threads=auto
 bindings:
-  seq_key: Mod(<<keycount:1000000000>>); ToString() -> String
+  seq_key: Mod(<<keyCount:1000000>>L); ToInt()
-  seq_value: Hash(); Mod(<<valuecount:1000000000>>); ToString() -> String
+  seq_value: Mod(<<valueCount:1000000000>>L); <<valueSizeDist:Hash()>>; ToString() -> String
-  rw_key: <<keydist:Uniform(0,1000000000)->int>>; ToString() -> String
+  rw_key: <<keyDist:Uniform(0,1000000)->long>>; ToInt()
-  rw_value: Hash(); <<valdist:Uniform(0,1000000000)->int>>; ToString() -> String
+  rw_value: <<valDist:Uniform(0,1000000000)->int>>; <<valueSizeDist:Hash()>>; ToString() -> String
 
 blocks:
   - name: rampup
@@ -19,7 +19,7 @@ blocks:
       - rampup-insert: |
           {
             insert: "<<collection:keyvalue>>",
-            documents: [ { key: {seq_key},
+            documents: [ { _id: {seq_key},
                            value: {seq_value} } ]
           }
         params:
@@ -31,12 +31,12 @@ blocks:
       phase: main
       type: read
     params:
-      ratio: <<read_ratio:5>>
+      ratio: <<read_ratio:1>>
     statements:
       - main-find: |
           {
             find: "<<collection:keyvalue>>",
-            filter: { key: {rw_key} }
+            filter: { _id: {rw_key} }
           }
         params:
           readPreference: primary
@@ -47,12 +47,12 @@ blocks:
       phase: main
       type: write
     params:
-      ratio: <<write_ratio:5>>
+      ratio: <<write_ratio:1>>
     statements:
       - main-insert: |
           {
             insert: "<<collection:keyvalue>>",
-            documents: [ { key: {rw_key},
+            documents: [ { _id: {rw_key},
                            value: {rw_value} } ]
           }
         params:

driver-mongodb/src/test/java/io/nosqlbench/driver/mongodb/ReadyMongoStatementTest.java

@@ -48,8 +48,8 @@ public class ReadyMongoStatementTest {
             ParsedStmt parsed = stmt.getParsed().orError();
             assertThat(parsed.getBindPoints()).hasSize(2);
 
-            BindPoint seqKey = new BindPoint("seq_key", "Mod(1000000000); ToString() -> String");
+            BindPoint seqKey = new BindPoint("seq_key", "Mod(1000000L); ToInt()");
-            BindPoint seqValue = new BindPoint("seq_value", "Hash(); Mod(1000000000); ToString() -> String");
+            BindPoint seqValue = new BindPoint("seq_value", "Mod(1000000000L); Hash(); ToString() -> String");
             assertThat(parsed.getBindPoints()).containsExactly(seqKey, seqValue);
 
             String statement = parsed.getPositionalStatement(Function.identity());
@@ -71,7 +71,7 @@ public class ReadyMongoStatementTest {
             ParsedStmt parsed = stmt.getParsed().orError();
             assertThat(parsed.getBindPoints()).hasSize(1);
 
-            BindPoint rwKey = new BindPoint("rw_key", "Uniform(0,1000000000)->int; ToString() -> String");
+            BindPoint rwKey = new BindPoint("rw_key", "Uniform(0,1000000)->long; ToInt()");
             assertThat(parsed.getBindPoints()).containsExactly(rwKey);
 
             String statement = parsed.getPositionalStatement(Function.identity());
@@ -93,8 +93,8 @@ public class ReadyMongoStatementTest {
             ParsedStmt parsed = stmt.getParsed().orError();
             assertThat(parsed.getBindPoints()).hasSize(2);
 
-            BindPoint rwKey = new BindPoint("rw_key", "Uniform(0,1000000000)->int; ToString() -> String");
+            BindPoint rwKey = new BindPoint("rw_key", "Uniform(0,1000000)->long; ToInt()");
-            BindPoint rwValue = new BindPoint("rw_value", "Hash(); Uniform(0,1000000000)->int; ToString() -> String");
+            BindPoint rwValue = new BindPoint("rw_value", "Uniform(0,1000000000)->int; Hash(); ToString() -> String");
             assertThat(parsed.getBindPoints()).containsExactly(rwKey, rwValue);
 
             String statement = parsed.getPositionalStatement(Function.identity());