[svn] commit: r3638 - in /branches/trac412: ./ src/bin/ src/bin/bind10/ src/bin/bind10/tests/ src/bin/recurse/
BIND 10 source code commits
bind10-changes at lists.isc.org
Thu Nov 25 13:53:42 UTC 2010
Author: stephen
Date: Thu Nov 25 13:53:42 2010
New Revision: 3638
Log:
Added start_auth and start_recurse options to the Boss process to determine
where to start the authoritative and/or recursive server. Additional
command-line options have been provided to set the address/port for the
latter.
Added:
branches/trac412/src/bin/recurse/
branches/trac412/src/bin/recurse/Makefile.am
branches/trac412/src/bin/recurse/README_FIRST.txt
branches/trac412/src/bin/recurse/recurse.py.in
branches/trac412/src/bin/recurse/recurse.spec.pre.in
branches/trac412/src/bin/recurse/run_b10-recurse.sh.in
Modified:
branches/trac412/configure.ac
branches/trac412/src/bin/Makefile.am
branches/trac412/src/bin/bind10/bind10.py.in
branches/trac412/src/bin/bind10/bob.spec
branches/trac412/src/bin/bind10/run_bind10.sh.in
branches/trac412/src/bin/bind10/tests/bind10_test.py
Modified: branches/trac412/configure.ac
==============================================================================
--- branches/trac412/configure.ac (original)
+++ branches/trac412/configure.ac Thu Nov 25 13:53:42 2010
@@ -467,6 +467,7 @@
src/bin/auth/tests/Makefile
src/bin/auth/tests/testdata/Makefile
src/bin/auth/benchmarks/Makefile
+ src/bin/recurse/Makefile
src/bin/xfrin/Makefile
src/bin/xfrin/tests/Makefile
src/bin/xfrout/Makefile
@@ -530,6 +531,9 @@
src/bin/xfrout/xfrout.spec.pre
src/bin/xfrout/tests/xfrout_test
src/bin/xfrout/run_b10-xfrout.sh
+ src/bin/recurse/recurse.py
+ src/bin/recurse/recurse.spec.pre
+ src/bin/recurse/run_b10-recurse.sh
src/bin/zonemgr/zonemgr.py
src/bin/zonemgr/zonemgr.spec.pre
src/bin/zonemgr/tests/zonemgr_test
@@ -572,6 +576,7 @@
chmod +x src/bin/cmdctl/run_b10-cmdctl.sh
chmod +x src/bin/xfrin/run_b10-xfrin.sh
chmod +x src/bin/xfrout/run_b10-xfrout.sh
+ chmod +x src/bin/recurse/run_b10-recurse.sh
chmod +x src/bin/zonemgr/run_b10-zonemgr.sh
chmod +x src/bin/stats/tests/stats_test
chmod +x src/bin/stats/run_b10-stats.sh
Modified: branches/trac412/src/bin/Makefile.am
==============================================================================
--- branches/trac412/src/bin/Makefile.am (original)
+++ branches/trac412/src/bin/Makefile.am Thu Nov 25 13:53:42 2010
@@ -1,4 +1,4 @@
SUBDIRS = bind10 bindctl cfgmgr loadzone msgq host cmdctl auth xfrin xfrout \
- usermgr zonemgr stats tests
+ usermgr zonemgr stats tests recurse
check-recursive: all-recursive
Modified: branches/trac412/src/bin/bind10/bind10.py.in
==============================================================================
--- branches/trac412/src/bin/bind10/bind10.py.in (original)
+++ branches/trac412/src/bin/bind10/bind10.py.in Thu Nov 25 13:53:42 2010
@@ -189,137 +189,242 @@
def respawn(self):
self._spawn()
+class CChannelConnectError(Exception): pass
+
class BoB:
"""Boss of BIND class."""
- def __init__(self, msgq_socket_file=None, auth_port=5300, address=None,
- nocache=False, verbose=False, setuid=None, username=None):
- """Initialize the Boss of BIND. This is a singleton (only one
- can run).
+ def __init__(self, msgq_socket_file=None, auth_port=5300, res_port=5301,
+ address=None, res_address=None, nocache=False, verbose=False,
+ setuid=None, username=None):
+ """
+ Initialize the Boss of BIND. This is a singleton (only one can run).
- The msgq_socket_file specifies the UNIX domain socket file
- that the msgq process listens on.
- If verbose is True, then the boss reports what it is doing.
- """
- self.verbose = verbose
- self.msgq_socket_file = msgq_socket_file
- self.auth_port = auth_port
+ The msgq_socket_file specifies the UNIX domain socket file that the
+ msgq process listens on. If verbose is True, then the boss reports
+ what it is doing.
+ """
self.address = None
if address:
self.address = address
+ self.auth_port = auth_port
self.cc_session = None
self.ccs = None
+ self.cfg_start_auth = True
+ self.cfg_start_recurse = False
+ self.curproc = None
+ self.dead_processes = {}
+ self.msgq_socket_file = msgq_socket_file
+ self.nocache = nocache
self.processes = {}
- self.dead_processes = {}
+ self.res_address = None
+ if res_address:
+ self.res_address = res_address
+ self.res_port = res_port
self.runnable = False
self.uid = setuid
self.username = username
- self.nocache = nocache
+ self.verbose = verbose
def config_handler(self, new_config):
if self.verbose:
- sys.stdout.write("[bind10] handling new config:\n")
- sys.stdout.write(new_config + "\n")
+ sys.stdout.write("[bind10] Handling new configuration: " +
+ str(new_config) + "\n")
answer = isc.config.ccsession.create_answer(0)
return answer
# TODO
def command_handler(self, command, args):
if self.verbose:
- sys.stdout.write("[bind10] Boss got command:\n")
- sys.stdout.write(command + "\n")
+ sys.stdout.write("[bind10] Boss got command: " + command + "\n")
answer = isc.config.ccsession.create_answer(1, "command not implemented")
if type(command) != str:
answer = isc.config.ccsession.create_answer(1, "bad command")
else:
cmd = command
if cmd == "shutdown":
- sys.stdout.write("[bind10] got shutdown command\n")
+ sys.stdout.write("[bind10] shutdown command received by Boss\n")
self.runnable = False
answer = isc.config.ccsession.create_answer(0)
else:
answer = isc.config.ccsession.create_answer(1,
"Unknown command")
return answer
-
- def startup(self):
- """Start the BoB instance.
-
- Returns None if successful, otherwise an string describing the
- problem.
- """
- # try to connect to the c-channel daemon,
- # to see if it is already running
- c_channel_env = {}
- if self.msgq_socket_file is not None:
- c_channel_env["BIND10_MSGQ_SOCKET_FILE"] = self.msgq_socket_file
- if self.verbose:
- sys.stdout.write("[bind10] Checking for already running b10-msgq\n")
- # try to connect, and if we can't wait a short while
- try:
- self.cc_session = isc.cc.Session(self.msgq_socket_file)
- return "b10-msgq already running, or socket file not cleaned , cannot start"
- except isc.cc.session.SessionError:
- # this is the case we want, where the msgq is not running
- pass
-
- # start the c-channel daemon
- if self.verbose:
- if self.msgq_socket_file:
- sys.stdout.write("[bind10] Starting b10-msgq\n")
- try:
- c_channel = ProcessInfo("b10-msgq", ["b10-msgq"], c_channel_env,
- True, not self.verbose, uid=self.uid,
- username=self.username)
- except Exception as e:
- return "Unable to start b10-msgq; " + str(e)
+
+ def kill_started_processes(self):
+ """
+ Called as part of the exception handling when a process fails to
+ start, this runs through the list of started processes, killing
+ each one. It then clears that list.
+ """
+ if self.verbose:
+ sys.stdout.write("[bind10] killing started processes:\n")
+
+ for pid in self.processes:
+ if self.verbose:
+ sys.stdout.write("[bind10] - %s\n" % self.processes[pid].name)
+ self.processes[pid].process.kill()
+ self.processes = {}
+
+ def read_bind10_config(self):
+ """
+ Reads the parameters associated with the BoB module itself.
+
+ At present these are the components to start although arguably this
+ information should be in the configuration for the appropriate
+ module itself. (However, this would cause difficulty in the case of
+ xfrin/xfrout and zone manager as we don't need to start those if we
+ are not running the authoritative server.)
+ """
+ if self.verbose:
+ sys.stdout.write("[bind10] Reading Boss configuration:\n")
+
+ config_data = self.ccs.get_full_config()
+ self.cfg_start_auth = config_data.get("start_auth")
+ self.cfg_start_recurse = config_data.get("start_recurse")
+
+ if self.verbose:
+ sys.stdout.write("[bind10] - start_auth: %s\n" %
+ str(self.cfg_start_auth))
+ sys.stdout.write("[bind10] - start_recurse: %s\n" %
+ str(self.cfg_start_recurse))
+
+ def log_starting(self, process, port = None, address = None):
+ """
+ A convenience function to output a "Starting xxx" message if the
+ verbose option is set. Putting this into a separate method ensures
+ that the output form is consistent across all processes.
+
+ The process name (passed as the first argument) is put into
+ self.curproc, and is used to indicate which process failed to
+ start if there is an error (and is used in the "Started" message
+ on success). The optional port and address information are
+ appended to the message (if present).
+ """
+ self.curproc = process
+ if self.verbose:
+ sys.stdout.write("[bind10] Starting %s" % self.curproc)
+ if port is not None:
+ sys.stdout.write(" on port %d" % port)
+ if address is not None:
+ sys.stdout.write(" (address %s)" % str(address))
+ sys.stdout.write("\n")
+
+ def log_started(self, pid = None):
+ """
+ A convenience function to output a 'Started xxxx (PID yyyy)'
+ message. As with starting_message(), this ensures a consistent
+ format.
+ """
+ if self.verbose:
+ sys.stdout.write("[bind10] Started %s" % self.curproc)
+ if pid is not None:
+ sys.stdout.write(" (PID %d)" % pid)
+ sys.stdout.write("\n")
+
+ # The next few methods start the individual processes of BIND-10. They
+ # are called via start_all_process(). If any fail, an exception is raised
+ # which is caught by the caller of start_all_processes(); this kills
+ # processes started up to that point before terminating the program.
+
+ def start_msgq(self, c_channel_env):
+ """
+ Start the message queue and connect to the command channel.
+ """
+ self.log_starting("b10-msgq")
+ c_channel = ProcessInfo("b10-msgq", ["b10-msgq"], c_channel_env,
+ True, not self.verbose, uid=self.uid,
+ username=self.username)
self.processes[c_channel.pid] = c_channel
- if self.verbose:
- sys.stdout.write("[bind10] Started b10-msgq (PID %d)\n" %
- c_channel.pid)
-
- # now connect to the c-channel
+ self.log_started(c_channel.pid)
+
+ # Now connect to the c-channel
cc_connect_start = time.time()
while self.cc_session is None:
# if we have been trying for "a while" give up
if (time.time() - cc_connect_start) > 5:
- c_channel.process.kill()
- return "Unable to connect to c-channel after 5 seconds"
+ raise CChannelConnectError("Unable to connect to c-channel after 5 seconds")
+
# try to connect, and if we can't wait a short while
try:
self.cc_session = isc.cc.Session(self.msgq_socket_file)
except isc.cc.session.SessionError:
time.sleep(0.1)
- # start the configuration manager
- if self.verbose:
- sys.stdout.write("[bind10] Starting b10-cfgmgr\n")
- try:
- bind_cfgd = ProcessInfo("b10-cfgmgr", ["b10-cfgmgr"],
- c_channel_env, uid=self.uid,
- username=self.username)
- except Exception as e:
- c_channel.process.kill()
- return "Unable to start b10-cfgmgr; " + str(e)
+ def start_cfgmgr(self, c_channel_env):
+ """
+ Starts the configuration manager process
+ """
+ self.log_starting("b10-cfgmgr")
+ bind_cfgd = ProcessInfo("b10-cfgmgr", ["b10-cfgmgr"],
+ c_channel_env, uid=self.uid,
+ username=self.username)
self.processes[bind_cfgd.pid] = bind_cfgd
- if self.verbose:
- sys.stdout.write("[bind10] Started b10-cfgmgr (PID %d)\n" %
- bind_cfgd.pid)
+ self.log_started(bind_cfgd.pid)
# sleep until b10-cfgmgr is fully up and running, this is a good place
# to have a (short) timeout on synchronized groupsend/receive
# TODO: replace the sleep by a listen for ConfigManager started
# message
time.sleep(1)
- if self.verbose:
- sys.stdout.write("[bind10] starting ccsession\n")
+
+ def start_ccsession(self, c_channel_env):
+ """
+ Start the CC Session
+
+ The argument c_channel_env is unused but is supplied to keep the
+ argument list the same for all start_xxx methods.
+ """
+ self.log_starting("ccsession")
self.ccs = isc.config.ModuleCCSession(SPECFILE_LOCATION,
self.config_handler, self.command_handler)
self.ccs.start()
- if self.verbose:
- sys.stdout.write("[bind10] ccsession started\n")
-
- # start b10-auth
+ self.log_started()
+
+ # A couple of utility methods for starting processes...
+
+ def start_process(self, name, args, c_channel_env, port=None, address=None):
+ """
+ Given a set of command arguments, start the process and output
+ appropriate log messages. If the start is successful, the process
+ is added to the list of started processes.
+
+ The port and address arguments are for log messages only.
+ """
+ self.log_starting(name, port, address)
+ newproc = ProcessInfo(name, args, c_channel_env)
+ self.processes[newproc.pid] = newproc
+ self.log_started(newproc.pid)
+
+ def start_simple(self, name, c_channel_env, port=None, address=None):
+ """
+ Most of the BIND-10 processes are started with the command:
+
+ <process-name> [-v]
+
+ ... where -v is appended if verbose is enabled. This method
+ generates the arguments from the name and starts the process.
+
+ The port and address arguments are for log messages only.
+ """
+ # Set up the command arguments.
+ args = [name]
+ if self.verbose:
+ args += ['-v']
+
+ # ... and start the process
+ self.start_process(name, args, c_channel_env, port, address)
+
+ # The next few methods start up the rest of the BIND-10 processes.
+ # Although many of these methods are little more than a call to
+ # start_simple, they are retained (a) for testing reasons and (b) as a place
+ # where modifications can be made if the process start-up sequence changes
+ # for a given process.
+
+ def start_auth(self, c_channel_env):
+ """
+ Start the Authoritative server
+ """
# XXX: this must be read from the configuration manager in the future
authargs = ['b10-auth', '-p', str(self.auth_port)]
if self.address:
@@ -330,130 +435,118 @@
authargs += ['-u', str(self.uid)]
if self.verbose:
authargs += ['-v']
- sys.stdout.write("Starting b10-auth using port %d" %
- self.auth_port)
- if self.address:
- sys.stdout.write(" on %s" % str(self.address))
- sys.stdout.write("\n")
- try:
- auth = ProcessInfo("b10-auth", authargs,
- c_channel_env)
- except Exception as e:
- c_channel.process.kill()
- bind_cfgd.process.kill()
- xfrout.process.kill()
- return "Unable to start b10-auth; " + str(e)
- self.processes[auth.pid] = auth
- if self.verbose:
- sys.stdout.write("[bind10] Started b10-auth (PID %d)\n" % auth.pid)
-
- # everything after the authoritative server can run as non-root
+
+ # ... and start
+ self.start_process("b10-auth", authargs, c_channel_env,
+ self.auth_port, self.address)
+
+ def start_recurse(self, c_channel_env):
+ """
+ Start the Resolver. At present, all these arguments and switches
+ are pure speculation. As with the auth daemon, they should be
+ read from the configuration database.
+ """
+ self.curproc = "b10-recurse"
+ # XXX: this must be read from the configuration manager in the future
+ resargs = ['b10-recurse', '-p', str(self.res_port)]
+ if self.res_address:
+ resargs += ['-a', str(self.res_address)]
+ if self.nocache:
+ resargs += ['-n']
+ if self.uid:
+ resargs += ['-u', str(self.uid)]
+ if self.verbose:
+ resargs += ['-v']
+
+ # ... and start
+ self.start_process("b10-recurse", resargs, c_channel_env,
+ self.res_port, self.res_address)
+
+ def start_xfrout(self, c_channel_env):
+ self.start_simple("b10-xfrout", c_channel_env)
+
+ def start_xfrin(self, c_channel_env):
+ self.start_simple("b10-xfrin", c_channel_env)
+
+ def start_zonemgr(self, c_channel_env):
+ self.start_simple("b10-zonemgr", c_channel_env)
+
+ def start_stats(self, c_channel_env):
+ self.start_simple("b10-stats", c_channel_env)
+
+ def start_cmdctl(self, c_channel_env):
+ # XXX: we hardcode port 8080
+ self.start_simple("b10-cmdctl", c_channel_env, 8080)
+
+ def start_all_processes(self, c_channel_env):
+ """
+ Starts up all the processes. Any exception generated during the
+ starting of the processes is handled by the caller.
+ """
+ self.start_msgq(c_channel_env)
+ self.start_cfgmgr(c_channel_env)
+ self.start_ccsession(c_channel_env)
+
+ # Extract the parameters associated with Bob. This can only be
+ # done after the CC Session is started.
+ self.read_bind10_config()
+
+ # Continue starting the processes. The authoritative server (if
+ # selected):
+ if self.cfg_start_auth:
+ self.start_auth(c_channel_env)
+
+ # ... and resolver (if selected):
+ if self.cfg_start_recurse:
+ self.start_recurse(c_channel_env)
+
+ # Everything after the main components can run as non-root
if self.uid is not None:
posix.setuid(self.uid)
- # start the xfrout before auth-server, to make sure every xfr-query can
- # be processed properly.
- xfrout_args = ['b10-xfrout']
- if self.verbose:
- sys.stdout.write("[bind10] Starting b10-xfrout\n")
- xfrout_args += ['-v']
+ # xfrin/xfrout and the zone manager are only meaningful if the
+ # authoritative server has been started.
+ if self.cfg_start_auth:
+ self.start_xfrout(c_channel_env)
+ self.start_xfrin(c_channel_env)
+ self.start_zonemgr(c_channel_env)
+
+ # ... and finally start the remaining processes
+ self.start_stats(c_channel_env)
+ self.start_cmdctl(c_channel_env)
+
+ def startup(self):
+ """
+ Start the BoB instance.
+
+ Returns None if successful, otherwise an string describing the
+ problem.
+ """
+ # Try to connect to the c-channel daemon, to see if it is already
+ # running
+ c_channel_env = {}
+ if self.msgq_socket_file is not None:
+ c_channel_env["BIND10_MSGQ_SOCKET_FILE"] = self.msgq_socket_file
+ if self.verbose:
+ sys.stdout.write("[bind10] Checking for already running b10-msgq\n")
+ # try to connect, and if we can't wait a short while
try:
- xfrout = ProcessInfo("b10-xfrout", xfrout_args,
- c_channel_env )
+ self.cc_session = isc.cc.Session(self.msgq_socket_file)
+ return "b10-msgq already running, or socket file not cleaned , cannot start"
+ except isc.cc.session.SessionError:
+ # this is the case we want, where the msgq is not running
+ pass
+
+ # Start all processes. If any one fails to start, kill all started
+ # processes and exit with an error indication.
+ try:
+ self.start_all_processes(c_channel_env)
except Exception as e:
- c_channel.process.kill()
- bind_cfgd.process.kill()
- return "Unable to start b10-xfrout; " + str(e)
- self.processes[xfrout.pid] = xfrout
- if self.verbose:
- sys.stdout.write("[bind10] Started b10-xfrout (PID %d)\n" %
- xfrout.pid)
-
- # start b10-xfrin
- xfrin_args = ['b10-xfrin']
- if self.verbose:
- sys.stdout.write("[bind10] Starting b10-xfrin\n")
- xfrin_args += ['-v']
- try:
- xfrind = ProcessInfo("b10-xfrin", xfrin_args,
- c_channel_env)
- except Exception as e:
- c_channel.process.kill()
- bind_cfgd.process.kill()
- xfrout.process.kill()
- auth.process.kill()
- return "Unable to start b10-xfrin; " + str(e)
- self.processes[xfrind.pid] = xfrind
- if self.verbose:
- sys.stdout.write("[bind10] Started b10-xfrin (PID %d)\n" %
- xfrind.pid)
-
- # start b10-zonemgr
- zonemgr_args = ['b10-zonemgr']
- if self.verbose:
- sys.stdout.write("[bind10] Starting b10-zonemgr\n")
- zonemgr_args += ['-v']
- try:
- zonemgr = ProcessInfo("b10-zonemgr", zonemgr_args,
- c_channel_env)
- except Exception as e:
- c_channel.process.kill()
- bind_cfgd.process.kill()
- xfrout.process.kill()
- auth.process.kill()
- xfrind.process.kill()
- return "Unable to start b10-zonemgr; " + str(e)
- self.processes[zonemgr.pid] = zonemgr
- if self.verbose:
- sys.stdout.write("[bind10] Started b10-zonemgr(PID %d)\n" %
- zonemgr.pid)
-
- # start b10-stats
- stats_args = ['b10-stats']
- if self.verbose:
- sys.stdout.write("[bind10] Starting b10-stats\n")
- stats_args += ['-v']
- try:
- statsd = ProcessInfo("b10-stats", stats_args,
- c_channel_env)
- except Exception as e:
- c_channel.process.kill()
- bind_cfgd.process.kill()
- xfrout.process.kill()
- auth.process.kill()
- xfrind.process.kill()
- zonemgr.process.kill()
- return "Unable to start b10-stats; " + str(e)
-
- self.processes[statsd.pid] = statsd
- if self.verbose:
- sys.stdout.write("[bind10] Started b10-stats (PID %d)\n" % statsd.pid)
-
- # start the b10-cmdctl
- # XXX: we hardcode port 8080
- cmdctl_args = ['b10-cmdctl']
- if self.verbose:
- sys.stdout.write("[bind10] Starting b10-cmdctl on port 8080\n")
- cmdctl_args += ['-v']
- try:
- cmd_ctrld = ProcessInfo("b10-cmdctl", cmdctl_args,
- c_channel_env)
- except Exception as e:
- c_channel.process.kill()
- bind_cfgd.process.kill()
- xfrout.process.kill()
- auth.process.kill()
- xfrind.process.kill()
- zonemgr.process.kill()
- statsd.process.kill()
- return "Unable to start b10-cmdctl; " + str(e)
- self.processes[cmd_ctrld.pid] = cmd_ctrld
- if self.verbose:
- sys.stdout.write("[bind10] Started b10-cmdctl (PID %d)\n" %
- cmd_ctrld.pid)
-
+ self.kill_started_processes()
+ return "Unable to start " + self.curproc + ": " + str(e)
+
+ # Started successfully
self.runnable = True
-
return None
def stop_all_processes(self):
@@ -462,6 +555,7 @@
self.cc_session.group_sendmsg(cmd, 'Cmdctl', 'Cmdctl')
self.cc_session.group_sendmsg(cmd, "ConfigManager", "ConfigManager")
self.cc_session.group_sendmsg(cmd, "Auth", "Auth")
+ self.cc_session.group_sendmsg(cmd, "Recurse", "Recurse")
self.cc_session.group_sendmsg(cmd, "Xfrout", "Xfrout")
self.cc_session.group_sendmsg(cmd, "Xfrin", "Xfrin")
self.cc_session.group_sendmsg(cmd, "Zonemgr", "Zonemgr")
@@ -616,6 +710,8 @@
try:
if opt_str in ['-p', '--port']:
parser.values.auth_port = isc.net.parse.port_parse(value)
+ elif opt_str in ['-q', '--res-port']:
+ parser.values.res_port = isc.net.parse.port_parse(value)
else:
raise OptionValueError("Unknown option " + opt_str)
except ValueError as e:
@@ -627,6 +723,8 @@
try:
if opt_str in ['-a', '--address']:
parser.values.address = isc.net.parse.addr_parse(value)
+ elif opt_str in ['-b', '--res-address']:
+ parser.values.res_address = isc.net.parse.addr_parse(value)
else:
raise OptionValueError("Unknown option " + opt_str)
except ValueError:
@@ -642,12 +740,15 @@
# Enforce line buffering on stdout, even when not a TTY
sys.stdout = io.TextIOWrapper(sys.stdout.detach(), line_buffering=True)
-
# Parse any command-line options.
parser = OptionParser(version=VERSION)
parser.add_option("-a", "--address", dest="address", type="string",
action="callback", callback=check_addr, default='',
help="address the b10-auth daemon will use (default: listen on all addresses)")
+ parser.add_option("-b", "--res-address", dest="res_address",
+ type="string",
+ action="callback", callback=check_addr, default='',
+ help="address the b10-recurse daemon will use (default: listen on all addresses)")
parser.add_option("-m", "--msgq-socket-file", dest="msgq_socket_file",
type="string", default=None,
help="UNIX domain socket file the b10-msgq daemon will use")
@@ -656,6 +757,9 @@
parser.add_option("-p", "--port", dest="auth_port", type="int",
action="callback", callback=check_port, default=5300,
help="port the b10-auth daemon will use (default 5300)")
+ parser.add_option("-q", "--res-port", dest="res_port", type="int",
+ action="callback", callback=check_port, default=5301,
+ help="b10-recurse daemon port (default 5301)")
parser.add_option("-u", "--user", dest="user",
type="string", default=None,
help="Change user after startup (must run as root)")
@@ -722,8 +826,8 @@
# Go bob!
boss_of_bind = BoB(options.msgq_socket_file, options.auth_port,
- options.address, options.nocache, options.verbose,
- setuid, username)
+ options.res_port, options.address, options.res_address,
+ options.nocache, options.verbose, setuid, username)
startup_result = boss_of_bind.startup()
if startup_result:
sys.stderr.write("[bind10] Error on startup: %s\n" % startup_result)
Modified: branches/trac412/src/bin/bind10/bob.spec
==============================================================================
--- branches/trac412/src/bin/bind10/bob.spec (original)
+++ branches/trac412/src/bin/bind10/bob.spec Thu Nov 25 13:53:42 2010
@@ -3,6 +3,18 @@
"module_name": "Boss",
"module_description": "Master process",
"config_data": [
+ {
+ "item_name": "start_auth",
+ "item_type": "boolean",
+ "item_optional": false,
+ "item_default": true
+ },
+ {
+ "item_name": "start_recurse",
+ "item_type": "boolean",
+ "item_optional": false,
+ "item_default": false
+ }
],
"commands": [
{
Modified: branches/trac412/src/bin/bind10/run_bind10.sh.in
==============================================================================
--- branches/trac412/src/bin/bind10/run_bind10.sh.in (original)
+++ branches/trac412/src/bin/bind10/run_bind10.sh.in Thu Nov 25 13:53:42 2010
@@ -20,7 +20,7 @@
BIND10_PATH=@abs_top_builddir@/src/bin/bind10
-PATH=@abs_top_builddir@/src/bin/msgq:@abs_top_builddir@/src/bin/auth:@abs_top_builddir@/src/bin/cfgmgr:@abs_top_builddir@/src/bin/cmdctl:@abs_top_builddir@/src/bin/stats:@abs_top_builddir@/src/bin/xfrin:@abs_top_builddir@/src/bin/xfrout:@abs_top_builddir@/src/bin/zonemgr:$PATH
+PATH=@abs_top_builddir@/src/bin/msgq:@abs_top_builddir@/src/bin/auth:@abs_top_builddir@/src/bin/cfgmgr:@abs_top_builddir@/src/bin/cmdctl:@abs_top_builddir@/src/bin/stats:@abs_top_builddir@/src/bin/xfrin:@abs_top_builddir@/src/bin/xfrout:@abs_top_builddir@/src/bin/zonemgr:@abs_top_builddir@/src/bin/recurse:$PATH
export PATH
PYTHONPATH=@abs_top_builddir@/src/lib/python:@abs_top_builddir@/src/lib/dns/python/.libs:@abs_top_builddir@/src/lib/xfr/.libs
Modified: branches/trac412/src/bin/bind10/tests/bind10_test.py
==============================================================================
--- branches/trac412/src/bin/bind10/tests/bind10_test.py (original)
+++ branches/trac412/src/bin/bind10/tests/bind10_test.py Thu Nov 25 13:53:42 2010
@@ -79,43 +79,280 @@
self.assertEqual(bob.verbose, False)
self.assertEqual(bob.msgq_socket_file, None)
self.assertEqual(bob.auth_port, 5300)
- self.assertEqual(bob.cc_session, None)
+ self.assertEqual(bob.res_port, 5301)
self.assertEqual(bob.address, None)
- self.assertEqual(bob.processes, {})
- self.assertEqual(bob.dead_processes, {})
- self.assertEqual(bob.runnable, False)
+ self.assertEqual(bob.cc_session, None)
+ self.assertEqual(bob.ccs, None)
+ self.assertEqual(bob.processes, {})
+ self.assertEqual(bob.dead_processes, {})
+ self.assertEqual(bob.runnable, False)
+ self.assertEqual(bob.uid, None)
+ self.assertEqual(bob.username, None)
+ self.assertEqual(bob.nocache, False)
+ self.assertEqual(bob.cfg_start_auth, True)
+ self.assertEqual(bob.cfg_start_recurse, False)
def test_init_alternate_socket(self):
bob = BoB("alt_socket_file")
self.assertEqual(bob.verbose, False)
self.assertEqual(bob.msgq_socket_file, "alt_socket_file")
- self.assertEqual(bob.cc_session, None)
- self.assertEqual(bob.processes, {})
- self.assertEqual(bob.dead_processes, {})
- self.assertEqual(bob.runnable, False)
+ self.assertEqual(bob.auth_port, 5300)
+ self.assertEqual(bob.res_port, 5301)
+ self.assertEqual(bob.address, None)
+ self.assertEqual(bob.cc_session, None)
+ self.assertEqual(bob.ccs, None)
+ self.assertEqual(bob.processes, {})
+ self.assertEqual(bob.dead_processes, {})
+ self.assertEqual(bob.runnable, False)
+ self.assertEqual(bob.uid, None)
+ self.assertEqual(bob.username, None)
+ self.assertEqual(bob.nocache, False)
+ self.assertEqual(bob.cfg_start_auth, True)
+ self.assertEqual(bob.cfg_start_recurse, False)
def test_init_alternate_auth_port(self):
bob = BoB(None, 9999)
self.assertEqual(bob.verbose, False)
self.assertEqual(bob.msgq_socket_file, None)
self.assertEqual(bob.auth_port, 9999)
- self.assertEqual(bob.cc_session, None)
+ self.assertEqual(bob.res_port, 5301)
self.assertEqual(bob.address, None)
- self.assertEqual(bob.processes, {})
- self.assertEqual(bob.dead_processes, {})
- self.assertEqual(bob.runnable, False)
+ self.assertEqual(bob.cc_session, None)
+ self.assertEqual(bob.ccs, None)
+ self.assertEqual(bob.processes, {})
+ self.assertEqual(bob.dead_processes, {})
+ self.assertEqual(bob.runnable, False)
+ self.assertEqual(bob.uid, None)
+ self.assertEqual(bob.username, None)
+ self.assertEqual(bob.nocache, False)
+ self.assertEqual(bob.cfg_start_auth, True)
+ self.assertEqual(bob.cfg_start_recurse, False)
+
+ def test_init_alternate_res_port(self):
+ bob = BoB(None, 9999, 9998)
+ self.assertEqual(bob.verbose, False)
+ self.assertEqual(bob.msgq_socket_file, None)
+ self.assertEqual(bob.auth_port, 9999)
+ self.assertEqual(bob.res_port, 9998)
+ self.assertEqual(bob.address, None)
+ self.assertEqual(bob.res_address, None)
+ self.assertEqual(bob.cc_session, None)
+ self.assertEqual(bob.ccs, None)
+ self.assertEqual(bob.processes, {})
+ self.assertEqual(bob.dead_processes, {})
+ self.assertEqual(bob.runnable, False)
+ self.assertEqual(bob.uid, None)
+ self.assertEqual(bob.username, None)
+ self.assertEqual(bob.nocache, False)
+ self.assertEqual(bob.cfg_start_auth, True)
+ self.assertEqual(bob.cfg_start_recurse, False)
def test_init_alternate_address(self):
- bob = BoB(None, 5300, IPAddr('127.127.127.127'))
- self.assertEqual(bob.verbose, False)
- self.assertEqual(bob.auth_port, 5300)
- self.assertEqual(bob.msgq_socket_file, None)
- self.assertEqual(bob.cc_session, None)
+ bob = BoB(None, 1234, 5678, IPAddr('127.127.127.127'))
+ self.assertEqual(bob.verbose, False)
+ self.assertEqual(bob.msgq_socket_file, None)
+ self.assertEqual(bob.auth_port, 1234)
+ self.assertEqual(bob.res_port, 5678)
self.assertEqual(bob.address.addr, socket.inet_aton('127.127.127.127'))
- self.assertEqual(bob.processes, {})
- self.assertEqual(bob.dead_processes, {})
- self.assertEqual(bob.runnable, False)
- # verbose testing...
+ self.assertEqual(bob.res_address, None)
+ self.assertEqual(bob.cc_session, None)
+ self.assertEqual(bob.ccs, None)
+ self.assertEqual(bob.processes, {})
+ self.assertEqual(bob.dead_processes, {})
+ self.assertEqual(bob.runnable, False)
+ self.assertEqual(bob.uid, None)
+ self.assertEqual(bob.username, None)
+ self.assertEqual(bob.nocache, False)
+ self.assertEqual(bob.cfg_start_auth, True)
+ self.assertEqual(bob.cfg_start_recurse, False)
+
+ def test_init_alternate_res_address(self):
+ bob = BoB(None, 1234, 5678, IPAddr('127.127.127.127'), IPAddr("255.254.253.252"))
+ self.assertEqual(bob.verbose, False)
+ self.assertEqual(bob.msgq_socket_file, None)
+ self.assertEqual(bob.auth_port, 1234)
+ self.assertEqual(bob.res_port, 5678)
+ self.assertEqual(bob.address.addr, socket.inet_aton('127.127.127.127'))
+ self.assertEqual(bob.res_address.addr, socket.inet_aton('255.254.253.252'))
+ self.assertEqual(bob.cc_session, None)
+ self.assertEqual(bob.ccs, None)
+ self.assertEqual(bob.processes, {})
+ self.assertEqual(bob.dead_processes, {})
+ self.assertEqual(bob.runnable, False)
+ self.assertEqual(bob.uid, None)
+ self.assertEqual(bob.username, None)
+ self.assertEqual(bob.nocache, False)
+ self.assertEqual(bob.cfg_start_auth, True)
+ self.assertEqual(bob.cfg_start_recurse, False)
+
+# Class for testing the Bob.start_all_processes() method call.
+#
+# Although testing that external processes start is outside the scope
+# of the unit test, by overriding the process start methods we can check
+# that the right processes are started depending on the configuration
+# options.
+class StartAllProcessesBob(BoB):
+ def __init__(self):
+ BoB.__init__(self)
+
+# Set flags as to which of the overridden methods has been run.
+ self.msgq = False
+ self.cfgmgr = False
+ self.ccsession = False
+ self.auth = False
+ self.recurse = False
+ self.xfrout = False
+ self.xfrin = False
+ self.zonemgr = False
+ self.stats = False
+ self.cmdctl = False
+
+ def read_bind10_config(self):
+ # Configuration options are set directly
+ pass
+
+ def start_msgq(self, c_channel_env):
+ self.msgq = True
+
+ def start_cfgmgr(self, c_channel_env):
+ self.cfgmgr = True
+
+ def start_ccsession(self, c_channel_env):
+ self.ccsession = True
+
+ def start_auth(self, c_channel_env):
+ self.auth = True
+
+ def start_recurse(self, c_channel_env):
+ self.recurse = True
+
+ def start_xfrout(self, c_channel_env):
+ self.xfrout = True
+
+ def start_xfrin(self, c_channel_env):
+ self.xfrin = True
+
+ def start_zonemgr(self, c_channel_env):
+ self.zonemgr = True
+
+ def start_stats(self, c_channel_env):
+ self.stats = True
+
+ def start_cmdctl(self, c_channel_env):
+ self.cmdctl = True
+
+# Check that the start_all_processes method starts the right combination
+# of processes.
+class TestStartAllProcessesBob(unittest.TestCase):
+ def check_preconditions(self, bob):
+ self.assertEqual(bob.msgq, False)
+ self.assertEqual(bob.cfgmgr, False)
+ self.assertEqual(bob.ccsession, False)
+ self.assertEqual(bob.auth, False)
+ self.assertEqual(bob.recurse, False)
+ self.assertEqual(bob.xfrout, False)
+ self.assertEqual(bob.xfrin, False)
+ self.assertEqual(bob.zonemgr, False)
+ self.assertEqual(bob.stats, False)
+ self.assertEqual(bob.cmdctl, False)
+
+ # Checks the processes started when starting neither auth nor recruse
+ # is specified.
+ def test_start_none(self):
+ # Created Bob and ensure initialization correct
+ bob = StartAllProcessesBob()
+ self.check_preconditions(bob)
+
+ # Start processes and check what was started
+ c_channel_env = {}
+ bob.cfg_start_auth = False
+ bob.cfg_start_recurse = False
+
+ bob.start_all_processes(c_channel_env)
+
+ self.assertEqual(bob.msgq, True)
+ self.assertEqual(bob.cfgmgr, True)
+ self.assertEqual(bob.ccsession, True)
+ self.assertEqual(bob.auth, False)
+ self.assertEqual(bob.recurse, False)
+ self.assertEqual(bob.xfrout, False)
+ self.assertEqual(bob.xfrin, False)
+ self.assertEqual(bob.zonemgr, False)
+ self.assertEqual(bob.stats, True)
+ self.assertEqual(bob.cmdctl, True)
+
+ # Checks the processes started when starting only the auth process
+ def test_start_auth(self):
+ # Created Bob and ensure initialization correct
+ bob = StartAllProcessesBob()
+ self.check_preconditions(bob)
+
+ # Start processes and check what was started
+ c_channel_env = {}
+ bob.cfg_start_auth = True
+ bob.cfg_start_recurse = False
+
+ bob.start_all_processes(c_channel_env)
+
+ self.assertEqual(bob.msgq, True)
+ self.assertEqual(bob.cfgmgr, True)
+ self.assertEqual(bob.ccsession, True)
+ self.assertEqual(bob.auth, True)
+ self.assertEqual(bob.recurse, False)
+ self.assertEqual(bob.xfrout, True)
+ self.assertEqual(bob.xfrin, True)
+ self.assertEqual(bob.zonemgr, True)
+ self.assertEqual(bob.stats, True)
+ self.assertEqual(bob.cmdctl, True)
+
+ # Checks the processes started when starting only the recurse process
+ def test_start_recurse(self):
+ # Created Bob and ensure initialization correct
+ bob = StartAllProcessesBob()
+ self.check_preconditions(bob)
+
+ # Start processes and check what was started
+ c_channel_env = {}
+ bob.cfg_start_auth = False
+ bob.cfg_start_recurse = True
+
+ bob.start_all_processes(c_channel_env)
+
+ self.assertEqual(bob.msgq, True)
+ self.assertEqual(bob.cfgmgr, True)
+ self.assertEqual(bob.ccsession, True)
+ self.assertEqual(bob.auth, False)
+ self.assertEqual(bob.recurse, True)
+ self.assertEqual(bob.xfrout, False)
+ self.assertEqual(bob.xfrin, False)
+ self.assertEqual(bob.zonemgr, False)
+ self.assertEqual(bob.stats, True)
+ self.assertEqual(bob.cmdctl, True)
+
+ # Checks the processes started when starting both auth and recurse process
+ def test_start_both(self):
+ # Created Bob and ensure initialization correct
+ bob = StartAllProcessesBob()
+ self.check_preconditions(bob)
+
+ # Start processes and check what was started
+ c_channel_env = {}
+ bob.cfg_start_auth = True
+ bob.cfg_start_recurse = True
+
+ bob.start_all_processes(c_channel_env)
+
+ self.assertEqual(bob.msgq, True)
+ self.assertEqual(bob.cfgmgr, True)
+ self.assertEqual(bob.ccsession, True)
+ self.assertEqual(bob.auth, True)
+ self.assertEqual(bob.recurse, True)
+ self.assertEqual(bob.xfrout, True)
+ self.assertEqual(bob.xfrin, True)
+ self.assertEqual(bob.zonemgr, True)
+ self.assertEqual(bob.stats, True)
+ self.assertEqual(bob.cmdctl, True)
+
if __name__ == '__main__':
unittest.main()
More information about the bind10-changes
mailing list