« back to all changes in this revision
Viewing changes to nova/twistd.py
- browse files at revision 1348.2.1
- compare with another revision
- download diff
- download tarball
- view history from revision 1348.2.1
- Committer: Brian Waldon
- Date: 2011-08-02 14:09:58 UTC
- mto: This revision was merged to the branch mainline in revision 1354.
- Revision ID: brian.waldon@rackspace.com-20110802140958-t4icdky513hqh96a
removing compute monitor
- files removed:
- bin/nova-instancemonitor
- files modified:
- bin/nova-logspool
added
removed
nova/twistd.py
1
# vim: tabstop=4 shiftwidth=4 softtabstop=4
2
3
# Copyright 2010 United States Government as represented by the
4
# Administrator of the National Aeronautics and Space Administration.
5
# All Rights Reserved.
6
#
7
# Licensed under the Apache License, Version 2.0 (the "License"); you may
8
# not use this file except in compliance with the License. You may obtain
9
# a copy of the License at
10
#
11
# http://www.apache.org/licenses/LICENSE-2.0
12
#
13
# Unless required by applicable law or agreed to in writing, software
14
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
16
# License for the specific language governing permissions and limitations
17
# under the License.
18
19
"""
20
Twisted daemon helpers, specifically to parse out gFlags from twisted flags,
21
manage pid files and support syslogging.
22
"""
23
24
import gflags
25
import os
26
import signal
27
import sys
28
import time
29
from twisted.scripts import twistd
30
from twisted.python import log
31
from twisted.python import reflect
32
from twisted.python import runtime
33
from twisted.python import usage
34
35
from nova import flags
36
from nova import log as logging
37
38
39
if runtime.platformType == "win32":
40
from twisted.scripts._twistw import ServerOptions
41
else:
42
from twisted.scripts._twistd_unix import ServerOptions
43
44
45
FLAGS = flags.FLAGS
46
47
48
class TwistdServerOptions(ServerOptions):
49
def parseArgs(self, *args):
50
return
51
52
53
class FlagParser(object):
54
# this is a required attribute for gflags
55
syntactic_help = ''
56
57
def __init__(self, parser):
58
self.parser = parser
59
60
def Parse(self, s):
61
return self.parser(s)
62
63
64
def WrapTwistedOptions(wrapped):
65
class TwistedOptionsToFlags(wrapped):
66
subCommands = None
67
68
def __init__(self):
69
# NOTE(termie): _data exists because Twisted stuff expects
70
# to be able to set arbitrary things that are
71
# not actual flags
72
self._data = {}
73
self._flagHandlers = {}
74
self._paramHandlers = {}
75
76
# Absorb the twistd flags into our FLAGS
77
self._absorbFlags()
78
self._absorbParameters()
79
self._absorbHandlers()
80
81
wrapped.__init__(self)
82
83
def _absorbFlags(self):
84
twistd_flags = []
85
reflect.accumulateClassList(self.__class__, 'optFlags',
86
twistd_flags)
87
for flag in twistd_flags:
88
key = flag[0].replace('-', '_')
89
if hasattr(FLAGS, key):
90
continue
91
flags.DEFINE_boolean(key, None, str(flag[-1]))
92
93
def _absorbParameters(self):
94
twistd_params = []
95
reflect.accumulateClassList(self.__class__, 'optParameters',
96
twistd_params)
97
for param in twistd_params:
98
key = param[0].replace('-', '_')
99
if hasattr(FLAGS, key):
100
continue
101
if len(param) > 4:
102
flags.DEFINE(FlagParser(param[4]),
103
key, param[2], str(param[3]),
104
serializer=gflags.ArgumentSerializer())
105
else:
106
flags.DEFINE_string(key, param[2], str(param[3]))
107
108
def _absorbHandlers(self):
109
twistd_handlers = {}
110
reflect.addMethodNamesToDict(self.__class__, twistd_handlers,
111
"opt_")
112
113
# NOTE(termie): Much of the following is derived/copied from
114
# twisted.python.usage with the express purpose of
115
# providing compatibility
116
for name in twistd_handlers.keys():
117
method = getattr(self, 'opt_' + name)
118
119
takesArg = not usage.flagFunction(method, name)
120
doc = getattr(method, '__doc__', None)
121
if not doc:
122
doc = 'undocumented'
123
124
if not takesArg:
125
if name not in FLAGS:
126
flags.DEFINE_boolean(name, None, doc)
127
self._flagHandlers[name] = method
128
else:
129
if name not in FLAGS:
130
flags.DEFINE_string(name, None, doc)
131
self._paramHandlers[name] = method
132
133
def _doHandlers(self):
134
for flag, handler in self._flagHandlers.iteritems():
135
if self[flag]:
136
handler()
137
for param, handler in self._paramHandlers.iteritems():
138
if self[param] is not None:
139
handler(self[param])
140
141
def __str__(self):
142
return str(FLAGS)
143
144
def parseOptions(self, options=None):
145
if options is None:
146
options = sys.argv
147
else:
148
options.insert(0, '')
149
150
args = FLAGS(options)
151
logging.setup()
152
argv = args[1:]
153
# ignore subcommands
154
155
try:
156
self.parseArgs(*argv)
157
except TypeError:
158
raise usage.UsageError(_("Wrong number of arguments."))
159
160
self.postOptions()
161
return args
162
163
def parseArgs(self, *args):
164
# TODO(termie): figure out a decent way of dealing with args
165
#return
166
wrapped.parseArgs(self, *args)
167
168
def postOptions(self):
169
self._doHandlers()
170
171
wrapped.postOptions(self)
172
173
def __getitem__(self, key):
174
key = key.replace('-', '_')
175
try:
176
return getattr(FLAGS, key)
177
except (AttributeError, KeyError):
178
return self._data[key]
179
180
def __setitem__(self, key, value):
181
key = key.replace('-', '_')
182
try:
183
return setattr(FLAGS, key, value)
184
except (AttributeError, KeyError):
185
self._data[key] = value
186
187
def get(self, key, default):
188
key = key.replace('-', '_')
189
try:
190
return getattr(FLAGS, key)
191
except (AttributeError, KeyError):
192
self._data.get(key, default)
193
194
return TwistedOptionsToFlags
195
196
197
def stop(pidfile):
198
"""
199
Stop the daemon
200
"""
201
# Get the pid from the pidfile
202
try:
203
pf = file(pidfile, 'r')
204
pid = int(pf.read().strip())
205
pf.close()
206
except IOError:
207
pid = None
208
209
if not pid:
210
message = _("pidfile %s does not exist. Daemon not running?\n")
211
sys.stderr.write(message % pidfile)
212
# Not an error in a restart
213
return
214
215
# Try killing the daemon process
216
try:
217
while 1:
218
os.kill(pid, signal.SIGKILL)
219
time.sleep(0.1)
220
except OSError, err:
221
err = str(err)
222
if err.find(_("No such process")) > 0:
223
if os.path.exists(pidfile):
224
os.remove(pidfile)
225
else:
226
print str(err)
227
sys.exit(1)
228
229
230
def serve(filename):
231
logging.debug(_("Serving %s") % filename)
232
name = os.path.basename(filename)
233
OptionsClass = WrapTwistedOptions(TwistdServerOptions)
234
options = OptionsClass()
235
argv = options.parseOptions()
236
FLAGS.python = filename
237
FLAGS.no_save = True
238
if not FLAGS.pidfile:
239
FLAGS.pidfile = '%s.pid' % name
240
elif FLAGS.pidfile.endswith('twistd.pid'):
241
FLAGS.pidfile = FLAGS.pidfile.replace('twistd.pid', '%s.pid' % name)
242
if not FLAGS.prefix:
243
FLAGS.prefix = name
244
elif FLAGS.prefix.endswith('twisted'):
245
FLAGS.prefix = FLAGS.prefix.replace('twisted', name)
246
247
action = 'start'
248
if len(argv) > 1:
249
action = argv.pop()
250
251
if action == 'stop':
252
stop(FLAGS.pidfile)
253
sys.exit()
254
elif action == 'restart':
255
stop(FLAGS.pidfile)
256
elif action == 'start':
257
pass
258
else:
259
print 'usage: %s [options] [start|stop|restart]' % argv[0]
260
sys.exit(1)
261
262
logging.debug(_("Full set of FLAGS:"))
263
for flag in FLAGS:
264
logging.debug("%s : %s" % (flag, FLAGS.get(flag, None)))
265
266
logging.audit(_("Starting %s"), name)
267
twistd.runApp(options)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1