← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to tests/lib/server_mgmt/drizzled.py

  • Committer: Lee Bieber
  • Date: 2010-11-14 23:15:42 UTC
  • mfrom: (1929.1.42 warning-stack-frame)
  • Revision ID: kalebral@gmail.com-20101114231542-fnnu6ydd2p17n582
Merge Monty - fix bug 672372: some functions use > 32k stack

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/lib/server_mgmt/drizzled.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
 
 
22
 
""" drizzled.py:  code to allow a serverManager
23
 
    to provision and start up a drizzled server object
24
 
    for test execution
25
 
 
26
 
"""
27
 
 
28
 
# imports
29
 
import os
30
 
 
31
 
class drizzleServer():
32
 
    """ represents a drizzle server, its possessions
33
 
        (datadir, ports, etc), and methods for controlling
34
 
        and querying it
35
 
 
36
 
        TODO: create a base server class that contains
37
 
              standard methods from which we can inherit
38
 
              Currently there are definitely methods / attr
39
 
              which are general
40
 
 
41
 
    """
42
 
 
43
 
    def __init__(self, name, server_manager, server_options
44
 
                , requester, workdir_root):
45
 
        self.skip_keys = [ 'server_manager'
46
 
                         , 'system_manager'
47
 
                         , 'dirset'
48
 
                         , 'preferred_base_port'
49
 
                         , 'no_secure_file_priv'
50
 
                         , 'secure_file_string'
51
 
                         , 'port_block'
52
 
                         ]
53
 
        self.debug = server_manager.debug
54
 
        self.verbose = server_manager.verbose
55
 
        self.initial_run = 1
56
 
        self.owner = requester
57
 
        self.server_options = server_options
58
 
        self.server_manager = server_manager
59
 
        # We register with server_manager asap
60
 
        self.server_manager.log_server(self, requester)
61
 
 
62
 
        self.system_manager = self.server_manager.system_manager
63
 
        self.valgrind = self.system_manager.valgrind
64
 
        self.gdb = self.system_manager.gdb
65
 
        if self.valgrind:
66
 
            self.valgrind_time_buffer = 10
67
 
        else:
68
 
            self.valgrind_time_buffer = 1
69
 
        self.cmd_prefix = self.system_manager.cmd_prefix
70
 
        self.logging = self.system_manager.logging
71
 
        self.no_secure_file_priv = self.server_manager.no_secure_file_priv
72
 
        self.code_tree = self.system_manager.code_tree
73
 
        self.preferred_base_port = 9306
74
 
        self.name = name
75
 
        self.status = 0 # stopped, 1 = running
76
 
        self.tried_start = 0
77
 
        self.failed_test = 0 # was the last test a failure?  our state is suspect
78
 
        self.server_start_timeout = 60 * self.valgrind_time_buffer
79
 
 
80
 
        # Get our ports
81
 
        self.port_block = self.system_manager.port_manager.get_port_block( self.name
82
 
                                                                         , self.preferred_base_port
83
 
                                                                         , 5 )
84
 
        self.master_port = self.port_block[0]
85
 
        self.drizzle_tcp_port = self.port_block[1]
86
 
        self.mc_port = self.port_block[2]
87
 
        self.pbms_port = self.port_block[3]
88
 
        self.rabbitmq_node_port = self.port_block[4]
89
 
        
90
 
 
91
 
        # Generate our working directories
92
 
        self.dirset = { self.name : { 'var': {'std_data_ln':( os.path.join(self.code_tree.testdir,'std_data'))
93
 
                                             ,'log':None
94
 
                                             ,'run':None
95
 
                                             ,'tmp':None
96
 
                                             ,'master-data': {'local': { 'test':None
97
 
                                                                       , 'mysql':None
98
 
                                                                       }
99
 
                                                             }
100
 
                                             }  
101
 
                                    } 
102
 
                      }
103
 
        self.workdir = self.system_manager.create_dirset( workdir_root
104
 
                                                        , self.dirset)
105
 
        self.vardir = os.path.join(self.workdir,'var')
106
 
        self.tmpdir = os.path.join(self.vardir,'tmp')
107
 
        self.rundir = os.path.join(self.vardir,'run')
108
 
        self.logdir = os.path.join(self.vardir,'log')
109
 
        self.datadir = os.path.join(self.vardir,'master-data')
110
 
 
111
 
        self.error_log = os.path.join(self.logdir,('%s.err' %(self.name)))
112
 
        self.pid_file = os.path.join(self.rundir,('%s.pid' %(self.name)))
113
 
        self.socket_file = os.path.join(self.vardir, ('%s.sock' %(self.name)))
114
 
        self.timer_file = os.path.join(self.logdir,('timer'))
115
 
        self.snapshot_path = os.path.join(self.tmpdir,('snapshot_%s' %(self.master_port)))
116
 
        # We want to use --secure-file-priv = $vardir by default
117
 
        # but there are times / tools when we need to shut this off
118
 
        if self.no_secure_file_priv:
119
 
            self.secure_file_string = ''
120
 
        else:
121
 
            self.secure_file_string = "--secure-file-priv='%s'" %(self.vardir)
122
 
        self.user_string = '--user=root'
123
 
 
124
 
        # client files
125
 
        self.drizzledump = self.code_tree.drizzledump
126
 
        self.drizzle_client = self.code_tree.drizzle_client
127
 
        self.drizzleimport = self.code_tree.drizzleimport
128
 
        self.drizzleadmin = self.code_tree.drizzleadmin
129
 
        self.drizzleslap = self.code_tree.drizzleslap
130
 
        self.server_path = self.code_tree.drizzle_server
131
 
        self.drizzle_client_path = self.code_tree.drizzle_client
132
 
        self.schemawriter = self.code_tree.schemawriter
133
 
 
134
 
        self.initialize_databases()
135
 
        self.take_db_snapshot()
136
 
 
137
 
        if self.debug:
138
 
            self.logging.debug_class(self)
139
 
 
140
 
    def report(self):
141
 
        """ We print out some general useful info """
142
 
        report_values = [ 'name'
143
 
                        , 'master_port'
144
 
                        , 'drizzle_tcp_port'
145
 
                        , 'mc_port'
146
 
                        , 'pbms_port'
147
 
                        , 'rabbitmq_node_port'
148
 
                        , 'vardir'
149
 
                        , 'status'
150
 
                        ]
151
 
        self.logging.info("%s master server:" %(self.owner))
152
 
        for key in report_values:
153
 
          value = vars(self)[key] 
154
 
          self.logging.info("%s: %s" %(key.upper(), value))
155
 
 
156
 
    def get_start_cmd(self):
157
 
        """ Return the command string that will start up the server 
158
 
            as desired / intended
159
 
 
160
 
        """
161
 
 
162
 
        server_args = [ self.process_server_options()
163
 
                      , "--mysql-protocol.port=%d" %(self.master_port)
164
 
                      , "--mysql-protocol.connect-timeout=60"
165
 
                      , "--innodb.data-file-path=ibdata1:20M:autoextend"
166
 
                      , "--sort-buffer-size=256K"
167
 
                      , "--max-heap-table-size=1M"
168
 
                      , "--mysql-unix-socket-protocol.path=%s" %(self.socket_file)
169
 
                      , "--pid-file=%s" %(self.pid_file)
170
 
                      , "--drizzle-protocol.port=%d" %(self.drizzle_tcp_port)
171
 
                      , "--datadir=%s" %(self.datadir)
172
 
                      , "--tmpdir=%s" %(self.tmpdir)
173
 
                      , self.secure_file_string
174
 
                      , self.user_string
175
 
                      ]
176
 
 
177
 
        if self.gdb:
178
 
            server_args.append('--gdb')
179
 
            return self.system_manager.handle_gdb_reqs(self, server_args)
180
 
        else:
181
 
            return "%s %s %s & " % ( self.cmd_prefix
182
 
                                   , self.server_path
183
 
                                   , " ".join(server_args)
184
 
                                   )
185
 
 
186
 
 
187
 
    def get_stop_cmd(self):
188
 
        """ Return the command that will shut us down """
189
 
        
190
 
        return "%s --user=root --port=%d --shutdown " %(self.drizzle_client_path, self.master_port)
191
 
           
192
 
 
193
 
    def get_ping_cmd(self):
194
 
        """Return the command string that will 
195
 
           ping / check if the server is alive 
196
 
 
197
 
        """
198
 
 
199
 
        return "%s --ping --port=%d --user=root" % (self.drizzle_client_path, self.master_port)
200
 
 
201
 
    def process_server_options(self):
202
 
        """Consume the list of options we have been passed.
203
 
           Return a string with them joined
204
 
 
205
 
        """
206
 
        
207
 
        return " ".join(self.server_options)
208
 
                  
209
 
    def initialize_databases(self):
210
 
        """ Call schemawriter to make db.opt files """
211
 
        databases = [ 'test'
212
 
                    , 'mysql'
213
 
                    ]
214
 
        for database in databases:
215
 
            db_path = os.path.join(self.datadir,'local',database,'db.opt')
216
 
            cmd = "%s %s %s" %(self.schemawriter, database, db_path)
217
 
            self.system_manager.execute_cmd(cmd)
218
 
 
219
 
    def take_db_snapshot(self):
220
 
        """ Take a snapshot of our vardir for quick restores """
221
 
       
222
 
        self.logging.info("Taking clean db snapshot...")
223
 
        if os.path.exists(self.snapshot_path):
224
 
            # We need to remove an existing path as python shutil
225
 
            # doesn't want an existing target
226
 
            self.system_manager.remove_dir(self.snapshot_path)
227
 
        self.system_manager.copy_dir(self.datadir, self.snapshot_path)
228
 
 
229
 
    def restore_snapshot(self):
230
 
        """ Restore from a stored snapshot """
231
 
        
232
 
        if self.verbose:
233
 
            self.logging.verbose("Restoring from db snapshot")
234
 
        if not os.path.exists(self.snapshot_path):
235
 
            self.logging.error("Could not find snapshot: %s" %(self.snapshot_path))
236
 
        self.system_manager.remove_dir(self.datadir)
237
 
        self.system_manager.copy_dir(self.snapshot_path, self.datadir)
238
 
 
239
 
    def cleanup(self):
240
 
        """ Cleanup - just free ports for now..."""
241
 
        self.system_manager.port_manager.free_ports(self.port_block)
242
 
 
243
 
    def set_server_options(self, server_options):
244
 
        """ We update our server_options to the new set """
245
 
        self.server_options = server_options
246
 
 
247
 
    def reset(self):
248
 
        """ Voodoo to reset ourselves """
249
 
        self.failed_test = 0
250
 
         
251
 
 
252
 
 
253
 
 
254