def main(args): CONFIG.register_descriptions({ "speedtest.client.uri": "Base URI to connect to", "speedtest.client.nconn": "Number of concurrent connections to use", "speedtest.client.latency_tries": "Number of latency measurements", }) common.main("speedtest.client", "Speedtest client", args) conf = CONFIG.copy() # # If possible use the runner, which will execute the # test in the context of the neubot daemon. Then exit # to bypass the POLLER.loop() invokation that is below # here. # If the runner fails, fallback to the usual code path, # which executes the test in the context of the local # process. # Set 'runned.enabled' to 0 to bypass the runner and # run the test locally. # if (utils.intify(conf['runner.enabled']) and runner_clnt.runner_client(conf["agent.api.address"], conf["agent.api.port"], LOG.noisy, "speedtest")): sys.exit(0) LOG.info('Will run the test in the local context...') client = ClientSpeedtest(POLLER) client.configure(conf) client.connect_uri() POLLER.loop()
def _api_config(self, stream, request, query): response = Message() indent, mimetype, sort_keys = None, "application/json", False dictionary = cgi.parse_qs(query) if "debug" in dictionary and utils.intify(dictionary["debug"][0]): indent, mimetype, sort_keys = 4, "text/plain", True if request.method == "POST": s = request.body.read() updates = qs_to_dictionary(s) privacy.check(updates) # Very low barrier to prevent damage from kiddies if "agent.interval" in updates: interval = int(updates["agent.interval"]) if interval < 1380 and interval != 0: raise ConfigError("Bad agent.interval") CONFIG.merge_api(updates, DATABASE.connection()) STATE.update("config", updates) # Empty JSON b/c '204 No Content' is treated as an error s = "{}" else: s = json.dumps(CONFIG.conf, sort_keys=sort_keys, indent=indent) stringio = StringIO.StringIO(s) response.compose(code="200", reason="Ok", body=stringio, mimetype=mimetype) stream.send_response(request, response)
def main(args): ''' main() of this module ''' CONFIG.register_descriptions({ "http.client.class": "Specify alternate ClientHTTP-like class", "http.client.method": "Specify alternate HTTP method", "http.client.stdout": "Enable writing response to stdout", "http.client.uri": "Specify URI to download from/upload to", }) common.main("http.client", "Simple Neubot HTTP client", args) conf = CONFIG.copy() make_client = TestClient if conf["http.client.class"]: make_client = utils.import_class(conf["http.client.class"]) if not conf["http.client.uri"]: sys.stdout.write("Please, specify URI via -D http.client.uri=URI\n") sys.exit(0) client = make_client(POLLER) client.configure(conf) client.connect_uri(conf["http.client.uri"]) POLLER.loop() sys.exit(0)
def main(args): ''' main() function of this module ''' CONFIG.register_descriptions({ "http.server.address": "Address to listen to", "http.server.class": "Use alternate ServerHTTP-like class", "http.server.mime": "Enable code that guess mime types", "http.server.ports": "List of ports to listen to", "http.server.rootdir": "Root directory for static pages", "http.server.ssi": "Enable server-side includes", }) common.main("http.server", "Neubot simple HTTP server", args) conf = CONFIG.copy() HTTP_SERVER.configure(conf) if conf["http.server.rootdir"] == ".": conf["http.server.rootdir"] = os.path.abspath(".") for port in conf["http.server.ports"].split(","): if port: HTTP_SERVER.listen((conf["http.server.address"], int(port))) POLLER.loop()
def main(args): CONFIG.register_descriptions({ "rendezvous.server.address": "Set rendezvous server address", "rendezvous.server.daemonize": "Enable daemon behavior", "rendezvous.server.ports": "List of rendezvous server ports", "rendezvous.server.update_uri": "Where to download updates from", "rendezvous.server.update_version": "Update Neubot version number", "rendezvous.geoip_wrapper.country_database": "Path of the GeoIP country database", "rendezvous.server.default": "Default test server to use", }) common.main("rendezvous.server", "Rendezvous server", args) conf = CONFIG.copy() HTTP_SERVER.configure(conf) for port in conf["rendezvous.server.ports"].split(","): HTTP_SERVER.listen((conf["rendezvous.server.address"], int(port))) # Really start this module run(POLLER, conf) if conf["rendezvous.server.daemonize"]: system.change_dir() system.go_background() LOG.redirect() system.drop_privileges(LOG.error) POLLER.loop()
def main(args): ''' Main() function ''' try: options, arguments = getopt.getopt(args[1:], '') except getopt.error: sys.exit('usage: neubot background_win32') if options or arguments: sys.exit('usage: neubot background_win32') # Read settings from database CONFIG.merge_database(DATABASE.connection()) # # Save logs into the database, to easily access # and show them via the web user interface. # LOG.use_database() # Complain if privacy settings are not OK privacy.complain_if_needed() background_api.start('127.0.0.1 ::1', '9774') BACKGROUND_RENDEZVOUS.start() __start_updater() POLLER.loop()
def main(args): ''' Main function ''' try: options, arguments = getopt.getopt(args[1:], 'f:nv') except getopt.error: sys.exit(USAGE) database_path = system.get_default_database_path() auto_discover = True for name, value in options: if name == '-f': database_path = value elif name == '-n': auto_discover = False elif name == '-v': CONFIG['verbose'] = 1 if len(arguments) != 1 and len(arguments) != 2: sys.exit(USAGE) DATABASE.set_path(database_path) CONFIG.merge_database(DATABASE.connection()) if len(arguments) == 2: RUNNER_TESTS.update({arguments[0]: [arguments[1]]}) ctx = {'uri': arguments[1]} else: ctx = None deferred = Deferred() deferred.add_callback(lambda param: None) RUNNER_CORE.run(arguments[0], deferred, auto_discover, ctx) POLLER.loop()
def main(args): ''' Main function ''' try: options, arguments = getopt.getopt(args[1:], 'D:t:v') except getopt.error: sys.exit('usage: notifier_browser [-v] [-D setting] [-t time] page...') if not arguments: sys.exit('usage: notifier_browser [-v] [-D setting] [-t time] page...') sleeptime = 0 for name, value in options: if name == '-D': CONFIG.register_property(value) elif name == '-t': sleeptime = int(value) elif name == '-v': CONFIG['verbose'] = 1 CONFIG.merge_properties() for argument in arguments: if argument == 'privacy': NOTIFIER_BROWSER.notify_bad_privacy() elif argument == 'update': NOTIFIER_BROWSER.notify_update_avail() else: sys.exit('Invalid page. Valid pages are: privacy, update') if sleeptime: logging.debug('notifier_browser: sleep for %d seconds', sleeptime) time.sleep(sleeptime)
def main(args): CONFIG.register_descriptions({ "speedtest.negotiate.address": "Address to listen to", "speedtest.negotiate.auth_only": "Enable doing tests for authorized clients only", "speedtest.negotiate.daemonize": "Enable going in background", "speedtest.negotiate.port": "Port to listen to", }) common.main("speedtest.negotiate", "Speedtest negotiation server", args) conf = CONFIG.copy() server = ServerSpeedtest(POLLER) server.configure(conf) server.listen((conf["speedtest.negotiate.address"], conf["speedtest.negotiate.port"])) if conf["speedtest.negotiate.daemonize"]: system.change_dir() system.go_background() LOG.redirect() system.drop_privileges(LOG.error) POLLER.loop()
def main(args): ''' Main function ''' try: options, arguments = getopt.getopt(args[1:], 'f:n') except getopt.error: sys.exit('Usage: %s [-n] [-f database] test [negotiate_uri]' % args[0]) if len(arguments) != 1 and len(arguments) != 2: sys.exit('Usage: %s [-n] [-f database] test [negotiate_uri]' % args[0]) database_path = system.get_default_database_path() auto_rendezvous = True for name, value in options: if name == '-f': database_path = value elif name == '-n': auto_rendezvous = False DATABASE.set_path(database_path) CONFIG.merge_database(DATABASE.connection()) if len(arguments) == 2: RUNNER_TESTS.update({arguments[0]: [arguments[1]]}) ctx = {'uri': arguments[1]} else: ctx = None RUNNER_CORE.run(arguments[0], lambda *args: None, auto_rendezvous, ctx) POLLER.loop()
def _do_run_queue(self, first_elem): ''' Actually run first element in queue ''' # Make a copy of current settings conf = CONFIG.copy() # Make sure we abide to M-Lab policy if privacy.count_valid(conf, 'privacy.') != 3: privacy.complain() raise RuntimeError('runner_core: bad privacy settings') elif first_elem[0] == 'rendezvous': runner_rendezvous.run(conf['agent.master'], '9773') elif first_elem[0] == 'speedtest': uri = RUNNER_TESTS.test_to_negotiate_uri('speedtest') conf['speedtest.client.uri'] = uri client = ClientSpeedtest(POLLER) client.configure(conf) client.connect_uri() elif first_elem[0] == 'bittorrent': uri = RUNNER_TESTS.test_to_negotiate_uri('bittorrent') conf['bittorrent._uri'] = uri bittorrent.run(POLLER, conf) elif first_elem[0] == 'dload': RunnerDload(first_elem[2]) elif first_elem[0] == 'raw': address = RUNNER_HOSTS.get_random_host() handler = RawNegotiate() handler.connect((address, 8080), CONFIG['prefer_ipv6'], 0, {}) elif first_elem[0] == 'mlab-ns': handler = RunnerMlabns() if not first_elem[2]: extra = {'policy': ''} # get closest server by default else: extra = first_elem[2] handler.connect(('mlab-ns.appspot.com', 80), CONFIG['prefer_ipv6'], 0, extra) elif first_elem[0] in self.dynamic_tests: address = RUNNER_HOSTS.get_random_host() port = 80 # XXX self.dynamic_tests[first_elem[0]]["test_func"]({ "address": address, "conf": CONFIG.copy(), "poller": POLLER, "port": port, }) else: raise RuntimeError('runner_core: asked to run an unknown test')
def main(args): """ Main function """ try: options, arguments = getopt.getopt(args[1:], "6A:np:vy") except getopt.error: sys.exit("usage: neubot skype [-6nvy] [-A address] [-p port]") if arguments: sys.exit("usage: neubot skype [-6nvy] [-A address] [-p port]") prefer_ipv6 = 0 # address = 'master.neubot.org' address = "localhost" runner = 1 port = 8080 noisy = 0 fakeprivacy = 0 for name, value in options: if name == "-6": prefer_ipv6 = 1 elif name == "-A": address = value elif name == "-n": runner = 0 elif name == "-p": port = int(value) elif name == "-v": noisy = 1 elif name == "-y": fakeprivacy = 1 if os.path.isfile(DATABASE.path): DATABASE.connect() CONFIG.merge_database(DATABASE.connection()) else: logging.warning("skype: database file is missing: %s", DATABASE.path) BACKEND.use_backend("null") if noisy: log.set_verbose() if runner: result = runner_clnt.runner_client( CONFIG["agent.api.address"], CONFIG["agent.api.port"], CONFIG["verbose"], "skype" ) if result: sys.exit(0) logging.info("skype: running the test in the local process context...") if not fakeprivacy and not privacy.allowed_to_run(): privacy.complain() logging.info("skype: otherwise use -y option to temporarily provide " "privacy permissions") sys.exit(1) handler = SkypeNegotiate() handler.connect((address, port), prefer_ipv6, 0, {}) POLLER.loop()
def main(args): CONFIG.register_descriptions({ "api.client.address": "Set address to connect to", "api.client.port": "Set port to connect to", }) common.main("api.client", "Minimal client for JSON API", args) client = APIStateTracker(POLLER) client.configure(CONFIG.copy()) client.loop()
def main(args): CONFIG.register_descriptions({ # General variables "net.stream.certfile": "Set SSL certfile path", "net.stream.ipv6": "Enable IPv6", "net.stream.key": "Set key for ARC4", "net.stream.secure": "Enable SSL", "net.stream.server_side": "Enable SSL server-side mode", "net.stream.rcvbuf": "Set sock recv buffer (0 = use default)", "net.stream.sndbuf": "Set sock send buffer (0 = use default)", # For main() "net.stream.address": "Set client or server address", "net.stream.chunk": "Chunk written by each write", "net.stream.clients": "Set number of client connections", "net.stream.daemonize": "Enable daemon behavior", "net.stream.duration": "Set duration of a test", "net.stream.listen": "Enable server mode", "net.stream.port": "Set client or server port", "net.stream.proto": "Set proto (chargen, discard, or echo)", }) common.main("net.stream", "TCP bulk transfer test", args) conf = CONFIG.copy() endpoint = (conf["net.stream.address"], conf["net.stream.port"]) if not conf["net.stream.proto"]: if conf["net.stream.listen"]: conf["net.stream.proto"] = "chargen" else: conf["net.stream.proto"] = "discard" elif conf["net.stream.proto"] not in ("chargen", "discard", "echo"): common.write_help(sys.stderr, "net.stream", "TCP bulk transfer test") sys.exit(1) handler = GenericHandler(POLLER) handler.configure(conf) if conf["net.stream.listen"]: if conf["net.stream.daemonize"]: system.change_dir() system.go_background() LOG.redirect() system.drop_privileges(LOG.error) conf["net.stream.server_side"] = True handler.listen(endpoint) else: handler.connect(endpoint, count=conf["net.stream.clients"]) POLLER.loop() sys.exit(0)
def run(poller, conf): ''' Start the negotiate server ''' NEGOTIATE_SERVER.register_module('speedtest', NEGOTIATE_SERVER_SPEEDTEST) NEGOTIATE_SERVER.register_module('bittorrent', NEGOTIATE_SERVER_BITTORRENT) HTTP_SERVER.register_child(NEGOTIATE_SERVER, '/negotiate/') HTTP_SERVER.register_child(NEGOTIATE_SERVER, '/collect/') CONFIG.register_descriptions({ 'negotiate.parallelism': 'Number of parallel tests', 'negotiate.min_thresh': 'Minimum trehshold for RED', 'negotiate.max_thresh': 'Maximum trehshold for RED', })
def main(args): """ Main function """ try: options, arguments = getopt.getopt(args[1:], "6A:fp:v") except getopt.error: sys.exit("usage: neubot speedtest [-6fv] [-A address] [-p port]") if arguments: sys.exit("usage: neubot speedtest [-6fv] [-A address] [-p port]") prefer_ipv6 = 0 address = "master.neubot.org" force = 0 port = 8080 noisy = 0 for name, value in options: if name == "-6": prefer_ipv6 = 1 elif name == "-A": address = value elif name == "-f": force = 1 elif name == "-p": port = int(value) elif name == "-v": noisy = 1 if os.path.isfile(DATABASE.path): DATABASE.connect() CONFIG.merge_database(DATABASE.connection()) else: logging.warning("speedtest: database file is missing: %s", DATABASE.path) BACKEND.use_backend("null") if noisy: log.set_verbose() conf = CONFIG.copy() conf["speedtest.client.uri"] = "http://%s:%d/" % (address, port) conf["prefer_ipv6"] = prefer_ipv6 if not force: if runner_clnt.runner_client(conf["agent.api.address"], conf["agent.api.port"], CONFIG["verbose"], "speedtest"): sys.exit(0) logging.warning("speedtest: failed to contact Neubot; is Neubot running?") sys.exit(1) logging.info("speedtest: run the test in the local process context...") client = ClientSpeedtest(POLLER) client.configure(conf) client.connect_uri() POLLER.loop()
def main(args): CONFIG.register_descriptions({ "speedtest.client.uri": "Base URI to connect to", "speedtest.client.nconn": "Number of concurrent connections to use", "speedtest.client.latency_tries": "Number of latency measurements", }) common.main("speedtest.client", "Speedtest client", args) conf = CONFIG.copy() client = ClientSpeedtest(POLLER) client.configure(conf) client.connect_uri() POLLER.loop()
def main(name, descr, args): Eflag = False lflag = False try: options, arguments = getopt.getopt(args[1:], "D:Ef:lVv", ["help"]) except getopt.GetoptError: write_help(sys.stderr, name, descr) sys.exit(1) if arguments: write_help(sys.stderr, name, descr) sys.exit(1) verbose = 0 for key, value in options: if key == "-D": # No shortcuts because it grows too confusing CONFIG.register_property(value) elif key == "-E": Eflag = True elif key == "-f": DATABASE.set_path(value) elif key == "--help": write_help(sys.stdout, name, descr) sys.exit(0) elif key == "-l": lflag = True elif key == "-V": sys.stdout.write(VERSION + "\n") sys.exit(0) elif key == "-v": verbose = 1 DATABASE.connect() CONFIG.merge_database(DATABASE.connection()) if not Eflag: CONFIG.merge_environ() CONFIG.merge_properties() # Apply the setting after we've read database and environment if verbose: CONFIG['verbose'] = 1 if lflag: CONFIG.print_descriptions(sys.stdout) sys.exit(0)
def main(args): CONFIG.register_descriptions({ "rendezvous.client.debug": "Do not perform any test", "rendezvous.client.version": "Set rendezvous client version", }) common.main("rendezvous.client", "Rendezvous client", args) conf = CONFIG.copy() client = ClientRendezvous(POLLER) client.configure(conf) client.connect_uri() POLLER.loop()
def start_api(address=None, port=None): ''' Starts API for background module ''' logging.debug('background_api: starting API server...') # Honor /etc/neubot/api settings = utils_rc.parse_safe(utils_hier.APIFILEPATH) if not address: address = settings.get('address', '::1 127.0.0.1') if not port: port = settings.get('port', '9774') # Configure HTTP server conf = CONFIG.copy() logging.debug('background_api: API server rootdir: %s', utils_hier.WWWDIR) conf['http.server.rootdir'] = utils_hier.WWWDIR conf['http.server.ssi'] = True conf['http.server.bind_or_die'] = True HTTP_SERVER.configure(conf) # Bind HTTP server to API server HTTP_SERVER.register_child(API_SERVER, '/api') # Bind HTTP server to address and port HTTP_SERVER.listen((address, port)) logging.debug('background_api: starting API server... done')
def __init__(self, ctx): """ Download a file """ self.ctx = ctx ClientHTTP.__init__(self, POLLER) self.configure(CONFIG.copy()) logging.info("runner_dload: connecting to %s", self.ctx["uri"]) self.connect_uri(self.ctx["uri"])
def __init__(self, ctx): ''' Download a file ''' self.ctx = ctx ClientHTTP.__init__(self, POLLER) self.configure(CONFIG.copy()) logging.debug('runner_dload: GET %s', self.ctx['uri']) self.connect_uri(self.ctx['uri'])
def open_or_die(self): ''' Open the database or die ''' if not GEOIP: logging.error("Missing dependency: GeoIP") logging.info("Please install GeoIP python wrappers, e.g.") logging.info(" sudo apt-get install python-geoip") sys.exit(1) path = CONFIG.get("rendezvous.geoip_wrapper.country_database", COUNTRY_DATABASE) # # Detect the common error case, i.e. that the user has # not downloaded the database. If something fancy is # going on, let the GeoIP library stacktrace for us. # if not os.path.exists(path): logging.error("Missing GeoLiteCountry database: %s", path) logging.info("Please download it from " "<http://www.maxmind.com/app/geolitecountry>.") sys.exit(1) self.countries = GEOIP.open(path, GEOIP.GEOIP_STANDARD)
def main(args): ''' Main function ''' try: options, arguments = getopt.getopt(args[1:], '6A:fp:v') except getopt.error: sys.exit('usage: neubot raw [-6fv] [-A address] [-p port]') if arguments: sys.exit('usage: neubot raw [-6fv] [-A address] [-p port]') prefer_ipv6 = 0 address = 'master.neubot.org' force = 0 port = 8080 noisy = 0 for name, value in options: if name == '-6': prefer_ipv6 = 1 elif name == '-A': address = value elif name == '-f': force = 1 elif name == '-p': port = int(value) elif name == '-v': noisy = 1 if os.path.isfile(DATABASE.path): DATABASE.connect() CONFIG.merge_database(DATABASE.connection()) else: logging.warning('raw: database file is missing: %s', DATABASE.path) BACKEND.use_backend('null') if noisy: log.set_verbose() if not force: result = runner_clnt.runner_client(CONFIG['agent.api.address'], CONFIG['agent.api.port'], CONFIG['verbose'], 'raw') if result: sys.exit(0) logging.warning('raw: failed to contact Neubot; is Neubot running?') sys.exit(1) logging.info('raw: run the test in the local process context...') handler = RawNegotiate() handler.connect((address, port), prefer_ipv6, 0, {}) POLLER.loop()
def run(poller, conf): """ Start the negotiate server """ NEGOTIATE_SERVER.register_module("speedtest", NEGOTIATE_SERVER_SPEEDTEST) NEGOTIATE_SERVER.register_module("bittorrent", NEGOTIATE_SERVER_BITTORRENT) NEGOTIATE_SERVER.register_module("raw", NEGOTIATE_SERVER_RAW) NEGOTIATE_SERVER.register_module("skype", NEGOTIATE_SERVER_SKYPE) HTTP_SERVER.register_child(NEGOTIATE_SERVER, "/negotiate/") HTTP_SERVER.register_child(NEGOTIATE_SERVER, "/collect/") CONFIG.register_descriptions( { "negotiate.parallelism": "Number of parallel tests", "negotiate.min_thresh": "Minimum trehshold for RED", "negotiate.max_thresh": "Maximum trehshold for RED", } )
def main(args): CONFIG.register_descriptions({ # General variables "net.stream.certfile": "Set SSL certfile path", "net.stream.secure": "Enable SSL", "net.stream.server_side": "Enable SSL server-side mode", # For main() "net.stream.address": "Set client or server address", "net.stream.chunk": "Chunk written by each write", "net.stream.clients": "Set number of client connections", "net.stream.duration": "Set duration of a test", "net.stream.listen": "Enable server mode", "net.stream.port": "Set client or server port", "net.stream.proto": "Set proto (chargen, discard, or echo)", }) common.main("net.stream", "TCP bulk transfer test", args) conf = CONFIG.copy() endpoint = (conf["net.stream.address"], conf["net.stream.port"]) if not conf["net.stream.proto"]: if conf["net.stream.listen"]: conf["net.stream.proto"] = "chargen" else: conf["net.stream.proto"] = "discard" elif conf["net.stream.proto"] not in ("chargen", "discard", "echo"): common.write_help(sys.stderr, "net.stream", "TCP bulk transfer test") sys.exit(1) handler = GenericHandler(POLLER) handler.configure(conf) if conf["net.stream.listen"]: conf["net.stream.server_side"] = True handler.listen(endpoint) else: handler.connect(endpoint, count=conf["net.stream.clients"]) POLLER.loop() sys.exit(0)
def main(args): ''' Main() function ''' try: options, arguments = getopt.getopt(args[1:], '') except getopt.error: sys.exit('usage: neubot background_win32') if options or arguments: sys.exit('usage: neubot background_win32') # Read settings from database CONFIG.merge_database(DATABASE.connection()) BACKEND.use_backend("neubot") BACKEND.datadir_init() # # Save logs into the database, to easily access # and show them via the web user interface. # LOG.use_database() logging.info('%s for Windows: starting up', utils_version.PRODUCT) # Complain if privacy settings are not OK privacy.complain_if_needed() background_api.start_api() BACKGROUND_RENDEZVOUS.start() __start_updater() POLLER.loop() logging.info('%s for Windows: shutting down', utils_version.PRODUCT) LOG.writeback() # # Make sure that we do not leave the database # in an inconsistent state. # DATABASE.close()
def main(args): ''' Main function ''' try: options, arguments = getopt.getopt(args[1:], 'f') except getopt.error: sys.exit('Usage: %s [-f database] test negotiate_uri' % args[0]) if len(arguments) != 2: sys.exit('Usage: %s [-f database] test negotiate_uri' % args[0]) database_path = system.get_default_database_path() for name, value in options: if name == '-f': database_path = value DATABASE.set_path(database_path) CONFIG.merge_database(DATABASE.connection()) run(arguments[0], arguments[1], lambda: None) POLLER.loop()
def main(args): """ Main function """ if not system.has_enough_privs(): sys.exit('FATAL: you must be root') common.main("agent", "Run in background, periodically run tests", args) conf = CONFIG.copy() privacy.complain_if_needed() BACKEND.use_backend("neubot") BACKEND.datadir_init() # FIXME We're ignoring agent.api.{address,port} that are now # deprecated and should be removed soon. background_api.start_api() if conf["agent.daemonize"]: LOG.redirect() system.go_background() if conf["agent.use_syslog"]: LOG.redirect() # # When we run as an agent we also save logs into # the database, to easily access and show them via # the web user interface. # LOG.use_database() logging.info('%s for POSIX: starting up', utils_version.PRODUCT) system.drop_privileges() if os.getuid() == 0 or os.geteuid() == 0: logging.error('agent: still running as root') os._exit(1) if conf["agent.rendezvous"]: BACKGROUND_RENDEZVOUS.start() POLLER.loop() logging.info('%s for POSIX: shutting down', utils_version.PRODUCT) LOG.writeback() # # Make sure that we do not leave the database # in an inconsistent state. # DATABASE.close()
def main(args): ''' main() function of this module ''' CONFIG.register_descriptions({ "http.server.address": "Address to listen to", "http.server.class": "Use alternate ServerHTTP-like class", "http.server.daemonize": "Run in background as a daemon", "http.server.mime": "Enable code that guess mime types", "http.server.ports": "List of ports to listen to", "http.server.rootdir": "Root directory for static pages", "http.server.ssi": "Enable server-side includes", }) common.main("http.server", "Neubot simple HTTP server", args) conf = CONFIG.copy() if conf["http.server.class"]: make_child = utils.import_class(conf["http.server.class"]) server = make_child(POLLER) else: server = HTTP_SERVER server.configure(conf) if conf["http.server.rootdir"] == ".": conf["http.server.rootdir"] = os.path.abspath(".") for port in conf["http.server.ports"].split(","): if port: server.listen((conf["http.server.address"], int(port))) if conf["http.server.daemonize"]: system.change_dir() system.go_background() system.write_pidfile() LOG.redirect() system.drop_privileges(LOG.error) POLLER.loop()
def test_success(self): ''' Make sure allowed_to_run() returns True on valid CONFIG ''' CONFIG.merge_kv(('privacy.informed', 1)) CONFIG.merge_kv(('privacy.can_collect', 1)) CONFIG.merge_kv(('privacy.can_publish', 1)) self.assertTrue(privacy.allowed_to_run())
def test_failure(self): ''' Make sure collect_allowed() returns False on bad input ''' CONFIG.merge_kv(('privacy.informed', 1)) CONFIG.merge_kv(('privacy.can_collect', 1)) CONFIG.merge_kv(('privacy.can_publish', 0)) self.assertFalse(privacy.allowed_to_run())