multivisor 6.0.2__py3-none-any.whl

multivisor/server/rpc.py

@@ -0,0 +1,156 @@
+from __future__ import print_function
+
+import sys
+import logging
+import xmlrpc.client
+
+from os import environ
+from functools import partial
+
+from gevent import spawn
+from gevent.lock import RLock
+from gevent.queue import Queue
+from gevent.fileobject import FileObject
+from zerorpc import stream, Server, LostRemote
+from supervisor.childutils import getRPCInterface
+
+
+READY = "READY\n"
+ACKNOWLEDGED = "RESULT 2\nOK"
+DEFAULT_BIND = "tcp://*:9002"
+
+
+def signal(stream, msg):
+    stream.write(msg)
+    stream.flush()
+
+
+def wait_for_event(stream):
+    header_line = stream.readline()
+    event = dict((x.split(":") for x in header_line.split()))
+    payload_str = stream.read(int(event["len"]))
+    event["payload"] = dict((x.split(":") for x in payload_str.split()))
+    return event
+
+
+def event_producer_loop(dispatch):
+    istream = FileObject(sys.stdin)
+    ostream = FileObject(sys.stdout, mode='w')
+    while True:
+        signal(ostream, READY)
+        event = wait_for_event(istream)
+        dispatch(event)
+        signal(ostream, ACKNOWLEDGED)
+
+
+def event_consumer_loop(queue, handler):
+    for event in queue:
+        try:
+            handler(event)
+        except:
+            logging.exception("Error processing %s", event)
+
+
+get_rpc = partial(getRPCInterface, environ)
+
+
+def build_method(supervisor, name):
+    subsystem_name, func_name = name.split(".", 1)
+    def method(*args):
+        subsystem = getattr(supervisor.rpc, subsystem_name)
+        with supervisor.lock:
+            return getattr(subsystem, func_name)(*args)
+    method.__name__ = func_name
+    return func_name, method
+
+
+class Supervisor(object):
+
+    def __init__(self, xml_rpc):
+        self.event_channels = set()
+        self.lock = RLock()
+        self.rpc = xml_rpc
+        for name in self.rpc.system.listMethods():
+            setattr(self, *build_method(self, name))
+
+    @stream
+    def event_stream(self):
+        logging.info("client connected to stream")
+        channel = Queue()
+        self.event_channels.add(channel)
+        try:
+            yield "First event to trigger connection. Please ignore me!"
+            for event in channel:
+                yield event
+        except LostRemote as e:
+            logging.info("remote end of stream disconnected")
+        finally:
+            self.event_channels.remove(channel)
+
+    def publish_event(self, event):
+        name = event["eventname"]
+        if name.startswith("TICK"):
+            return
+        event = dict(event)
+        if name.startswith("PROCESS_STATE"):
+            payload = event["payload"]
+            pname = "{}:{}".format(payload["groupname"], payload["processname"])
+            logging.info("handling %s of %s", name, pname)
+            try:
+                payload["process"] = self.getProcessInfo(pname)
+            except xmlrpc.client.Fault:
+                # probably supervisor is shutting down
+                logging.warn("probably shutting down...")
+                return
+        elif not name.startswith("SUPERVISOR_STATE"):
+            logging.warning("ignored %s", name)
+            return
+        for channel in self.event_channels:
+            channel.put(event)
+
+
+def run(xml_rpc, bind=DEFAULT_BIND):
+    channel = Queue()
+    supervisor = Supervisor(xml_rpc)
+    t1 = spawn(event_consumer_loop, channel, supervisor.publish_event)
+    t2 = spawn(event_producer_loop, channel.put)
+    server = Server(supervisor)
+    server.bind(bind)
+    server.run()
+
+
+def main(args=None):
+    import gevent.monkey
+
+    gevent.monkey.patch_all(thread=False, sys=True)
+
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--bind", help="bind address", default=DEFAULT_BIND)
+    parser.add_argument(
+        "--log-level",
+        help="log level",
+        type=str,
+        default="INFO",
+        choices=["DEBUG", "INFO", "WARN", "ERROR"],
+    )
+    options = parser.parse_args(args)
+
+    log_level = getattr(logging, options.log_level.upper())
+    log_fmt = "%(levelname)s %(asctime)-15s %(name)s: %(message)s"
+    logging.basicConfig(level=log_level, format=log_fmt)
+
+    bind = options.bind
+    if "://" not in bind:
+        bind = "tcp://" + bind
+    try:
+        rpc = get_rpc()
+    except KeyError:
+        print("multivisor-rpc can only run as supervisor eventlistener", file=sys.stderr)
+        exit(1)
+    run(rpc, bind)
+
+
+if __name__ == "__main__":
+    main()

multivisor/server/tests/conftest.py

@@ -0,0 +1 @@
+import pytest

multivisor/server/tests/test_web.py

@@ -0,0 +1,194 @@
+import requests
+
+from tests.functions import assert_fields_in_object
+from tests.conftest import *
+
+
+@pytest.mark.usefixtures("api_base_url")
+def test_data_view(api_base_url):
+    url = "{}/data".format(api_base_url)
+    response = requests.get(url)
+    assert response.status_code == 200
+    data = response.json()
+    assert_fields_in_object(["name", "supervisors"], data)
+    assert "test001" in data["supervisors"]
+    supervisor = data["supervisors"]["test001"]
+    assert_fields_in_object(
+        [
+            "processes",
+            "name",
+            "url",
+            "pid",
+            "running",
+            "host",
+            "version",
+            "identification",
+            "supervisor_version",
+            "api_version",
+        ],
+        supervisor,
+    )
+
+    assert supervisor["running"]
+    processes = supervisor["processes"]
+    for name, process in processes.items():
+        assert_fields_in_object(
+            [
+                "stderr_logfile",
+                "description",
+                "statename",
+                "pid",
+                "stdout_logfile",
+                "full_name",
+                "supervisor",
+                "logfile",
+                "exitstatus",
+            ],
+            process,
+        )
+
+
+@pytest.mark.usefixtures("api_base_url")
+def test_config_view(api_base_url):
+    url = "{}/config/file".format(api_base_url)
+    response = requests.get(url)
+    assert response.status_code == 200
+    data = response.json()
+    assert "content" in data
+
+
+@pytest.mark.usefixtures("api_base_url")
+def test_list_processes_view(api_base_url):
+    url = "{}/process/list".format(api_base_url)
+    response = requests.get(url)
+    assert response.status_code == 200
+    data = response.json()
+    assert isinstance(data, list)
+    assert len(data) == 10
+
+
+@pytest.mark.usefixtures("api_base_url")
+def test_process_info_view(api_base_url):
+    uid = "test001:PLC:wcid00d"
+    url = "{}/process/info/{}".format(api_base_url, uid)
+    response = requests.get(url)
+    assert response.status_code == 200
+    process_data = response.json()
+    keys = [
+        u"logfile",
+        u"statename",
+        u"group",
+        u"description",
+        u"pid",
+        u"stderr_logfile",
+        u"stop",
+        u"running",
+        u"name",
+        u"start",
+        u"state",
+        u"spawnerr",
+        u"full_name",
+        u"host",
+        u"supervisor",
+        u"now",
+        u"exitstatus",
+        u"stdout_logfile",
+        u"uid",
+    ]
+
+    assert_fields_in_object(keys, process_data)
+    assert process_data["uid"] == uid
+    assert process_data["supervisor"] == "test001"
+    assert process_data["group"] == "PLC"
+    assert process_data["name"] == "wcid00d"
+
+
+@pytest.mark.usefixtures("api_base_url")
+def test_supervisor_info_view(api_base_url):
+    uid = "test001"
+    url = "{}/supervisor/info/{}".format(api_base_url, uid)
+    response = requests.get(url)
+    assert response.status_code == 200
+    supervisor_data = response.json()
+    keys = [
+        u"processes",
+        u"name",
+        u"url",
+        u"pid",
+        u"running",
+        u"host",
+        u"version",
+        u"identification",
+        u"supervisor_version",
+        u"api_version",
+    ]
+
+    assert_fields_in_object(keys, supervisor_data)
+    assert supervisor_data["name"] == uid
+    assert len(supervisor_data["processes"]) == 10
+
+
+@pytest.mark.usefixtures("api_base_url")
+def test_reload_view(api_base_url):
+    url = "{}/admin/reload".format(api_base_url)
+    response = requests.get(url)
+    assert response.status_code == 200
+
+
+@pytest.mark.usefixtures("api_base_url")
+def test_refresh_view(api_base_url):
+    url = "{}/refresh".format(api_base_url)
+    response = requests.get(url)
+    assert response.status_code == 200
+
+
+@pytest.mark.usefixtures("api_base_url")
+def test_stop_process_view(api_base_url, multivisor_instance):
+    multivisor_instance.refresh()  # processes are empty before calling this
+    uid = "test001:PLC:wcid00d"
+    process = multivisor_instance.get_process(uid)
+    # assert process is currently running
+    index, max_retries = 0, 10
+    while not process["running"]:
+        multivisor_instance.refresh()
+        process = multivisor_instance.get_process(uid)
+        sleep(0.5)
+        if index == max_retries:
+            raise AssertionError("Process {} is not running".format(uid))
+        index += 1
+
+    # stop the process
+    url = "{}/process/stop".format(api_base_url)
+    response = requests.post(url, {"uid": uid})
+    assert response.status_code == 200
+
+    # assert process is stopped
+    index, max_retries = 0, 10
+    while process["running"]:
+        multivisor_instance.refresh()
+        process = multivisor_instance.get_process(uid)
+        sleep(0.5)
+        if index == max_retries:
+            raise AssertionError("Process {} is not stopped".format(uid))
+        index += 1
+
+
+@pytest.mark.usefixtures("api_base_url")
+def test_restart_process_view(api_base_url, multivisor_instance):
+    multivisor_instance.refresh()  # processes are empty before calling this
+    uid = "test001:PLC:wcid00d"
+    process = multivisor_instance.get_process(uid)
+    # stop process if it's currently running
+    if process["running"]:
+        multivisor_instance.stop_processes(uid)
+        assert not process["running"]
+
+    # restart the process
+    url = "{}/process/restart".format(api_base_url)
+    response = requests.post(url, {"uid": uid})
+    assert response.status_code == 200
+
+    # assert process is restarted
+    multivisor_instance.refresh()
+    process = multivisor_instance.get_process(uid)
+    assert process["running"]

multivisor/server/util.py

@@ -0,0 +1,70 @@
+import hashlib
+import functools
+
+from flask import session, abort
+
+
+def is_login_valid(app, username, password):
+    username = username.strip()
+    password = password.strip()
+
+    correct_username = app.multivisor.config["username"]
+    correct_password = app.multivisor.config["password"]
+    return constant_time_compare(username, correct_username) and constant_time_compare(
+        password, correct_password
+    )
+
+
+def constant_time_compare(val1, val2):
+    """
+    Returns True if the two strings are equal, False otherwise.
+
+    The time taken is independent of the number of characters that match.
+
+    For the sake of simplicity, this function executes in constant time only
+    when the two strings have the same length. It short-circuits when they
+    have different lengths.
+
+    Taken from Django Source Code
+    """
+    val1 = hashlib.sha1(_safe_encode(val1)).hexdigest()
+    if val2.startswith("{SHA}"):  # password can be specified as SHA-1 hash in config
+        val2 = val2.split("{SHA}")[1]
+    else:
+        val2 = hashlib.sha1(_safe_encode(val2)).hexdigest()
+    if len(val1) != len(val2):
+        return False
+    result = 0
+    for x, y in zip(val1, val2):
+        result |= ord(x) ^ ord(y)
+    return result == 0
+
+
+def _safe_encode(data):
+    """Safely encode @data string to utf-8"""
+    try:
+        result = data.encode("utf-8")
+    except (UnicodeDecodeError, UnicodeEncodeError, AttributeError):
+        result = data
+    return result
+
+
+def login_required(app):
+    """
+    Decorator to mark view as requiring being logged in
+    """
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper_login_required(*args, **kwargs):
+            auth_on = app.multivisor.use_authentication
+
+            if not auth_on or "username" in session:
+                return func(*args, **kwargs)
+
+            # user not authenticated, return 401
+            abort(401)
+
+        return wrapper_login_required
+
+    return decorator