from flask_restful import Resource
 from oslo_config import cfg
 from oslo_log import log as logging
-from moon_interface.tools import call
+from moon_utilities.security_functions import call
 from moon_interface.tools import check_auth
 
 __version__ = "0.2.0"
         }
         :internal_api: update_subject_assignment
         """
-        return call(ctx={"id": uuid, "method": "update_subject_assignment", "user_id": user_id}, args=request.json)
+        return call("security_router",
+                    ctx={"id": uuid, "method": "update_subject_assignment", "user_id": user_id}, args=request.json)
 
     @check_auth
     def delete(self, uuid=None, perimeter_id=None, category_id=None, data_id=None, user_id=None):
         }
         :internal_api: delete_subject_assignment
         """
-        return call(ctx={"id": uuid, "method": "delete_subject_assignment", "perimeter_id": perimeter_id, "category_id": category_id, "user_id": user_id},
+        return call("security_router",
+                    ctx={"id": uuid, "method": "delete_subject_assignment", "perimeter_id": perimeter_id, "category_id": category_id, "user_id": user_id},
                     args={"data_id": data_id})
 
 
         }
         :internal_api: get_object_assignments
         """
-        return call(ctx={"id": uuid, "method": "get_object_assignments", "perimeter_id": perimeter_id, "category_id": category_id, "user_id": user_id},
+        return call("security_router",
+                    ctx={"id": uuid, "method": "get_object_assignments", "perimeter_id": perimeter_id, "category_id": category_id, "user_id": user_id},
                     args={"data_id": data_id})
 
     @check_auth
         }
         :internal_api: update_object_assignment
         """
-        return call(ctx={"id": uuid, "method": "update_object_assignment", "user_id": user_id}, args=request.json)
+        return call("security_router",
+                    ctx={"id": uuid, "method": "update_object_assignment", "user_id": user_id}, args=request.json)
 
     @check_auth
     def delete(self, uuid=None, perimeter_id=None, category_id=None, data_id=None, user_id=None):
         }
         :internal_api: delete_object_assignment
         """
-        return call(ctx={"id": uuid, "method": "delete_object_assignment", "perimeter_id": perimeter_id, "category_id": category_id, "user_id": user_id},
+        return call("security_router",
+                    ctx={"id": uuid, "method": "delete_object_assignment", "perimeter_id": perimeter_id, "category_id": category_id, "user_id": user_id},
                     args={"data_id": data_id})
 
 
         }
         :internal_api: get_action_assignments
         """
-        return call(ctx={"id": uuid, "method": "get_action_assignments", "perimeter_id": perimeter_id, "category_id": category_id, "user_id": user_id},
+        return call("security_router", ctx={"id": uuid, "method": "get_action_assignments", "perimeter_id": perimeter_id, "category_id": category_id, "user_id": user_id},
                     args={"data_id": data_id})
 
     @check_auth
         }
         :internal_api: update_action_assignment
         """
-        return call(ctx={"id": uuid, "method": "update_action_assignment", "user_id": user_id},
+        return call("security_router", ctx={"id": uuid, "method": "update_action_assignment", "user_id": user_id},
                     args=request.json)
 
     @check_auth
         }
         :internal_api: delete_action_assignment
         """
-        return call(ctx={"id": uuid, "method": "delete_action_assignment", "perimeter_id": perimeter_id, "category_id": category_id, "user_id": user_id},
+        return call("security_router", ctx={"id": uuid, "method": "delete_action_assignment", "perimeter_id": perimeter_id, "category_id": category_id, "user_id": user_id},
                     args={"data_id": data_id})
 
 from flask_restful import Resource
 from oslo_config import cfg
 from oslo_log import log as logging
-from moon_interface.tools import call
+from moon_utilities.security_functions import call
 from moon_interface.tools import check_auth
 
 __version__ = "0.1.0"
         """
         # Note (asteroide): user_id default to admin to be able to read the database
         # it would be better to have a read-only user.
-        return call(ctx={"id": uuid,
+        return call("security_router", ctx={"id": uuid,
                          "call_master": False,
                          "method": "authz",
                          "subject_name": subject_name,
 
 from flask_restful import Resource
 from oslo_config import cfg
 from oslo_log import log as logging
-from moon_interface.tools import call
+from moon_utilities.security_functions import call
 from moon_interface.tools import check_auth
 
 __version__ = "0.2.0"
         }]
         :internal_api: get_subject_data
         """
-        return call(ctx={"id": uuid, "method": "get_subject_data", "category_id": category_id, "user_id": user_id},
+        return call("security_router", ctx={"id": uuid, "method": "get_subject_data", "category_id": category_id, "user_id": user_id},
                     args={"data_id": data_id})
 
     @check_auth
         }
         :internal_api: add_subject_data
         """
-        return call(ctx={"id": uuid, "method": "add_subject_data", "category_id": category_id, "user_id": user_id},
+        return call("security_router", ctx={"id": uuid, "method": "add_subject_data", "category_id": category_id, "user_id": user_id},
                     args=request.json)
 
     @check_auth
         }]
         :internal_api: delete_subject_data
         """
-        return call(ctx={"id": uuid, "method": "delete_subject_data", "category_id": category_id, "user_id": user_id},
+        return call("security_router", ctx={"id": uuid, "method": "delete_subject_data", "category_id": category_id, "user_id": user_id},
                     args={"data_id": data_id})
 
 
         }]
         :internal_api: get_object_data
         """
-        return call(ctx={"id": uuid, "method": "get_object_data", "category_id": category_id, "user_id": user_id},
+        return call("security_router", ctx={"id": uuid, "method": "get_object_data", "category_id": category_id, "user_id": user_id},
                     args={"data_id": data_id})
 
     @check_auth
         }
         :internal_api: add_object_data
         """
-        return call(ctx={"id": uuid, "method": "add_object_data", "category_id": category_id, "user_id": user_id}, args=request.json)
+        return call("security_router", ctx={"id": uuid, "method": "add_object_data", "category_id": category_id, "user_id": user_id}, args=request.json)
 
     @check_auth
     def delete(self, uuid=None, category_id=None, data_id=None, user_id=None):
         }
         :internal_api: delete_object_data
         """
-        return call(ctx={"id": uuid, "method": "delete_object_data", "category_id": category_id, "user_id": user_id},
+        return call("security_router", ctx={"id": uuid, "method": "delete_object_data", "category_id": category_id, "user_id": user_id},
                     args={"data_id": data_id})
 
 
         }]
         :internal_api: get_action_data
         """
-        return call(ctx={"id": uuid, "method": "get_action_data", "category_id": category_id, "user_id": user_id},
+        return call("security_router", ctx={"id": uuid, "method": "get_action_data", "category_id": category_id, "user_id": user_id},
                     args={"data_id": data_id})
 
     @check_auth
         }
         :internal_api: add_action_data
         """
-        return call(ctx={"id": uuid, "method": "add_action_data", "category_id": category_id, "user_id": user_id},
+        return call("security_router", ctx={"id": uuid, "method": "add_action_data", "category_id": category_id, "user_id": user_id},
                     args=request.json)
 
     @check_auth
         }
         :internal_api: delete_action_data
         """
-        return call(ctx={"id": uuid, "method": "delete_action_data", "category_id": category_id, "user_id": user_id},
+        return call("security_router", ctx={"id": uuid, "method": "delete_action_data", "category_id": category_id, "user_id": user_id},
                     args={"data_id": data_id})
 
 
 
 from flask_restful import Resource, request
 from oslo_config import cfg
 from oslo_log import log as logging
-from moon_interface.tools import call
+from moon_utilities.security_functions import call
 import moon_interface.api
 from moon_interface.tools import check_auth
 
           }
         }
         """
-        return call(method="get_status", ctx={"component_id": component_id})
+        return call("security_router", method="get_status", ctx={"component_id": component_id})
 
 
 class Logs(Resource):
         args["to"] = to_str
         args["event_number"] = event_number
 
-        return call(method="get_logs", ctx={"component_id": component_id}, args=args)
+        return call("security_router", method="get_logs", ctx={"component_id": component_id}, args=args)
 
 
 class API(Resource):
         if component_id in api_list:
             api_desc = dict()
             api_desc["name"] = component_id
-            api_desc["endpoints"] = call(component_id, {}, "list_api")
+            api_desc["endpoints"] = call("security_router", component_id, {}, "list_api")
             return api_desc
 
 
 from flask_restful import Resource
 from oslo_config import cfg
 from oslo_log import log as logging
-from moon_interface.tools import call
+from moon_utilities.security_functions import call
 from moon_interface.tools import check_auth
 
 __version__ = "0.2.0"
         }
         :internal_api: get_subject_categories
         """
-        return call(ctx={"method": "get_subject_categories", "user_id": user_id}, args={"category_id": category_id})
+        return call("security_router", ctx={"method": "get_subject_categories", "user_id": user_id}, args={"category_id": category_id})
 
     @check_auth
     def post(self, category_id=None, user_id=None):
         }
         :internal_api: add_subject_category
         """
-        return call(ctx={"method": "set_subject_category", "user_id": user_id}, args=request.json)
+        return call("security_router", ctx={"method": "set_subject_category", "user_id": user_id}, args=request.json)
 
     @check_auth
     def delete(self, category_id=None, user_id=None):
         }
         :internal_api: delete_subject_category
         """
-        return call(ctx={"method": "delete_subject_category", "user_id": user_id}, args={"category_id": category_id})
+        return call("security_router", ctx={"method": "delete_subject_category", "user_id": user_id}, args={"category_id": category_id})
 
 
 class ObjectCategories(Resource):
         }
         :internal_api: get_object_categories
         """
-        return call(ctx={"method": "get_object_categories", "user_id": user_id}, args={"category_id": category_id})
+        return call("security_router", ctx={"method": "get_object_categories", "user_id": user_id}, args={"category_id": category_id})
 
     @check_auth
     def post(self, category_id=None, user_id=None):
         }
         :internal_api: add_object_category
         """
-        return call(ctx={"method": "set_object_category", "user_id": user_id}, args=request.json)
+        return call("security_router", ctx={"method": "set_object_category", "user_id": user_id}, args=request.json)
 
     @check_auth
     def delete(self, category_id=None, user_id=None):
         }
         :internal_api: delete_object_category
         """
-        return call(ctx={"method": "delete_object_category", "user_id": user_id}, args={"category_id": category_id})
+        return call("security_router", ctx={"method": "delete_object_category", "user_id": user_id}, args={"category_id": category_id})
 
 
 class ActionCategories(Resource):
         }
         :internal_api: get_action_categories
         """
-        return call(ctx={"method": "get_action_categories", "user_id": user_id}, args={"category_id": category_id})
+        return call("security_router", ctx={"method": "get_action_categories", "user_id": user_id}, args={"category_id": category_id})
 
     @check_auth
     def post(self, category_id=None, user_id=None):
         }
         :internal_api: add_action_category
         """
-        return call(ctx={"method": "set_action_category", "user_id": user_id}, args=request.json)
+        return call("security_router", ctx={"method": "set_action_category", "user_id": user_id}, args=request.json)
 
     @check_auth
     def delete(self, category_id=None, user_id=None):
         }
         :internal_api: delete_action_category
         """
-        return call(ctx={"method": "delete_action_category", "user_id": user_id}, args={"category_id": category_id})
+        return call("security_router", ctx={"method": "delete_action_category", "user_id": user_id}, args={"category_id": category_id})
 
 from flask_restful import Resource
 from oslo_config import cfg
 from oslo_log import log as logging
-from moon_interface.tools import call
+from moon_utilities.security_functions import call
 from moon_interface.tools import check_auth
 
 __version__ = "0.1.0"
         }
         :internal_api: get_meta_rules
         """
-        return call(ctx={"method": "get_meta_rules",
+        return call("security_router", ctx={"method": "get_meta_rules",
                          "user_id": user_id,
                          "meta_rule_id": meta_rule_id}, args={})
 
         }
         :internal_api: add_meta_rules
         """
-        return call(ctx={"method": "add_meta_rules",
+        return call("security_router", ctx={"method": "add_meta_rules",
                          "user_id": user_id,
                          "meta_rule_id": meta_rule_id}, args=request.json)
 
         }
         :internal_api: set_meta_rules
         """
-        return call(ctx={"method": "set_meta_rules",
+        return call("security_router", ctx={"method": "set_meta_rules",
                          "user_id": user_id,
                          "meta_rule_id": meta_rule_id}, args=request.json)
 
         }
         :internal_api: delete_meta_rules
         """
-        return call(ctx={"method": "delete_meta_rules",
+        return call("security_router", ctx={"method": "delete_meta_rules",
                          "user_id": user_id,
                          "meta_rule_id": meta_rule_id}, args=request.json)
 
 
 from flask_restful import Resource
 from oslo_config import cfg
 from oslo_log import log as logging
-from moon_interface.tools import call
+from moon_utilities.security_functions import call
 from moon_interface.tools import check_auth
 
 __version__ = "0.1.0"
         }
         :internal_api: get_models
         """
-        return call(ctx={"id": uuid, "method": "get_models", "user_id": user_id}, args={})
+        return call("security_router", ctx={"id": uuid, "method": "get_models", "user_id": user_id}, args={})
 
     @check_auth
     def post(self, uuid=None, user_id=None):
         }
         :internal_api: add_model
         """
-        return call(ctx={"id": uuid, "method": "add_model", "user_id": user_id}, args=request.json)
+        return call("security_router", ctx={"id": uuid, "method": "add_model", "user_id": user_id}, args=request.json)
 
     @check_auth
     def delete(self, uuid=None, user_id=None):
         }
         :internal_api: delete_model
         """
-        return call(ctx={"id": uuid, "method": "delete_model", "user_id": user_id}, args={})
+        return call("security_router", ctx={"id": uuid, "method": "delete_model", "user_id": user_id}, args={})
 
     @check_auth
     def patch(self, uuid=None, user_id=None):
         }
         :internal_api: update_model
         """
-        return call(ctx={"id": uuid, "method": "update_model", "user_id": user_id}, args=request.json)
+        return call("security_router", ctx={"id": uuid, "method": "update_model", "user_id": user_id}, args=request.json)
 
 
 from flask_restful import Resource
 from oslo_config import cfg
 from oslo_log import log as logging
-from moon_interface.tools import call
+from moon_utilities.security_functions import call
 from moon_interface.tools import check_auth
 
 __version__ = "0.1.0"
         }
         :internal_api: get_pdp
         """
-        return call(ctx={"id": uuid, "method": "get_pdp", "user_id": user_id}, args={})
+        return call("security_router", ctx={"id": uuid, "method": "get_pdp", "user_id": user_id}, args={})
 
     @check_auth
     def post(self, uuid=None, user_id=None):
         }
         :internal_api: add_pdp
         """
-        return call(ctx={"id": uuid, "method": "add_pdp", "user_id": user_id}, args=request.json)
+        return call("security_router", ctx={"id": uuid, "method": "add_pdp", "user_id": user_id}, args=request.json)
 
     @check_auth
     def delete(self, uuid=None, user_id=None):
         }
         :internal_api: delete_pdp
         """
-        return call(ctx={"id": uuid, "method": "delete_pdp", "user_id": user_id}, args={})
+        return call("security_router", ctx={"id": uuid, "method": "delete_pdp", "user_id": user_id}, args={})
 
     @check_auth
     def patch(self, uuid=None, user_id=None):
         }
         :internal_api: update_pdp
         """
-        return call(ctx={"id": uuid, "method": "update_pdp", "user_id": user_id}, args=request.json)
+        return call("security_router", ctx={"id": uuid, "method": "update_pdp", "user_id": user_id}, args=request.json)
 
 
 from flask_restful import Resource
 from oslo_config import cfg
 from oslo_log import log as logging
-from moon_interface.tools import call
+from moon_utilities.security_functions import call
 from moon_interface.tools import check_auth
 
 __version__ = "0.2.0"
         }
         :internal_api: get_subjects
         """
-        return call(ctx={"id": uuid, "method": "get_subjects", "user_id": user_id}, args={"perimeter_id": perimeter_id})
+        return call("security_router", ctx={"id": uuid, "method": "get_subjects", "user_id": user_id}, args={"perimeter_id": perimeter_id})
 
     @check_auth
     def post(self, uuid=None, perimeter_id=None, user_id=None):
         }
         :internal_api: set_subject
         """
-        return call(ctx={"id": uuid, "method": "set_subject", "user_id": user_id, "perimeter_id": None},
+        return call("security_router", ctx={"id": uuid, "method": "set_subject", "user_id": user_id, "perimeter_id": None},
                     args=request.json)
 
     @check_auth
         }
         :internal_api: set_subject
         """
-        return call(ctx={"id": uuid, "method": "set_subject", "user_id": user_id, "perimeter_id": perimeter_id},
+        return call("security_router", ctx={"id": uuid, "method": "set_subject", "user_id": user_id, "perimeter_id": perimeter_id},
                     args=request.json)
 
     @check_auth
         }
         :internal_api: delete_subject
         """
-        return call(ctx={"id": uuid, "method": "delete_subject", "user_id": user_id}, args={"perimeter_id": perimeter_id})
+        return call("security_router", ctx={"id": uuid, "method": "delete_subject", "user_id": user_id}, args={"perimeter_id": perimeter_id})
 
 
 class Objects(Resource):
         }
         :internal_api: get_objects
         """
-        return call(ctx={"id": uuid, "method": "get_objects", "user_id": user_id}, args={"perimeter_id": perimeter_id})
+        return call("security_router", ctx={"id": uuid, "method": "get_objects", "user_id": user_id}, args={"perimeter_id": perimeter_id})
 
     @check_auth
     def post(self, uuid=None, perimeter_id=None, user_id=None):
         }
         :internal_api: set_object
         """
-        return call(ctx={"id": uuid, "method": "set_object", "user_id": user_id, "perimeter_id": None},
+        return call("security_router", ctx={"id": uuid, "method": "set_object", "user_id": user_id, "perimeter_id": None},
                     args=request.json)
 
     @check_auth
         }
         :internal_api: set_object
         """
-        return call(ctx={"id": uuid, "method": "set_object", "user_id": user_id, "perimeter_id": perimeter_id},
+        return call("security_router", ctx={"id": uuid, "method": "set_object", "user_id": user_id, "perimeter_id": perimeter_id},
                     args=request.json)
 
     @check_auth
         }
         :internal_api: delete_object
         """
-        return call(ctx={"id": uuid, "method": "delete_object", "user_id": user_id}, args={"perimeter_id": perimeter_id})
+        return call("security_router", ctx={"id": uuid, "method": "delete_object", "user_id": user_id}, args={"perimeter_id": perimeter_id})
 
 
 class Actions(Resource):
         }
         :internal_api: get_actions
         """
-        return call(ctx={"id": uuid, "method": "get_actions", "user_id": user_id}, args={"perimeter_id": perimeter_id})
+        return call("security_router", ctx={"id": uuid, "method": "get_actions", "user_id": user_id}, args={"perimeter_id": perimeter_id})
 
     @check_auth
     def post(self, uuid=None, perimeter_id=None, user_id=None):
         }
         :internal_api: set_action
         """
-        return call(ctx={"id": uuid, "method": "set_action", "user_id": user_id, "perimeter_id": None},
+        return call("security_router", ctx={"id": uuid, "method": "set_action", "user_id": user_id, "perimeter_id": None},
                     args=request.json)
 
     @check_auth
         }
         :internal_api: set_action
         """
-        return call(ctx={"id": uuid, "method": "set_action", "user_id": user_id, "perimeter_id": perimeter_id},
+        return call("security_router", ctx={"id": uuid, "method": "set_action", "user_id": user_id, "perimeter_id": perimeter_id},
                     args=request.json)
 
     @check_auth
         }
         :internal_api: delete_action
         """
-        return call(ctx={"id": uuid, "method": "delete_action", "user_id": user_id}, args={"perimeter_id": perimeter_id})
+        return call("security_router", ctx={"id": uuid, "method": "delete_action", "user_id": user_id}, args={"perimeter_id": perimeter_id})
 
 from flask_restful import Resource
 from oslo_config import cfg
 from oslo_log import log as logging
-from moon_interface.tools import call
+from moon_utilities.security_functions import call
 from moon_interface.tools import check_auth
 
 __version__ = "0.1.0"
         }
         :internal_api: get_policies
         """
-        return call(ctx={"id": uuid, "method": "get_policies", "user_id": user_id}, args={})
+        return call("security_router", ctx={"id": uuid, "method": "get_policies", "user_id": user_id}, args={})
 
     @check_auth
     def post(self, uuid=None, user_id=None):
         }
         :internal_api: add_policy
         """
-        return call(ctx={"id": uuid, "method": "add_policy", "user_id": user_id}, args=request.json)
+        return call("security_router", ctx={"id": uuid, "method": "add_policy", "user_id": user_id}, args=request.json)
 
     @check_auth
     def delete(self, uuid=None, user_id=None):
         }
         :internal_api: delete_policy
         """
-        return call(ctx={"id": uuid, "method": "delete_policy", "user_id": user_id}, args={})
+        return call("security_router", ctx={"id": uuid, "method": "delete_policy", "user_id": user_id}, args={})
 
     @check_auth
     def patch(self, uuid=None, user_id=None):
         }
         :internal_api: update_policy
         """
-        return call(ctx={"id": uuid, "method": "update_policy", "user_id": user_id}, args=request.json)
+        return call("security_router", ctx={"id": uuid, "method": "update_policy", "user_id": user_id}, args=request.json)
 
 
 from flask_restful import Resource
 from oslo_config import cfg
 from oslo_log import log as logging
-from moon_interface.tools import call
+from moon_utilities.security_functions import call
 from moon_interface.tools import check_auth
 
 __version__ = "0.1.0"
         }
         :internal_api: get_rules
         """
-        return call(ctx={"id": uuid,
+        return call("security_router", ctx={"id": uuid,
                          "method": "get_rules",
                          "user_id": user_id,
                          "rule_id": rule_id}, args={})
         }
         :internal_api: add_rule
         """
-        return call(ctx={"id": uuid,
+        return call("security_router", ctx={"id": uuid,
                          "method": "add_rule",
                          "user_id": user_id,
                          "rule_id": rule_id}, args=request.json)
         :return: { "result": true }
         :internal_api: delete_rule
         """
-        return call(ctx={"id": uuid,
+        return call("security_router", ctx={"id": uuid,
                          "method": "delete_rule",
                          "user_id": user_id,
                          "rule_id": rule_id}, args={})
 
 TOKENS = {}
 
 
-def timeit(function):
-    def wrapper(*args, **kwargs):
-        LOG.info("Calling {} with {} {}...".format(function, args, kwargs))
-        ret = function(*args, **kwargs)
-        LOG.info("End of {}".format(function))
-        return ret
-    return wrapper
-
-
-def call(topic="security_router", ctx=None, method="route", **kwargs):
-    if not ctx:
-        ctx = dict()
-    transport = oslo_messaging.get_transport(CONF)
-    target = oslo_messaging.Target(topic=topic, version='1.0')
-    client = oslo_messaging.RPCClient(transport, target)
-    LOG.info("Calling {} on {}...".format(method, topic))
-    return client.call(ctx, method, **kwargs)
-
-
 def check_token(token, url=None):
     _verify = False
     if CONF.keystone.server_crt: