← Back to branch summary

~drizzle-trunk/drizzle/jenkins-Drizzle-Builder-73

« back to all changes in this revision

Viewing changes to tests/qp_tests/drizzleslap/drizzleslap_test.py

  • Committer: Continuous Integration
  • Date: 2012-08-22 16:46:57 UTC
  • mfrom: (2582.1.1 qp-sysbench-gsoc)
  • Revision ID: ci@drizzle.org-20120822164657-kscwyfppucshsl7v
added:
  tests/lib/util/database_connect.py
  tests/lib/util/drizzleslap_methods.py
  tests/lib/util/mailing_report.py
  tests/lib/util/sysbenchTestCase.py
  tests/qp_tests/drizzleslap/
  tests/qp_tests/drizzleslap/drizzleslap_test.py
  tests/qp_tests/sysbench/sysbench_readwrite_test.py
  tests/std_data/sysbench_db.sql
modified:
  docs/testing/kewpie.rst
  docs/testing/sysbench.rst
  tests/lib/modes/native/native_test_execution.py
  tests/lib/opts/test_run_options.py
  tests/lib/server_mgmt/drizzled.py
  tests/lib/server_mgmt/server.py
  tests/lib/sys_mgmt/system_management.py
  tests/lib/util/crashme_methods.py
  tests/lib/util/mysql_methods.py
  tests/lib/util/sysbench_methods.py
  tests/qp_tests/crashme/crashme_test.py
  tests/qp_tests/sqlbench/sqlbench_test.py
  tests/qp_tests/sysbench/sysbench_readonly_test.py
pending merge tips: (use -v to see all merge revisions)
  M.Sharan Kumar 2012-08-21 [merge] This branch consists of the work done in connection with GSoC.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/qp_tests/drizzleslap/drizzleslap_test.py
 
1
#! /usr/bin/env python
 
2
# -*- mode: python; indent-tabs-mode: nil; -*-
 
3
# vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
4
#
 
5
# Copyright (C) 2011 Patrick Crews
 
6
# Copyright (C) 2012 Sharan Kumar
 
7
#
 
8
#
 
9
# This program is free software; you can redistribute it and/or modify
 
10
# it under the terms of the GNU General Public License as published by
 
11
# the Free Software Foundation; either version 2 of the License, or
 
12
# (at your option) any later version.
 
13
#
 
14
# This program is distributed in the hope that it will be useful,
 
15
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
17
# GNU General Public License for more details.
 
18
#
 
19
# You should have received a copy of the GNU General Public License
 
20
# along with this program; if not, write to the Free Software
 
21
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
22
 
 
23
import unittest
 
24
import subprocess
 
25
import time
 
26
import re
 
27
 
 
28
from lib.util.drizzleslap_methods import prepare_drizzleslap
 
29
from lib.util.drizzleslap_methods import execute_drizzleslap
 
30
from lib.util.drizzleslap_methods import process_drizzleslap_output
 
31
from lib.util.mysqlBaseTestCase import mysqlBaseTestCase
 
32
from lib.util.database_connect import results_db_connect
 
33
from lib.util.mailing_report import kewpieSendMail
 
34
from lib.opts.test_run_options import parse_qp_options
 
35
 
 
36
# TODO:  make server_options vary depending on the type of server being used here
 
37
# drizzle options
 
38
#server_requirements = [['innodb.buffer-pool-size=256M innodb.log-file-size=64M innodb.log-buffer-size=8M innodb.thread-concurrency=0 innodb.additional-mem-pool-size=16M table-open-cache=4096 table-definition-cache=4096 mysql-protocol.max-connections=2048']]
 
39
# mysql options
 
40
#server_requirements = [['innodb_buffer_pool_size=256M innodb_log_file_size=64M innodb_log_buffer_size=8M innodb_thread_concurrency=0 innodb_additional_mem_pool_size=16M table_open_cache=4096 table_definition_cache=4096 max_connections=2048']]
 
41
server_requirements = [[]]
 
42
servers = []
 
43
server_manager = None
 
44
test_executor = None
 
45
 
 
46
class basicTest(mysqlBaseTestCase):
 
47
        
 
48
    def test_drizzleslap(self):
 
49
        self.logging = test_executor.logging
 
50
        master_server = servers[0]
 
51
        
 
52
        # test group
 
53
        test_groups = ['guid','guid-scale',
 
54
                      'key','key-scale',
 
55
                      'mixed','mixed-commit','mixed-commit-scale','mixed-scale',
 
56
                      'scan','scan-scale',
 
57
                      'update','update-commit','update-commit-scale','update-scale',
 
58
                      'write','write-commit','write-commit-scale','write-scale']
 
59
 
 
60
        # test options specific to each test group
 
61
        test_options = {'guid':" --auto-generate-sql-guid-primary --auto-generate-sql-load-type=write --number-of-queries=100000",
 
62
                        'guid-scale':" --auto-generate-sql-guid-primary --auto-generate-sql-load-type=write --auto-generate-sql-execute-number=1000",
 
63
                        'key':"--auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=key --number-of-queries=100000",
 
64
                        'key-scale':"--auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=key --auto-generate-sql-execute-number=1000",
 
65
                        'mixed':" --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=mixed --number-of-queries=100000",
 
66
                        'mixed-commit':" --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=mixed --number-of-queries=100000 --commit=8",
 
67
                        'mixed-commit-scale':" --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=mixed --auto-generate-sql-execute-number=1000 --commit=8",
 
68
                        'mixed-scale':" --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=mixed --auto-generate-sql-execute-number=1000",
 
69
                        'scan':" --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=read --number-of-queries=100000",
 
70
                        'scan-scale':" --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=read --auto-generate-sql-execute-number=1000",
 
71
                        'update':" --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=update --number-of-queries=100000 --auto-generate-sql-write-number=50000",
 
72
                        'update-commit':"  --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=update --number-of-queries=100000 --auto-generate-sql-write-number=50000 --commit=8 ",
 
73
                        'update-commit-scale':" --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=update --auto-generate-sql-execute-number=1000  --auto-generate-sql-write-number=50000 --commit=8 ",
 
74
                        'update-scale':" --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=update --auto-generate-sql-execute-number=1000 --auto-generate-sql-write-number=50000",
 
75
                        'write':"--auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=write --number-of-queries=100000",
 
76
                        'write-commit':" --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=write --number-of-queries=100000 --commit=8",
 
77
                        'write-commit-scale':"--auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=write --auto-generate-sql-execute-number=1000 --commit=8 ",
 
78
                        'write-scale':" --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=write --auto-generate-sql-execute-number=1000" 
 
79
                       } 
 
80
 
 
81
        # our base test command
 
82
        test_cmd = [ "drizzleslap_tests"
 
83
                   , "--%s-table-engine=innodb" %master_server.type
 
84
                   , "--%s-user=root" %master_server.type
 
85
                   , "--%s-db=test" %master_server.type
 
86
                   , "--%s-port=%d" %(master_server.type, master_server.master_port)
 
87
                   , "--%s-host=localhost" %master_server.type
 
88
                   , "--db-driver=%s" %master_server.type
 
89
                   ]
 
90
 
 
91
        if master_server.type == 'drizzle':
 
92
            test_cmd.append("--drizzle-mysql=on")
 
93
        if master_server.type == 'mysql':
 
94
            test_cmd.append("--mysql-socket=%s" %master_server.socket_file)
 
95
       
 
96
        # We sleep for a minute to wait
 
97
        time.sleep(10) 
 
98
        # how many times to run drizzleslap at each concurrency
 
99
        iterations = 10
 
100
        
 
101
        # setting concurreny for drizzleslap. This concurrency is fixed
 
102
        concurrencies = [50]
 
103
 
 
104
 
 
105
        # we setup once.  This is a readwrite test and we don't
 
106
        # alter the test bed once it is created
 
107
        exec_cmd = " ".join(test_cmd)
 
108
        retcode, output = prepare_drizzleslap(test_executor, exec_cmd)
 
109
        err_msg = ("drizzleslap 'prepare' phase failed.\n"
 
110
                   "retcode:  %d"
 
111
                   "output:  %s" %(retcode,output))
 
112
        self.assertEqual(retcode, 0, msg = err_msg) 
 
113
 
 
114
        # start the test!
 
115
        for concurrency in concurrencies:
 
116
            
 
117
            for group in test_groups:
 
118
                exec_cmd = " ".join(test_cmd)
 
119
                exec_cmd = exec_cmd.join(test_options[group])
 
120
                exec_cmd += "--num-threads=%d" %concurrency
 
121
 
 
122
                for test_iteration in range(iterations): 
 
123
 
 
124
                    retcode, output = execute_drizzleslap(test_executor, exec_cmd)
 
125
                    self.assertEqual(retcode, 0, msg = output)
 
126
                    parsed_output = process_drizzleslap_output(output)
 
127
                    self.logging.info(parsed_output)
 
128
 
 
129
                    #gathering the data from the output
 
130
# TODO
 
131
                    regexes={
 
132
                      'run_id':re.compile()
 
133
                    , 'engine_name':re.compile()
 
134
                    , 'test_name':re.compile()
 
135
                    , 'queries_average':re.compile()
 
136
                    , 'queries_min':re.compile()
 
137
                    , 'queries_max':re.compile()
 
138
                    , 'total_time':re.compile()
 
139
                    , 'stddev':re.compile()
 
140
                    , 'iterations':re.compile()
 
141
                    , 'concurrency':re.compile()
 
142
                    , 'concurrency2':re.compile()
 
143
                    , 'queries_per_client':re.compile()
 
144
                    }
 
145
            
 
146
                    run={}
 
147
                    for line in output.split("\n"):
 
148
                        for key in regexes:
 
149
                            result=regexes[key].match(line)
 
150
                            if result:
 
151
                                run[key]=float(result.group(1))
 
152
          
 
153
 
 
154
                    # fetching test results from results_db database
 
155
                    sql_select="SELECT * FROM drizzleslap_run_iterations WHERE concurrency=%d AND iteration=%d" % (concurrency,test_iteration)
 
156
                    self.logging.info("dsn_string:%s" % dsn_string)
 
157
                    fetch=results_db_connect(dsn_string,"select",sql_select)
 
158
                    fetch['concurrency']=concurrency
 
159
                    fetch['iteration']=test_iteration
 
160
 
 
161
                    # deleting record with current concurrency and iteration
 
162
                    if fetch['concurrency']==concurrency and fetch['iteration']==test_iteration:
 
163
                        sql_delete="DELETE FROM drizzleslap_run_iterations WHERE concurrency=%d AND iteration=%d" % (concurrency,test_iteration)
 
164
                        results_db_connect(dsn_string,"delete",sql_delete)
 
165
            
 
166
                    # updating the results_db database with test results
 
167
                    # it for historical comparison over the life of the code...
 
168
                    sql_insert="""INSERT INTO  drizzleslap_run_iterations VALUES (%d,'%s','%s',%0.3f,%0.3f,%0.3f,%0.3f,%0.3f,%d,%d,%d,%d )""" % ( 
 
169
                                                                           run['run_id'],
 
170
                                                                           run['engine_name'],
 
171
                                                                           run['test_name'],
 
172
                                                                           float(run['queries_avg']),
 
173
                                                                           float(run['queries_min']),
 
174
                                                                           float(run['queries_max']),
 
175
                                                                           float(run['total_time']),
 
176
                                                                           float(run['stddev']),
 
177
                                                                           int(run['iterations']),
 
178
                                                                           int(run['concurrency']),
 
179
                                                                           int(run['concurrency2']),
 
180
                                                                           int(run['queries_per_client']) )
 
181
            
 
182
                    results_db_connect(dsn_string,"insert",sql_insert)
 
183
 
 
184
#TODO get drizzleslap test result ( should modify this and add util method too )
 
185
                #getting test result as report for sysbench
 
186
                sys_report=getSysbenchReport(run,fetch)
 
187
           
 
188
                #mailing sysbench report
 
189
                if mail_tgt:
 
190
                  kewpieSendMail(test_executor,mail_tgt,sys_report)
 
191
 
 
192
 
 
193
    def tearDown(self):
 
194
            server_manager.reset_servers(test_executor.name)
 
195