def test_get_config_no_exist(self, base_server: Server):
fake_path = pathlib.Path("no_exist")
if fake_path.exists():
pytest.fail("Path exists")
args = dict(base_server.app_args)
args["config_file"] = str(fake_path)
with pytest.raises(ConfigError):
confighelper.get_configuration(base_server, args)
def test_get_config_no_server(self, base_server: Server,
path_args: Dict[str, pathlib.Path]):
assets = path_args['asset_path']
sup_cfg_path = assets.joinpath("moonraker/supplemental.conf")
if not sup_cfg_path.exists():
pytest.fail("Supplemental config not found")
args = dict(base_server.app_args)
args["config_file"] = str(sup_cfg_path)
with pytest.raises(ConfigError):
confighelper.get_configuration(base_server, args)
def test_get_config_no_access(self, base_server: Server,
path_args: Dict[str, pathlib.Path]):
cfg_path = path_args["config_path"]
test_cfg = cfg_path.joinpath("test.conf")
shutil.copy(path_args["moonraker.conf"], test_cfg)
test_cfg.chmod(mode=222)
args = dict(base_server.app_args)
args["config_file"] = str(test_cfg)
with pytest.raises(ConfigError):
confighelper.get_configuration(base_server, args)
def __init__(self, args, file_logger):
self.file_logger = file_logger
config = confighelper.get_configuration(self, args)
# log config file
strio = io.StringIO()
config.write_config(strio)
cfg_item = f"\n{'#'*20} Moonraker Configuration {'#'*20}\n\n"
cfg_item += strio.getvalue()
cfg_item += "#" * 65
strio.close()
self.add_log_rollover_item('config', cfg_item)
self.host = config.get('host', "0.0.0.0")
self.port = config.getint('port', 7125)
# Event initialization
self.events = {}
# Klippy Connection Handling
self.klippy_address = config.get('klippy_uds_address',
"/tmp/klippy_uds")
self.klippy_connection = KlippyConnection(self.process_command,
self.on_connection_closed)
self.klippy_info = {}
self.init_list = []
self.init_handle = None
self.init_attempts = 0
self.klippy_state = "disconnected"
self.subscriptions = {}
self.failed_plugins = []
# Server/IOLoop
self.server_running = False
self.moonraker_app = app = MoonrakerApp(config)
self.register_endpoint = app.register_local_handler
self.register_static_file_handler = app.register_static_file_handler
self.register_upload_handler = app.register_upload_handler
self.ioloop = IOLoop.current()
self.register_endpoint("/server/info", ['GET'],
self._handle_info_request)
self.register_endpoint("/server/restart", ['POST'],
self._handle_server_restart)
# Setup remote methods accessable to Klippy. Note that all
# registered remote methods should be of the notification type,
# they do not return a response to Klippy after execution
self.pending_requests = {}
self.remote_methods = {}
self.klippy_reg_methods = []
self.register_remote_method('process_gcode_response',
self._process_gcode_response,
need_klippy_reg=False)
self.register_remote_method('process_status_update',
self._process_status_update,
need_klippy_reg=False)
# Plugin initialization
self.plugins = {}
self.klippy_apis = self.load_plugin(config, 'klippy_apis')
self._load_plugins(config)
def __init__(self, args):
config = confighelper.get_configuration(self, args)
self.host = config.get('host', "0.0.0.0")
self.port = config.getint('port', 7125)
# Event initialization
self.events = {}
# Klippy Connection Handling
self.klippy_address = config.get(
'klippy_uds_address', "/tmp/klippy_uds")
self.klippy_connection = KlippyConnection(
self.process_command, self.on_connection_closed)
self.init_list = []
self.init_handle = None
self.init_attempts = 0
self.klippy_state = "disconnected"
# XXX - currently moonraker maintains a superset of all
# subscriptions, the results of which are forwarded to all
# connected websockets. A better implementation would open a
# unique unix domain socket for each websocket client and
# allow Klipper to forward only those subscriptions back to
# correct client.
self.all_subscriptions = {}
# Server/IOLoop
self.server_running = False
self.moonraker_app = app = MoonrakerApp(config)
self.register_endpoint = app.register_local_handler
self.register_static_file_handler = app.register_static_file_handler
self.register_upload_handler = app.register_upload_handler
self.ioloop = IOLoop.current()
self.register_endpoint(
"/server/info", ['GET'], self._handle_info_request)
self.register_endpoint(
"/server/restart", ['POST'], self._handle_server_restart)
# Setup remote methods accessable to Klippy. Note that all
# registered remote methods should be of the notification type,
# they do not return a response to Klippy after execution
self.pending_requests = {}
self.remote_methods = {}
self.klippy_reg_methods = []
self.register_remote_method(
'process_gcode_response', self._process_gcode_response,
need_klippy_reg=False)
self.register_remote_method(
'process_status_update', self._process_status_update,
need_klippy_reg=False)
# Plugin initialization
self.plugins = {}
self.klippy_apis = self.load_plugin(config, 'klippy_apis')
self._load_plugins(config)
def _parse_config(self) -> confighelper.ConfigHelper:
config = confighelper.get_configuration(self, self.app_args)
# log config file
strio = io.StringIO()
config.write_config(strio)
cfg_item = f"\n{'#'*20} Moonraker Configuration {'#'*20}\n\n"
cfg_item += strio.getvalue()
cfg_item += "#" * 65
strio.close()
self.add_log_rollover_item('config', cfg_item)
return config
def __init__(self,
args: Dict[str, Any],
file_logger: Optional[utils.MoonrakerLoggingHandler],
event_loop: EventLoop
) -> None:
self.event_loop = event_loop
self.file_logger = file_logger
self.app_args = args
self.config = config = confighelper.get_configuration(self, args)
# log config file
strio = io.StringIO()
config.write_config(strio)
cfg_item = f"\n{'#'*20} Moonraker Configuration {'#'*20}\n\n"
cfg_item += strio.getvalue()
cfg_item += "#"*65
strio.close()
self.add_log_rollover_item('config', cfg_item)
self.host: str = config.get('host', "0.0.0.0")
self.port: int = config.getint('port', 7125)
self.ssl_port: int = config.getint('ssl_port', 7130)
self.exit_reason: str = ""
# Configure Debug Logging
self.debug = config.getboolean('enable_debug_logging', False)
asyncio_debug = config.getboolean('enable_asyncio_debug', False)
log_level = logging.DEBUG if self.debug else logging.INFO
logging.getLogger().setLevel(log_level)
self.event_loop.set_debug(asyncio_debug)
# Event initialization
self.events: Dict[str, List[FlexCallback]] = {}
# Klippy Connection Handling
self.klippy_address: str = config.get(
'klippy_uds_address', "/tmp/klippy_uds")
self.klippy_connection = KlippyConnection(
self.process_command, self.on_connection_closed, event_loop)
self.klippy_info: Dict[str, Any] = {}
self.init_list: List[str] = []
self.init_handle: Optional[asyncio.Handle] = None
self.init_attempts: int = 0
self.klippy_state: str = "disconnected"
self.klippy_disconnect_evt: Optional[asyncio.Event] = None
self.connection_init_lock: asyncio.Lock = asyncio.Lock()
self.subscriptions: Dict[Subscribable, Dict[str, Any]] = {}
self.failed_components: List[str] = []
self.warnings: List[str] = []
# Tornado Application/Server
self.server_running: bool = False
self.moonraker_app = app = MoonrakerApp(config)
self.register_endpoint = app.register_local_handler
self.register_static_file_handler = app.register_static_file_handler
self.register_upload_handler = app.register_upload_handler
self.get_websocket_manager = app.get_websocket_manager
self.register_api_transport = app.register_api_transport
self.register_endpoint(
"/server/info", ['GET'], self._handle_info_request)
self.register_endpoint(
"/server/config", ['GET'], self._handle_config_request)
self.register_endpoint(
"/server/restart", ['POST'], self._handle_server_restart)
self.register_notification("server:klippy_ready")
self.register_notification("server:klippy_shutdown")
self.register_notification("server:klippy_disconnect",
"klippy_disconnected")
self.register_notification("server:gcode_response")
# Setup remote methods accessable to Klippy. Note that all
# registered remote methods should be of the notification type,
# they do not return a response to Klippy after execution
self.pending_requests: Dict[int, BaseRequest] = {}
self.remote_methods: Dict[str, FlexCallback] = {}
self.klippy_reg_methods: List[str] = []
self.register_remote_method(
'process_gcode_response', self._process_gcode_response,
need_klippy_reg=False)
self.register_remote_method(
'process_status_update', self._process_status_update,
need_klippy_reg=False)
# Component initialization
self.components: Dict[str, Any] = {}
self._load_components(config)
self.klippy_apis: KlippyAPI = self.lookup_component('klippy_apis')
config.validate_config()
self.event_loop.add_signal_handler(
signal.SIGTERM, self._handle_term_signal)
self.event_loop.register_callback(self._start_server)
def __init__(self, args: argparse.Namespace,
file_logger: Optional[utils.MoonrakerLoggingHandler]) -> None:
self.file_logger = file_logger
self.config = config = confighelper.get_configuration(self, args)
# log config file
strio = io.StringIO()
config.write_config(strio)
cfg_item = f"\n{'#'*20} Moonraker Configuration {'#'*20}\n\n"
cfg_item += strio.getvalue()
cfg_item += "#" * 65
strio.close()
self.add_log_rollover_item('config', cfg_item)
self.host: str = config.get('host', "0.0.0.0")
self.port: int = config.getint('port', 7125)
self.ssl_port: int = config.getint('ssl_port', 7130)
self.exit_reason: str = ""
# Event initialization
self.events: Dict[str, List[FlexCallback]] = {}
# Klippy Connection Handling
self.klippy_address: str = config.get('klippy_uds_address',
"/tmp/klippy_uds")
self.klippy_connection = KlippyConnection(self.process_command,
self.on_connection_closed)
self.klippy_info: Dict[str, Any] = {}
self.init_list: List[str] = []
self.init_handle: Optional[object] = None
self.init_attempts: int = 0
self.klippy_state: str = "disconnected"
self.klippy_disconnect_evt: Optional[Event] = None
self.subscriptions: Dict[Subscribable, Dict[str, Any]] = {}
self.failed_components: List[str] = []
self.warnings: List[str] = []
# Server/IOLoop
self.server_running: bool = False
self.moonraker_app = app = MoonrakerApp(config)
self.register_endpoint = app.register_local_handler
self.register_static_file_handler = app.register_static_file_handler
self.register_upload_handler = app.register_upload_handler
self.ioloop = IOLoop.current()
self.register_endpoint("/server/info", ['GET'],
self._handle_info_request)
self.register_endpoint("/server/config", ['GET'],
self._handle_config_request)
self.register_endpoint("/server/restart", ['POST'],
self._handle_server_restart)
self.register_notification("server:klippy_ready")
self.register_notification("server:klippy_shutdown")
self.register_notification("server:klippy_disconnect",
"klippy_disconnected")
self.register_notification("server:gcode_response")
# Setup remote methods accessable to Klippy. Note that all
# registered remote methods should be of the notification type,
# they do not return a response to Klippy after execution
self.pending_requests: Dict[int, BaseRequest] = {}
self.remote_methods: Dict[str, FlexCallback] = {}
self.klippy_reg_methods: List[str] = []
self.register_remote_method('process_gcode_response',
self._process_gcode_response,
need_klippy_reg=False)
self.register_remote_method('process_status_update',
self._process_status_update,
need_klippy_reg=False)
# Component initialization
self.components: Dict[str, Any] = {}
self._load_components(config)
self.klippy_apis: KlippyAPI = self.lookup_component('klippy_apis')
config.validate_config()