bind10.py.in 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900
  1. #!@PYTHON@
  2. # Copyright (C) 2010 Internet Systems Consortium.
  3. #
  4. # Permission to use, copy, modify, and distribute this software for any
  5. # purpose with or without fee is hereby granted, provided that the above
  6. # copyright notice and this permission notice appear in all copies.
  7. #
  8. # THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SYSTEMS CONSORTIUM
  9. # DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
  10. # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
  11. # INTERNET SYSTEMS CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
  12. # INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
  13. # FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  14. # NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
  15. # WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16. """
  17. This file implements the Boss of Bind (BoB, or bob) program.
  18. Its purpose is to start up the BIND 10 system, and then manage the
  19. processes, by starting and stopping processes, plus restarting
  20. processes that exit.
  21. To start the system, it first runs the c-channel program (msgq), then
  22. connects to that. It then runs the configuration manager, and reads
  23. its own configuration. Then it proceeds to starting other modules.
  24. The Python subprocess module is used for starting processes, but
  25. because this is not efficient for managing groups of processes,
  26. SIGCHLD signals are caught and processed using the signal module.
  27. Most of the logic is contained in the BoB class. However, since Python
  28. requires that signal processing happen in the main thread, we do
  29. signal handling outside of that class, in the code running for
  30. __main__.
  31. """
  32. import sys; sys.path.append ('@@PYTHONPATH@@')
  33. import os
  34. # If B10_FROM_SOURCE is set in the environment, we use data files
  35. # from a directory relative to that, otherwise we use the ones
  36. # installed on the system
  37. if "B10_FROM_SOURCE" in os.environ:
  38. SPECFILE_LOCATION = os.environ["B10_FROM_SOURCE"] + "/src/bin/bind10/bob.spec"
  39. else:
  40. PREFIX = "@prefix@"
  41. DATAROOTDIR = "@datarootdir@"
  42. SPECFILE_LOCATION = "@datadir@/@PACKAGE@/bob.spec".replace("${datarootdir}", DATAROOTDIR).replace("${prefix}", PREFIX)
  43. import subprocess
  44. import signal
  45. import re
  46. import errno
  47. import time
  48. import select
  49. import random
  50. import socket
  51. from optparse import OptionParser, OptionValueError
  52. import io
  53. import pwd
  54. import posix
  55. import isc.cc
  56. import isc.util.process
  57. import isc.net.parse
  58. # Assign this process some longer name
  59. isc.util.process.rename(sys.argv[0])
  60. # This is the version that gets displayed to the user.
  61. # The VERSION string consists of the module name, the module version
  62. # number, and the overall BIND 10 version number (set in configure.ac).
  63. VERSION = "bind10 20101129 (BIND 10 @PACKAGE_VERSION@)"
  64. # This is for bind10.boottime of stats module
  65. _BASETIME = time.gmtime()
  66. class RestartSchedule:
  67. """
  68. Keeps state when restarting something (in this case, a process).
  69. When a process dies unexpectedly, we need to restart it. However, if
  70. it fails to restart for some reason, then we should not simply keep
  71. restarting it at high speed.
  72. A more sophisticated algorithm can be developed, but for now we choose
  73. a simple set of rules:
  74. * If a process was been running for >=10 seconds, we restart it
  75. right away.
  76. * If a process was running for <10 seconds, we wait until 10 seconds
  77. after it was started.
  78. To avoid programs getting into lockstep, we use a normal distribution
  79. to avoid being restarted at exactly 10 seconds."""
  80. def __init__(self, restart_frequency=10.0):
  81. self.restart_frequency = restart_frequency
  82. self.run_start_time = None
  83. self.run_stop_time = None
  84. self.restart_time = None
  85. def set_run_start_time(self, when=None):
  86. if when is None:
  87. when = time.time()
  88. self.run_start_time = when
  89. sigma = self.restart_frequency * 0.05
  90. self.restart_time = when + random.normalvariate(self.restart_frequency,
  91. sigma)
  92. def set_run_stop_time(self, when=None):
  93. """We don't actually do anything with stop time now, but it
  94. might be useful for future algorithms."""
  95. if when is None:
  96. when = time.time()
  97. self.run_stop_time = when
  98. def get_restart_time(self, when=None):
  99. if when is None:
  100. when = time.time()
  101. return max(when, self.restart_time)
  102. class ProcessInfoError(Exception): pass
  103. class ProcessInfo:
  104. """Information about a process"""
  105. dev_null = open(os.devnull, "w")
  106. def __init__(self, name, args, env={}, dev_null_stdout=False,
  107. dev_null_stderr=False, uid=None, username=None):
  108. self.name = name
  109. self.args = args
  110. self.env = env
  111. self.dev_null_stdout = dev_null_stdout
  112. self.dev_null_stderr = dev_null_stderr
  113. self.restart_schedule = RestartSchedule()
  114. self.uid = uid
  115. self.username = username
  116. self._spawn()
  117. def _preexec_work(self):
  118. """Function used before running a program that needs to run as a
  119. different user."""
  120. # First, put us into a separate process group so we don't get
  121. # SIGINT signals on Ctrl-C (the boss will shut everthing down by
  122. # other means).
  123. os.setpgrp()
  124. # Second, set the user ID if one has been specified
  125. if self.uid is not None:
  126. try:
  127. posix.setuid(self.uid)
  128. except OSError as e:
  129. if e.errno == errno.EPERM:
  130. # if we failed to change user due to permission report that
  131. raise ProcessInfoError("Unable to change to user %s (uid %d)" % (self.username, self.uid))
  132. else:
  133. # otherwise simply re-raise whatever error we found
  134. raise
  135. def _spawn(self):
  136. if self.dev_null_stdout:
  137. spawn_stdout = self.dev_null
  138. else:
  139. spawn_stdout = None
  140. if self.dev_null_stderr:
  141. spawn_stderr = self.dev_null
  142. else:
  143. spawn_stderr = None
  144. # Environment variables for the child process will be a copy of those
  145. # of the boss process with any additional specific variables given
  146. # on construction (self.env).
  147. spawn_env = os.environ
  148. spawn_env.update(self.env)
  149. if 'B10_FROM_SOURCE' not in os.environ:
  150. spawn_env['PATH'] = "@@LIBEXECDIR@@:" + spawn_env['PATH']
  151. self.process = subprocess.Popen(self.args,
  152. stdin=subprocess.PIPE,
  153. stdout=spawn_stdout,
  154. stderr=spawn_stderr,
  155. close_fds=True,
  156. env=spawn_env,
  157. preexec_fn=self._preexec_work)
  158. self.pid = self.process.pid
  159. self.restart_schedule.set_run_start_time()
  160. def respawn(self):
  161. self._spawn()
  162. class CChannelConnectError(Exception): pass
  163. class BoB:
  164. """Boss of BIND class."""
  165. def __init__(self, msgq_socket_file=None, dns_port=5300, address=None,
  166. forward=None, nocache=False, verbose=False, setuid=None,
  167. username=None):
  168. """
  169. Initialize the Boss of BIND. This is a singleton (only one can run).
  170. The msgq_socket_file specifies the UNIX domain socket file that the
  171. msgq process listens on. If verbose is True, then the boss reports
  172. what it is doing.
  173. """
  174. self.address = address
  175. self.dns_port = dns_port
  176. self.forward = None
  177. self.recursive = False
  178. if forward:
  179. self.forward = forward
  180. self.recursive = True
  181. self.nocache = False
  182. self.cc_session = None
  183. self.ccs = None
  184. self.cfg_start_auth = True
  185. self.cfg_start_recurse = False
  186. self.curproc = None
  187. self.dead_processes = {}
  188. self.msgq_socket_file = msgq_socket_file
  189. self.nocache = nocache
  190. self.processes = {}
  191. self.runnable = False
  192. self.uid = setuid
  193. self.username = username
  194. self.verbose = verbose
  195. def config_handler(self, new_config):
  196. if self.verbose:
  197. sys.stdout.write("[bind10] Handling new configuration: " +
  198. str(new_config) + "\n")
  199. answer = isc.config.ccsession.create_answer(0)
  200. return answer
  201. # TODO
  202. def command_handler(self, command, args):
  203. if self.verbose:
  204. sys.stdout.write("[bind10] Boss got command: " + command + "\n")
  205. answer = isc.config.ccsession.create_answer(1, "command not implemented")
  206. if type(command) != str:
  207. answer = isc.config.ccsession.create_answer(1, "bad command")
  208. else:
  209. if command == "shutdown":
  210. self.runnable = False
  211. answer = isc.config.ccsession.create_answer(0)
  212. else:
  213. answer = isc.config.ccsession.create_answer(1,
  214. "Unknown command")
  215. return answer
  216. def kill_started_processes(self):
  217. """
  218. Called as part of the exception handling when a process fails to
  219. start, this runs through the list of started processes, killing
  220. each one. It then clears that list.
  221. """
  222. if self.verbose:
  223. sys.stdout.write("[bind10] killing started processes:\n")
  224. for pid in self.processes:
  225. if self.verbose:
  226. sys.stdout.write("[bind10] - %s\n" % self.processes[pid].name)
  227. self.processes[pid].process.kill()
  228. self.processes = {}
  229. def read_bind10_config(self):
  230. """
  231. Reads the parameters associated with the BoB module itself.
  232. At present these are the components to start although arguably this
  233. information should be in the configuration for the appropriate
  234. module itself. (However, this would cause difficulty in the case of
  235. xfrin/xfrout and zone manager as we don't need to start those if we
  236. are not running the authoritative server.)
  237. """
  238. if self.verbose:
  239. sys.stdout.write("[bind10] Reading Boss configuration:\n")
  240. config_data = self.ccs.get_full_config()
  241. self.cfg_start_auth = config_data.get("start_auth")
  242. self.cfg_start_recurse = config_data.get("start_recurse")
  243. if self.verbose:
  244. sys.stdout.write("[bind10] - start_auth: %s\n" %
  245. str(self.cfg_start_auth))
  246. sys.stdout.write("[bind10] - start_recurse: %s\n" %
  247. str(self.cfg_start_recurse))
  248. def log_starting(self, process, port = None, address = None):
  249. """
  250. A convenience function to output a "Starting xxx" message if the
  251. verbose option is set. Putting this into a separate method ensures
  252. that the output form is consistent across all processes.
  253. The process name (passed as the first argument) is put into
  254. self.curproc, and is used to indicate which process failed to
  255. start if there is an error (and is used in the "Started" message
  256. on success). The optional port and address information are
  257. appended to the message (if present).
  258. """
  259. self.curproc = process
  260. if self.verbose:
  261. sys.stdout.write("[bind10] Starting %s" % self.curproc)
  262. if port is not None:
  263. sys.stdout.write(" on port %d" % port)
  264. if address is not None:
  265. sys.stdout.write(" (address %s)" % str(address))
  266. sys.stdout.write("\n")
  267. def log_started(self, pid = None):
  268. """
  269. A convenience function to output a 'Started xxxx (PID yyyy)'
  270. message. As with starting_message(), this ensures a consistent
  271. format.
  272. """
  273. if self.verbose:
  274. sys.stdout.write("[bind10] Started %s" % self.curproc)
  275. if pid is not None:
  276. sys.stdout.write(" (PID %d)" % pid)
  277. sys.stdout.write("\n")
  278. # The next few methods start the individual processes of BIND-10. They
  279. # are called via start_all_process(). If any fail, an exception is raised
  280. # which is caught by the caller of start_all_processes(); this kills
  281. # processes started up to that point before terminating the program.
  282. def start_msgq(self, c_channel_env):
  283. """
  284. Start the message queue and connect to the command channel.
  285. """
  286. self.log_starting("b10-msgq")
  287. c_channel = ProcessInfo("b10-msgq", ["b10-msgq"], c_channel_env,
  288. True, not self.verbose, uid=self.uid,
  289. username=self.username)
  290. self.processes[c_channel.pid] = c_channel
  291. self.log_started(c_channel.pid)
  292. # Now connect to the c-channel
  293. cc_connect_start = time.time()
  294. while self.cc_session is None:
  295. # if we have been trying for "a while" give up
  296. if (time.time() - cc_connect_start) > 5:
  297. raise CChannelConnectError("Unable to connect to c-channel after 5 seconds")
  298. # try to connect, and if we can't wait a short while
  299. try:
  300. self.cc_session = isc.cc.Session(self.msgq_socket_file)
  301. except isc.cc.session.SessionError:
  302. time.sleep(0.1)
  303. def start_cfgmgr(self, c_channel_env):
  304. """
  305. Starts the configuration manager process
  306. """
  307. self.log_starting("b10-cfgmgr")
  308. bind_cfgd = ProcessInfo("b10-cfgmgr", ["b10-cfgmgr"],
  309. c_channel_env, uid=self.uid,
  310. username=self.username)
  311. self.processes[bind_cfgd.pid] = bind_cfgd
  312. self.log_started(bind_cfgd.pid)
  313. # sleep until b10-cfgmgr is fully up and running, this is a good place
  314. # to have a (short) timeout on synchronized groupsend/receive
  315. # TODO: replace the sleep by a listen for ConfigManager started
  316. # message
  317. time.sleep(1)
  318. def start_ccsession(self, c_channel_env):
  319. """
  320. Start the CC Session
  321. The argument c_channel_env is unused but is supplied to keep the
  322. argument list the same for all start_xxx methods.
  323. """
  324. self.log_starting("ccsession")
  325. self.ccs = isc.config.ModuleCCSession(SPECFILE_LOCATION,
  326. self.config_handler, self.command_handler)
  327. self.ccs.start()
  328. self.log_started()
  329. # A couple of utility methods for starting processes...
  330. def start_process(self, name, args, c_channel_env, port=None, address=None):
  331. """
  332. Given a set of command arguments, start the process and output
  333. appropriate log messages. If the start is successful, the process
  334. is added to the list of started processes.
  335. The port and address arguments are for log messages only.
  336. """
  337. self.log_starting(name, port, address)
  338. newproc = ProcessInfo(name, args, c_channel_env)
  339. self.processes[newproc.pid] = newproc
  340. self.log_started(newproc.pid)
  341. def start_simple(self, name, c_channel_env, port=None, address=None):
  342. """
  343. Most of the BIND-10 processes are started with the command:
  344. <process-name> [-v]
  345. ... where -v is appended if verbose is enabled. This method
  346. generates the arguments from the name and starts the process.
  347. The port and address arguments are for log messages only.
  348. """
  349. # Set up the command arguments.
  350. args = [name]
  351. if self.verbose:
  352. args += ['-v']
  353. # ... and start the process
  354. self.start_process(name, args, c_channel_env, port, address)
  355. # The next few methods start up the rest of the BIND-10 processes.
  356. # Although many of these methods are little more than a call to
  357. # start_simple, they are retained (a) for testing reasons and (b) as a place
  358. # where modifications can be made if the process start-up sequence changes
  359. # for a given process.
  360. def start_auth(self, c_channel_env):
  361. """
  362. Start the Authoritative server
  363. """
  364. # XXX: this must be read from the configuration manager in the future
  365. if self.recursive:
  366. dns_prog = 'b10-recurse'
  367. else:
  368. dns_prog = 'b10-auth'
  369. dnsargs = [dns_prog]
  370. if not self.recursive:
  371. # The recursive uses configuration manager for these
  372. dnsargs += ['-p', str(self.dns_port)]
  373. if self.address:
  374. dnsargs += ['-a', str(self.address)]
  375. if self.nocache:
  376. dnsargs += ['-n']
  377. if self.uid:
  378. dnsargs += ['-u', str(self.uid)]
  379. if self.verbose:
  380. dnsargs += ['-v']
  381. # ... and start
  382. self.start_process("b10-auth", dnsargs, c_channel_env,
  383. self.dns_port, self.address)
  384. def start_recurse(self, c_channel_env):
  385. """
  386. Start the Resolver. At present, all these arguments and switches
  387. are pure speculation. As with the auth daemon, they should be
  388. read from the configuration database.
  389. """
  390. self.curproc = "b10-recurse"
  391. # XXX: this must be read from the configuration manager in the future
  392. resargs = ['b10-recurse']
  393. if self.uid:
  394. resargs += ['-u', str(self.uid)]
  395. if self.verbose:
  396. resargs += ['-v']
  397. # ... and start
  398. self.start_process("b10-recurse", resargs, c_channel_env)
  399. def start_xfrout(self, c_channel_env):
  400. self.start_simple("b10-xfrout", c_channel_env)
  401. def start_xfrin(self, c_channel_env):
  402. self.start_simple("b10-xfrin", c_channel_env)
  403. def start_zonemgr(self, c_channel_env):
  404. self.start_simple("b10-zonemgr", c_channel_env)
  405. def start_stats(self, c_channel_env):
  406. self.start_simple("b10-stats", c_channel_env)
  407. def start_cmdctl(self, c_channel_env):
  408. # XXX: we hardcode port 8080
  409. self.start_simple("b10-cmdctl", c_channel_env, 8080)
  410. def start_all_processes(self, c_channel_env):
  411. """
  412. Starts up all the processes. Any exception generated during the
  413. starting of the processes is handled by the caller.
  414. """
  415. self.start_msgq(c_channel_env)
  416. self.start_cfgmgr(c_channel_env)
  417. self.start_ccsession(c_channel_env)
  418. # Extract the parameters associated with Bob. This can only be
  419. # done after the CC Session is started.
  420. self.read_bind10_config()
  421. # Continue starting the processes. The authoritative server (if
  422. # selected):
  423. if self.cfg_start_auth:
  424. self.start_auth(c_channel_env)
  425. # ... and resolver (if selected):
  426. if self.cfg_start_recurse:
  427. self.start_recurse(c_channel_env)
  428. # Everything after the main components can run as non-root.
  429. # TODO: this is only temporary - once the privileged socket creator is
  430. # fully working, nothing else will run as root.
  431. if self.uid is not None:
  432. posix.setuid(self.uid)
  433. # xfrin/xfrout and the zone manager are only meaningful if the
  434. # authoritative server has been started.
  435. if self.cfg_start_auth:
  436. self.start_xfrout(c_channel_env)
  437. self.start_xfrin(c_channel_env)
  438. self.start_zonemgr(c_channel_env)
  439. # ... and finally start the remaining processes
  440. self.start_stats(c_channel_env)
  441. self.start_cmdctl(c_channel_env)
  442. def startup(self):
  443. """
  444. Start the BoB instance.
  445. Returns None if successful, otherwise an string describing the
  446. problem.
  447. """
  448. # Try to connect to the c-channel daemon, to see if it is already
  449. # running
  450. c_channel_env = {}
  451. if self.msgq_socket_file is not None:
  452. c_channel_env["BIND10_MSGQ_SOCKET_FILE"] = self.msgq_socket_file
  453. if self.verbose:
  454. sys.stdout.write("[bind10] Checking for already running b10-msgq\n")
  455. # try to connect, and if we can't wait a short while
  456. try:
  457. self.cc_session = isc.cc.Session(self.msgq_socket_file)
  458. return "b10-msgq already running, or socket file not cleaned , cannot start"
  459. except isc.cc.session.SessionError:
  460. # this is the case we want, where the msgq is not running
  461. pass
  462. # Start all processes. If any one fails to start, kill all started
  463. # processes and exit with an error indication.
  464. try:
  465. self.start_all_processes(c_channel_env)
  466. except Exception as e:
  467. self.kill_started_processes()
  468. return "Unable to start " + self.curproc + ": " + str(e)
  469. # Started successfully
  470. self.runnable = True
  471. return None
  472. def stop_all_processes(self):
  473. """Stop all processes."""
  474. cmd = { "command": ['shutdown']}
  475. self.cc_session.group_sendmsg(cmd, 'Cmdctl', 'Cmdctl')
  476. self.cc_session.group_sendmsg(cmd, "ConfigManager", "ConfigManager")
  477. self.cc_session.group_sendmsg(cmd, "Auth", "Auth")
  478. self.cc_session.group_sendmsg(cmd, "Recurse", "Recurse")
  479. self.cc_session.group_sendmsg(cmd, "Xfrout", "Xfrout")
  480. self.cc_session.group_sendmsg(cmd, "Xfrin", "Xfrin")
  481. self.cc_session.group_sendmsg(cmd, "Zonemgr", "Zonemgr")
  482. self.cc_session.group_sendmsg(cmd, "Stats", "Stats")
  483. def stop_process(self, process):
  484. """Stop the given process, friendly-like."""
  485. # XXX nothing yet
  486. pass
  487. def shutdown(self):
  488. """Stop the BoB instance."""
  489. if self.verbose:
  490. sys.stdout.write("[bind10] Stopping the server.\n")
  491. # first try using the BIND 10 request to stop
  492. try:
  493. self.stop_all_processes()
  494. except:
  495. pass
  496. # XXX: some delay probably useful... how much is uncertain
  497. # I have changed the delay from 0.5 to 1, but sometime it's
  498. # still not enough.
  499. time.sleep(1)
  500. self.reap_children()
  501. # next try sending a SIGTERM
  502. processes_to_stop = list(self.processes.values())
  503. for proc_info in processes_to_stop:
  504. if self.verbose:
  505. sys.stdout.write("[bind10] Sending SIGTERM to %s (PID %d).\n" %
  506. (proc_info.name, proc_info.pid))
  507. try:
  508. proc_info.process.terminate()
  509. except OSError:
  510. # ignore these (usually ESRCH because the child
  511. # finally exited)
  512. pass
  513. # finally, send SIGKILL (unmaskable termination) until everybody dies
  514. while self.processes:
  515. # XXX: some delay probably useful... how much is uncertain
  516. time.sleep(0.1)
  517. self.reap_children()
  518. processes_to_stop = list(self.processes.values())
  519. for proc_info in processes_to_stop:
  520. if self.verbose:
  521. sys.stdout.write("[bind10] Sending SIGKILL to %s (PID %d).\n" %
  522. (proc_info.name, proc_info.pid))
  523. try:
  524. proc_info.process.kill()
  525. except OSError:
  526. # ignore these (usually ESRCH because the child
  527. # finally exited)
  528. pass
  529. if self.verbose:
  530. sys.stdout.write("[bind10] All processes ended, server done.\n")
  531. def reap_children(self):
  532. """Check to see if any of our child processes have exited,
  533. and note this for later handling.
  534. """
  535. while True:
  536. try:
  537. (pid, exit_status) = os.waitpid(-1, os.WNOHANG)
  538. except OSError as o:
  539. if o.errno == errno.ECHILD: break
  540. # XXX: should be impossible to get any other error here
  541. raise
  542. if pid == 0: break
  543. if pid in self.processes:
  544. # One of the processes we know about. Get information on it.
  545. proc_info = self.processes.pop(pid)
  546. proc_info.restart_schedule.set_run_stop_time()
  547. self.dead_processes[proc_info.pid] = proc_info
  548. # Write out message, but only if in the running state:
  549. # During startup and shutdown, these messages are handled
  550. # elsewhere.
  551. if self.runnable:
  552. if exit_status is None:
  553. sys.stdout.write(
  554. "[bind10] Process %s (PID %d) died: exit status not available" %
  555. (proc_info.name, proc_info.pid))
  556. else:
  557. sys.stdout.write(
  558. "[bind10] Process %s (PID %d) terminated, exit status = %d\n" %
  559. (proc_info.name, proc_info.pid, exit_status))
  560. # Was it a special process?
  561. if proc_info.name == "b10-msgq":
  562. sys.stdout.write(
  563. "[bind10] The b10-msgq process died, shutting down.\n")
  564. self.runnable = False
  565. else:
  566. sys.stdout.write("[bind10] Unknown child pid %d exited.\n" % pid)
  567. def restart_processes(self):
  568. """
  569. Restart any dead processes:
  570. * Returns the time when the next process is ready to be restarted.
  571. * If the server is shutting down, returns 0.
  572. * If there are no processes, returns None.
  573. The values returned can be safely passed into select() as the
  574. timeout value.
  575. """
  576. next_restart = None
  577. # if we're shutting down, then don't restart
  578. if not self.runnable:
  579. return 0
  580. # otherwise look through each dead process and try to restart
  581. still_dead = {}
  582. now = time.time()
  583. for proc_info in self.dead_processes.values():
  584. restart_time = proc_info.restart_schedule.get_restart_time(now)
  585. if restart_time > now:
  586. if (next_restart is None) or (next_restart > restart_time):
  587. next_restart = restart_time
  588. still_dead[proc_info.pid] = proc_info
  589. else:
  590. if self.verbose:
  591. sys.stdout.write("[bind10] Resurrecting dead %s process...\n" %
  592. proc_info.name)
  593. try:
  594. proc_info.respawn()
  595. self.processes[proc_info.pid] = proc_info
  596. sys.stdout.write("[bind10] Resurrected %s (PID %d)\n" %
  597. (proc_info.name, proc_info.pid))
  598. except:
  599. still_dead[proc_info.pid] = proc_info
  600. # remember any processes that refuse to be resurrected
  601. self.dead_processes = still_dead
  602. # return the time when the next process is ready to be restarted
  603. return next_restart
  604. # global variables, needed for signal handlers
  605. options = None
  606. boss_of_bind = None
  607. def reaper(signal_number, stack_frame):
  608. """A child process has died (SIGCHLD received)."""
  609. # don't do anything...
  610. # the Python signal handler has been set up to write
  611. # down a pipe, waking up our select() bit
  612. pass
  613. def get_signame(signal_number):
  614. """Return the symbolic name for a signal."""
  615. for sig in dir(signal):
  616. if sig.startswith("SIG") and sig[3].isalnum():
  617. if getattr(signal, sig) == signal_number:
  618. return sig
  619. return "Unknown signal %d" % signal_number
  620. # XXX: perhaps register atexit() function and invoke that instead
  621. def fatal_signal(signal_number, stack_frame):
  622. """We need to exit (SIGINT or SIGTERM received)."""
  623. global options
  624. global boss_of_bind
  625. if options.verbose:
  626. sys.stdout.write("[bind10] Received %s.\n" % get_signame(signal_number))
  627. signal.signal(signal.SIGCHLD, signal.SIG_DFL)
  628. boss_of_bind.runnable = False
  629. def check_port(option, opt_str, value, parser):
  630. """Function to insure that the port we are passed is actually
  631. a valid port number. Used by OptionParser() on startup."""
  632. try:
  633. if opt_str in ['-p', '--port']:
  634. parser.values.dns_port = isc.net.parse.port_parse(value)
  635. else:
  636. raise OptionValueError("Unknown option " + opt_str)
  637. except ValueError as e:
  638. raise OptionValueError(str(e))
  639. def check_addr(option, opt_str, value, parser):
  640. """Function to insure that the address we are passed is actually
  641. a valid address. Used by OptionParser() on startup."""
  642. try:
  643. if opt_str in ['-a', '--address']:
  644. parser.values.address = isc.net.parse.addr_parse(value)
  645. if opt_str in ['-f', '--forward']:
  646. parser.values.forward = isc.net.parse.addr_parse(value)
  647. else:
  648. raise OptionValueError("Unknown option " + opt_str)
  649. except ValueError:
  650. raise OptionValueError("%s requires a valid IPv4 or IPv6 address" % opt_str)
  651. def process_rename(option, opt_str, value, parser):
  652. """Function that renames the process if it is requested by a option."""
  653. isc.util.process.rename(value)
  654. def main():
  655. global options
  656. global boss_of_bind
  657. # Enforce line buffering on stdout, even when not a TTY
  658. sys.stdout = io.TextIOWrapper(sys.stdout.detach(), line_buffering=True)
  659. # Parse any command-line options.
  660. parser = OptionParser(version=VERSION)
  661. parser.add_option("-a", "--address", dest="address", type="string",
  662. action="callback", callback=check_addr, default=None,
  663. help="address the DNS server will use (default: listen on all addresses)")
  664. parser.add_option("-f", "--forward", dest="forward", type="string",
  665. action="callback", callback=check_addr, default='',
  666. help="nameserver to which DNS queries should be forwarded")
  667. parser.add_option("-m", "--msgq-socket-file", dest="msgq_socket_file",
  668. type="string", default=None,
  669. help="UNIX domain socket file the b10-msgq daemon will use")
  670. parser.add_option("-n", "--no-cache", action="store_true", dest="nocache",
  671. default=False, help="disable hot-spot cache in authoritative DNS server")
  672. parser.add_option("-p", "--port", dest="dns_port", type="int",
  673. action="callback", callback=check_port, default=5300,
  674. help="port the DNS server will use (default 5300)")
  675. parser.add_option("-u", "--user", dest="user", type="string", default=None,
  676. help="Change user after startup (must run as root)")
  677. parser.add_option("-v", "--verbose", dest="verbose", action="store_true",
  678. help="display more about what is going on")
  679. parser.add_option("--pretty-name", type="string", action="callback",
  680. callback=process_rename,
  681. help="Set the process name (displayed in ps, top, ...)")
  682. (options, args) = parser.parse_args()
  683. if args:
  684. parser.print_help()
  685. sys.exit(1)
  686. # Check user ID.
  687. setuid = None
  688. username = None
  689. if options.user:
  690. # Try getting information about the user, assuming UID passed.
  691. try:
  692. pw_ent = pwd.getpwuid(int(options.user))
  693. setuid = pw_ent.pw_uid
  694. username = pw_ent.pw_name
  695. except ValueError:
  696. pass
  697. except KeyError:
  698. pass
  699. # Next try getting information about the user, assuming user name
  700. # passed.
  701. # If the information is both a valid user name and user number, we
  702. # prefer the name because we try it second. A minor point, hopefully.
  703. try:
  704. pw_ent = pwd.getpwnam(options.user)
  705. setuid = pw_ent.pw_uid
  706. username = pw_ent.pw_name
  707. except KeyError:
  708. pass
  709. if setuid is None:
  710. sys.stderr.write("bind10: invalid user: '%s'\n" % options.user)
  711. sys.exit(1)
  712. # Announce startup.
  713. if options.verbose:
  714. sys.stdout.write("%s\n" % VERSION)
  715. # Create wakeup pipe for signal handlers
  716. wakeup_pipe = os.pipe()
  717. signal.set_wakeup_fd(wakeup_pipe[1])
  718. # Set signal handlers for catching child termination, as well
  719. # as our own demise.
  720. signal.signal(signal.SIGCHLD, reaper)
  721. signal.siginterrupt(signal.SIGCHLD, False)
  722. signal.signal(signal.SIGINT, fatal_signal)
  723. signal.signal(signal.SIGTERM, fatal_signal)
  724. # Block SIGPIPE, as we don't want it to end this process
  725. signal.signal(signal.SIGPIPE, signal.SIG_IGN)
  726. # Go bob!
  727. boss_of_bind = BoB(options.msgq_socket_file, options.dns_port,
  728. options.address, options.forward, options.nocache,
  729. options.verbose, setuid, username)
  730. startup_result = boss_of_bind.startup()
  731. if startup_result:
  732. sys.stderr.write("[bind10] Error on startup: %s\n" % startup_result)
  733. sys.exit(1)
  734. sys.stdout.write("[bind10] BIND 10 started\n")
  735. # send "bind10.boot_time" to b10-stats
  736. time.sleep(1) # wait a second
  737. if options.verbose:
  738. sys.stdout.write("[bind10] send \"bind10.boot_time\" to b10-stats\n")
  739. cmd = isc.config.ccsession.create_command('set',
  740. { "stats_data": {
  741. 'bind10.boot_time': time.strftime('%Y-%m-%dT%H:%M:%SZ', _BASETIME)
  742. }
  743. })
  744. boss_of_bind.cc_session.group_sendmsg(cmd, 'Stats')
  745. # In our main loop, we check for dead processes or messages
  746. # on the c-channel.
  747. wakeup_fd = wakeup_pipe[0]
  748. ccs_fd = boss_of_bind.ccs.get_socket().fileno()
  749. while boss_of_bind.runnable:
  750. # clean up any processes that exited
  751. boss_of_bind.reap_children()
  752. next_restart = boss_of_bind.restart_processes()
  753. if next_restart is None:
  754. wait_time = None
  755. else:
  756. wait_time = max(next_restart - time.time(), 0)
  757. # select() can raise EINTR when a signal arrives,
  758. # even if they are resumable, so we have to catch
  759. # the exception
  760. try:
  761. (rlist, wlist, xlist) = select.select([wakeup_fd, ccs_fd], [], [],
  762. wait_time)
  763. except select.error as err:
  764. if err.args[0] == errno.EINTR:
  765. (rlist, wlist, xlist) = ([], [], [])
  766. else:
  767. sys.stderr.write("[bind10] Error with select(); %s\n" % err)
  768. break
  769. for fd in rlist + xlist:
  770. if fd == ccs_fd:
  771. try:
  772. boss_of_bind.ccs.check_command()
  773. except isc.cc.session.ProtocolError:
  774. if options.verbose:
  775. sys.stderr.write("[bind10] msgq channel disappeared.\n")
  776. break
  777. elif fd == wakeup_fd:
  778. os.read(wakeup_fd, 32)
  779. # shutdown
  780. signal.signal(signal.SIGCHLD, signal.SIG_DFL)
  781. boss_of_bind.shutdown()
  782. sys.stdout.write("[bind10] BIND 10 exiting\n");
  783. sys.exit(0)
  784. if __name__ == "__main__":
  785. main()