github.com/anuvu/tyk@v2.9.0-beta9-dl-apic+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  
    47      def register_handlers(self):
    48          new_handlers = {}
    49          for attr in dir(self.module):
    50              attr_value = getattr(self.module, attr)
    51              if callable(attr_value):
    52                  attr_type = type(attr_value)
    53                  if attr_type in HandlerDecorators:
    54                      handler_type = attr_value.__class__.__name__.lower()
    55                      if handler_type not in new_handlers:
    56                          new_handlers[handler_type] = []
    57                      new_handlers[handler_type].append(attr_value)
    58          self.handlers = new_handlers
    59  
    60      def build_hooks_and_event_handlers(self):
    61          hooks = {}
    62          for hook_type in self.handlers:
    63              for handler in self.handlers[hook_type]:
    64                  handler.middleware = self
    65                  hooks[handler.name] = handler
    66                  tyk.log("Loading hook '{0}' ({1})".format(handler.name, self.filepath), "debug")
    67          return hooks
    68  
    69      def cleanup(self):
    70          sys.meta_path.pop()
    71          for m in self.imported_modules:
    72              del sys.modules[m]
    73  
    74      def process(self, handler, object):
    75          handlerType = type(handler)
    76  
    77          if handlerType == decorators.Event:
    78              handler(object, object.spec)
    79              return
    80          elif handler.arg_count == 4:
    81              md = object.session.metadata
    82              object.request, object.session, md = handler(object.request, object.session, md, object.spec)
    83              object.session.metadata.MergeFrom(md)
    84          elif handler.arg_count == 3:
    85              object.request, object.session = handler(object.request, object.session, object.spec)
    86          return object
    87  
    88      def parse_manifest(self):
    89          manifest_path = os.path.join(self.module_path, "manifest.json")
    90          with open(manifest_path, 'r') as f:
    91              self.manifest = json.load(f)