aboutsummaryrefslogtreecommitdiffstats
path: root/fg21sim/webui/websocket.py
diff options
context:
space:
mode:
authorAaron LI <aaronly.me@outlook.com>2016-11-15 18:23:00 +0800
committerAaron LI <aaronly.me@outlook.com>2016-11-15 18:23:00 +0800
commite74ccdc92478ceb50aa2617e21f6f7eb4bc181de (patch)
treeca0832af2e1e0132edf68f756dc854fc24cc6958 /fg21sim/webui/websocket.py
parentbcdc84fb416820493e048fe28ca59e9090762ffb (diff)
downloadfg21sim-e74ccdc92478ceb50aa2617e21f6f7eb4bc181de.tar.bz2
webui: Place handlers under the directory "hnadlers/"
Diffstat (limited to 'fg21sim/webui/websocket.py')
-rw-r--r--fg21sim/webui/websocket.py436
1 files changed, 0 insertions, 436 deletions
diff --git a/fg21sim/webui/websocket.py b/fg21sim/webui/websocket.py
deleted file mode 100644
index 00bda03..0000000
--- a/fg21sim/webui/websocket.py
+++ /dev/null
@@ -1,436 +0,0 @@
-# Copyright (c) 2016 Weitian LI <liweitianux@live.com>
-# MIT license
-
-"""
-Communicate with the "fg21sim" simulation program through the Web UI using
-the WebSocket_ protocol, which provides full-duplex communication channels
-over a single TCP connection.
-
-.. _WebSocket: https://en.wikipedia.org/wiki/WebSocket
-
-
-References
-----------
-- Tornado WebSocket:
- http://www.tornadoweb.org/en/stable/websocket.html
-- Can I Use: WebSocket:
- http://caniuse.com/#feat=websockets
-"""
-
-import os
-import json
-import logging
-
-import tornado.websocket
-from tornado.options import options
-
-from .consolehandler import ConsoleHandler
-from .utils import get_host_ip, ip_in_network
-from ..errors import ConfigError
-
-
-logger = logging.getLogger(__name__)
-
-
-class FG21simWSHandler(tornado.websocket.WebSocketHandler):
- """
- WebSocket for bi-directional communication between the Web UI and
- the server, which can deal with the configurations and execute the
- simulation task.
-
- Generally, WebSocket send and receive data as *string*. Therefore,
- the more complex data are stringified as JSON string before sending,
- which will be parsed after receive.
-
- Each message (as a JSON object or Python dictionary) has a ``type``
- field which will be used to determine the following action to take.
-
- Attributes
- ----------
- name : str
- Name to distinguish this WebSocket handle.
- from_localhost : bool
- Set to ``True`` if the access is from the localhost,
- otherwise ``False``.
- configs : `~ConfigManager`
- A ``ConfigManager`` instance, for configuration manipulations when
- communicating with the Web UI.
- """
- name = "fg21sim"
- from_localhost = None
-
- def check_origin(self, origin):
- """Check the origin of the WebSocket access.
-
- Attributes
- ----------
- from_localhost : bool
- Set to ``True`` if the access is from the localhost,
- otherwise ``False``.
-
- NOTE
- ----
- Currently, only allow access from the ``localhost``
- (i.e., 127.0.0.1) and local LAN.
- """
- self.from_localhost = False
- logger.info("WebSocket: {0}: origin: {1}".format(self.name, origin))
- ip = get_host_ip(url=origin)
- network = options.hosts_allowed
- if ip == "127.0.0.1":
- self.from_localhost = True
- allow = True
- logger.info("WebSocket: %s: origin is localhost" % self.name)
- elif network.upper() == "ANY":
- # Any hosts are allowed
- allow = True
- logger.warning("WebSocket: %s: any hosts are allowed" % self.name)
- elif ip_in_network(ip, network):
- allow = True
- logger.info("WebSocket: %s: " % self.name +
- "client is in the allowed network: %s" % network)
- else:
- allow = False
- logger.error("WebSocket: %s: " % self.name +
- "client is NOT in the allowed network: %s" % network)
- return allow
-
- def open(self):
- """Invoked when a new WebSocket is opened by the client."""
- # FIXME:
- # * better to move to the `Application` class ??
- # * or create a ``ConfigsHandler`` similar to the ``ConsoleHandler``
- self.configs = self.application.configmanager
- self.console_handler = ConsoleHandler(websocket=self)
- #
- logger.info("WebSocket: {0}: opened".format(self.name))
- logger.info("Allowed hosts: {0}".format(options.hosts_allowed))
-
- def on_close(self):
- """Invoked when a new WebSocket is closed by the client."""
- code, reason = None, None
- if hasattr(self, "close_code"):
- code = self.close_code
- if hasattr(self, "close_reason"):
- reason = self.close_reason
- logger.info("WebSocket: {0}: closed by client: {1}, {2}".format(
- self.name, code, reason))
-
- # FIXME/XXX:
- # * How to be non-blocking ??
- # NOTE: WebSocket.on_message: may NOT be a coroutine at the moment (v4.3)
- # References:
- # [1] https://stackoverflow.com/a/35543856/4856091
- # [2] https://stackoverflow.com/a/33724486/4856091
- def on_message(self, message):
- """Handle incoming messages and dispatch task according to the
- message type.
-
- NOTE
- ----
- The received message (parsed to a Python dictionary) has a ``type``
- item which will be used to determine the following action to take.
-
- Currently supported message types are:
- ``configs``:
- Request or set the configurations
- ``console``:
- Control the simulation tasks, or request logging messages
- ``results``:
- Request the simulation results
-
- The sent message also has a ``type`` item of same value, which the
- client can be used to figure out the proper actions.
- There is a ``success`` item which indicates the status of the
- requested operation, and an ``error`` recording the error message
- if ``success=False``.
- """
- logger.debug("WebSocket: %s: received: %s" % (self.name, message))
- try:
- msg = json.loads(message)
- msg_type = msg["type"]
- except json.JSONDecodeError:
- logger.warning("WebSocket: {0}: ".format(self.name) +
- "message is not a valid JSON string")
- response = {"success": False,
- "type": None,
- "error": "message is not a valid JSON string"}
- except (KeyError, TypeError):
- logger.warning("WebSocket: %s: skip invalid message" % self.name)
- response = {"success": False,
- "type": None,
- "error": "type is missing"}
- else:
- # Check the message type and dispatch task
- if msg_type == "configs":
- # Request or set the configurations
- response = self._handle_configs(msg)
- elif msg_type == "console":
- # Control the simulation tasks, or request logging messages
- # FIXME/XXX:
- # * How to make this asynchronously ??
- response = self.console_handler.handle_message(msg)
- elif msg_type == "results":
- # Request the simulation results
- response = self._handle_results(msg)
- else:
- # Message of unknown type
- logger.warning("WebSocket: {0}: ".format(self.name) +
- "unknown message type: {0}".format(msg_type))
- response = {"success": False,
- "type": msg_type,
- "error": "unknown message type %s" % msg_type}
- #
- msg_response = json.dumps(response)
- self.write_message(msg_response)
-
- def _handle_configs(self, msg):
- """Handle the message of type "configs", which request to get or
- set some configurations by the client.
-
- TODO:
- * improve the description ...
- * split these handling functions into a separate class in a module
-
- Parameters
- ----------
- msg : dict
- A dictionary parsed from the incoming JSON message, which
- generally has the following syntax:
- ``{"type": "configs", "action": <action>, "data": <data>}``
- where the ``<action>`` is ``set`` or ``get``, and the ``<data>``
- is a list of config keys or a dict of config key-value pairs.
-
- Returns
- -------
- response : dict
- A dictionary parsed from the incoming JSON message, which
- generally has the following syntax:
- ``{"type": "configs", "action": <action>,
- "data": <data>, "errors": <errors>}``
- where the ``<action>`` is the same as input, the ``<data>`` is
- a list of config keys or a dict of config key-value pairs, and
- ``<errors>`` contains the error message for the invalid config
- values.
- """
- try:
- msg_type = msg["type"]
- msg_action = msg["action"]
- response = {"type": msg_type, "action": msg_action}
- logger.info("WebSocket: {0}: handle message: ".format(self.name) +
- "type: {0}, action: {1}".format(msg_type, msg_action))
- if msg_action == "get":
- # Get the values of the specified options
- try:
- data, errors = self._get_configs(keys=msg["keys"])
- response["success"] = True
- response["data"] = data
- response["errors"] = errors
- except KeyError:
- response["success"] = False
- response["error"] = "'keys' is missing"
- elif msg_action == "set":
- # Set the values of the specified options
- try:
- errors = self._set_configs(data=msg["data"])
- response["success"] = True
- response["data"] = {} # be more consistent
- response["errors"] = errors
- except KeyError:
- response["success"] = False
- response["error"] = "'data' is missing"
- elif msg_action == "reset":
- # Reset the configurations to the defaults
- self._reset_configs()
- response["success"] = True
- elif msg_action == "load":
- # Load the supplied user configuration file
- try:
- success, error = self._load_configs(msg["userconfig"])
- response["success"] = success
- if not success:
- response["error"] = error
- except KeyError:
- response["success"] = False
- response["error"] = "'userconfig' is missing"
- elif msg_action == "save":
- # Save current configurations to file
- try:
- success, error = self._save_configs(msg["outfile"],
- msg["clobber"])
- response["success"] = success
- if not success:
- response["error"] = error
- except KeyError:
- response["success"] = False
- response["error"] = "'outfile' or 'clobber' is missing"
- else:
- logger.warning("WebSocket: {0}: ".format(self.name) +
- "unknown action: {0}".format(msg_action))
- response["success"] = False
- response["error"] = "unknown action: {0}".format(msg_action)
- except KeyError:
- # Received message has wrong syntax/format
- response = {"success": False,
- "type": msg_type,
- "error": "no action specified"}
- #
- logger.debug("WebSocket: {0}: ".format(self.name) +
- "response: {0}".format(response))
- return response
-
- def _get_configs(self, keys=None):
- """Get the values of the config options specified by the given keys.
-
- Parameters
- ----------
- keys : list[str], optional
- A list of keys specifying the config options whose values will
- be obtained.
- If ``keys=None``, then all the configurations values are dumped.
-
- Returns
- -------
- data : dict
- A dictionary with keys the same as the input keys, and values
- the corresponding config option values.
- errors : dict
- When error occurs (e.g., invalid key), then the specific errors
- with details are stored in this dictionary.
-
- NOTE
- ----
- Do not forget the ``userconfig`` option.
- """
- if keys is None:
- # Dump all the configurations
- data = self.configs.dump(flatten=True)
- data["userconfig"] = self.configs.userconfig
- errors = {}
- else:
- data = {}
- errors = {}
- for key in keys:
- if key == "userconfig":
- data["userconfig"] = self.configs.userconfig
- else:
- try:
- data[key] = self.configs.getn(key)
- except KeyError as e:
- errors[key] = str(e)
- #
- return (data, errors)
-
- def _set_configs(self, data):
- """Set the values of the config options specified by the given keys
- to the corresponding supplied data.
-
- NOTE
- ----
- The ``userconfig`` needs special handle.
- The ``workdir`` and ``configfile`` options should be ignored.
-
- Parameters
- ----------
- data : dict
- A dictionary of key-value pairs, with keys specifying the config
- options whose value will be changed, and values the new values
- to which config options will be set.
- NOTE:
- If want to set the ``userconfig`` option, an *absolute path*
- must be provided.
-
- Returns
- -------
- errors : dict
- When error occurs (e.g., invalid key, invalid values), then the
- specific errors with details are stored in this dictionary.
- """
- errors = {}
- for key, value in data.items():
- if key in ["workdir", "configfile"]:
- # Ignore "workdir" and "configfile"
- continue
- elif key == "userconfig":
- if os.path.isabs(os.path.expanduser(value)):
- self.configs.userconfig = value
- else:
- errors[key] = "Not an absolute path"
- else:
- try:
- self.configs.setn(key, value)
- except KeyError as e:
- errors[key] = str(e)
- # NOTE:
- # Check the whole configurations after all provided options are
- # updated, and merge the validation errors.
- __, cherr = self.configs.check_all(raise_exception=False)
- errors.update(cherr)
- return errors
-
- def _reset_configs(self):
- """Reset the configurations to the defaults."""
- self.configs.reset()
-
- def _load_configs(self, userconfig):
- """Load configurations from the provided user configuration file.
-
- Parameters
- ----------
- userconfig: str
- The filepath to the user configuration file, which must be
- an *absolute path*.
-
- Returns
- -------
- success : bool
- ``True`` if the operation succeeded, otherwise, ``False``.
- error : str
- If failed, this ``error`` saves the details, otherwise, ``None``.
- """
- success = False
- error = None
- if os.path.isabs(os.path.expanduser(userconfig)):
- try:
- self.configs.read_userconfig(userconfig)
- success = True
- except ConfigError as e:
- error = str(e)
- else:
- error = "Not an absolute path"
- return (success, error)
-
- def _save_configs(self, outfile, clobber=False):
- """Save current configurations to file.
-
- Parameters
- ----------
- outfile: str
- The filepath to the output configuration file, which must be
- an *absolute path*.
- clobber : bool, optional
- Whether overwrite the output file if already exists?
-
- Returns
- -------
- success : bool
- ``True`` if the operation succeeded, otherwise, ``False``.
- error : str
- If failed, this ``error`` saves the details, otherwise, ``None``.
- """
- success = False
- error = None
- try:
- self.configs.save(outfile, clobber=clobber)
- success = True
- except (ValueError, OSError) as e:
- error = str(e)
- return (success, error)
-
- def _handle_results(self, msg):
- # Got a message of supported types
- msg_type = msg["type"]
- logger.info("WebSocket: {0}: ".format(self.name) +
- "handle message of type: {0}".format(msg_type))
- response = {"success": True, "type": msg_type}
- return response