def startServer(configfile, basedir, host, port, debug, allowRoot, logConf=None): signal(SIGTERM, lambda signum, stack_frame: sys.exit(1) ) #Redirects "nice" kill commands to SystemExit exception signal(SIGINT, lambda signum, stack_frame: sys.exit(1) ) #Redirects CTRL+C to SystemExit exception global astrobox astrobox = Server(configfile, basedir, host, port, debug, allowRoot, logConf) try: from gi.repository import GObject from dbus.mainloop.glib import DBusGMainLoop, threads_init DBusGMainLoop(set_as_default=True) GObject.threads_init() threads_init() except ImportError: pass astrobox.run()
def main(): import argparse parser = argparse.ArgumentParser(prog="run") parser.add_argument("-v", "--version", action="store_true", dest="version", help="Output OctoPrint's version and exit") parser.add_argument("-d", "--debug", action="store_true", dest="debug", help="Enable debug mode") parser.add_argument("--host", action="store", type=str, dest="host", help="Specify the host on which to bind the server") parser.add_argument("--port", action="store", type=int, dest="port", help="Specify the port on which to bind the server") parser.add_argument("-c", "--config", action="store", dest="config", help="Specify the config file to use. OctoPrint needs to have write access for the settings dialog to work. Defaults to ~/.octoprint/config.yaml") parser.add_argument("-b", "--basedir", action="store", dest="basedir", help="Specify the basedir to use for uploads, timelapses etc. OctoPrint needs to have write access. Defaults to ~/.octoprint") parser.add_argument("--logging", action="store", dest="logConf", help="Specify the config file to use for configuring logging. Defaults to ~/.octoprint/logging.yaml") parser.add_argument("--daemon", action="store", type=str, choices=["start", "stop", "restart"], help="Daemonize/control daemonized OctoPrint instance (only supported under Linux right now)") parser.add_argument("--pid", action="store", type=str, dest="pidfile", default="/tmp/octoprint.pid", help="Pidfile to use for daemonizing, defaults to /tmp/octoprint.pid") parser.add_argument("--iknowwhatimdoing", action="store_true", dest="allowRoot", help="Allow OctoPrint to run as user root") args = parser.parse_args() if args.version: print "OctoPrint version %s" % __version__ sys.exit(0) if args.daemon: if sys.platform == "darwin" or sys.platform == "win32": print >> sys.stderr, "Sorry, daemon mode is only supported under Linux right now" sys.exit(2) daemon = Main(args.pidfile, args.config, args.basedir, args.host, args.port, args.debug, args.allowRoot, args.logConf) if "start" == args.daemon: daemon.start() elif "stop" == args.daemon: daemon.stop() elif "restart" == args.daemon: daemon.restart() else: octoprint = Server(configfile=args.config, basedir=args.basedir, host=args.host, port=args.port, debug=args.debug, allowRoot=args.allowRoot, logConf=args.logConf) octoprint.run()
def startServer(configfile, basedir, host, port, debug, allowRoot, logConf = None): signal(SIGTERM, lambda signum, stack_frame: sys.exit(1)) #Redirects "nice" kill commands to SystemExit exception signal(SIGINT, lambda signum, stack_frame: sys.exit(1)) #Redirects CTRL+C to SystemExit exception global astrobox astrobox = Server(configfile, basedir, host, port, debug, allowRoot, logConf) astrobox.run()
def main(): import argparse parser = argparse.ArgumentParser(prog="run") parser.add_argument("-v", "--version", action="store_true", dest="version", help="Output AstroBox's version and exit") parser.add_argument("-d", "--debug", action="store_true", dest="debug", help="Enable debug mode") parser.add_argument("--host", action="store", type=str, dest="host", help="Specify the host on which to bind the server") parser.add_argument("--port", action="store", type=int, dest="port", help="Specify the port on which to bind the server") parser.add_argument("-c", "--config", action="store", dest="config", help="Specify the config file to use. AstroBox needs to have write access for the settings dialog to work. Defaults to /etc/astrobox/config.yaml") parser.add_argument("-b", "--basedir", action="store", dest="basedir", help="Specify the basedir to use for uploads, timelapses etc. AstroBox needs to have write access. Defaults to /etc/astrobox") parser.add_argument("--logging", action="store", dest="logConf", help="Specify the config file to use for configuring logging. Defaults to /etc/astrobox/logging.yaml") parser.add_argument("--daemon", action="store", type=str, choices=["start", "stop", "restart"], help="Daemonize/control daemonized AstroBox instance (only supported under Linux right now)") parser.add_argument("--pid", action="store", type=str, dest="pidfile", default="/tmp/astrobox.pid", help="Pidfile to use for daemonizing, defaults to /tmp/astrobox.pid") parser.add_argument("--iknowwhatimdoing", action="store_true", dest="allowRoot", help="Allow AstroBox to run as user root") args = parser.parse_args() if args.version: print "AstroBox version %s" % __version__ sys.exit(0) if args.daemon: if sys.platform == "darwin" or sys.platform == "win32": print >> sys.stderr, "Sorry, daemon mode is only supported under Linux right now" sys.exit(2) daemon = Main(args.pidfile, args.config, args.basedir, args.host, args.port, args.debug, args.allowRoot, args.logConf) if "start" == args.daemon: daemon.start() elif "stop" == args.daemon: daemon.stop() elif "restart" == args.daemon: daemon.restart() else: signal(SIGTERM, lambda signum, stack_frame: sys.exit(1)) #Redirects "nice" kill commands to SystemExit exception signal(SIGINT, lambda signum, stack_frame: sys.exit(1)) #Redirects CTRL+C to SystemExit exception astrobox = Server(args.config, args.basedir, args.host, args.port, args.debug, args.allowRoot, args.logConf) astrobox.run()
def run(self): octoprint = Server(configfile=self._configfile, basedir=self._basedir, host=self._host, port=self._port, debug=self._debug, allowRoot=self._allowRoot, logConf=self._logConf, octoprint_daemon=self) octoprint.run()
def run_server(basedir, configfile, host, port, debug, allow_root, logging_config, verbosity, safe_mode, octoprint_daemon=None): """Initializes the environment and starts up the server.""" from octoprint import init_platform, __display_version__, FatalStartupError def log_startup(recorder=None, safe_mode=None, **kwargs): logger = logging.getLogger("octoprint.server") logger.info("Starting OctoPrint {}".format(__display_version__)) if safe_mode: logger.info("Starting in SAFE MODE. Third party plugins will be disabled!") if recorder and len(recorder): logger.info("--- Logged during platform initialization: ---") from octoprint.logging.handlers import CombinedLogHandler handler = CombinedLogHandler(*logging.getLogger().handlers) recorder.setTarget(handler) recorder.flush() logger.info("----------------------------------------------") from octoprint import urllib3_ssl if not urllib3_ssl: logging.getLogger("octoprint.server")\ .warn("requests/urllib3 will run in an insecure SSL environment. " "You might see corresponding warnings logged later " "(\"InsecurePlatformWarning\"). It is recommended to either " "update to a Python version >= 2.7.9 or alternatively " "install PyOpenSSL plus its dependencies. For details see " "https://urllib3.readthedocs.org/en/latest/security.html#openssl-pyopenssl") try: settings, _, safe_mode, plugin_manager = init_platform(basedir, configfile, logging_file=logging_config, debug=debug, verbosity=verbosity, uncaught_logger=__name__, safe_mode=safe_mode, after_safe_mode=log_startup) except FatalStartupError as e: click.echo(e.message, err=True) click.echo("There was a fatal error starting up OctoPrint.", err=True) else: from octoprint.server import Server octoprint_server = Server(settings=settings, plugin_manager=plugin_manager, host=host, port=port, debug=debug, safe_mode=safe_mode, allow_root=allow_root, octoprint_daemon=octoprint_daemon) octoprint_server.run()
def main(): import argparse parser = argparse.ArgumentParser(prog="run") parser.add_argument("-v", "--version", action="store_true", dest="version", help="Output OctoPrint's version and exit") parser.add_argument("-d", "--debug", action="store_true", dest="debug", help="Enable debug mode") parser.add_argument("--host", action="store", type=str, dest="host", help="Specify the host on which to bind the server") parser.add_argument("--port", action="store", type=int, dest="port", help="Specify the port on which to bind the server") parser.add_argument("-c", "--config", action="store", dest="config", help="Specify the config file to use. OctoPrint needs to have write access for the settings dialog to work. Defaults to ~/.octoprint/config.yaml") parser.add_argument("-b", "--basedir", action="store", dest="basedir", help="Specify the basedir to use for uploads, timelapses etc. OctoPrint needs to have write access. Defaults to ~/.octoprint") parser.add_argument("--daemon", action="store", type=str, choices=["start", "stop", "restart"], help="Daemonize/control daemonized OctoPrint instance (only supported under Linux right now)") parser.add_argument("--pid", action="store", type=str, dest="pidfile", default="/tmp/octoprint.pid", help="Pidfile to use for daemonizing, defaults to /tmp/octoprint.pid") parser.add_argument("--iknowwhatimdoing", action="store_true", dest="allowRoot", help="Allow OctoPrint to run as user root") parser.add_argument("-s", "--startUartScreen", action="store", type=str, choices=["true", "false"], dest="sus", default="true", help="Specify start uartscreen with the octoprint(true or false, defaults true)") args = parser.parse_args() if args.version: print "OctoPrint version %s" % __version__ sys.exit(0) if args.daemon: if sys.platform == "darwin" or sys.platform == "win32": print >> sys.stderr, "Sorry, daemon mode is only supported under Linux right now" sys.exit(2) daemon = Main(args.pidfile, args.config, args.basedir, args.host, args.port, args.debug, args.allowRoot, args.sus) if "start" == args.daemon: daemon.start() elif "stop" == args.daemon: daemon.stop() elif "restart" == args.daemon: daemon.restart() else: octoprint = Server(args.config, args.basedir, args.host, args.port, args.debug, args.allowRoot, args.sus) octoprint.run()
def startServer(configfile, basedir, host, port, debug, allowRoot, logConf = None): signal(SIGTERM, lambda signum, stack_frame: sys.exit(1)) #Redirects "nice" kill commands to SystemExit exception signal(SIGINT, lambda signum, stack_frame: sys.exit(1)) #Redirects CTRL+C to SystemExit exception global astrobox astrobox = Server(configfile, basedir, host, port, debug, allowRoot, logConf) try: from gi.repository import GObject from dbus.mainloop.glib import DBusGMainLoop, threads_init DBusGMainLoop(set_as_default=True) GObject.threads_init() threads_init() except ImportError: pass astrobox.run()
def run_server(basedir, configfile, host, port, v6_only, debug, allow_root, logging_config, verbosity, safe_mode, ignore_blacklist, octoprint_daemon=None): """Initializes the environment and starts up the server.""" from octoprint import init_platform, __display_version__, FatalStartupError def log_startup(recorder=None, safe_mode=None, **kwargs): from octoprint.logging import get_divider_line logger = logging.getLogger("octoprint.startup") logger.info(get_divider_line("*")) logger.info("Starting fw-OctoPrint {}".format(__display_version__)) if safe_mode: logger.info( "Starting in SAFE MODE. Third party plugins will be disabled!") if safe_mode == "flag": reason = "command line flag" elif safe_mode == "settings": reason = "setting in config.yaml" elif safe_mode == "incomplete_startup": reason = "problem during last startup" else: reason = "unknown" logger.info("Reason for safe mode: {}".format(reason)) if recorder and len(recorder): logger.info( get_divider_line("-", "Logged during platform initialization:")) from octoprint.logging.handlers import CombinedLogHandler handler = CombinedLogHandler(*logging.getLogger().handlers) recorder.setTarget(handler) recorder.flush() logger.info(get_divider_line("-")) from octoprint import urllib3_ssl if not urllib3_ssl: logging.getLogger("octoprint.server")\ .warn("requests/urllib3 will run in an insecure SSL environment. " "You might see corresponding warnings logged later " "(\"InsecurePlatformWarning\"). It is recommended to either " "update to a Python version >= 2.7.9 or alternatively " "install PyOpenSSL plus its dependencies. For details see " "https://urllib3.readthedocs.org/en/latest/security.html#openssl-pyopenssl") logger.info(get_divider_line("*")) def log_register_rollover(safe_mode=None, plugin_manager=None, environment_detector=None, **kwargs): from octoprint.logging import get_handler, log_to_handler, get_divider_line from octoprint.logging.handlers import OctoPrintLogHandler def rollover_callback(): handler = get_handler("file") if handler is None: return logger = logging.getLogger("octoprint.server") def _log(message, level=logging.INFO): log_to_handler(logger, handler, level, message) _log(get_divider_line("-", "Log roll over detected")) _log("OctoPrint {}".format(__display_version__)) if safe_mode: _log("SAFE MODE is active. Third party plugins are disabled!") plugin_manager.log_all_plugins(only_to_handler=handler) environment_detector.log_detected_environment( only_to_handler=handler) _log(get_divider_line("-")) OctoPrintLogHandler.registerRolloverCallback(rollover_callback) try: components = init_platform( basedir, configfile, logging_file=logging_config, debug=debug, verbosity=verbosity, uncaught_logger=__name__, safe_mode=safe_mode, ignore_blacklist=ignore_blacklist, after_safe_mode=log_startup, after_environment_detector=log_register_rollover) settings, _, safe_mode, event_manager, connectivity_checker, plugin_manager, environment_detector = components except FatalStartupError as e: logger = logging.getLogger("octoprint.startup").fatal echo = lambda x: click.echo(x, err=True) for method in logger, echo: method(str(e)) method("There was a fatal error starting up OctoPrint.") else: from octoprint.server import Server octoprint_server = Server(settings=settings, plugin_manager=plugin_manager, event_manager=event_manager, connectivity_checker=connectivity_checker, environment_detector=environment_detector, host=host, port=port, v6_only=v6_only, debug=debug, safe_mode=safe_mode, allow_root=allow_root, octoprint_daemon=octoprint_daemon) octoprint_server.run()
def main(): # from mozpi import Mozpi # import threading # m = Mozpi("ws://localhost:8080") # t = threading.Thread(target=m.start()) # t.start() # print "******** blocking released" import argparse parser = argparse.ArgumentParser(prog="run") parser.add_argument("-v", "--version", action="store_true", dest="version", help="Output OctoPrint's version and exit") parser.add_argument("-d", "--debug", action="store_true", dest="debug", help="Enable debug mode") parser.add_argument("--host", action="store", type=str, dest="host", help="Specify the host on which to bind the server") parser.add_argument("--port", action="store", type=int, dest="port", help="Specify the port on which to bind the server") parser.add_argument("-c", "--config", action="store", dest="config", help="Specify the config file to use. OctoPrint needs to have write access for the settings dialog to work. Defaults to ~/.octoprint/config.yaml") parser.add_argument("-b", "--basedir", action="store", dest="basedir", help="Specify the basedir to use for uploads, timelapses etc. OctoPrint needs to have write access. Defaults to ~/.octoprint") parser.add_argument("--logging", action="store", dest="logConf", help="Specify the config file to use for configuring logging. Defaults to ~/.octoprint/logging.yaml") parser.add_argument("--daemon", action="store", type=str, choices=["start", "stop", "restart"], help="Daemonize/control daemonized OctoPrint instance (only supported under Linux right now)") parser.add_argument("--pid", action="store", type=str, dest="pidfile", default="/tmp/octoprint.pid", help="Pidfile to use for daemonizing, defaults to /tmp/octoprint.pid") parser.add_argument("--iknowwhatimdoing", action="store_true", dest="allowRoot", help="Allow OctoPrint to run as user root") args = parser.parse_args() if args.version: print "OctoPrint version %s" % __version__ sys.exit(0) if args.daemon: if sys.platform == "darwin" or sys.platform == "win32": print >> sys.stderr, "Sorry, daemon mode is only supported under Linux right now" sys.exit(2) daemon = Main(args.pidfile, args.config, args.basedir, args.host, args.port, args.debug, args.allowRoot, args.logConf) if "start" == args.daemon: daemon.start() elif "stop" == args.daemon: daemon.stop() elif "restart" == args.daemon: daemon.restart() else: octoprint = Server(configfile=args.config, basedir=args.basedir, host=args.host, port=args.port, debug=args.debug, allowRoot=args.allowRoot, logConf=args.logConf) octoprint.run()
def run(self): octoprint = Server(self._configfile, self._basedir, self._host, self._port, self._debug, self._allowRoot) octoprint.run()
def run_server(basedir, configfile, host, port, debug, allow_root, logging_config, verbosity, safe_mode, octoprint_daemon=None): """Initializes the environment and starts up the server.""" from octoprint import init_platform, __display_version__, FatalStartupError def log_startup(recorder=None, safe_mode=None, **kwargs): logger = logging.getLogger("octoprint.server") logger.info("Starting OctoPrint {}".format(__display_version__)) if safe_mode: logger.info( "Starting in SAFE MODE. Third party plugins will be disabled!") if recorder and len(recorder): logger.info("--- Logged during platform initialization: ---") from octoprint.logging.handlers import CombinedLogHandler handler = CombinedLogHandler(*logging.getLogger().handlers) recorder.setTarget(handler) recorder.flush() logger.info("----------------------------------------------") from octoprint import urllib3_ssl if not urllib3_ssl: logging.getLogger("octoprint.server")\ .warn("requests/urllib3 will run in an insecure SSL environment. " "You might see corresponding warnings logged later " "(\"InsecurePlatformWarning\"). It is recommended to either " "update to a Python version >= 2.7.9 or alternatively " "install PyOpenSSL plus its dependencies. For details see " "https://urllib3.readthedocs.org/en/latest/security.html#openssl-pyopenssl") try: settings, _, safe_mode, plugin_manager = init_platform( basedir, configfile, logging_file=logging_config, debug=debug, verbosity=verbosity, uncaught_logger=__name__, safe_mode=safe_mode, after_safe_mode=log_startup) except FatalStartupError as e: click.echo(e.message, err=True) click.echo("There was a fatal error starting up OctoPrint.", err=True) else: from octoprint.server import Server octoprint_server = Server(settings=settings, plugin_manager=plugin_manager, host=host, port=port, debug=debug, safe_mode=safe_mode, allow_root=allow_root, octoprint_daemon=octoprint_daemon) octoprint_server.run()
def run_server(basedir, configfile, host, port, debug, allow_root, logging_config, verbosity, safe_mode, ignore_blacklist, octoprint_daemon=None): """Initializes the environment and starts up the server.""" from octoprint import init_platform, __display_version__, FatalStartupError def log_startup(recorder=None, safe_mode=None, **kwargs): from octoprint.logging import get_divider_line logger = logging.getLogger("octoprint.startup") logger.info(get_divider_line("*")) logger.info("Starting OctoPrint {}".format(__display_version__)) if safe_mode: logger.info("Starting in SAFE MODE. Third party plugins will be disabled!") if recorder and len(recorder): logger.info(get_divider_line("-", "Logged during platform initialization:")) from octoprint.logging.handlers import CombinedLogHandler handler = CombinedLogHandler(*logging.getLogger().handlers) recorder.setTarget(handler) recorder.flush() logger.info(get_divider_line("-")) from octoprint import urllib3_ssl if not urllib3_ssl: logging.getLogger("octoprint.server")\ .warn("requests/urllib3 will run in an insecure SSL environment. " "You might see corresponding warnings logged later " "(\"InsecurePlatformWarning\"). It is recommended to either " "update to a Python version >= 2.7.9 or alternatively " "install PyOpenSSL plus its dependencies. For details see " "https://urllib3.readthedocs.org/en/latest/security.html#openssl-pyopenssl") logger.info(get_divider_line("*")) def log_register_rollover(safe_mode=None, plugin_manager=None, environment_detector=None, **kwargs): from octoprint.logging import get_handler, log_to_handler, get_divider_line from octoprint.logging.handlers import OctoPrintLogHandler def rollover_callback(): handler = get_handler("file") if handler is None: return logger = logging.getLogger("octoprint.server") def _log(message, level=logging.INFO): log_to_handler(logger, handler, level, message) _log(get_divider_line("-", "Log roll over detected")) _log("OctoPrint {}".format(__display_version__)) if safe_mode: _log("SAFE MODE is active. Third party plugins are disabled!") plugin_manager.log_all_plugins(only_to_handler=handler) environment_detector.log_detected_environment(only_to_handler=handler) _log(get_divider_line("-")) OctoPrintLogHandler.registerRolloverCallback(rollover_callback) try: components = init_platform(basedir, configfile, logging_file=logging_config, debug=debug, verbosity=verbosity, uncaught_logger=__name__, safe_mode=safe_mode, ignore_blacklist=ignore_blacklist, after_safe_mode=log_startup, after_environment_detector=log_register_rollover) settings, _, safe_mode, event_manager, connectivity_checker, plugin_manager, environment_detector = components except FatalStartupError as e: logger = logging.getLogger("octoprint.startup").fatal echo = lambda x: click.echo(x, err=True) for method in logger, echo: method(str(e)) method("There was a fatal error starting up OctoPrint.") else: from octoprint.server import Server octoprint_server = Server(settings=settings, plugin_manager=plugin_manager, event_manager=event_manager, connectivity_checker=connectivity_checker, environment_detector=environment_detector, host=host, port=port, debug=debug, safe_mode=safe_mode, allow_root=allow_root, octoprint_daemon=octoprint_daemon) octoprint_server.run()