docs: def pipeline(self, config, request):
          """
          The pipeline() function handles authentication and invocation of
          the correct consumer based on the server configuration, that is
          provided at initialization time.
  
          When authentication is performed all the authenticators are
          executed. If any returns False, authentication fails and a 403
          error is raised. If none of them positively succeeds and they all
          return None then also authentication fails and a 403 error is
          raised. Authentication plugins can add attributes to the request
          object for use of authorization or other plugins.
  
          When authorization is performed and positive result will cause the
          operation to be accepted and any negative result will cause it to
          fail. If no authorization plugin returns a positive result a 403
          error is returned.
  
          Once authentication and authorization are successful the pipeline
          will parse the path component and find the consumer plugin that
          handles the provided path walking up the path component by
          component until a consumer is found.
  
          Paths are walked up from the leaf to the root, so if two consumers
          hang on the same tree, the one closer to the leaf will be used. If
          there is a trailing path when the conumer is selected then it will
          be stored in the request dicstionary named 'trail'. The 'trail' is
          an ordered list of the path components below the consumer entry
          point.
          """
          path_chain = request['path_chain']
          if not path_chain or path_chain[0] != '':
              # no path or not an absolute path
              raise HTTPError(400)
  
          # auth framework here
          authers = config.get('authenticators')
          if authers is None:
              raise HTTPError(403)
          valid_once = False
          for auth in authers:
              valid = authers[auth].handle(request)
              if valid is False:
                  raise HTTPError(403)
              elif valid is True:
                  valid_once = True
          if valid_once is not True:
              self.server.auditlog.svc_access(self.__class__.__name__,
                                              log.AUDIT_SVC_AUTH_FAIL,
                                              request['client_id'], 'No auth')
              raise HTTPError(403)
  
          # auhz framework here
          authzers = config.get('authorizers')
          if authzers is None:
              raise HTTPError(403)
          authz_ok = None
          for authz in authzers:
              valid = authzers[authz].handle(request)
              if valid is True:
                  authz_ok = True
              elif valid is False:
                  authz_ok = False
                  break
          if authz_ok is not True:
              self.server.auditlog.svc_access(self.__class__.__name__,
                                              log.AUDIT_SVC_AUTHZ_FAIL,
                                              request['client_id'],
                                              path_chain)
              raise HTTPError(403)
  
          # Select consumer
          trail = []
          while path_chain:
              if path_chain in config['consumers']:
                  con = config['consumers'][path_chain]
                  if len(trail) != 0:
                      request['trail'] = trail
                  return con.handle(request)
              trail.insert(0, path_chain[-1])
              path_chain = path_chain[:-1]
  
          raise HTTPError(404)