Merge lp:~aisrael/charms/trusty/mongodb/benchmarking into lp:charms/trusty/mongodb

[Adam Israel]

Add support for benchmarking mongodb with mongoperf, using juju actions.

[lp:~aisrael/charms/trusty/mongodb/benchmarking]

71. By Adam Israel on 2015-05-07

Remove stub for dex benchmark

[uosci-testing-bot (uosci-testing-bot)]

charm_lint_check #4469 mongodb for aisrael mp258558
    LINT OK: passed

Build: http://10.245.162.77:8080/job/charm_lint_check/4469/

[uosci-testing-bot (uosci-testing-bot)]

charm_unit_test #4194 mongodb for aisrael mp258558
    UNIT OK: passed

Build: http://10.245.162.77:8080/job/charm_unit_test/4194/

[uosci-testing-bot (uosci-testing-bot)]

charm_amulet_test #4092 mongodb for aisrael mp258558
    AMULET OK: passed

Build: http://10.245.162.77:8080/job/charm_amulet_test/4092/

[Tim Van Steenburgh (tvansteenburgh)]

+1 LGTM. Very nice, thanks Adam!

review: Approve

=== modified file 'README.md'
--- README.md	2015-01-22 15:31:20 +0000
+++ README.md	2015-05-07 20:42:54 +0000
@@ -236,6 +236,45 @@
 
 To fetch the backups scp the files down from the path in the config.
 
+### Benchmarking
+
+Mongo units can be benchmarked via the `perf` juju action, available beginning with juju 1.23.
+
+    $ juju action defined mongodb
+    perf: The standard mongoperf benchmark.
+    $ juju action do mongodb/0 perf
+    Action queued with id: 23532149-15c2-47f0-8d97-115fb7dfa1cd
+    $ juju action fetch --wait 0 23532149-15c2-47f0-8d97-115fb7dfa1cd
+    results:
+      meta:
+        composite:
+          direction: desc
+          units: ops/sec
+          value: "7736507.70391"
+        start: 2015-05-07T16:36:04Z
+        stop: 2015-05-07T16:39:05Z
+      results:
+        average:
+          units: ops/sec
+          value: "7736507.70391"
+        iterations:
+          units: iterations
+          value: "179"
+        max:
+          units: ops/sec
+          value: "10282496"
+        min:
+          units: ops/sec
+          value: "3874546"
+        total:
+          units: ops
+          value: "1384834879"
+    status: completed
+    timing:
+      completed: 2015-05-07 16:39:06 +0000 UTC
+      enqueued: 2015-05-07 16:36:01 +0000 UTC
+      started: 2015-05-07 16:36:04 +0000 UTC
+
 ## Known Limitations and Issues
 
 - If your master/slave/replicaset deployment is not updating correctly, check the log files at `/var/log/mongodb/mongodb.log` to see if there is an obvious reason ( port not open etc.).

=== added directory 'actions'
=== added file 'actions.yaml'
--- actions.yaml	1970-01-01 00:00:00 +0000
+++ actions.yaml	2015-05-07 20:42:54 +0000
@@ -0,0 +1,49 @@
+perf:
+  description: The standard mongoperf benchmark.
+  params:
+    runtime:
+      description: The time, in seconds, to run mongoperf.
+      type: integer
+      default: 180
+    nthreads:
+      description: |
+        Defines the number of threads mongoperf will use in the test. To saturate your system’s storage system you will need multiple threads. Consider setting nThreads to 16.
+      type: integer
+      default: 1
+    fileSizeMB:
+      description: Test file size, in megabytes.
+      type: integer
+      default: 1
+    sleepMicros:
+      description: |
+        mongoperf will pause for the number of specified sleepMicros divided by the nThreads between each operation.
+      type: integer
+      default: 0
+    mmf:
+      description: |
+        Set mmf to true to use memory mapped files for the tests.
+      type: boolean
+      default:  False
+    r:
+      description: |
+        Set r to true to perform reads as part of the tests.
+      type: boolean
+      default: False
+    w:
+      description: |
+        Set w to true to perform writes as part of the tests.
+      type: boolean
+      default: False
+    recSizeKB:
+      description: The size of each write operation, in kilobytes.
+      type: integer
+      default: 4
+    syncDelay:
+      description: |
+        Seconds between disk flushes. mongoperf.syncDelay is similar to --syncdelay for mongod.
+
+        The syncDelay controls how frequently mongoperf performs an asynchronous disk flush of the memory mapped file used for testing. By default, mongod performs this operation every 60 seconds. Use syncDelay to test basic system performance of this type of operation.
+
+        Only use syncDelay in conjunction with mmf set to true.
+      type: integer
+      default: 0

=== added file 'actions/perf'
--- actions/perf	1970-01-01 00:00:00 +0000
+++ actions/perf	2015-05-07 20:42:54 +0000
@@ -0,0 +1,127 @@
+#!/usr/bin/env python
+import signal
+import subprocess
+import os
+import json
+import re
+from tempfile import NamedTemporaryFile
+from distutils.spawn import find_executable
+
+try:
+    from charmhelpers.contrib.benchmark import Benchmark
+except ImportError:
+    subprocess.check_call(['apt-get', 'install', '-y', 'python-pip'])
+    subprocess.check_call(['pip', 'install', 'charmhelpers'])
+    from charmhelpers.contrib.benchmark import Benchmark
+
+
+def handler(signum, frame):
+    raise IOError('Timeout')
+
+
+def action_set(key, val):
+    action_cmd = ['action-set']
+    if isinstance(val, dict):
+        for k, v in val.iteritems():
+            action_set('%s.%s' % (key, k), v)
+        return
+
+    action_cmd.append('%s=%s' % (key, val))
+    subprocess.check_call(action_cmd)
+
+
+def action_get(key):
+    if find_executable('action-get'):
+        return subprocess.check_output(['action-get', key]).strip()
+    return None
+
+
+def main():
+
+    Benchmark.start()
+
+    """
+    mongoperf runs until interupted so we have to use a
+    signal handler to stop it and gather the results
+    """
+    signal.signal(signal.SIGALRM, handler)
+    runtime = int(action_get('runtime') or 180)
+    signal.alarm(runtime)
+
+    js = {}
+    js['nThreads'] = int(action_get('nthreads'))
+    js['fileSizeMB'] = int(action_get('fileSizeMB'))
+    js['sleepMicros'] = int(action_get('sleepMicros'))
+    js['mmf'] = action_get('mmf')
+    js['r'] = action_get('r')
+    js['w'] = action_get('w')
+    js['recSizeKB'] = int(action_get('recSizeKB'))
+    js['syncDelay'] = int(action_get('syncDelay'))
+
+    config = NamedTemporaryFile(delete=False)
+    config.write(json.dumps(js))
+    config.close()
+    config = open(config.name, 'r')
+
+    output = NamedTemporaryFile(delete=False)
+
+    p = None
+    try:
+        p = subprocess.Popen(
+            'mongoperf',
+            stdin=config,
+            stdout=output,
+        )
+        os.waitpid(p.pid, 0)
+    except subprocess.CalledProcessError as e:
+        rc = e.returncode
+        print "Exit with error code %d" % rc
+    except IOError as e:
+        signal.alarm(0)
+        os.kill(p.pid, signal.SIGKILL)
+    finally:
+        os.unlink(config.name)
+
+    output.close()
+    output = open(output.name, 'r')
+    scores = []
+    regex = re.compile(r'(\d+)\sops\/sec')
+    for line in output:
+        m = regex.match(line)
+        if m:
+            scores.append(int(m.group(1)))
+
+    action_set(
+        "results.total",
+        {'value': sum(scores), 'units': 'ops'}
+    )
+
+    action_set(
+        "results.iterations",
+        {'value': len(scores), 'units': 'iterations'}
+    )
+
+    action_set(
+        "results.average",
+        {'value': sum(scores) / float(len(scores)), 'units': 'ops/sec'}
+    )
+    action_set(
+        "results.max",
+        {'value': max(scores), 'units': 'ops/sec'}
+    )
+    action_set(
+        "results.min",
+        {'value': min(scores), 'units': 'ops/sec'}
+    )
+
+    Benchmark.set_composite_score(
+        sum(scores) / float(len(scores)),
+        'ops/sec',
+        'desc'
+    )
+
+    Benchmark.finish()
+
+
+if __name__ == "__main__":
+    main()

=== modified file 'metadata.yaml'
--- metadata.yaml	2014-10-30 06:00:52 +0000
+++ metadata.yaml	2015-05-07 20:42:54 +0000
@@ -37,6 +37,8 @@
     interface: shard
   mongos:
     interface: mongodb
+  benchmark:
+    interface: benchmark
 peers:
   replica-set:
     interface: mongodb-replica-set