← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to tests/lib/sys_mgmt/codeTree.py

  • Committer: Mark Atwood
  • Date: 2011-10-11 22:37:47 UTC
  • mfrom: (2429.2.1 dbqp_revamp)
  • Revision ID: me@mark.atwood.name-20111011223747-vomebzgvnxxysqrm
merge lp:~patrick-crews/drizzle/dbqp_revamp

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/lib/sys_mgmt/codeTree.py
2
2
# -*- mode: python; indent-tabs-mode: nil; -*-
3
3
# vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
4
4
#
5
 
# Copyright (C) 2010 Patrick Crews
 
5
# Copyright (C) 2010, 2011 Patrick Crews
6
6
#
7
7
# This program is free software; you can redistribute it and/or modify
8
8
# it under the terms of the GNU General Public License as published by
29
29
"""
30
30
# imports
31
31
import os
 
32
import sys
32
33
 
33
34
 
34
35
class codeTree:
58
59
        self.skip_keys = ['ld_lib_paths']
59
60
        self.debug = variables['debug']
60
61
        self.verbose = variables['verbose']
61
 
        self.basedir = self.system_manager.find_path([os.path.abspath(variables['basedir'])])
 
62
        self.basedir = self.system_manager.find_path([os.path.abspath(variables['basedir'][0])])
62
63
        self.source_dist = os.path.isdir(os.path.join(self.basedir, 'drizzled'))
63
64
        self.builddir = self.system_manager.find_path([os.path.abspath(self.basedir)])
64
65
        self.top_builddir = variables['topbuilddir']
67
68
                                     , os.path.join(self.basedir, 'client')
68
69
                                     , os.path.join(self.basedir, 'bin')])
69
70
        self.srcdir = self.system_manager.find_path([self.basedir])
70
 
        self.suite_paths = [ os.path.join(self.basedir,'plugin')
71
 
                           , os.path.join(self.testdir,'suite')
72
 
                           ]
 
71
        self.suite_paths = variables['suitepaths']
73
72
 
74
73
 
75
74
        self.drizzle_client = self.system_manager.find_path([os.path.join(self.clientbindir,
100
99
        self.drizzletest = self.system_manager.find_path([os.path.join(self.clientbindir,
101
100
                                                   'drizzletest')])
102
101
 
103
 
        self.drizzle_trx_reader = self.system_manager.find_path([os.path.join(self.basedir,
 
102
        self.trx_reader = self.system_manager.find_path([os.path.join(self.basedir,
104
103
                                                                 'plugin/transaction_log/utilities/drizzletrx')])
105
104
 
106
105
        self.server_version_string = None
109
108
        self.server_compile_os = None
110
109
        self.server_platform = None
111
110
        self.server_compile_comment = None
112
 
        self.type = 'Drizzle'
 
111
        self.type = 'drizzle'
113
112
 
114
113
        self.process_server_version()
115
114
        self.ld_lib_paths = self.get_ld_lib_paths()
116
115
         
117
116
        self.report()
118
117
 
119
 
        if self.debug:
120
 
            self.logging.debug_class(self)
 
118
        self.logging.debug_class(self)
121
119
 
122
120
    def report(self):
123
121
        self.logging.info("Using Drizzle source tree:")
147
145
    def get_ld_lib_paths(self):
148
146
        """ Return a list of paths we want added to LD_LIB variables
149
147
 
150
 
            These are processed later by the system manager, but we want to 
 
148
            These are processed later at the server_manager level, but we want to 
151
149
            specify them here (for a drizzle source tree) and now
152
150
  
153
151
        """
154
152
        ld_lib_paths = []
155
153
        if self.source_dist:
156
154
            ld_lib_paths = [ os.path.join(self.basedir,"libdrizzleclient/.libs/")
157
 
                           , os.path.join(self.basedir,"libdrizzle-2.0/libdrizzle.libs")
 
155
                           #, os.path.join(self.basedir,"libdrizzle-2.0/libdrizzle.libs")
158
156
                           , os.path.join(self.basedir,"libdrizzle/.libs")
159
157
                           , os.path.join(self.basedir,"libdrizzle-2.0/libdrizzle/.libs")
160
158
                           , os.path.join(self.basedir,"libdrizzle-1.0/libdrizzle/.libs")
167
165
            ld_lib_paths = [ os.path.join(self.basedir,"lib")]
168
166
        return ld_lib_paths
169
167
 
 
168
class mysqlTree(codeTree):
 
169
    """ What a MySQL code tree should look like to the test-runner
 
170
    
 
171
    """
 
172
 
 
173
    def __init__(self, variables,system_manager):
 
174
        self.system_manager = system_manager
 
175
        self.logging = self.system_manager.logging
 
176
        self.skip_keys = ['ld_lib_paths']
 
177
        self.debug = variables['debug']
 
178
        self.verbose = variables['verbose']
 
179
        self.basedir = self.system_manager.find_path([os.path.abspath(variables['basedir'][0])])
 
180
        self.source_dist = os.path.isdir(os.path.join(self.basedir, 'mysqld'))
 
181
        self.builddir = self.system_manager.find_path([os.path.abspath(self.basedir)])
 
182
        self.top_builddir = variables['topbuilddir']
 
183
        self.testdir = self.system_manager.find_path([os.path.abspath(variables['testdir'])])
 
184
        self.clientbindir = self.system_manager.find_path([os.path.join(self.basedir, 'client_release')
 
185
                                                         , os.path.join(self.basedir, 'client_debug')
 
186
                                                         , os.path.join(self.basedir, 'client')
 
187
                                                         , os.path.join(self.basedir, 'bin')])
 
188
        self.charsetdir = self.system_manager.find_path([os.path.join(self.basedir, 'mysql/charsets')
 
189
                                                       , os.path.join(self.basedir, 'sql/share/charsets')
 
190
                                                       , os.path.join(self.basedir, 'share/charsets')])
 
191
        self.langdir = self.system_manager.find_path([os.path.join(self.basedir, 'share/mysql')
 
192
                                                    , os.path.join(self.basedir, 'sql/share')
 
193
                                                    , os.path.join(self.basedir, 'share')])
 
194
 
 
195
 
 
196
        self.srcdir = self.system_manager.find_path([self.basedir])
 
197
        self.suite_paths = variables['suitepaths']
 
198
 
 
199
        self.mysql_client = self.system_manager.find_path([os.path.join(self.clientbindir,
 
200
                                                           'mysql')])
 
201
 
 
202
        self.mysqldump = self.system_manager.find_path([os.path.join(self.clientbindir,
 
203
                                                        'mysqldump')])
 
204
 
 
205
        self.mysqlimport = self.system_manager.find_path([os.path.join(self.clientbindir,
 
206
                                                          'mysqlimport')])
 
207
 
 
208
        self.mysqladmin = self.system_manager.find_path([os.path.join(self.clientbindir,
 
209
                                                         'mysqladmin')])
 
210
 
 
211
        self.mysql_server = self.system_manager.find_path([ os.path.join(self.basedir, '/sql/mysqld-debug')
 
212
                                                          , os.path.join(self.basedir, '/libexec/mysqld-debug')
 
213
                                                          , os.path.join(self.basedir, '/sbin/mysqld-debug')
 
214
                                                          , os.path.join(self.basedir, '/bin/mysqld-debug')
 
215
                                                          , os.path.join(self.basedir, '/sql/mysqld')
 
216
                                                          , os.path.join(self.basedir, '/libexec/mysqld')
 
217
                                                          , os.path.join(self.basedir, '/sbin/mysqld')
 
218
                                                          , os.path.join(self.basedir, '/bin/mysqld')
 
219
                                                          , os.path.join(self.basedir, '/sql/mysqld-max-nt')
 
220
                                                          , os.path.join(self.basedir, '/libexec/mysqld-max-nt')
 
221
                                                          , os.path.join(self.basedir, '/sbin/mysqld-max-nt')
 
222
                                                          , os.path.join(self.basedir, '/bin/mysqld-max-nt')
 
223
                                                          , os.path.join(self.basedir, '/sql/mysqld-max')
 
224
                                                          , os.path.join(self.basedir, '/libexec/mysqld-max')
 
225
                                                          , os.path.join(self.basedir, '/sbin/mysqld-max')
 
226
                                                          , os.path.join(self.basedir, '/bin/mysqld-max')
 
227
                                                          , os.path.join(self.basedir, '/sql/mysqld-nt')
 
228
                                                          , os.path.join(self.basedir, '/libexec/mysqld-nt')
 
229
                                                          , os.path.join(self.basedir, '/sbin/mysqld-nt')
 
230
                                                          , os.path.join(self.basedir, '/bin/mysqld-nt')
 
231
                                                          ])
 
232
 
 
233
 
 
234
 
 
235
        self.mysqlslap = self.system_manager.find_path([os.path.join(self.clientbindir,
 
236
                                                     'mysqlslap')])
 
237
 
 
238
        self.mysqltest = self.system_manager.find_path([os.path.join(self.clientbindir,
 
239
                                                   'mysqltest')])
 
240
        self.server_version_string = None
 
241
        self.server_executable = None
 
242
        self.server_version = None
 
243
        self.server_compile_os = None
 
244
        self.server_platform = None
 
245
        self.server_compile_comment = None
 
246
        self.type = 'mysql'
 
247
        self.process_server_version()
 
248
        self.ld_lib_paths = self.get_ld_lib_paths()
 
249
        self.bootstrap_path = os.path.join( self.system_manager.workdir
 
250
                                          , 'mysql_bootstrap.sql' )
 
251
        self.generate_bootstrap()
 
252
         
 
253
        self.report()
 
254
 
 
255
        self.logging.debug_class(self)
 
256
 
 
257
    def report(self):
 
258
        self.logging.info("Using mysql source tree:")
 
259
        report_keys = ['basedir'
 
260
                      ,'clientbindir'
 
261
                      ,'testdir'
 
262
                      ,'server_version'
 
263
                      ,'server_compile_os'
 
264
                      ,'server_platform'
 
265
                      ,'server_comment']
 
266
        for key in report_keys:
 
267
            self.logging.info("%s: %s" %(key, vars(self)[key]))
 
268
        
 
269
    def process_server_version(self):
 
270
        """ Get the server version number from the found server executable """
 
271
        (retcode, self.server_version_string) = self.system_manager.execute_cmd(("%s --no-defaults --version" %(self.mysql_server)))
 
272
        # This is a bit bobo, but we're doing it, so nyah
 
273
        # TODO fix this : )
 
274
        self.server_executable, data_string = [data_item.strip() for data_item in self.server_version_string.split('Ver ')]
 
275
        self.server_version, data_string = [data_item.strip() for data_item in data_string.split('for ')]
 
276
        self.server_compile_os, data_string = [data_item.strip() for data_item in data_string.split(' on')]
 
277
        self.server_platform = data_string.split(' ')[0].strip()
 
278
        self.server_comment = data_string.replace(self.server_platform,'').strip()
 
279
 
 
280
    def get_ld_lib_paths(self):
 
281
        """ Return a list of paths we want added to LD_LIB variables
 
282
 
 
283
            These are processed later at the server_manager level, but we want to 
 
284
            specify them here (for a mysql source tree) and now
 
285
  
 
286
        """
 
287
        ld_lib_paths = []
 
288
        if self.source_dist:
 
289
            ld_lib_paths = [ os.path.join(self.basedir,"libmysql/.libs/")
 
290
                           , os.path.join(self.basedir,"libmysql_r/.libs")
 
291
                           , os.path.join(self.basedir,"zlib/.libs")
 
292
                           ]
 
293
        else:
 
294
            ld_lib_paths = [ os.path.join(self.basedir,"lib")
 
295
                           , os.path.join(self.basedir,"lib/mysql")]
 
296
        return ld_lib_paths
 
297
 
 
298
    def generate_bootstrap(self):
 
299
        """ We do the voodoo that we need to in order to create the bootstrap
 
300
            file needed by MySQL
 
301
 
 
302
        """
 
303
        found_new_sql = False
 
304
        # determine if we have a proper area for our sql or if we
 
305
        # use the rigged method from 5.0 / 5.1
 
306
        # first we search various possible locations
 
307
        test_file = "mysql_system_tables.sql"
 
308
        for candidate_dir in [ "mysql"
 
309
                         , "sql/share"
 
310
                         , "share/mysql"
 
311
                                           , "share"
 
312
                         , "scripts"]:
 
313
            candidate_path = os.path.join(self.basedir, candidate_dir, test_file)
 
314
            if os.path.exists(candidate_path):
 
315
                bootstrap_file = open(self.bootstrap_path,'w')
 
316
                bootstrap_file.write("use mysql\n")
 
317
                for sql_file in [ 'mysql_system_tables.sql' #official mysql system tables
 
318
                                , 'mysql_system_tables_data.sql' #initial data for sys tables
 
319
                                , 'mysql_test_data_timezone.sql' # subset of full tz table data for testing
 
320
                                , 'fill_help_tables.sql' # fill help tables populated only w/ src dist(?)
 
321
                                ]:
 
322
                    sql_file_path = os.path.join(self.basedir,candidate_dir,sql_file)
 
323
                    sql_file_handle = open(sql_file_path,'r')
 
324
                    bootstrap_file.write(sql_file_handle.readlines())
 
325
                    sql_file_handle.close()
 
326
                found_new_sql = True
 
327
                break
 
328
        if not found_new_sql:
 
329
            # Install the system db's from init_db.sql
 
330
            # that is in early 5.1 and 5.0 versions of MySQL
 
331
            sql_file_path = os.path.join(self.basedir,'mysql-test/lib/init_db.sql')
 
332
            self.logging.info("Attempting to use bootstrap file - %s" %(sql_file_path))
 
333
            try:
 
334
                in_file = open(sql_file_path,'r')
 
335
                bootstrap_file = open(self.bootstrap_path,'w')
 
336
                bootstrap_file.write(in_file.readlines())
 
337
                in_file.close()
 
338
            except IOError:
 
339
                self.logging.error("Cannot find data for generating bootstrap file")
 
340
                self.logging.error("Cannot proceed without this, system exiting...")
 
341
                sys.exit(1)
 
342
        # Remove anonymous users
 
343
        bootstrap_file.write("DELETE FROM mysql.user where user= '';\n")
 
344
        # Create mtr database
 
345
        bootstrap_file.write("CREATE DATABASE mtr;\n")
 
346
        for sql_file in [ 'mtr_warnings.sql' # help tables + data for warning detection / suppression
 
347
                        , 'mtr_check.sql' # Procs for checking proper restore post-testcase
 
348
                        ]:
 
349
            sql_file_path = os.path.join(self.basedir,'mysql-test/include',sql_file)
 
350
            sql_file_handle = open(sql_file_path,'r')
 
351
            bootstrap_file.write(sql_file_handle.readlines())
 
352
            sql_file_handle.close()
 
353
        bootstrap_file.close()
 
354
        return
 
355
 
 
356
 
 
357
        
 
358
 
 
359
 
170
360