3diy
/
moonraker
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

all: Replace strings with RequestType flags 

Signed-off-by:  Eric Callahan <arksine.code@gmail.com>
This commit is contained in:
Eric Callahan 2023-11-05 05:21:10 -05:00
parent 6e8b720d17
commit b18e9cc222
No known key found for this signature in database
GPG Key ID: 5A1EB336DFB4C71B
23 changed files with 313 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
moonraker/components/announcements.py
View File

@ -11,6 +11,7 @@ import asyncio
import logging import logging
import email.utils import email.utils
import xml.etree.ElementTree as etree import xml.etree.ElementTree as etree
from ..common import RequestType
from typing import ( from typing import (
TYPE_CHECKING, TYPE_CHECKING,
Awaitable, Awaitable,
@ -57,23 +58,23 @@ class Announcements:
) )
self.server.register_endpoint( self.server.register_endpoint(
"/server/announcements/list", ["GET"], "/server/announcements/list", RequestType.GET,
self._list_announcements self._list_announcements
) )
self.server.register_endpoint( self.server.register_endpoint(
"/server/announcements/dismiss", ["POST"], "/server/announcements/dismiss", RequestType.POST,
self._handle_dismiss_request self._handle_dismiss_request
) )
self.server.register_endpoint( self.server.register_endpoint(
"/server/announcements/update", ["POST"], "/server/announcements/update", RequestType.POST,
self._handle_update_request self._handle_update_request
) )
self.server.register_endpoint( self.server.register_endpoint(
"/server/announcements/feed", ["POST", "DELETE"], "/server/announcements/feed", RequestType.POST | RequestType.DELETE,
self._handle_feed_request self._handle_feed_request
) )
self.server.register_endpoint( self.server.register_endpoint(
"/server/announcements/feeds", ["GET"], "/server/announcements/feeds", RequestType.GET,
self._handle_list_feeds self._handle_list_feeds
) )
self.server.register_notification( self.server.register_notification(
@ -170,13 +171,13 @@ class Announcements:
async def _handle_feed_request( async def _handle_feed_request(
self, web_request: WebRequest self, web_request: WebRequest
) -> Dict[str, Any]: ) -> Dict[str, Any]:
action = web_request.get_action() req_type = web_request.get_request_type()
name: str = web_request.get("name") name: str = web_request.get("name")
name = name.lower() name = name.lower()
changed: bool = False changed: bool = False
db: MoonrakerDatabase = self.server.lookup_component("database") db: MoonrakerDatabase = self.server.lookup_component("database")
result = "skipped" result = "skipped"
if action == "POST": if req_type == RequestType.POST:
if name not in self.subscriptions: if name not in self.subscriptions:
feed = RssFeed(name, self.entry_mgr, self.dev_mode) feed = RssFeed(name, self.entry_mgr, self.dev_mode)
self.subscriptions[name] = feed self.subscriptions[name] = feed
@ -187,7 +188,7 @@ class Announcements:
"moonraker", "announcements.stored_feeds", self.stored_feeds "moonraker", "announcements.stored_feeds", self.stored_feeds
) )
result = "added" result = "added"
elif action == "DELETE": elif req_type == RequestType.DELETE:
if name not in self.stored_feeds: if name not in self.stored_feeds:
raise self.server.error(f"Feed '{name}' not stored") raise self.server.error(f"Feed '{name}' not stored")
if name in self.configured_feeds: if name in self.configured_feeds:

64
moonraker/components/authorization.py
View File

@ -20,6 +20,7 @@ import logging
from tornado.web import HTTPError from tornado.web import HTTPError
from libnacl.sign import Signer, Verifier from libnacl.sign import Signer, Verifier
from ..utils import json_wrapper as jsonw from ..utils import json_wrapper as jsonw
from ..common import RequestType, TransportType
# Annotation imports # Annotation imports
from typing import ( from typing import (
@ -226,32 +227,42 @@ class Authorization:
self.permitted_paths.add("/access/refresh_jwt") self.permitted_paths.add("/access/refresh_jwt")
self.permitted_paths.add("/access/info") self.permitted_paths.add("/access/info")
self.server.register_endpoint( self.server.register_endpoint(
"/access/login", ['POST'], self._handle_login, "/access/login", RequestType.POST, self._handle_login,
transports=['http', 'websocket']) transports=TransportType.HTTP | TransportType.WEBSOCKET
)
self.server.register_endpoint( self.server.register_endpoint(
"/access/logout", ['POST'], self._handle_logout, "/access/logout", RequestType.POST, self._handle_logout,
transports=['http', 'websocket']) transports=TransportType.HTTP | TransportType.WEBSOCKET
)
self.server.register_endpoint( self.server.register_endpoint(
"/access/refresh_jwt", ['POST'], self._handle_refresh_jwt, "/access/refresh_jwt", RequestType.POST, self._handle_refresh_jwt,
transports=['http', 'websocket']) transports=TransportType.HTTP | TransportType.WEBSOCKET
)
self.server.register_endpoint( self.server.register_endpoint(
"/access/user", ['GET', 'POST', 'DELETE'], "/access/user", RequestType.all(), self._handle_user_request,
self._handle_user_request, transports=['http', 'websocket']) transports=TransportType.HTTP | TransportType.WEBSOCKET
)
self.server.register_endpoint( self.server.register_endpoint(
"/access/users/list", ['GET'], self._handle_list_request, "/access/users/list", RequestType.GET, self._handle_list_request,
transports=['http', 'websocket']) transports=TransportType.HTTP | TransportType.WEBSOCKET
)
self.server.register_endpoint( self.server.register_endpoint(
"/access/user/password", ['POST'], self._handle_password_reset, "/access/user/password", RequestType.POST, self._handle_password_reset,
transports=['http', 'websocket']) transports=TransportType.HTTP | TransportType.WEBSOCKET
)
self.server.register_endpoint( self.server.register_endpoint(
"/access/api_key", ['GET', 'POST'], "/access/api_key", RequestType.GET | RequestType.POST,
self._handle_apikey_request, transports=['http', 'websocket']) self._handle_apikey_request,
transports=TransportType.HTTP | TransportType.WEBSOCKET
)
self.server.register_endpoint( self.server.register_endpoint(
"/access/oneshot_token", ['GET'], "/access/oneshot_token", RequestType.GET, self._handle_oneshot_request,
self._handle_oneshot_request, transports=['http', 'websocket']) transports=TransportType.HTTP | TransportType.WEBSOCKET
)
self.server.register_endpoint( self.server.register_endpoint(
"/access/info", ['GET'], "/access/info", RequestType.GET, self._handle_info_request,
self._handle_info_request, transports=['http', 'websocket']) transports=TransportType.HTTP | TransportType.WEBSOCKET
)
wsm: WebsocketManager = self.server.lookup_component("websockets") wsm: WebsocketManager = self.server.lookup_component("websockets")
wsm.register_notification("authorization:user_created") wsm.register_notification("authorization:user_created")
wsm.register_notification( wsm.register_notification(
@ -274,8 +285,7 @@ class Authorization:
self.prune_timer.start(delay=PRUNE_CHECK_TIME) self.prune_timer.start(delay=PRUNE_CHECK_TIME)
async def _handle_apikey_request(self, web_request: WebRequest) -> str: async def _handle_apikey_request(self, web_request: WebRequest) -> str:
action = web_request.get_action() if web_request.get_request_type() == RequestType.POST:
if action.upper() == 'POST':
self.api_key = uuid.uuid4().hex self.api_key = uuid.uuid4().hex
self.users[API_USER]['api_key'] = self.api_key self.users[API_USER]['api_key'] = self.api_key
self._sync_user(API_USER) self._sync_user(API_USER)
@ -360,11 +370,11 @@ class Authorization:
'action': 'user_jwt_refresh' 'action': 'user_jwt_refresh'
} }
async def _handle_user_request(self, async def _handle_user_request(
web_request: WebRequest self, web_request: WebRequest
) -> Dict[str, Any]: ) -> Dict[str, Any]:
action = web_request.get_action() req_type = web_request.get_request_type()
if action == "GET": if req_type == RequestType.GET:
user = web_request.get_current_user() user = web_request.get_current_user()
if user is None: if user is None:
return { return {
@ -378,10 +388,10 @@ class Authorization:
'source': user.get("source", "moonraker"), 'source': user.get("source", "moonraker"),
'created_on': user.get('created_on') 'created_on': user.get('created_on')
} }
elif action == "POST": elif req_type == RequestType.POST:
# Create User # Create User
return await self._login_jwt_user(web_request, create=True) return await self._login_jwt_user(web_request, create=True)
elif action == "DELETE": elif req_type == RequestType.DELETE:
# Delete User # Delete User
return self._delete_jwt_user(web_request) return self._delete_jwt_user(web_request)
raise self.server.error("Invalid Request Method") raise self.server.error("Invalid Request Method")

11
moonraker/components/data_store.py
View File

@ -8,6 +8,7 @@ from __future__ import annotations
import logging import logging
import time import time
from collections import deque from collections import deque
from ..common import RequestType
# Annotation imports # Annotation imports
from typing import ( from typing import (
@ -59,11 +60,13 @@ class DataStore:
# Register endpoints # Register endpoints
self.server.register_endpoint( self.server.register_endpoint(
"/server/temperature_store", ['GET'], "/server/temperature_store", RequestType.GET,
self._handle_temp_store_request) self._handle_temp_store_request
)
self.server.register_endpoint( self.server.register_endpoint(
"/server/gcode_store", ['GET'], "/server/gcode_store", RequestType.GET,
self._handle_gcode_store_request) self._handle_gcode_store_request
)
async def _init_sensors(self) -> None: async def _init_sensors(self) -> None:
klippy_apis: APIComp = self.server.lookup_component('klippy_apis') klippy_apis: APIComp = self.server.lookup_component('klippy_apis')

28
moonraker/components/database.py
View File

@ -15,6 +15,7 @@ from threading import Lock as ThreadLock
import lmdb import lmdb
from ..utils import Sentinel, ServerError from ..utils import Sentinel, ServerError
from ..utils import json_wrapper as jsonw from ..utils import json_wrapper as jsonw
from ..common import RequestType
# Annotation imports # Annotation imports
from typing import ( from typing import (
@ -174,15 +175,17 @@ class MoonrakerDatabase:
self.insert_item("moonraker", "database.unsafe_shutdowns", self.insert_item("moonraker", "database.unsafe_shutdowns",
unsafe_shutdowns + 1) unsafe_shutdowns + 1)
self.server.register_endpoint( self.server.register_endpoint(
"/server/database/list", ['GET'], self._handle_list_request) "/server/database/list", RequestType.GET, self._handle_list_request
)
self.server.register_endpoint( self.server.register_endpoint(
"/server/database/item", ["GET", "POST", "DELETE"], "/server/database/item", RequestType.all(), self._handle_item_request
self._handle_item_request) )
self.server.register_debug_endpoint( self.server.register_debug_endpoint(
"/debug/database/list", ['GET'], self._handle_list_request) "/debug/database/list", RequestType.GET, self._handle_list_request
)
self.server.register_debug_endpoint( self.server.register_debug_endpoint(
"/debug/database/item", ["GET", "POST", "DELETE"], "/debug/database/item", RequestType.all(), self._handle_item_request
self._handle_item_request) )
def get_database_path(self) -> str: def get_database_path(self) -> str:
return self.database_path return self.database_path
@ -735,7 +738,7 @@ class MoonrakerDatabase:
async def _handle_item_request(self, async def _handle_item_request(self,
web_request: WebRequest web_request: WebRequest
) -> Dict[str, Any]: ) -> Dict[str, Any]:
action = web_request.get_action() req_type = web_request.get_request_type()
is_debug = web_request.get_endpoint().startswith("/debug/") is_debug = web_request.get_endpoint().startswith("/debug/")
namespace = web_request.get_str("namespace") namespace = web_request.get_str("namespace")
if namespace in self.forbidden_namespaces and not is_debug: if namespace in self.forbidden_namespaces and not is_debug:
@ -744,7 +747,7 @@ class MoonrakerDatabase:
" is forbidden", 403) " is forbidden", 403)
key: Any key: Any
valid_types: Tuple[type, ...] valid_types: Tuple[type, ...]
if action != "GET": if req_type != RequestType.GET:
if namespace in self.protected_namespaces and not is_debug: if namespace in self.protected_namespaces and not is_debug:
raise self.server.error( raise self.server.error(
f"Write access to namespace '{namespace}'" f"Write access to namespace '{namespace}'"
@ -758,16 +761,17 @@ class MoonrakerDatabase:
raise self.server.error( raise self.server.error(
"Value for argument 'key' is an invalid type: " "Value for argument 'key' is an invalid type: "
f"{type(key).__name__}") f"{type(key).__name__}")
if action == "GET": if req_type == RequestType.GET:
val = await self.get_item(namespace, key) val = await self.get_item(namespace, key)
elif action == "POST": elif req_type == RequestType.POST:
val = web_request.get("value") val = web_request.get("value")
await self.insert_item(namespace, key, val) await self.insert_item(namespace, key, val)
elif action == "DELETE": elif req_type == RequestType.DELETE:
val = await self.delete_item(namespace, key, drop_empty_db=True) val = await self.delete_item(namespace, key, drop_empty_db=True)
if is_debug: if is_debug:
self.debug_counter[action.lower()] += 1 name = req_type.name or str(req_type).split(".", 1)[-1]
self.debug_counter[name.lower()] += 1
await self.insert_item( await self.insert_item(
"moonraker", "database.debug_counter", self.debug_counter "moonraker", "database.debug_counter", self.debug_counter
) )

14
moonraker/components/extensions.py
View File

@ -7,7 +7,7 @@ from __future__ import annotations
import asyncio import asyncio
import pathlib import pathlib
import logging import logging
from ..common import BaseRemoteConnection from ..common import BaseRemoteConnection, RequestType, TransportType
from ..utils import get_unix_peer_credentials from ..utils import get_unix_peer_credentials
# Annotation imports # Annotation imports
@ -35,19 +35,19 @@ class ExtensionManager:
self.agent_methods: Dict[int, List[str]] = {} self.agent_methods: Dict[int, List[str]] = {}
self.uds_server: Optional[asyncio.AbstractServer] = None self.uds_server: Optional[asyncio.AbstractServer] = None
self.server.register_endpoint( self.server.register_endpoint(
"/connection/register_remote_method", ["POST"], "/connection/register_remote_method", RequestType.POST,
self._register_agent_method, self._register_agent_method,
transports=["websocket"] transports=TransportType.WEBSOCKET
) )
self.server.register_endpoint( self.server.register_endpoint(
"/connection/send_event", ["POST"], self._handle_agent_event, "/connection/send_event", RequestType.POST, self._handle_agent_event,
transports=["websocket"] transports=TransportType.WEBSOCKET
) )
self.server.register_endpoint( self.server.register_endpoint(
"/server/extensions/list", ["GET"], self._handle_list_extensions "/server/extensions/list", RequestType.GET, self._handle_list_extensions
) )
self.server.register_endpoint( self.server.register_endpoint(
"/server/extensions/request", ["POST"], self._handle_call_agent "/server/extensions/request", RequestType.POST, self._handle_call_agent
) )
def register_agent(self, connection: BaseRemoteConnection) -> None: def register_agent(self, connection: BaseRemoteConnection) -> None:

43
moonraker/components/file_manager/file_manager.py
View File

@ -20,6 +20,7 @@ from inotify_simple import INotify
from inotify_simple import flags as iFlags from inotify_simple import flags as iFlags
from ...utils import source_info from ...utils import source_info
from ...utils import json_wrapper as jsonw from ...utils import json_wrapper as jsonw
from ...common import RequestType, TransportType
# Annotation imports # Annotation imports
from typing import ( from typing import (
@ -108,27 +109,37 @@ class FileManager:
# Register file management endpoints # Register file management endpoints
self.server.register_endpoint( self.server.register_endpoint(
"/server/files/list", ['GET'], self._handle_filelist_request) "/server/files/list", RequestType.GET, self._handle_filelist_request
)
self.server.register_endpoint( self.server.register_endpoint(
"/server/files/metadata", ['GET'], self._handle_metadata_request) "/server/files/metadata", RequestType.GET, self._handle_metadata_request
)
self.server.register_endpoint( self.server.register_endpoint(
"/server/files/metascan", ['POST'], self._handle_metascan_request) "/server/files/metascan", RequestType.POST, self._handle_metascan_request
)
self.server.register_endpoint( self.server.register_endpoint(
"/server/files/thumbnails", ['GET'], self._handle_list_thumbs) "/server/files/thumbnails", RequestType.GET, self._handle_list_thumbs
)
self.server.register_endpoint( self.server.register_endpoint(
"/server/files/roots", ['GET'], self._handle_list_roots) "/server/files/roots", RequestType.GET, self._handle_list_roots
)
self.server.register_endpoint( self.server.register_endpoint(
"/server/files/directory", ['GET', 'POST', 'DELETE'], "/server/files/directory", RequestType.all(),
self._handle_directory_request) self._handle_directory_request
)
self.server.register_endpoint( self.server.register_endpoint(
"/server/files/move", ['POST'], self._handle_file_move_copy) "/server/files/move", RequestType.POST, self._handle_file_move_copy
)
self.server.register_endpoint( self.server.register_endpoint(
"/server/files/copy", ['POST'], self._handle_file_move_copy) "/server/files/copy", RequestType.POST, self._handle_file_move_copy
)
self.server.register_endpoint( self.server.register_endpoint(
"/server/files/zip", ['POST'], self._handle_zip_files) "/server/files/zip", RequestType.POST, self._handle_zip_files
)
self.server.register_endpoint( self.server.register_endpoint(
"/server/files/delete_file", ['DELETE'], self._handle_file_delete, "/server/files/delete_file", RequestType.DELETE, self._handle_file_delete,
transports=["websocket"]) transports=TransportType.WEBSOCKET
)
# register client notificaitons # register client notificaitons
self.server.register_notification("file_manager:filelist_changed") self.server.register_notification("file_manager:filelist_changed")
@ -474,8 +485,8 @@ class FileManager:
) -> Dict[str, Any]: ) -> Dict[str, Any]:
directory = web_request.get_str('path', "gcodes") directory = web_request.get_str('path', "gcodes")
root, dir_path = self._convert_request_path(directory) root, dir_path = self._convert_request_path(directory)
method = web_request.get_action() req_type = web_request.get_request_type()
if method == 'GET': if req_type == RequestType.GET:
is_extended = web_request.get_boolean('extended', False) is_extended = web_request.get_boolean('extended', False)
# Get list of files and subdirectories for this target # Get list of files and subdirectories for this target
dir_info = self._list_directory(dir_path, root, is_extended) dir_info = self._list_directory(dir_path, root, is_extended)
@ -483,7 +494,7 @@ class FileManager:
async with self.sync_lock: async with self.sync_lock:
self.check_reserved_path(dir_path, True) self.check_reserved_path(dir_path, True)
action = "create_dir" action = "create_dir"
if method == 'POST' and root in self.full_access_roots: if req_type == RequestType.POST and root in self.full_access_roots:
# Create a new directory # Create a new directory
self.sync_lock.setup("create_dir", dir_path) self.sync_lock.setup("create_dir", dir_path)
try: try:
@ -491,7 +502,7 @@ class FileManager:
except Exception as e: except Exception as e:
raise self.server.error(str(e)) raise self.server.error(str(e))
self.fs_observer.on_item_create(root, dir_path, is_dir=True) self.fs_observer.on_item_create(root, dir_path, is_dir=True)
elif method == 'DELETE' and root in self.full_access_roots: elif req_type == RequestType.DELETE and root in self.full_access_roots:
# Remove a directory # Remove a directory
action = "delete_dir" action = "delete_dir"
if directory.strip("/") == root: if directory.strip("/") == root:

23
moonraker/components/history.py
View File

@ -6,7 +6,7 @@ from __future__ import annotations
import time import time
import logging import logging
from asyncio import Lock from asyncio import Lock
from ..common import JobEvent from ..common import JobEvent, RequestType
# Annotation imports # Annotation imports
from typing import ( from typing import (
@ -54,14 +54,19 @@ class History:
self.server.register_notification("history:history_changed") self.server.register_notification("history:history_changed")
self.server.register_endpoint( self.server.register_endpoint(
"/server/history/job", ['GET', 'DELETE'], self._handle_job_request) "/server/history/job", RequestType.GET | RequestType.DELETE,
self._handle_job_request
)
self.server.register_endpoint( self.server.register_endpoint(
"/server/history/list", ['GET'], self._handle_jobs_list) "/server/history/list", RequestType.GET, self._handle_jobs_list
)
self.server.register_endpoint( self.server.register_endpoint(
"/server/history/totals", ['GET'], self._handle_job_totals) "/server/history/totals", RequestType.GET, self._handle_job_totals
)
self.server.register_endpoint( self.server.register_endpoint(
"/server/history/reset_totals", ['POST'], "/server/history/reset_totals", RequestType.POST,
self._handle_job_total_reset) self._handle_job_total_reset
)
database.register_local_namespace(HIST_NAMESPACE) database.register_local_namespace(HIST_NAMESPACE)
self.history_ns = database.wrap_namespace(HIST_NAMESPACE, self.history_ns = database.wrap_namespace(HIST_NAMESPACE,
@ -78,14 +83,14 @@ class History:
web_request: WebRequest web_request: WebRequest
) -> Dict[str, Any]: ) -> Dict[str, Any]:
async with self.request_lock: async with self.request_lock:
action = web_request.get_action() req_type = web_request.get_request_type()
if action == "GET": if req_type == RequestType.GET:
job_id = web_request.get_str("uid") job_id = web_request.get_str("uid")
if job_id not in self.cached_job_ids: if job_id not in self.cached_job_ids:
raise self.server.error(f"Invalid job uid: {job_id}", 404) raise self.server.error(f"Invalid job uid: {job_id}", 404)
job = await self.history_ns[job_id] job = await self.history_ns[job_id]
return {"job": self._prep_requested_job(job, job_id)} return {"job": self._prep_requested_job(job, job_id)}
if action == "DELETE": if req_type == RequestType.DELETE:
all = web_request.get_boolean("all", False) all = web_request.get_boolean("all", False)
if all: if all:
deljobs = self.cached_job_ids deljobs = self.cached_job_ids

33
moonraker/components/job_queue.py
View File

@ -8,7 +8,7 @@ from __future__ import annotations
import asyncio import asyncio
import time import time
import logging import logging
from ..common import JobEvent from ..common import JobEvent, RequestType
# Annotation imports # Annotation imports
from typing import ( from typing import (
@ -56,16 +56,21 @@ class JobQueue:
self.start_queue) self.start_queue)
self.server.register_endpoint( self.server.register_endpoint(
"/server/job_queue/job", ['POST', 'DELETE'], "/server/job_queue/job", RequestType.POST | RequestType.DELETE,
self._handle_job_request) self._handle_job_request
)
self.server.register_endpoint( self.server.register_endpoint(
"/server/job_queue/pause", ['POST'], self._handle_pause_queue) "/server/job_queue/pause", RequestType.POST, self._handle_pause_queue
)
self.server.register_endpoint( self.server.register_endpoint(
"/server/job_queue/start", ['POST'], self._handle_start_queue) "/server/job_queue/start", RequestType.POST, self._handle_start_queue
)
self.server.register_endpoint( self.server.register_endpoint(
"/server/job_queue/status", ['GET'], self._handle_queue_status) "/server/job_queue/status", RequestType.GET, self._handle_queue_status
)
self.server.register_endpoint( self.server.register_endpoint(
"/server/job_queue/jump", ['POST'], self._handle_jump) "/server/job_queue/jump", RequestType.POST, self._handle_jump
)
async def _handle_ready(self) -> None: async def _handle_ready(self) -> None:
async with self.lock: async with self.lock:
@ -248,23 +253,23 @@ class JobQueue:
'queue_state': self.queue_state 'queue_state': self.queue_state
}) })
async def _handle_job_request(self, async def _handle_job_request(
web_request: WebRequest self, web_request: WebRequest
) -> Dict[str, Any]: ) -> Dict[str, Any]:
action = web_request.get_action() req_type = web_request.get_request_type()
if action == "POST": if req_type == RequestType.POST:
files = web_request.get_list('filenames') files = web_request.get_list('filenames')
reset = web_request.get_boolean("reset", False) reset = web_request.get_boolean("reset", False)
# Validate that all files exist before queueing # Validate that all files exist before queueing
await self.queue_job(files, reset=reset) await self.queue_job(files, reset=reset)
elif action == "DELETE": elif req_type == RequestType.DELETE:
if web_request.get_boolean("all", False): if web_request.get_boolean("all", False):
await self.delete_job([], all=True) await self.delete_job([], all=True)
else: else:
job_ids = web_request.get_list('job_ids') job_ids = web_request.get_list('job_ids')
await self.delete_job(job_ids) await self.delete_job(job_ids)
else: else:
raise self.server.error(f"Invalid action: {action}") raise self.server.error(f"Invalid request type: {req_type}")
return { return {
'queued_jobs': self._job_map_to_list(), 'queued_jobs': self._job_map_to_list(),
'queue_state': self.queue_state 'queue_state': self.queue_state

20
moonraker/components/klippy_apis.py
View File

@ -6,7 +6,7 @@
from __future__ import annotations from __future__ import annotations
from ..utils import Sentinel from ..utils import Sentinel
from ..common import WebRequest, Subscribable from ..common import WebRequest, Subscribable, RequestType
# Annotation imports # Annotation imports
from typing import ( from typing import (
@ -52,17 +52,23 @@ class KlippyAPI(Subscribable):
# Register GCode Aliases # Register GCode Aliases
self.server.register_endpoint( self.server.register_endpoint(
"/printer/print/pause", ['POST'], self._gcode_pause) "/printer/print/pause", RequestType.POST, self._gcode_pause
)
self.server.register_endpoint( self.server.register_endpoint(
"/printer/print/resume", ['POST'], self._gcode_resume) "/printer/print/resume", RequestType.POST, self._gcode_resume
)
self.server.register_endpoint( self.server.register_endpoint(
"/printer/print/cancel", ['POST'], self._gcode_cancel) "/printer/print/cancel", RequestType.POST, self._gcode_cancel
)
self.server.register_endpoint( self.server.register_endpoint(
"/printer/print/start", ['POST'], self._gcode_start_print) "/printer/print/start", RequestType.POST, self._gcode_start_print
)
self.server.register_endpoint( self.server.register_endpoint(
"/printer/restart", ['POST'], self._gcode_restart) "/printer/restart", RequestType.POST, self._gcode_restart
)
self.server.register_endpoint( self.server.register_endpoint(
"/printer/firmware_restart", ['POST'], self._gcode_firmware_restart) "/printer/firmware_restart", RequestType.POST, self._gcode_firmware_restart
)
self.server.register_event_handler( self.server.register_event_handler(
"server:klippy_disconnect", self._on_klippy_disconnect "server:klippy_disconnect", self._on_klippy_disconnect
) )

30
moonraker/components/machine.py
View File

@ -23,6 +23,7 @@ import configparser
from ..confighelper import FileSourceWrapper from ..confighelper import FileSourceWrapper
from ..utils import source_info from ..utils import source_info
from ..utils import json_wrapper as jsonw from ..utils import json_wrapper as jsonw
from ..common import RequestType
# Annotation imports # Annotation imports
from typing import ( from typing import (
@ -132,26 +133,29 @@ class Machine:
self.sudo_requests: List[Tuple[SudoCallback, str]] = [] self.sudo_requests: List[Tuple[SudoCallback, str]] = []
self.server.register_endpoint( self.server.register_endpoint(
"/machine/reboot", ['POST'], self._handle_machine_request) "/machine/reboot", RequestType.POST, self._handle_machine_request
)
self.server.register_endpoint( self.server.register_endpoint(
"/machine/shutdown", ['POST'], self._handle_machine_request) "/machine/shutdown", RequestType.POST, self._handle_machine_request
)
self.server.register_endpoint( self.server.register_endpoint(
"/machine/services/restart", ['POST'], "/machine/services/restart", RequestType.POST, self._handle_service_request
self._handle_service_request) )
self.server.register_endpoint( self.server.register_endpoint(
"/machine/services/stop", ['POST'], "/machine/services/stop", RequestType.POST, self._handle_service_request
self._handle_service_request) )
self.server.register_endpoint( self.server.register_endpoint(
"/machine/services/start", ['POST'], "/machine/services/start", RequestType.POST, self._handle_service_request
self._handle_service_request) )
self.server.register_endpoint( self.server.register_endpoint(
"/machine/system_info", ['GET'], "/machine/system_info", RequestType.GET, self._handle_sysinfo_request
self._handle_sysinfo_request) )
self.server.register_endpoint( self.server.register_endpoint(
"/machine/sudo/info", ["GET"], self._handle_sudo_info) "/machine/sudo/info", RequestType.GET, self._handle_sudo_info
)
self.server.register_endpoint( self.server.register_endpoint(
"/machine/sudo/password", ["POST"], "/machine/sudo/password", RequestType.POST, self._set_sudo_password
self._set_sudo_password) )
self.server.register_notification("machine:service_state_changed") self.server.register_notification("machine:service_state_changed")
self.server.register_notification("machine:sudo_alert") self.server.register_notification("machine:sudo_alert")

14
moonraker/components/mqtt.py
View File

@ -303,14 +303,18 @@ class MQTTClient(APITransport, Subscribable):
self.pending_responses: List[asyncio.Future] = [] self.pending_responses: List[asyncio.Future] = []
self.pending_acks: Dict[int, asyncio.Future] = {} self.pending_acks: Dict[int, asyncio.Future] = {}
# We don't need to register these endpoints over the MQTT transport as they
# are redundant. MQTT clients can already publish and subscribe.
ep_transports = TransportType.all() & ~TransportType.MQTT
self.server.register_endpoint( self.server.register_endpoint(
"/server/mqtt/publish", ["POST"], "/server/mqtt/publish", RequestType.POST, self._handle_publish_request,
self._handle_publish_request, transports=ep_transports
transports=["http", "websocket", "internal"]) )
self.server.register_endpoint( self.server.register_endpoint(
"/server/mqtt/subscribe", ["POST"], "/server/mqtt/subscribe", RequestType.POST,
self._handle_subscription_request, self._handle_subscription_request,
transports=["http", "websocket", "internal"]) transports=ep_transports
)
# Subscribe to API requests # Subscribe to API requests
self.json_rpc = JsonRPC(self.server, transport="MQTT") self.json_rpc = JsonRPC(self.server, transport="MQTT")

6
moonraker/components/notifier.py
View File

@ -10,7 +10,7 @@ import apprise
import logging import logging
import pathlib import pathlib
import re import re
from ..common import JobEvent from ..common import JobEvent, RequestType
# Annotation imports # Annotation imports
from typing import ( from typing import (
@ -76,10 +76,10 @@ class Notifier:
def register_endpoints(self, config: ConfigHelper): def register_endpoints(self, config: ConfigHelper):
self.server.register_endpoint( self.server.register_endpoint(
"/server/notifiers/list", ["GET"], self._handle_notifier_list "/server/notifiers/list", RequestType.GET, self._handle_notifier_list
) )
self.server.register_debug_endpoint( self.server.register_debug_endpoint(
"/debug/notifiers/test", ["POST"], self._handle_notifier_test "/debug/notifiers/test", RequestType.POST, self._handle_notifier_test
) )
async def _handle_notifier_list( async def _handle_notifier_list(

50
moonraker/components/octoprint_compat.py
View File

@ -6,6 +6,7 @@
from __future__ import annotations from __future__ import annotations
import logging import logging
from ..common import RequestType, TransportType
# Annotation imports # Annotation imports
from typing import ( from typing import (
@ -65,22 +66,27 @@ class OctoPrintCompat:
# Version & Server information # Version & Server information
self.server.register_endpoint( self.server.register_endpoint(
'/api/version', ['GET'], self._get_version, '/api/version', RequestType.GET, self._get_version,
transports=['http'], wrap_result=False) transports=TransportType.HTTP, wrap_result=False
)
self.server.register_endpoint( self.server.register_endpoint(
'/api/server', ['GET'], self._get_server, '/api/server', RequestType.GET, self._get_server,
transports=['http'], wrap_result=False) transports=TransportType.HTTP, wrap_result=False
)
# Login, User & Settings # Login, User & Settings
self.server.register_endpoint( self.server.register_endpoint(
'/api/login', ['POST'], self._post_login_user, '/api/login', RequestType.POST, self._post_login_user,
transports=['http'], wrap_result=False) transports=TransportType.HTTP, wrap_result=False
)
self.server.register_endpoint( self.server.register_endpoint(
'/api/currentuser', ['GET'], self._post_login_user, '/api/currentuser', RequestType.GET, self._post_login_user,
transports=['http'], wrap_result=False) transports=TransportType.HTTP, wrap_result=False
)
self.server.register_endpoint( self.server.register_endpoint(
'/api/settings', ['GET'], self._get_settings, '/api/settings', RequestType.GET, self._get_settings,
transports=['http'], wrap_result=False) transports=TransportType.HTTP, wrap_result=False
)
# File operations # File operations
# Note that file upload is handled in file_manager.py # Note that file upload is handled in file_manager.py
@ -88,30 +94,34 @@ class OctoPrintCompat:
# Job operations # Job operations
self.server.register_endpoint( self.server.register_endpoint(
'/api/job', ['GET'], self._get_job, '/api/job', RequestType.GET, self._get_job,
transports=['http'], wrap_result=False) transports=TransportType.HTTP, wrap_result=False
)
# TODO: start/cancel/restart/pause jobs # TODO: start/cancel/restart/pause jobs
# Printer operations # Printer operations
self.server.register_endpoint( self.server.register_endpoint(
'/api/printer', ['GET'], self._get_printer, '/api/printer', RequestType.GET, self._get_printer,
transports=['http'], wrap_result=False) transports=TransportType.HTTP, wrap_result=False)
self.server.register_endpoint( self.server.register_endpoint(
'/api/printer/command', ['POST'], self._post_command, '/api/printer/command', RequestType.POST, self._post_command,
transports=['http'], wrap_result=False) transports=TransportType.HTTP, wrap_result=False
)
# TODO: head/tool/bed/chamber specific read/issue # TODO: head/tool/bed/chamber specific read/issue
# Printer profiles # Printer profiles
self.server.register_endpoint( self.server.register_endpoint(
'/api/printerprofiles', ['GET'], self._get_printerprofiles, '/api/printerprofiles', RequestType.GET, self._get_printerprofiles,
transports=['http'], wrap_result=False) transports=TransportType.HTTP, wrap_result=False
)
# Upload Handlers # Upload Handlers
self.server.register_upload_handler( self.server.register_upload_handler(
"/api/files/local", location_prefix="api/files/moonraker") "/api/files/local", location_prefix="api/files/moonraker")
self.server.register_endpoint( self.server.register_endpoint(
"/api/files/moonraker/(?P<relative_path>.+)", ['POST'], "/api/files/moonraker/(?P<relative_path>.+)", RequestType.POST,
self._select_file, transports=['http'], wrap_result=False) self._select_file, transports=TransportType.HTTP, wrap_result=False
)
# System # System
# TODO: shutdown/reboot/restart operations # TODO: shutdown/reboot/restart operations

54
moonraker/components/power.py
View File

@ -12,6 +12,7 @@ import asyncio
import time import time
from urllib.parse import quote, urlencode from urllib.parse import quote, urlencode
from ..utils import json_wrapper as jsonw from ..utils import json_wrapper as jsonw
from ..common import RequestType
# Annotation imports # Annotation imports
from typing import ( from typing import (
@ -74,20 +75,24 @@ class PrinterPower:
self.devices[dev.get_name()] = dev self.devices[dev.get_name()] = dev
self.server.register_endpoint( self.server.register_endpoint(
"/machine/device_power/devices", ['GET'], "/machine/device_power/devices", RequestType.GET, self._handle_list_devices
self._handle_list_devices) )
self.server.register_endpoint( self.server.register_endpoint(
"/machine/device_power/status", ['GET'], "/machine/device_power/status", RequestType.GET,
self._handle_batch_power_request) self._handle_batch_power_request
)
self.server.register_endpoint( self.server.register_endpoint(
"/machine/device_power/on", ['POST'], "/machine/device_power/on", RequestType.POST,
self._handle_batch_power_request) self._handle_batch_power_request
)
self.server.register_endpoint( self.server.register_endpoint(
"/machine/device_power/off", ['POST'], "/machine/device_power/off", RequestType.POST,
self._handle_batch_power_request) self._handle_batch_power_request
)
self.server.register_endpoint( self.server.register_endpoint(
"/machine/device_power/device", ['GET', 'POST'], "/machine/device_power/device", RequestType.GET | RequestType.POST,
self._handle_single_power_request) self._handle_single_power_request
)
self.server.register_remote_method( self.server.register_remote_method(
"set_device_power", self.set_device_power) "set_device_power", self.set_device_power)
self.server.register_event_handler( self.server.register_event_handler(
@ -122,34 +127,35 @@ class PrinterPower:
) )
await dev.process_request("on") await dev.process_request("on")
async def _handle_list_devices(self, async def _handle_list_devices(
web_request: WebRequest self, web_request: WebRequest
) -> Dict[str, Any]: ) -> Dict[str, Any]:
dev_list = [d.get_device_info() for d in self.devices.values()] dev_list = [d.get_device_info() for d in self.devices.values()]
output = {"devices": dev_list} output = {"devices": dev_list}
return output return output
async def _handle_single_power_request(self, async def _handle_single_power_request(
web_request: WebRequest self, web_request: WebRequest
) -> Dict[str, Any]: ) -> Dict[str, Any]:
dev_name: str = web_request.get_str('device') dev_name: str = web_request.get_str('device')
req_action = web_request.get_action() req_type = web_request.get_request_type()
if dev_name not in self.devices: if dev_name not in self.devices:
raise self.server.error(f"No valid device named {dev_name}") raise self.server.error(f"No valid device named {dev_name}")
dev = self.devices[dev_name] dev = self.devices[dev_name]
if req_action == 'GET': if req_type == RequestType.GET:
action = "status" action = "status"
elif req_action == "POST": elif req_type == RequestType.POST:
action = web_request.get_str('action').lower() action = web_request.get_str('action').lower()
if action not in ["on", "off", "toggle"]: if action not in ["on", "off", "toggle"]:
raise self.server.error( raise self.server.error(f"Invalid requested action '{action}'")
f"Invalid requested action '{action}'") else:
raise self.server.error(f"Invalid Request Type: {req_type}")
result = await dev.process_request(action) result = await dev.process_request(action)
return {dev_name: result} return {dev_name: result}
async def _handle_batch_power_request(self, async def _handle_batch_power_request(
web_request: WebRequest self, web_request: WebRequest
) -> Dict[str, Any]: ) -> Dict[str, Any]:
args = web_request.get_args() args = web_request.get_args()
ep = web_request.get_endpoint() ep = web_request.get_endpoint()
if not args: if not args:

7
moonraker/components/proc_stats.py
View File

@ -15,6 +15,7 @@ import pathlib
import logging import logging
from collections import deque from collections import deque
from ..utils import ioctl_macros from ..utils import ioctl_macros
from ..common import RequestType
# Annotation imports # Annotation imports
from typing import ( from typing import (
@ -79,9 +80,11 @@ class ProcStats:
self.cpu_stats_file = pathlib.Path(CPU_STAT_PATH) self.cpu_stats_file = pathlib.Path(CPU_STAT_PATH)
self.meminfo_file = pathlib.Path(MEM_AVAIL_PATH) self.meminfo_file = pathlib.Path(MEM_AVAIL_PATH)
self.server.register_endpoint( self.server.register_endpoint(
"/machine/proc_stats", ["GET"], self._handle_stat_request) "/machine/proc_stats", RequestType.GET, self._handle_stat_request
)
self.server.register_event_handler( self.server.register_event_handler(
"server:klippy_shutdown", self._handle_shutdown) "server:klippy_shutdown", self._handle_shutdown
)
self.server.register_notification("proc_stats:proc_stat_update") self.server.register_notification("proc_stats:proc_stat_update")
self.proc_stat_queue: Deque[Dict[str, Any]] = deque(maxlen=30) self.proc_stat_queue: Deque[Dict[str, Any]] = deque(maxlen=30)
self.last_update_time = time.time() self.last_update_time = time.time()

7
moonraker/components/sensor.py
View File

@ -12,6 +12,7 @@ import logging
from collections import defaultdict, deque from collections import defaultdict, deque
from dataclasses import dataclass, replace from dataclasses import dataclass, replace
from functools import partial from functools import partial
from ..common import RequestType
# Annotation imports # Annotation imports
from typing import ( from typing import (
@ -180,17 +181,17 @@ class Sensors:
# Register endpoints # Register endpoints
self.server.register_endpoint( self.server.register_endpoint(
"/server/sensors/list", "/server/sensors/list",
["GET"], RequestType.GET,
self._handle_sensor_list_request, self._handle_sensor_list_request,
) )
self.server.register_endpoint( self.server.register_endpoint(
"/server/sensors/info", "/server/sensors/info",
["GET"], RequestType.GET,
self._handle_sensor_info_request, self._handle_sensor_info_request,
) )
self.server.register_endpoint( self.server.register_endpoint(
"/server/sensors/measurements", "/server/sensors/measurements",
["GET"], RequestType.GET,
self._handle_sensor_measurements_request, self._handle_sensor_measurements_request,
) )

7
moonraker/components/spoolman.py
View File

@ -9,6 +9,7 @@ import asyncio
import datetime import datetime
import logging import logging
from typing import TYPE_CHECKING, Dict, Any from typing import TYPE_CHECKING, Dict, Any
from ..common import RequestType
if TYPE_CHECKING: if TYPE_CHECKING:
from typing import Optional from typing import Optional
@ -64,12 +65,12 @@ class SpoolManager:
def _register_endpoints(self): def _register_endpoints(self):
self.server.register_endpoint( self.server.register_endpoint(
"/server/spoolman/spool_id", "/server/spoolman/spool_id",
["GET", "POST"], RequestType.GET | RequestType.POST,
self._handle_spool_id_request, self._handle_spool_id_request,
) )
self.server.register_endpoint( self.server.register_endpoint(
"/server/spoolman/proxy", "/server/spoolman/proxy",
["POST"], RequestType.POST,
self._proxy_spoolman_request, self._proxy_spoolman_request,
) )
@ -157,7 +158,7 @@ class SpoolManager:
self.extruded = 0 self.extruded = 0
async def _handle_spool_id_request(self, web_request: WebRequest): async def _handle_spool_id_request(self, web_request: WebRequest):
if web_request.get_action() == "POST": if web_request.get_request_type() == RequestType.POST:
spool_id = web_request.get_int("spool_id", None) spool_id = web_request.get_int("spool_id", None)
await self.set_active_spool(spool_id) await self.set_active_spool(spool_id)
# For GET requests we will simply return the spool_id # For GET requests we will simply return the spool_id

37
moonraker/components/update_manager/update_manager.py
View File

@ -17,6 +17,7 @@ from .git_deploy import GitDeploy
from .zip_deploy import ZipDeploy from .zip_deploy import ZipDeploy
from .system_deploy import PackageDeploy from .system_deploy import PackageDeploy
from .web_deploy import WebClientDeploy from .web_deploy import WebClientDeploy
from ...common import RequestType
# Annotation imports # Annotation imports
from typing import ( from typing import (
@ -130,32 +131,32 @@ class UpdateManager:
self._handle_auto_refresh) self._handle_auto_refresh)
self.server.register_endpoint( self.server.register_endpoint(
"/machine/update/moonraker", ["POST"], "/machine/update/moonraker", RequestType.POST, self._handle_update_request
self._handle_update_request) )
self.server.register_endpoint( self.server.register_endpoint(
"/machine/update/klipper", ["POST"], "/machine/update/klipper", RequestType.POST, self._handle_update_request
self._handle_update_request) )
self.server.register_endpoint( self.server.register_endpoint(
"/machine/update/system", ["POST"], "/machine/update/system", RequestType.POST, self._handle_update_request
self._handle_update_request) )
self.server.register_endpoint( self.server.register_endpoint(
"/machine/update/client", ["POST"], "/machine/update/client", RequestType.POST, self._handle_update_request
self._handle_update_request) )
self.server.register_endpoint( self.server.register_endpoint(
"/machine/update/full", ["POST"], "/machine/update/full", RequestType.POST, self._handle_full_update_request
self._handle_full_update_request) )
self.server.register_endpoint( self.server.register_endpoint(
"/machine/update/status", ["GET"], "/machine/update/status", RequestType.GET, self._handle_status_request
self._handle_status_request) )
self.server.register_endpoint( self.server.register_endpoint(
"/machine/update/refresh", ["POST"], "/machine/update/refresh", RequestType.POST, self._handle_refresh_request
self._handle_refresh_request) )
self.server.register_endpoint( self.server.register_endpoint(
"/machine/update/recover", ["POST"], "/machine/update/recover", RequestType.POST, self._handle_repo_recovery
self._handle_repo_recovery) )
self.server.register_endpoint( self.server.register_endpoint(
"/machine/update/rollback", ["POST"], "/machine/update/rollback", RequestType.POST, self._handle_rollback
self._handle_rollback) )
self.server.register_notification("update_manager:update_response") self.server.register_notification("update_manager:update_response")
self.server.register_notification("update_manager:update_refreshed") self.server.register_notification("update_manager:update_refreshed")

19
moonraker/components/webcam.py
View File

@ -10,6 +10,7 @@ import ipaddress
import socket import socket
import uuid import uuid
import logging import logging
from ..common import RequestType
from typing import ( from typing import (
TYPE_CHECKING, TYPE_CHECKING,
Optional, Optional,
@ -50,14 +51,14 @@ class WebcamManager:
self.webcams[webcam.name] = webcam self.webcams[webcam.name] = webcam
self.server.register_endpoint( self.server.register_endpoint(
"/server/webcams/list", ["GET"], self._handle_webcam_list "/server/webcams/list", RequestType.GET, self._handle_webcam_list
) )
self.server.register_endpoint( self.server.register_endpoint(
"/server/webcams/item", ["GET", "POST", "DELETE"], "/server/webcams/item", RequestType.all(),
self._handle_webcam_request self._handle_webcam_request
) )
self.server.register_endpoint( self.server.register_endpoint(
"/server/webcams/test", ["POST"], self._handle_webcam_test "/server/webcams/test", RequestType.POST, self._handle_webcam_test
) )
self.server.register_notification("webcam:webcams_changed") self.server.register_notification("webcam:webcams_changed")
self.server.register_event_handler( self.server.register_event_handler(
@ -163,13 +164,13 @@ class WebcamManager:
return webcam return webcam
async def _handle_webcam_request(self, web_request: WebRequest) -> Dict[str, Any]: async def _handle_webcam_request(self, web_request: WebRequest) -> Dict[str, Any]:
action = web_request.get_action() req_type = web_request.get_request_type()
webcam = self._lookup_camera(web_request, action != "POST") webcam = self._lookup_camera(web_request, req_type != RequestType.POST)
webcam_data: Dict[str, Any] = {} webcam_data: Dict[str, Any] = {}
if action == "GET": if req_type == RequestType.GET:
assert webcam is not None assert webcam is not None
webcam_data = webcam.as_dict() webcam_data = webcam.as_dict()
elif action == "POST": elif req_type == RequestType.POST:
if webcam is not None: if webcam is not None:
if webcam.source == "config": if webcam.source == "config":
raise self.server.error( raise self.server.error(
@ -191,7 +192,7 @@ class WebcamManager:
webcam = WebCam.from_web_request(self.server, web_request, uid) webcam = WebCam.from_web_request(self.server, web_request, uid)
await self._save_cam(webcam) await self._save_cam(webcam)
webcam_data = webcam.as_dict() webcam_data = webcam.as_dict()
elif action == "DELETE": elif req_type == RequestType.DELETE:
assert webcam is not None assert webcam is not None
if webcam.source == "config": if webcam.source == "config":
raise self.server.error( raise self.server.error(
@ -200,7 +201,7 @@ class WebcamManager:
) )
webcam_data = webcam.as_dict() webcam_data = webcam.as_dict()
self._delete_cam(webcam) self._delete_cam(webcam)
if action != "GET": if req_type != RequestType.GET:
self.server.send_event( self.server.send_event(
"webcam:webcams_changed", {"webcams": self._list_webcams()} "webcam:webcams_changed", {"webcams": self._list_webcams()}
) )

40
moonraker/components/wled.py
View File

@ -16,6 +16,7 @@ import serial_asyncio
from tornado.httpclient import AsyncHTTPClient from tornado.httpclient import AsyncHTTPClient
from tornado.httpclient import HTTPRequest from tornado.httpclient import HTTPRequest
from ..utils import json_wrapper as jsonw from ..utils import json_wrapper as jsonw
from ..common import RequestType
# Annotation imports # Annotation imports
from typing import ( from typing import (
@ -388,23 +389,24 @@ class WLED:
# As moonraker is about making things a web api, let's try it # As moonraker is about making things a web api, let's try it
# Yes, this is largely a cut-n-paste from power.py # Yes, this is largely a cut-n-paste from power.py
self.server.register_endpoint( self.server.register_endpoint(
"/machine/wled/strips", ["GET"], "/machine/wled/strips", RequestType.GET, self._handle_list_strips
self._handle_list_strips) )
self.server.register_endpoint( self.server.register_endpoint(
"/machine/wled/status", ["GET"], "/machine/wled/status", RequestType.GET, self._handle_batch_wled_request
self._handle_batch_wled_request) )
self.server.register_endpoint( self.server.register_endpoint(
"/machine/wled/on", ["POST"], "/machine/wled/on", RequestType.POST, self._handle_batch_wled_request
self._handle_batch_wled_request) )
self.server.register_endpoint( self.server.register_endpoint(
"/machine/wled/off", ["POST"], "/machine/wled/off", RequestType.POST, self._handle_batch_wled_request
self._handle_batch_wled_request) )
self.server.register_endpoint( self.server.register_endpoint(
"/machine/wled/toggle", ["POST"], "/machine/wled/toggle", RequestType.POST, self._handle_batch_wled_request
self._handle_batch_wled_request) )
self.server.register_endpoint( self.server.register_endpoint(
"/machine/wled/strip", ["GET", "POST"], "/machine/wled/strip", RequestType.GET | RequestType.POST,
self._handle_single_wled_request) self._handle_single_wled_request
)
async def component_init(self) -> None: async def component_init(self) -> None:
try: try:
@ -521,19 +523,19 @@ class WLED:
intensity: int = web_request.get_int('intensity', -1) intensity: int = web_request.get_int('intensity', -1)
speed: int = web_request.get_int('speed', -1) speed: int = web_request.get_int('speed', -1)
req_action = web_request.get_action() req_type = web_request.get_request_type()
if strip_name not in self.strips: if strip_name not in self.strips:
raise self.server.error(f"No valid strip named {strip_name}") raise self.server.error(f"No valid strip named {strip_name}")
strip = self.strips[strip_name] strip = self.strips[strip_name]
if req_action == 'GET': if req_type == RequestType.GET:
return {strip_name: strip.get_strip_info()} return {strip_name: strip.get_strip_info()}
elif req_action == "POST": elif req_type == RequestType.POST:
action = web_request.get_str('action').lower() action = web_request.get_str('action').lower()
if action not in ["on", "off", "toggle", "control"]: if action not in ["on", "off", "toggle", "control"]:
raise self.server.error( raise self.server.error(f"Invalid requested action '{action}'")
f"Invalid requested action '{action}'") result = await self._process_request(
result = await self._process_request(strip, action, preset, strip, action, preset, brightness, intensity, speed
brightness, intensity, speed) )
return {strip_name: result} return {strip_name: result}
async def _handle_batch_wled_request(self: WLED, async def _handle_batch_wled_request(self: WLED,

5
moonraker/components/zeroconf.py
View File

@ -14,6 +14,7 @@ from itertools import cycle
from email.utils import formatdate from email.utils import formatdate
from zeroconf import IPVersion from zeroconf import IPVersion
from zeroconf.asyncio import AsyncServiceInfo, AsyncZeroconf from zeroconf.asyncio import AsyncServiceInfo, AsyncZeroconf
from ..common import RequestType, TransportType
from typing import ( from typing import (
TYPE_CHECKING, TYPE_CHECKING,
@ -214,9 +215,9 @@ class SSDPServer(asyncio.protocols.DatagramProtocol):
auth.register_permited_path("/server/zeroconf/ssdp") auth.register_permited_path("/server/zeroconf/ssdp")
self.server.register_endpoint( self.server.register_endpoint(
"/server/zeroconf/ssdp", "/server/zeroconf/ssdp",
["GET"], RequestType.GET,
self._handle_xml_request, self._handle_xml_request,
transports=["http"], transports=TransportType.HTTP,
wrap_result=False, wrap_result=False,
content_type="application/xml" content_type="application/xml"
) )

3
moonraker/loghelper.py
View File

@ -12,6 +12,7 @@ import os
import sys import sys
import asyncio import asyncio
from queue import SimpleQueue as Queue from queue import SimpleQueue as Queue
from .common import RequestType
# Annotation imports # Annotation imports
from typing import ( from typing import (
@ -112,7 +113,7 @@ class LogManager:
def set_server(self, server: Server) -> None: def set_server(self, server: Server) -> None:
self.server = server self.server = server
self.server.register_endpoint( self.server.register_endpoint(
"/server/logs/rollover", ['POST'], self._handle_log_rollover "/server/logs/rollover", RequestType.POST, self._handle_log_rollover
) )
def set_rollover_info(self, name: str, item: str) -> None: def set_rollover_info(self, name: str, item: str) -> None:

10
moonraker/server.py
View File

@ -25,6 +25,7 @@ from .app import MoonrakerApp
from .klippy_connection import KlippyConnection from .klippy_connection import KlippyConnection
from .utils import ServerError, Sentinel, get_software_info, json_wrapper from .utils import ServerError, Sentinel, get_software_info, json_wrapper
from .loghelper import LogManager from .loghelper import LogManager
from .common import RequestType
# Annotation imports # Annotation imports
from typing import ( from typing import (
@ -102,11 +103,14 @@ class Server:
self.add_warning(warning) self.add_warning(warning)
self.register_endpoint( self.register_endpoint(
"/server/info", ['GET'], self._handle_info_request) "/server/info", RequestType.GET, self._handle_info_request
)
self.register_endpoint( self.register_endpoint(
"/server/config", ['GET'], self._handle_config_request) "/server/config", RequestType.GET, self._handle_config_request
)
self.register_endpoint( self.register_endpoint(
"/server/restart", ['POST'], self._handle_server_restart) "/server/restart", RequestType.POST, self._handle_server_restart
)
self.register_notification("server:klippy_ready") self.register_notification("server:klippy_ready")
self.register_notification("server:klippy_shutdown") self.register_notification("server:klippy_shutdown")
self.register_notification("server:klippy_disconnect", self.register_notification("server:klippy_disconnect",