Support registration in Consul and created a driver to connect other Services Discovery

.github/workflows/python-package.yml

@@ -39,7 +39,7 @@ jobs:
     - name: Lint with flake8
       run: |
         # stop the build if there are Python syntax errors or undefined names
-        flake8 pyms --show-source --statistics --statistics
+        flake8 pyms --show-source --statistics
     - name: Lint with pylint
       run: |
         pylint --rcfile=pylintrc pyms

examples/microservice_service_discovery_consul/config.yml

@@ -0,0 +1,10 @@
+pyms:
+  services:
+    service_discovery:
+      client: "consul"
+      host: "http://localhost:8500"
+  config:
+    DEBUG: true
+    TESTING: false
+    APP_NAME: "Python Microservice"
+    APPLICATION_ROOT: ""

examples/microservice_service_discovery_consul/main.py

@@ -0,0 +1,15 @@
+from flask import jsonify
+
+from pyms.flask.app import Microservice
+
+ms = Microservice(path=__file__)
+app = ms.create_app()
+
+
+@app.route("/")
+def example():
+    return jsonify({"main": "hello world"})
+
+
+if __name__ == '__main__':
+    app.run()

pyms/exceptions.py

@@ -23,3 +23,7 @@ class ConfigErrorException(Exception):
 
 class PackageNotExists(Exception):
     pass
+
+
+class ServiceDiscoveryConnectionException(Exception):
+    pass

pyms/flask/app/create_app.py

@@ -9,11 +9,11 @@
 from pyms.constants import LOGGER_NAME, CONFIG_BASE
 from pyms.crypt.driver import CryptResource
 from pyms.flask.app.utils import SingletonMeta, ReverseProxied
-from pyms.flask.healthcheck import healthcheck_blueprint
 from pyms.flask.configreload import configreload_blueprint
+from pyms.flask.healthcheck import healthcheck_blueprint
 from pyms.flask.services.driver import ServicesResource, DriverService
 from pyms.logger import CustomJsonFormatter
-from pyms.utils import check_package_exists, import_from
+from pyms.utils import check_package_exists
 
 logger = logging.getLogger(LOGGER_NAME)
 
@@ -108,6 +108,14 @@ def init_services(self) -> None:
             if service_name not in self.services or not getattr(self, service_name, False):
                 self.services.append(service_name)
                 setattr(self, service_name, service)
+                # if getattr(service, "init_action"):
+                #     service.init_action(self)
+
+    def init_services_actions(self):
+        for service_name in self.services:
+            srv_action = getattr(getattr(self, service_name), "init_action")
+            if srv_action:
+                srv_action(self)
 
     def init_crypt(self, *args, **kwargs) -> None:
         """
@@ -135,15 +143,6 @@ def init_libs(self) -> Flask:
         """
         return self.application
 
-    def init_tracer(self) -> None:
-        """Set attribute in flask `tracer`. See in `pyms.flask.services.tracer` how it works
-        :return: None
-        """
-        if self.tracer:
-            FlaskTracing = import_from("flask_opentracing", "FlaskTracing")
-            client = self.tracer.get_client()
-            self.application.tracer = FlaskTracing(client, True, self.application)
-
     def init_logger(self) -> None:
         """
         Set a logger and return in JSON format.
@@ -185,18 +184,6 @@ def init_app(self) -> Flask:
 
         return application
 
-    def init_metrics(self) -> None:
-        """Set attribute in flask `metrics`. See in `pyms.flask.services.metrics` how it works
-        :return: None
-        """
-        if self.metrics:
-            self.application.register_blueprint(self.metrics.metrics_blueprint)
-            self.metrics.add_logger_handler(
-                self.application.logger,
-                self.application.config["APP_NAME"]
-            )
-            self.metrics.monitor(self.application.config["APP_NAME"], self.application)
-
     def reload_conf(self):
         self.delete_services()
         self.config.reload()
@@ -214,7 +201,6 @@ def create_app(self) -> Flask:
         """
         self.application = self.init_app()
         self.application.config.from_object(self.config.to_flask())
-        self.application.tracer = None
         self.application.ms = self
 
         # Initialize Blueprints
@@ -223,12 +209,9 @@ def create_app(self) -> Flask:
 
         self.init_libs()
         self.add_error_handlers()
-
-        self.init_tracer()
-
         self.init_logger()
 
-        self.init_metrics()
+        self.init_services_actions()
 
         logger.debug("Started app with PyMS and this services: {}".format(self.services))
 

pyms/flask/services/driver.py

@@ -39,6 +39,8 @@ class DriverService(ConfigResource):
     """
     enabled = True
 
+    init_action = False
+
     def __init__(self, *args, **kwargs):
         self.config_resource = get_service_name(service=self.config_resource)
         super().__init__(*args, **kwargs)

pyms/flask/services/metrics.py

@@ -1,10 +1,9 @@
-import time
 import logging
-
-from typing import Text
+import time
 
 from flask import Blueprint, Response, request, Flask
 from prometheus_client import multiprocess, Counter, Histogram, generate_latest, CollectorRegistry, REGISTRY
+
 from pyms.flask.services.driver import DriverService
 
 # Based on https://github.com/sbarratt/flask-prometheus
@@ -47,14 +46,21 @@ class Service(DriverService):
     """
     Adds [Prometheus](https://prometheus.io/) metrics using the [Prometheus Client Library](https://github.com/prometheus/client_python).
     """
-    config_resource: Text = "metrics"
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.metrics_blueprint = Blueprint("metrics", __name__)
         self.init_registry()
         self.serve_metrics()
 
+    def init_action(self, microservice_instance):
+        microservice_instance.application.register_blueprint(microservice_instance.metrics.metrics_blueprint)
+        self.add_logger_handler(
+            microservice_instance.application.logger,
+            microservice_instance.application.config["APP_NAME"]
+        )
+        self.monitor(microservice_instance.application.config["APP_NAME"], microservice_instance.application)
+
     def init_registry(self) -> None:
         try:
             multiprocess_registry = CollectorRegistry()

pyms/flask/services/service_discovery.py

@@ -0,0 +1,82 @@
+import json
+import logging
+import uuid
+
+import requests
+from requests.exceptions import RequestException
+from pyms.constants import LOGGER_NAME
+from pyms.exceptions import ServiceDiscoveryConnectionException
+from pyms.flask.services.driver import DriverService
+
+logger = logging.getLogger(LOGGER_NAME)
+
+CONSUL_SERVICE_DISCOVERY = "consul"
+
+DEFAULT_SERVICE_DISCOVERY = CONSUL_SERVICE_DISCOVERY
+
+
+class ServiceDiscoveryBase:
+    def register_service(self, id_app, host, port, healtcheck_url, app_name):
+        pass
+
+
+class ServiceDiscoveryConsul(ServiceDiscoveryBase):
+    def register_service(self, id_app, host, port, healtcheck_url, app_name):
+        headers = {
+            'Content-Type': 'application/json; charset=utf-8'
+        }
+        data = {
+            "id": app_name + "-" + id_app,
+            "name": app_name,
+            "port": port,
+            "check": {
+                "name": "ping check",
+                "http": healtcheck_url,
+                "interval": "30s",
+                "status": "passing"
+            }
+        }
+        error = False
+        msg_error = "Failed to establish a new connection"
+        try:
+            response = requests.put("{host}/v1/agent/service/register".format(host=host), data=json.dumps(data),
+                                    headers=headers)
+            if response.status_code != 200:
+                msg_error = response.content
+                error = True
+        except RequestException:
+            error = True
+
+        if error:
+            raise ServiceDiscoveryConnectionException("Host %s raise an error: %s" % (host, msg_error))
+
+
+class Service(DriverService):
+    id_app = str(uuid.uuid1())
+    config_resource = "service_discovery"
+    default_values = {
+        "client": DEFAULT_SERVICE_DISCOVERY,
+        "host": "http://localhost:8500",
+        "port": 5000,
+        "healtcheck_url": "http://127.0.0.1.nip.io:5000/healthcheck",
+    }
+
+    def init_action(self, microservice_instance):
+        self.client.register_service(
+            id_app=self.id_app,
+            host=self.host,
+            healtcheck_url=self.healtcheck_url,
+            port=self.port,
+            app_name=microservice_instance.application.config["APP_NAME"])
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.client = self.get_client()
+
+    def get_client(self) -> ServiceDiscoveryBase:
+        client = False
+        if self.config.client == CONSUL_SERVICE_DISCOVERY:
+            client = ServiceDiscoveryConsul()
+
+        logger.debug("Init %s as service discovery", client)
+        return client

pyms/flask/services/tracer.py

@@ -58,6 +58,11 @@ class Service(DriverService):
         "client": DEFAULT_CLIENT,
     }
 
+    def init_action(self, microservice_instance):
+        FlaskTracing = import_from("flask_opentracing", "FlaskTracing")
+        client = self.get_client()
+        microservice_instance.application.tracer = FlaskTracing(client, True, microservice_instance.application)
+
     def get_client(self) -> Union[bool, type]:
         opentracing_tracer = False
         if self.config.client == JAEGER_CLIENT: