#!/usr/bin/env python
"""Launch.py
DESCRIPTION
Python launch script for the WebKit application server.
This launch script will run in its standard location in the Webware/WebKit
directory as well as in a WebKit work directory outside of the Webware tree.
USAGE
Launch.py [StartOptions] [AppServer [AppServerOptions]]
StartOptions:
-d, --work-dir=... Set the path to the app server working directory.
By default this is the directory containing Lauch.py.
-w, --webware-dir=... Set the path to the Webware root directory.
By default this is the parent directory.
-l, --library=... Other directories to be included in the search path.
You may specify this option multiple times.
-p, --run-profile Set this to get profiling going (see Profiler.py).
-o, --log-file=... Redirect standard output and error to this file.
-i, --pid-file=... Set the file path to hold the app server process id.
This option is fully supported under Unix only.
-u, --user=... The name or uid of the user to run the app server.
This option is supported under Unix only.
-g, --group=... The name or gid of the group to run the app server.
This option is supported under Unix only.
AppServer:
The name of the application server module.
By default, the ThreadedAppServer will be used.
AppServerOptions:
Options that shall be passed to the application server.
For instance, the ThreadedAppServer accepts: start, stop, daemon
You can also change configuration settings here by passing
arguments of the form ClassName.SettingName=value
Please note that the default values for the StartOptions and the AppServer
can be easily changed at the top of the Launch.py script.
"""
# FUTURE
# * This shares a lot of code with ThreadedAppServer.py and Launch.py.
# Try to consolidate these things. The default settings below in the
# global variables could go completely into AppServer.config.
# CREDITS
# * Contributed to Webware for Python by Chuck Esterbrook
# * Improved by Ian Bicking
# * Improved by Christoph Zwerschke
## Default options ##
# You can change the following default values:
# The path to the app server working directory, if you do not
# want to use the directory containing this script:
workDir = None
# The path to the Webware root directory; by default this will
# be the parent directory of the directory containing this script:
webwareDir = None
# A list of additional directories (usually some libraries)
# that you want to include into the search path for modules:
libraryDirs = []
# To get profiling going, set runProfile = 1 (see also
# the description in the docstring of Profiler.py):
runProfile = 0
# The path to the log file, if you want to redirect the
# standard output and error to a log file:
logFile = None
# The pass to the pid file, if you want to check and terminate
# a running server by storing its server process id:
pidFile = None
# The name or uid of the server process user, if you want
# to run the server under a different user:
user = None
# The name or uid of the server process group, if you want
# to run the server under a different group:
group = None
# The default app server to be used:
appServer = 'ThreadedAppServer'
## Launch app server ##
import os, sys
def usage():
"""Print the docstring and exit with error."""
sys.stdout.write(__doc__)
sys.exit(2)
def launchWebKit(appServer=appServer, workDir=None, args=None):
"""Import and launch the specified WebKit app server.
appServer -- the name of the WebKit app server module
workDir -- the server-side work directory of the app server
args -- other options that will be given to the app server
"""
# Set up the arguments for the app server:
if args is None:
args = []
if workDir:
args.append('workdir=' + workDir)
# Allow for a .py on the server name:
if appServer[-3:] == '.py':
appServer = appServer[:-3]
# Import the app server's main() function:
try:
appServerMain = __import__('WebKit.' + appServer, None, None, 'main').main
except ImportError, e:
print 'Error: Cannot import the AppServer module.'
print 'Reason:', str(e)
sys.exit(1)
# Set Profiler.startTime if this has not been done already:
from WebKit import Profiler
if Profiler.startTime is None:
from time import time
Profiler.startTime = time()
# Run the app server:
return appServerMain(args) # go!
## Main ##
def main(args=None):
"""Evaluate the command line arguments and call launchWebKit."""
global workDir, webwareDir, libraryDirs, runProfile, \
logFile, pidFile, user, group, appServer
if args is None:
args = sys.argv[1:]
# Accept AppServer even if placed before StartOptions:
if args and not args[0].startswith('-'):
arg2 = args.pop(0)
else:
arg2 = None
# Accept AppServerOptions that look like StartOptions:
args1 = []
args2 = []
while args:
arg = args.pop(0)
if arg.startswith('--') and \
2 < arg.find('.', 2) < arg.find('=', 5):
args2.append(arg)
else:
args1.append(arg)
# Get all launch options:
from getopt import getopt,GetoptError
try:
opts, args1 = getopt(args1, 'd:w:l:po:i:u:g:', [
'work-dir=', 'webware-dir=', 'library=', 'run-profile',
'log-file=', 'pid-file=', 'user=', 'group='])
except GetoptError, error:
print str(error)
print
usage()
for opt, arg in opts:
if opt in ('-d', '--work-dir'):
workDir = arg
elif opt in ('-w', '--webware-dir'):
webwareDir = arg
elif opt in ('-l', '--library'):
libraryDirs.append(arg)
elif opt in ('-p', '--run-profile'):
runProfile = 1
elif opt in ('-o', '--log-file'):
logFile = arg
elif opt in ('-i', '--pid-file'):
pidFile = arg
elif opt in ('-u', '--user'):
user = arg
elif opt in ('-g', '--group'):
group = arg
if arg2:
appServer = arg2
elif args1 and not args1[0].startswith('-') \
and args1[0].find('=') < 0:
appServer = args1.pop(0)
args = args2 + args1
# Figure out the group id:
gid = group
if gid is not None:
try:
gid = int(gid)
except ValueError:
try:
import grp
entry = grp.getgrnam(gid)
except KeyError:
print 'Error: Group %r does not exist.' % gid
sys.exit(2)
except ImportError:
print 'Error: Group names are not supported.'
sys.exit(2)
gid = entry[2]
# Figure out the user id:
uid = user
if uid is not None:
try:
uid = int(uid)
except ValueError:
try:
import pwd
entry = pwd.getpwnam(uid)
except KeyError:
print 'Error: User %r does not exist.' % uid
sys.exit(2)
except ImportError:
print 'Error: User names are not supported.'
sys.exit(2)
if not gid:
gid = entry[3]
uid = entry[2]
# Figure out the work directory and make it the current directory:
if workDir:
workDir = os.path.expanduser(workDir)
else:
scriptName = sys.argv and sys.argv[0]
if not scriptName or scriptName == '-c':
scriptName = 'Launch.py'
workDir = os.path.dirname(os.path.abspath(scriptName))
try:
os.chdir(workDir)
except OSError, error:
print 'Error: Could not set working directory.'
print 'The path %r cannot be used.' % workDir
print error.strerror
print 'Check the --work-dir option.'
sys.exit(1)
workDir = os.curdir
# Expand user components in directories:
if webwareDir:
webwareDir = os.path.expanduser(webwareDir)
else:
webwareDir = os.pardir
if libraryDirs:
libraryDirs = map(os.path.expanduser, libraryDirs)
# If this module is inside a package, make it a standalone module,
# because otherwise the package path will be used for imports, too:
global __name__, __package__
name = __name__.split('.')[-1]
if name != __name__:
sys.modules[name] = sys.modules[__name__]
del sys.modules[__name__]
__name__ = name
__package__ = None
# Check the validity of the Webware directory:
sysPath = sys.path # memorize the standard Python search path
sys.path = [webwareDir] # now include only the Webware directory
try: # check whether Webware is really located here
from Properties import name
from WebKit.Properties import name
except ImportError:
webwareName = None
if webwareName != 'Webware for Python' or webKitName != 'WebKit':
print 'Error: Cannot find the Webware directory.'
print 'The path %r seems to be wrong.' % webwareDir
print 'Check the --webware-dir option.'
sys.exit(1)
if not os.path.exists(os.path.join(webwareDir, 'install.log')):
print 'Error: Webware has not been installed.'
print 'Please run install.py in the Webware directory:'
print '> cd', os.path.abspath(webwareDir)
print '> python install.py'
sys.exit(1)
# Now assemble a new clean Python search path:
path = [] # the new search path will be collected here
webKitDir = os.path.abspath(os.path.join(webwareDir, 'WebKit'))
for p in [workDir, webwareDir] + libraryDirs + sysPath:
if not p:
continue # do not include the empty ("current") directory
p = os.path.abspath(p)
if p == webKitDir or p in path or not os.path.exists(p):
continue # do not include WebKit and duplicates
path.append(p)
sys.path = path # set the new search path
# Prepare the arguments for launchWebKit:
args = (appServer, workDir, args)
# Handle special case where app server shall be stopped:
if 'stop' in args[2]:
print 'Stopping WebKit.%s...' % appServer
errorlevel = launchWebKit(*args)
if not errorlevel:
if pidFile and os.path.exists(pidFile):
try:
os.remove(pidFile)
except Exception:
print 'The pid file could not be removed.'
print
sys.exit(errorlevel)
# Handle the pid file:
if pidFile:
pidFile = os.path.expanduser(pidFile)
# Read the old pid file:
try:
pid = int(open(pidFile).read())
except Exception:
pid = None
if pid is not None:
print 'According to the pid file, the server is still running.'
# Try to kill an already running server:
killed = 0
try:
from signal import SIGTERM,SIGKILL
print 'Trying to terminate the server with pid %d...' % pid
os.kill(pid, SIGTERM)
except OSError, error:
from errno import ESRCH
if error.errno == ESRCH: # no such process
print 'The pid file was stale, continuing with startup...'
killed = 1
else:
print 'Cannot terminate server with pid %d.' % pid
print error.strerror
sys.exit(1)
except (ImportError, AttributeError):
print 'Cannot check or terminate server with pid %d.' % pid
sys.exit(1)
if not killed:
from time import sleep
try:
for i in range(100):
sleep(0.1)
os.kill(pid, SIGTERM)
except OSError, error:
from errno import ESRCH
if error.errno == ESRCH:
print 'Server with pid %d has been terminated.' % pid
killed = 1
if not killed:
try:
for i in range(100):
sleep(0.1)
os.kill(pid, SIGKILL)
except OSError, error:
from errno import ESRCH
if error.errno == ESRCH:
print 'Server with pid %d has been killed by force.' % pid
killed = 1
if not killed:
print 'Server with pid %d cannot be terminated.' % pid
sys.exit(1)
# Write a new pid file:
try:
open(pidFile, 'w').write(str(os.getpid()))
except Exception:
print 'The pid file %r could not be written.' % pidFile
sys.exit(1)
olduid = oldgid = stdout = stderr = log = None
errorlevel = 1
try:
# Change server process group:
if gid is not None:
try:
oldgid = os.getgid()
if gid != oldgid:
os.setgid(gid)
if group:
print 'Changed server process group to %r.' % group
else:
oldgid = None
except Exception:
if group:
print 'Could not set server process group to %r.' % group
oldgid = None
sys.exit(1)
# Change server process user:
if uid is not None:
try:
olduid = os.getuid()
if uid != olduid:
os.setuid(uid)
print 'Changed server process user to %r.' % user
else:
olduid = None
except Exception:
print 'Could not change server process user to %r.' % user
olduid = None
sys.exit(1)
msg = 'WebKit.' + appServer
if args[2]:
msg = '%s %s' % (msg, ' '.join(args[2]))
else:
msg = 'Starting %s...' % msg
print msg
# Handle the log file:
if logFile:
logFile = os.path.expanduser(logFile)
try:
log = open(logFile, 'a', 1) # append, line buffered mode
print 'Output has been redirected to %r...' % logFile
stdout, stderr = sys.stdout, sys.stderr
sys.stdout = sys.stderr = log
except IOError, error:
print 'Cannot redirect output to %r.' % logFile
print error.strerror
log = None
sys.exit(1)
else:
print
# Set up a reference to our profiler so apps can import and use it:
from WebKit import Profiler
if Profiler.startTime is None:
from time import time
Profiler.startTime = time()
# Now start the app server:
if runProfile:
print 'Profiling is on.', \
'See docstring in Profiler.py for more info.'
print
from profile import Profile
profiler = Profile()
Profiler.profiler = profiler
errorlevel = Profiler.runCall(launchWebKit, *args)
print
print 'Writing profile stats to %s...' % Profiler.statsFilename
Profiler.dumpStats()
print 'WARNING: Applications run much slower when profiled,'
print 'so turn off profiling in Launch.py when you are finished.'
else:
errorlevel = launchWebKit(*args)
finally:
print
# Close the log file properly:
if log:
sys.stdout, sys.stderr = stdout, stderr
log.close()
# Restore server process group and user.
# Note that because we changed the real group and
# user id of the process (most secure thing), we
# cannot change them back now, but we try anyway:
if oldgid is not None:
try:
os.setgid(oldgid)
except Exception:
pass
else:
oldgid = None
if olduid is not None:
try:
os.setuid(olduid)
except Exception:
pass
else:
olduid = None
# Remove the pid file again.
# Note that this may fail when the group or user id
# has been changed, but we try anyway:
if pidFile and os.path.exists(pidFile):
try:
os.remove(pidFile)
except Exception:
if oldgid is None and olduid is None:
print 'The pid file could not be removed.'
print
sys.exit(errorlevel)
if __name__ == '__main__':
main()
|