github.com/craicoverflow/tyk@v2.9.6-rc3+incompatible/coprocess/python/tyk/middleware.py (about)

     1  from importlib import invalidate_caches as invalidate_caches
     2  
     3  from types import ModuleType
     4  
     5  import imp, inspect, sys, os, json
     6  from time import sleep
     7  
     8  import tyk.decorators as decorators
     9  from tyk.loader import MiddlewareLoader
    10  from gateway import TykGateway as tyk
    11  
    12  HandlerDecorators = list( map( lambda m: m[1], inspect.getmembers(decorators, inspect.isclass) ) )
    13  
    14  class TykMiddleware:
    15      def __init__(self, filepath, bundle_root_path=None):
    16          tyk.log( "Loading module: '{0}'".format(filepath), "info")
    17          self.filepath = filepath
    18          self.handlers = {}
    19  
    20          self.bundle_id = filepath
    21          self.bundle_root_path = bundle_root_path
    22  
    23          self.imported_modules = []
    24          
    25          module_splits = filepath.split('_')
    26          self.api_id, self.middleware_id = module_splits[0], module_splits[1]
    27  
    28          self.module_path = os.path.join(self.bundle_root_path, filepath)
    29          self.parse_manifest()
    30  
    31          self.mw_path = os.path.join(self.module_path, "middleware.py")
    32  
    33          # Fallback for single file bundles:
    34          if len(self.manifest['file_list']) == 1:
    35              self.mw_path = os.path.join(self.module_path, self.manifest['file_list'][0])
    36  
    37          try:
    38              self.loader = MiddlewareLoader(self)
    39              sys.meta_path.append(self.loader)
    40              invalidate_caches()
    41              self.module = imp.load_source(filepath, self.mw_path)
    42              self.register_handlers()
    43              self.cleanup()
    44          except Exception as e:
    45              tyk.log_error("Middleware initialization error: {0}".format(e))
    46              pass
    47  
    48      def register_handlers(self):
    49          new_handlers = {}
    50          for attr in dir(self.module):
    51              attr_value = getattr(self.module, attr)
    52              if callable(attr_value):
    53                  attr_type = type(attr_value)
    54                  if attr_type in HandlerDecorators:
    55                      handler_type = attr_value.__class__.__name__.lower()
    56                      if handler_type not in new_handlers:
    57                          new_handlers[handler_type] = []
    58                      new_handlers[handler_type].append(attr_value)
    59          self.handlers = new_handlers
    60  
    61      def build_hooks_and_event_handlers(self):
    62          hooks = {}
    63          for hook_type in self.handlers:
    64              for handler in self.handlers[hook_type]:
    65                  handler.middleware = self
    66                  hooks[handler.name] = handler
    67                  tyk.log("Loading hook '{0}' ({1})".format(handler.name, self.filepath), "debug")
    68          return hooks
    69  
    70      def cleanup(self):
    71          sys.meta_path.pop()
    72          for m in self.imported_modules:
    73              del sys.modules[m]
    74  
    75      def process(self, handler, object):
    76          handlerType = type(handler)
    77  
    78          if handlerType == decorators.Event:
    79              handler(object, object.spec)
    80              return
    81          elif handler.arg_count == 4:
    82              md = object.session.metadata
    83              object.request, object.session, md = handler(object.request, object.session, md, object.spec)
    84              object.session.metadata.MergeFrom(md)
    85          elif handler.arg_count == 3:
    86              object.request, object.session = handler(object.request, object.session, object.spec)
    87          return object
    88  
    89      def parse_manifest(self):
    90          manifest_path = os.path.join(self.module_path, "manifest.json")
    91          with open(manifest_path, 'r') as f:
    92              self.manifest = json.load(f)