Merge pull request #1047 from Yaser-Amiri/master

Add auto reloading.

sanic/app.py

@@ -1,3 +1,4 @@
+import os
 import logging
 import logging.config
 import re
@@ -22,6 +23,7 @@ from sanic.static import register as static_register
 from sanic.testing import SanicTestClient
 from sanic.views import CompositionView
 from sanic.websocket import WebSocketProtocol, ConnectionClosed
+import sanic.reloader_helpers as reloader_helpers
 
 
 class Sanic:
@@ -647,7 +649,7 @@ class Sanic:
     def run(self, host=None, port=None, debug=False, ssl=None,
             sock=None, workers=1, protocol=None,
             backlog=100, stop_event=None, register_sys_signals=True,
-            access_log=True):
+            access_log=True, auto_reload=False):
         """Run the HTTP Server and listen until keyboard interrupt or term
         signal. On termination, drain connections before closing.
 
@@ -681,12 +683,21 @@ class Sanic:
             host=host, port=port, debug=debug, ssl=ssl, sock=sock,
             workers=workers, protocol=protocol, backlog=backlog,
             register_sys_signals=register_sys_signals,
-            access_log=access_log)
+            access_log=access_log, auto_reload=auto_reload)
 
         try:
             self.is_running = True
             if workers == 1:
-                serve(**server_settings)
+                if auto_reload and os.name != 'posix':
+                    # This condition must be removed after implementing
+                    # auto reloader for other operating systems.
+                    raise NotImplementedError
+
+                if auto_reload and \
+                        os.environ.get('SANIC_SERVER_RUNNING') != 'true':
+                    reloader_helpers.watchdog(2)
+                else:
+                    serve(**server_settings)
             else:
                 serve_multiple(server_settings, workers)
         except BaseException:
@@ -776,7 +787,8 @@ class Sanic:
     def _helper(self, host=None, port=None, debug=False,
                 ssl=None, sock=None, workers=1, loop=None,
                 protocol=HttpProtocol, backlog=100, stop_event=None,
-                register_sys_signals=True, run_async=False, access_log=True):
+                register_sys_signals=True, run_async=False, access_log=True,
+                auto_reload=False):
         """Helper function used by `run` and `create_server`."""
         if isinstance(ssl, dict):
             # try common aliaseses
@@ -844,14 +856,16 @@ class Sanic:
 
         if self.configure_logging and debug:
             logger.setLevel(logging.DEBUG)
-        if self.config.LOGO is not None:
+
+        if self.config.LOGO is not None and \
+                os.environ.get('SANIC_SERVER_RUNNING') != 'true':
             logger.debug(self.config.LOGO)
 
         if run_async:
             server_settings['run_async'] = True
 
         # Serve
-        if host and port:
+        if host and port and os.environ.get('SANIC_SERVER_RUNNING') != 'true':
             proto = "http"
             if ssl is not None:
                 proto = "https"

sanic/reloader_helpers.py

@@ -0,0 +1,121 @@
+import os
+import sys
+import signal
+import subprocess
+from time import sleep
+from multiprocessing import Process
+
+
+def _iter_module_files():
+    """This iterates over all relevant Python files.
+
+    It goes through all
+    loaded files from modules, all files in folders of already loaded modules
+    as well as all files reachable through a package.
+    """
+    # The list call is necessary on Python 3 in case the module
+    # dictionary modifies during iteration.
+    for module in list(sys.modules.values()):
+        if module is None:
+            continue
+        filename = getattr(module, '__file__', None)
+        if filename:
+            old = None
+            while not os.path.isfile(filename):
+                old = filename
+                filename = os.path.dirname(filename)
+                if filename == old:
+                    break
+            else:
+                if filename[-4:] in ('.pyc', '.pyo'):
+                    filename = filename[:-1]
+                yield filename
+
+
+def _get_args_for_reloading():
+    """Returns the executable."""
+    rv = [sys.executable]
+    rv.extend(sys.argv)
+    return rv
+
+
+def restart_with_reloader():
+    """Create a new process and a subprocess in it with the same arguments as
+    this one.
+    """
+    args = _get_args_for_reloading()
+    new_environ = os.environ.copy()
+    new_environ['SANIC_SERVER_RUNNING'] = 'true'
+    cmd = ' '.join(args)
+    worker_process = Process(
+                            target=subprocess.call, args=(cmd,),
+                            kwargs=dict(shell=True, env=new_environ))
+    worker_process.start()
+    return worker_process
+
+
+def kill_process_children_unix(pid):
+    """Find and kill child process of a process (maximum two level).
+
+    :param pid: PID of process (process ID)
+    :return: Nothing
+    """
+    root_process_path = "/proc/{pid}/task/{pid}/children".format(pid=pid)
+    if not os.path.isfile(root_process_path):
+        return
+    with open(root_process_path) as children_list_file:
+        children_list_pid = children_list_file.read().split()
+
+    for child_pid in children_list_pid:
+        children_proc_path = "/proc/%s/task/%s/children" % \
+            (child_pid, child_pid)
+        if not os.path.isfile(children_proc_path):
+            continue
+        with open(children_proc_path) as children_list_file_2:
+            children_list_pid_2 = children_list_file_2.read().split()
+        for _pid in children_list_pid_2:
+            os.kill(int(_pid), signal.SIGTERM)
+
+
+def kill_program_completly(proc):
+    """Kill worker and it's child processes and exit.
+
+    :param proc: worker process (process ID)
+    :return: Nothing
+    """
+    kill_process_children_unix(proc.pid)
+    proc.terminate()
+    os._exit(0)
+
+
+def watchdog(sleep_interval):
+    """Watch project files, restart worker process if a change happened.
+
+    :param sleep_interval: interval in second.
+    :return: Nothing
+    """
+    mtimes = {}
+    worker_process = restart_with_reloader()
+    signal.signal(
+        signal.SIGTERM, lambda *args: kill_program_completly(worker_process))
+    signal.signal(
+        signal.SIGINT, lambda *args: kill_program_completly(worker_process))
+    while True:
+        for filename in _iter_module_files():
+            try:
+                mtime = os.stat(filename).st_mtime
+            except OSError:
+                continue
+
+            old_time = mtimes.get(filename)
+            if old_time is None:
+                mtimes[filename] = mtime
+                continue
+            elif mtime > old_time:
+                kill_process_children_unix(worker_process.pid)
+                worker_process = restart_with_reloader()
+
+                mtimes[filename] = mtime
+                break
+
+        sleep(sleep_interval)

tests/test_auto_reload.py

@@ -0,0 +1,108 @@
+import os
+import sys
+import subprocess
+import signal
+from threading import Thread
+from time import sleep
+from json.decoder import JSONDecodeError
+import aiohttp
+import asyncio
+import async_timeout
+
+sanic_project_content_one = '''
+from sanic import Sanic
+from sanic import response
+
+app = Sanic(__name__)
+
+
+@app.route("/")
+async def test(request):
+    return response.json({"test": 1})
+
+
+if __name__ == '__main__':
+    app.run(host="127.0.0.1", port=8000, auto_reload=True)
+'''
+
+sanic_project_content_two = '''
+from sanic import Sanic
+from sanic import response
+
+app = Sanic(__name__)
+
+
+@app.route("/")
+async def test(request):
+    return response.json({"test": 2})
+
+
+if __name__ == '__main__':
+    app.run(host="127.0.0.1", port=8000, auto_reload=True)
+'''
+
+process_id = None
+
+
+def execute_cmd(command):
+    process = subprocess.Popen(command, shell=True)
+    global process_id
+    process_id = process.pid
+    process.communicate()
+
+
+class TestAutoReloading:
+
+    def check_response(self, url, response):
+        """Send http request and tries to take it's response as json.
+        Returns a dictionary.
+        """
+        async def req(url, excepted_response):
+            async with aiohttp.ClientSession() as session:
+                with async_timeout.timeout(10):
+                    async with session.get(url) as response:
+                        try:
+                            result = await response.json()
+                        except JSONDecodeError:
+                            result = {}
+            return result == excepted_response
+
+        loop = asyncio.get_event_loop()
+        return loop.run_until_complete(req(url, response))
+
+    def test_reloading_after_change_file(self, capsys):
+        if os.name != 'posix':
+            return
+
+        with capsys.disabled():
+            pass
+        sanic_app_file_path = "simple_sanic_app.py"
+        with open(sanic_app_file_path, "w") as _file:
+            _file.write(sanic_project_content_one)
+
+        cmd = ' '.join([sys.executable, sanic_app_file_path])
+        thread = Thread(target=execute_cmd, args=(cmd,))
+        thread.start()
+
+        sleep(2)  # wait for completing server start process
+        assert self.check_response("http://127.0.0.1:8000/", {"test": 1})
+
+        with open(sanic_app_file_path, "w") as _file:
+            _file.write(sanic_project_content_two)
+
+        sleep(2)  # wait for completing server start process
+        assert self.check_response("http://127.0.0.1:8000/", {"test": 2})
+
+        thread.join(1)
+        os.remove(sanic_app_file_path)
+
+    def teardown_method(self, method):
+        if process_id:
+            root_proc_path = \
+                "/proc/{pid}/task/{pid}/children".format(pid=process_id)
+            if not os.path.isfile(root_proc_path):
+                return
+            with open(root_proc_path) as children_list_file:
+                children_list_pid = children_list_file.read().split()
+            for child_pid in children_list_pid:
+                os.kill(int(child_pid), signal.SIGTERM)