← 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: lbieber
  • Date: 2010-10-02 19:48:35 UTC
  • mfrom: (1730.6.19 drizzle-make-lcov)
  • Revision ID: lbieber@orisndriz08-20101002194835-q5zd9qc4lvx1xnfo
Merge Hartmut - clean up lex, now require flex to build, also "make lcov" improvements

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/lib/sys_mgmt/codeTree.py
1
 
#! /usr/bin/env python
2
 
# -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
3
 
# vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
4
 
#
5
 
# Copyright (C) 2010 Patrick Crews
6
 
#
7
 
# This program is free software; you can redistribute it and/or modify
8
 
# it under the terms of the GNU General Public License as published by
9
 
# the Free Software Foundation; either version 2 of the License, or
10
 
# (at your option) any later version.
11
 
#
12
 
# This program is distributed in the hope that it will be useful,
13
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 
# GNU General Public License for more details.
16
 
#
17
 
# You should have received a copy of the GNU General Public License
18
 
# along with this program; if not, write to the Free Software
19
 
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20
 
 
21
 
"""codeTree
22
 
 
23
 
   definition of what a code tree should look like
24
 
   to the test-runner (which files /directories it should find where)
25
 
   
26
 
   Files paths can be in one of several locations that we locate via
27
 
   systemManager methods
28
 
 
29
 
"""
30
 
# imports
31
 
import os
32
 
 
33
 
 
34
 
class codeTree:
35
 
    """ Defines what files / directories we should find and where
36
 
        allows for optional / required.
37
 
 
38
 
    """
39
 
  
40
 
    def __init__(self, variables, system_manager):
41
 
        self.debug = variables['debug']
42
 
        self.system_manager = system_manager
43
 
        self.logging = system_manager.logging
44
 
 
45
 
    def debug_status(self):
46
 
            self.logging.debug(self)
47
 
            for key, item in sorted(vars(self).items()):
48
 
                self.logging.debug("%s: %s" %(key, item))
49
 
 
50
 
class drizzleTree(codeTree):
51
 
    """ What a Drizzle code tree should look like to the test-runner
52
 
    
53
 
    """
54
 
 
55
 
    def __init__(self, variables,system_manager):
56
 
        self.system_manager = system_manager
57
 
        self.logging = self.system_manager.logging
58
 
        self.skip_keys = ['ld_lib_paths']
59
 
        self.debug = variables['debug']
60
 
        self.verbose = variables['verbose']
61
 
        self.basedir = self.system_manager.find_path([os.path.abspath(variables['basedir'])])
62
 
        self.source_dist = os.path.isdir(os.path.join(self.basedir, 'drizzled'))
63
 
        self.builddir = self.system_manager.find_path([os.path.abspath(self.basedir)])
64
 
        self.testdir = self.system_manager.find_path([os.path.abspath(variables['testdir'])])
65
 
        self.clientbindir = self.system_manager.find_path([os.path.join(self.builddir, 'client')
66
 
                                     , os.path.join(self.basedir, 'client')
67
 
                                     , os.path.join(self.basedir, 'bin')])
68
 
        self.srcdir = self.system_manager.find_path([self.basedir])
69
 
        self.suite_paths = [ os.path.join(self.basedir,'plugin')
70
 
                           , os.path.join(self.testdir,'suite')
71
 
                           ]
72
 
 
73
 
 
74
 
        self.drizzleadmin = self.system_manager.find_path([os.path.join(self.clientbindir,
75
 
                                                     'drizzleadmin')])
76
 
 
77
 
        self.drizzle_client = self.system_manager.find_path([os.path.join(self.clientbindir,
78
 
                                                     'drizzle')])
79
 
 
80
 
        self.drizzledump = self.system_manager.find_path([os.path.join(self.clientbindir,
81
 
                                                     'drizzledump')])
82
 
 
83
 
        self.drizzleimport = self.system_manager.find_path([os.path.join(self.clientbindir,
84
 
                                                     'drizzleimport')])
85
 
 
86
 
        self.drizzle_server = self.system_manager.find_path([os.path.join(self.basedir,'drizzled/drizzled'),
87
 
                                         os.path.join(self.clientbindir,'drizzled'),
88
 
                                         os.path.join(self.basedir,'libexec/drizzled'),
89
 
                                         os.path.join(self.basedir,'bin/drizzled'),
90
 
                                         os.path.join(self.basedir,'sbin/drizzled'),
91
 
                                         os.path.join(self.builddir,'drizzled/drizzled')])
92
 
 
93
 
 
94
 
        self.drizzleslap = self.system_manager.find_path([os.path.join(self.clientbindir,
95
 
                                                     'drizzleslap')])
96
 
 
97
 
        self.schemawriter = self.system_manager.find_path([os.path.join(self.basedir,
98
 
                                                     'drizzled/message/schema_writer'),
99
 
                                        os.path.join(self.builddir,
100
 
                                                     'drizzled/message/schema_writer')])
101
 
 
102
 
        self.drizzletest = self.system_manager.find_path([os.path.join(self.clientbindir,
103
 
                                                   'drizzletest')])
104
 
 
105
 
        self.server_version_string = None
106
 
        self.server_executable = None
107
 
        self.server_version = None
108
 
        self.server_compile_os = None
109
 
        self.server_platform = None
110
 
        self.server_compile_comment = None
111
 
        self.type = 'Drizzle'
112
 
 
113
 
        self.process_server_version()
114
 
        self.ld_lib_paths = self.get_ld_lib_paths()
115
 
         
116
 
        self.report()
117
 
 
118
 
        if self.debug:
119
 
            self.logging.debug_class(self)
120
 
 
121
 
    def report(self):
122
 
        self.logging.info("Using Drizzle source tree:")
123
 
        report_keys = ['basedir'
124
 
                      ,'clientbindir'
125
 
                      ,'testdir'
126
 
                      ,'server_version'
127
 
                      ,'server_compile_os'
128
 
                      ,'server_platform'
129
 
                      ,'server_comment']
130
 
        for key in report_keys:
131
 
            self.logging.info("%s: %s" %(key, vars(self)[key]))
132
 
        
133
 
 
134
 
 
135
 
    def process_server_version(self):
136
 
        """ Get the server version number from the found server executable """
137
 
        (retcode, self.server_version_string) = self.system_manager.execute_cmd(("%s --no-defaults --version" %(self.drizzle_server)))
138
 
        # This is a bit bobo, but we're doing it, so nyah
139
 
        # TODO fix this : )
140
 
        self.server_executable, data_string = [data_item.strip() for data_item in self.server_version_string.split('Ver ')]
141
 
        self.server_version, data_string = [data_item.strip() for data_item in data_string.split('for ')]
142
 
        self.server_compile_os, data_string = [data_item.strip() for data_item in data_string.split(' on')]
143
 
        self.server_platform = data_string.split(' ')[0].strip()
144
 
        self.server_comment = data_string.replace(self.server_platform,'').strip()
145
 
 
146
 
    def get_ld_lib_paths(self):
147
 
        """ Return a list of paths we want added to LD_LIB variables
148
 
 
149
 
            These are processed later by the system manager, but we want to 
150
 
            specify them here (for a drizzle source tree) and now
151
 
  
152
 
        """
153
 
        ld_lib_paths = []
154
 
        if self.source_dist:
155
 
            ld_lib_paths = [ os.path.join(self.basedir,"libdrizzleclient/.libs/")
156
 
                               , os.path.join(self.basedir,"mysys/.libs/")
157
 
                               , os.path.join(self.basedir,"mystrings/.libs/")
158
 
                               , os.path.join(self.basedir,"drizzled/.libs/")
159
 
                                                 , "/usr/local/lib"
160
 
                               ]
161
 
        else:
162
 
            ld_lib_paths = [ os.path.join(self.basedir,"lib")]
163
 
        return ld_lib_paths
164
 
 
165