Merge c227bb3139 into a0c9a9585d

freqtrade/rpc/api_server.py

@@ -1,22 +1,32 @@
 import json
 import threading
 import logging
-# import json
 
-from flask import Flask, request, jsonify
+from flask import request
-# from flask_restful import Resource, Api
 from json import dumps
 from freqtrade.rpc.rpc import RPC, RPCException
 from ipaddress import IPv4Address
+from freqtrade.rpc.api_server_common import MyApiApp
 
 
 logger = logging.getLogger(__name__)
-app = Flask(__name__)
+"""
+api server routes that do not need access to rpc.rpc
+are held within api_server_common.api_server
+"""
+app = MyApiApp(__name__)
 
 
 class ApiServer(RPC):
     """
-    This class is for REST calls across api server
+    This class runs api server and provides rpc.rpc functionality to it
+
+    This class starts a none blocking thread the api server runs within
+    Any routes that require access to rpc.rpc defs are held within this
+    class.
+
+    Any routes that do not require access to rpc.rcp should be registered
+    in api_server_common.MyApiApp
     """
     def __init__(self, freqtrade) -> None:
         """
@@ -29,20 +39,11 @@ class ApiServer(RPC):
         self._config = freqtrade.config
 
         # Register application handling
-        self.register_rest_other()
         self.register_rest_rpc_urls()
 
         thread = threading.Thread(target=self.run, daemon=True)
         thread.start()
 
-    def register_rest_other(self):
-        """
-        Registers flask app URLs that are not calls to functionality in rpc.rpc.
-        :return:
-        """
-        app.register_error_handler(404, self.page_not_found)
-        app.add_url_rule('/', 'hello', view_func=self.hello, methods=['GET'])
-
     def register_rest_rpc_urls(self):
         """
         Registers flask app URLs that are calls to functonality in rpc.rpc.
@@ -88,28 +89,10 @@ class ApiServer(RPC):
     Define the application methods here, called by app.add_url_rule
     each Telegram command should have a like local substitute
     """
-
+    def stop_api(self):
-    def page_not_found(self, error):
+        """ For calling shutdown_api_server over via api server HTTP"""
-        # Return "404 not found", 404.
+        self.shutdown_api_server()
-        return jsonify({'status': 'error',
+        return 'Api Server shutting down... '
-                        'reason': '''There's no API call for %s''' % request.base_url,
-                        'code': 404}), 404
-
-    def hello(self):
-        """
-        None critical but helpful default index page.
-
-        That lists URLs added to the flask server.
-        This may be deprecated at any time.
-        :return: index.html
-        """
-        rest_cmds = 'Commands implemented: <br>' \
-                    '<a href=/daily?timescale=7>/daily?timescale=7</a>' \
-                    '<br>' \
-                    '<a href=/stop>/stop</a>' \
-                    '<br>' \
-                    '<a href=/start>/start</a>'
-        return rest_cmds
 
     def daily(self):
         """
@@ -119,7 +102,6 @@ class ApiServer(RPC):
         """
         try:
             timescale = request.args.get('timescale')
-            logger.info("LocalRPC - Daily Command Called")
             timescale = int(timescale)
 
             stats = self._rpc_daily_profit(timescale,

freqtrade/rpc/api_server_common.py

@@ -0,0 +1,74 @@
+import logging
+import flask
+from flask import request, jsonify
+
+logger = logging.getLogger(__name__)
+
+
+class MyApiApp(flask.Flask):
+    def __init__(self, import_name):
+        """
+        Contains common rest routes and resource that do not need
+        to access to rpc.rpc functionality
+        """
+        super(MyApiApp, self).__init__(import_name)
+
+        """
+        Registers flask app URLs that are not calls to functionality in rpc.rpc.
+        :return:
+        """
+        self.before_request(self.my_preprocessing)
+        self.register_error_handler(404, self.page_not_found)
+        self.add_url_rule('/', 'hello', view_func=self.hello, methods=['GET'])
+        self.add_url_rule('/stop_api', 'stop_api', view_func=self.stop_api, methods=['GET'])
+
+    def my_preprocessing(self):
+        # Do stuff to flask.request
+        pass
+
+    def page_not_found(self, error):
+        # Return "404 not found", 404.
+        return jsonify({'status': 'error',
+                        'reason': '''There's no API call for %s''' % request.base_url,
+                        'code': 404}), 404
+
+    def hello(self):
+        """
+        None critical but helpful default index page.
+
+        That lists URLs added to the flask server.
+        This may be deprecated at any time.
+        :return: index.html
+        """
+        rest_cmds = 'Commands implemented: <br>' \
+                    '<a href=/daily?timescale=7>Show 7 days of stats</a>' \
+                    '<br>' \
+                    '<a href=/stop>Stop the Trade thread</a>' \
+                    '<br>' \
+                    '<a href=/start>Start the Traded thread</a>' \
+                    '<br>' \
+                    '<a href=/paypal> 404 page does not exist</a>' \
+                    '<br>' \
+                    '<br>' \
+                    '<a href=/stop_api>Shut down the api server -  be sure</a>'
+        return rest_cmds
+
+    def stop_api(self):
+        """ For calling shutdown_api_server over via api server HTTP"""
+        self.shutdown_api_server()
+        return 'Api Server shutting down... '
+
+    def shutdown_api_server(self):
+        """
+        Stop the running flask application
+
+        Records the shutdown in logger.info
+        :return:
+        """
+        func = request.environ.get('werkzeug.server.shutdown')
+        if func is None:
+            raise RuntimeError('Not running the Flask Werkzeug Server')
+        if func is not None:
+            logger.info('Stopping the Local Rest Server')
+            func()
+            return