runzeo.py 13.6 KB
Newer Older
1 2
##############################################################################
#
3
# Copyright (c) 2001, 2002, 2003 Zope Foundation and Contributors.
4 5 6
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
Jim Fulton's avatar
Jim Fulton committed
7
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
8 9 10 11 12 13 14 15
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE
#
##############################################################################
"""Start the ZEO storage server.

16
Usage: %s [-C URL] [-a ADDRESS] [-f FILENAME] [-h]
17 18

Options:
19
-C/--configuration URL -- configuration file or URL
20 21 22
-a/--address ADDRESS -- server address of the form PORT, HOST:PORT, or PATH
                        (a PATH must contain at least one "/")
-f/--filename FILENAME -- filename for FileStorage
Tim Peters's avatar
Tim Peters committed
23
-t/--timeout TIMEOUT -- transaction timeout in seconds (default no timeout)
24
-h/--help -- print this usage message and exit
25
-m/--monitor ADDRESS -- address of monitor server ([HOST:]PORT or PATH)
26 27 28
--pid-file PATH -- relative path to output file containing this process's pid;
                   default $(INSTANCE_HOME)/var/ZEO.pid but only if envar
                   INSTANCE_HOME is defined
29

30
Unless -C is specified, -a and -f are required.
31 32 33 34 35 36
"""

# The code here is designed to be reused by other, similar servers.
# For the forseeable future, it must work under Python 2.1 as well as
# 2.2 and above.

37
import asyncore
38 39 40 41
import os
import sys
import signal
import socket
42
import logging
43

Jim Fulton's avatar
Jim Fulton committed
44
import ZConfig.datatypes
45
import ZEO
46
from zdaemon.zdoptions import ZDOptions
47

48 49 50 51 52 53 54 55
logger = logging.getLogger('ZEO.runzeo')
_pid = str(os.getpid())

def log(msg, level=logging.INFO, exc_info=False):
    """Internal: generic logging function."""
    message = "(%s) %s" % (_pid, msg)
    logger.log(level, message, exc_info=exc_info)

56
def parse_binding_address(arg):
57
    # Caution:  Not part of the official ZConfig API.
58
    obj = ZConfig.datatypes.SocketBindingAddress(arg)
59 60
    return obj.family, obj.address

61 62 63 64
def windows_shutdown_handler():
    # Called by the signal mechanism on Windows to perform shutdown.
    import asyncore
    asyncore.close_all()
65

66
class ZEOOptionsMixin:
67 68 69 70

    storages = None

    def handle_address(self, arg):
71
        self.family, self.address = parse_binding_address(arg)
72 73

    def handle_monitor_address(self, arg):
74
        self.monitor_family, self.monitor_address = parse_binding_address(arg)
75 76 77 78 79 80 81 82 83 84

    def handle_filename(self, arg):
        from ZODB.config import FileStorage # That's a FileStorage *opener*!
        class FSConfig:
            def __init__(self, name, path):
                self._name = name
                self.path = path
                self.stop = None
            def getSectionName(self):
                return self._name
85
        if not self.storages:
86 87 88 89 90
            self.storages = []
        name = str(1 + len(self.storages))
        conf = FileStorage(FSConfig(name, arg))
        self.storages.append(conf)

91 92 93 94
    testing_exit_immediately = False
    def handle_test(self, *args):
        self.testing_exit_immediately = True

95
    def add_zeo_options(self):
96
        self.add(None, None, None, "test", self.handle_test)
97 98 99 100 101 102 103 104
        self.add(None, None, "a:", "address=", self.handle_address)
        self.add(None, None, "f:", "filename=", self.handle_filename)
        self.add("family", "zeo.address.family")
        self.add("address", "zeo.address.address",
                 required="no server address specified; use -a or -C")
        self.add("read_only", "zeo.read_only", default=0)
        self.add("invalidation_queue_size", "zeo.invalidation_queue_size",
                 default=100)
105
        self.add("invalidation_age", "zeo.invalidation_age")
106 107
        self.add("transaction_timeout", "zeo.transaction_timeout",
                 "t:", "timeout=", float)
108 109
        self.add("monitor_address", "zeo.monitor_address.address",
                 "m:", "monitor=", self.handle_monitor_address)
110 111 112 113 114 115
        self.add('auth_protocol', 'zeo.authentication_protocol',
                 None, 'auth-protocol=', default=None)
        self.add('auth_database', 'zeo.authentication_database',
                 None, 'auth-database=')
        self.add('auth_realm', 'zeo.authentication_realm',
                 None, 'auth-realm=')
116 117
        self.add('pid_file', 'zeo.pid_filename',
                 None, 'pid-file=')
118 119 120

class ZEOOptions(ZDOptions, ZEOOptionsMixin):

Chris Withers's avatar
Chris Withers committed
121 122
    __doc__ = __doc__

123
    logsectionname = "eventlog"
124
    schemadir = os.path.dirname(ZEO.__file__)
125

126 127 128 129 130 131
    def __init__(self):
        ZDOptions.__init__(self)
        self.add_zeo_options()
        self.add("storages", "storages",
                 required="no storages specified; use -f or -C")

132 133 134 135 136 137 138 139 140 141 142 143 144
    def realize(self, *a, **k):
        ZDOptions.realize(self, *a, **k)
        nunnamed = [s for s in self.storages if s.name is None]
        if nunnamed:
            if len(nunnamed) > 1:
                return self.usage("No more than one storage may be unnamed.")
            if [s for s in self.storages if s.name == '1']:
                return self.usage(
                    "Can't have an unnamed storage and a storage named 1.")
            for s in self.storages:
                if s.name is None:
                    s.name = '1'
                    break
145

146

147
class ZEOServer:
148

149
    def __init__(self, options):
Guido van Rossum's avatar
Guido van Rossum committed
150
        self.options = options
151 152

    def main(self):
153
        self.setup_default_logging()
154 155
        self.check_socket()
        self.clear_socket()
156
        self.make_pidfile()
157
        try:
158 159
            self.open_storages()
            self.setup_signals()
160 161 162
            self.create_server()
            self.loop_forever()
        finally:
Jim Fulton's avatar
Jim Fulton committed
163
            self.server.close()
164
            self.clear_socket()
165
            self.remove_pidfile()
166

167 168 169
    def setup_default_logging(self):
        if self.options.config_logger is not None:
            return
170
        # No log file is configured; default to stderr.
171 172 173 174 175
        root = logging.getLogger()
        root.setLevel(logging.INFO)
        fmt = logging.Formatter(
            "------\n%(asctime)s %(levelname)s %(name)s %(message)s",
            "%Y-%m-%dT%H:%M:%S")
176
        handler = logging.StreamHandler()
177 178
        handler.setFormatter(fmt)
        root.addHandler(handler)
179

180
    def check_socket(self):
181 182 183 184
        if (isinstance(self.options.address, tuple) and
            self.options.address[1] is None):
            self.options.address = self.options.address[0], 0
            return
Guido van Rossum's avatar
Guido van Rossum committed
185 186 187
        if self.can_connect(self.options.family, self.options.address):
            self.options.usage("address %s already in use" %
                               repr(self.options.address))
188 189 190

    def can_connect(self, family, address):
        s = socket.socket(family, socket.SOCK_STREAM)
191
        try:
192
            s.connect(address)
193
        except socket.error:
194
            return 0
195 196
        else:
            s.close()
197
            return 1
198 199

    def clear_socket(self):
Guido van Rossum's avatar
Guido van Rossum committed
200
        if isinstance(self.options.address, type("")):
201
            try:
Guido van Rossum's avatar
Guido van Rossum committed
202
                os.unlink(self.options.address)
203 204 205 206 207
            except os.error:
                pass

    def open_storages(self):
        self.storages = {}
208
        for opener in self.options.storages:
209 210
            log("opening storage %r using %s"
                % (opener.name, opener.__class__.__name__))
211
            self.storages[opener.name] = opener.open()
212 213 214 215 216 217 218 219 220 221

    def setup_signals(self):
        """Set up signal handlers.

        The signal handler for SIGFOO is a method handle_sigfoo().
        If no handler method is defined for a signal, the signal
        action is not changed from its initial value.  The handler
        method is called without additional arguments.
        """
        if os.name != "posix":
222 223
            if os.name == "nt":
                self.setup_win32_signals()
224 225 226 227 228 229 230 231 232 233 234
            return
        if hasattr(signal, 'SIGXFSZ'):
            signal.signal(signal.SIGXFSZ, signal.SIG_IGN) # Special case
        init_signames()
        for sig, name in signames.items():
            method = getattr(self, "handle_" + name.lower(), None)
            if method is not None:
                def wrapper(sig_dummy, frame_dummy, method=method):
                    method()
                signal.signal(sig, wrapper)

235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
    def setup_win32_signals(self):
        # Borrow the Zope Signals package win32 support, if available.
        # Signals does a check/log for the availability of pywin32.
        try:
            import Signals.Signals
        except ImportError:
            logger.debug("Signals package not found. "
                         "Windows-specific signal handler "
                         "will *not* be installed.")
            return
        SignalHandler = Signals.Signals.SignalHandler
        if SignalHandler is not None: # may be None if no pywin32.
            SignalHandler.registerHandler(signal.SIGTERM,
                                          windows_shutdown_handler)
            SignalHandler.registerHandler(signal.SIGINT,
                                          windows_shutdown_handler)
            SIGUSR2 = 12 # not in signal module on Windows.
252
            SignalHandler.registerHandler(SIGUSR2, self.handle_sigusr2)
253

254
    def create_server(self):
255
        self.server = create_server(self.storages, self.options)
256 257

    def loop_forever(self):
258 259 260
        if self.options.testing_exit_immediately:
            print "testing exit immediately"
        else:
261
            self.server.loop()
262 263

    def handle_sigterm(self):
264
        log("terminated by SIGTERM")
265 266 267
        sys.exit(0)

    def handle_sigint(self):
268
        log("terminated by SIGINT")
269 270
        sys.exit(0)

271
    def handle_sighup(self):
272
        log("restarted by SIGHUP")
273 274
        sys.exit(1)

275
    def handle_sigusr2(self):
Jim Fulton's avatar
Jim Fulton committed
276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
        # log rotation signal - do the same as Zope 2.7/2.8...
        if self.options.config_logger is None or os.name not in ("posix", "nt"):
            log("received SIGUSR2, but it was not handled!", 
                level=logging.WARNING)
            return

        loggers = [self.options.config_logger]

        if os.name == "posix":
            for l in loggers:
                l.reopen()
            log("Log files reopened successfully", level=logging.INFO)
        else: # nt - same rotation code as in Zope's Signals/Signals.py
            for l in loggers:
                for f in l.handler_factories:
                    handler = f()
                    if hasattr(handler, 'rotate') and callable(handler.rotate):
                        handler.rotate()
            log("Log files rotation complete", level=logging.INFO)

296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
    def _get_pidfile(self):
        pidfile = self.options.pid_file
        # 'pidfile' is marked as not required.
        if not pidfile:
            # Try to find a reasonable location if the pidfile is not
            # set. If we are running in a Zope environment, we can
            # safely assume INSTANCE_HOME.
            instance_home = os.environ.get("INSTANCE_HOME")
            if not instance_home:
                # If all our attempts failed, just log a message and
                # proceed.
                logger.debug("'pidfile' option not set, and 'INSTANCE_HOME' "
                             "environment variable could not be found. "
                             "Cannot guess pidfile location.")
                return
            self.options.pid_file = os.path.join(instance_home,
                                                 "var", "ZEO.pid")

    def make_pidfile(self):
        if not self.options.read_only:
            self._get_pidfile()
            pidfile = self.options.pid_file
            if pidfile is None:
                return
            pid = os.getpid()
            try:
                if os.path.exists(pidfile):
                    os.unlink(pidfile)
                f = open(pidfile, 'w')
                print >> f, pid
                f.close()
                log("created PID file '%s'" % pidfile)
            except IOError:
                logger.error("PID file '%s' cannot be opened" % pidfile)

    def remove_pidfile(self):
        if not self.options.read_only:
            pidfile = self.options.pid_file
            if pidfile is None:
                return
            try:
                if os.path.exists(pidfile):
                    os.unlink(pidfile)
                    log("removed PID file '%s'" % pidfile)
            except IOError:
                logger.error("PID file '%s' could not be removed" % pidfile)
342

343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359

def create_server(storages, options):
    from ZEO.StorageServer import StorageServer
    return StorageServer(
        options.address,
        storages,
        read_only = options.read_only,
        invalidation_queue_size = options.invalidation_queue_size,
        invalidation_age = options.invalidation_age,
        transaction_timeout = options.transaction_timeout,
        monitor_address = options.monitor_address,
        auth_protocol = options.auth_protocol,
        auth_database = options.auth_database,
        auth_realm = options.auth_realm,
        )


360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388
# Signal names

signames = None

def signame(sig):
    """Return a symbolic name for a signal.

    Return "signal NNN" if there is no corresponding SIG name in the
    signal module.
    """

    if signames is None:
        init_signames()
    return signames.get(sig) or "signal %d" % sig

def init_signames():
    global signames
    signames = {}
    for name, sig in signal.__dict__.items():
        k_startswith = getattr(name, "startswith", None)
        if k_startswith is None:
            continue
        if k_startswith("SIG") and not k_startswith("SIG_"):
            signames[sig] = name


# Main program

def main(args=None):
389 390
    options = ZEOOptions()
    options.realize(args)
Guido van Rossum's avatar
Guido van Rossum committed
391
    s = ZEOServer(options)
392
    s.main()
393 394 395

if __name__ == "__main__":
    main()