def register(self, gateways):
     '''
     Register the method override gateways based on the provided gateways.
     '''
     assert isinstance(gateways, Iterable), 'Invalid gateways %s' % gateways
     for gateway in gateways:
         assert isinstance(gateway, Gateway), 'Invalid gateway %s' % gateway
         yield gateway
         if not gateway.Methods: continue
         
         methods, overrides = set(), set()
         for method in gateway.Methods:
             override = self.methods_override.get(method)
             if override:
                 methods.add(method)
                 overrides.update(override)
         
         # If the override methods are already declared as methods we don't need to declare them anymore
         if methods.union(overrides).issubset(gateway.Methods): continue
             
         ogateway = Gateway()
         copy(gateway, ogateway, exclude=('Methods',))
         ogateway.Methods = list(overrides)
         if Gateway.Headers not in ogateway: ogateway.Headers = []
         for method in methods:
             ogateway.Headers.append(self.pattern_xmethod_override % method)
         yield ogateway
Example #2
0
    def process(self, chain, solicit: Solicit, **keyargs):
        '''
        @see: HandlerProcessor.process
        
        Adds the method override to gateways.
        '''
        assert isinstance(solicit, Solicit), 'Invalid solicit %s' % solicit
        if solicit.gateways is None: return

        gateways, indexed = [], {}
        for gateway in solicit.gateways:
            assert isinstance(gateway, Gateway), 'Invalid gateway %s' % gateway
            gateways.append(gateway)
            if not gateway.Methods: continue

            methods, overrides = set(), set()
            for method in gateway.Methods:
                override = self.methods_override.get(method)
                if override:
                    methods.add(method)
                    overrides.update(override)

            # If the override methods are already declared as methods we don't need to declare them anymore
            if methods.union(overrides).issubset(gateway.Methods): continue

            ogateway = Gateway()
            copyContainer(gateway, ogateway, exclude=self.excluded)
            ogateway.Methods = sorted(overrides)
            if ogateway.Headers is None: ogateway.Headers = []
            for method in methods:
                ogateway.Headers.append(self.pattern_xmethod_override % method)

            byPattern = indexed.get(ogateway.Pattern)
            if byPattern is None: byPattern = indexed[ogateway.Pattern] = []
            byPattern.append((overrides, ogateway))

        if indexed: solicit.gateways = self.iterOverrides(gateways, indexed)
        else: solicit.gateways = gateways
 def process(self, chain, solicit:Solicit, **keyargs):
     '''
     @see: HandlerProcessor.process
     
     Adds the method override to gateways.
     '''
     assert isinstance(solicit, Solicit), 'Invalid solicit %s' % solicit
     if solicit.gateways is None: return
     
     gateways, indexed = [], {}
     for gateway in solicit.gateways:
         assert isinstance(gateway, Gateway), 'Invalid gateway %s' % gateway
         gateways.append(gateway)
         if not gateway.Methods: continue
         
         methods, overrides = set(), set()
         for method in gateway.Methods:
             override = self.methods_override.get(method)
             if override:
                 methods.add(method)
                 overrides.update(override)
         
         # If the override methods are already declared as methods we don't need to declare them anymore
         if methods.union(overrides).issubset(gateway.Methods): continue
             
         ogateway = Gateway()
         copyContainer(gateway, ogateway, exclude=self.excluded)
         ogateway.Methods = sorted(overrides)
         if ogateway.Headers is None: ogateway.Headers = []
         for method in methods:
             ogateway.Headers.append(self.pattern_xmethod_override % method)
         
         byPattern = indexed.get(ogateway.Pattern)
         if byPattern is None: byPattern = indexed[ogateway.Pattern] = []
         byPattern.append((overrides, ogateway))
     
     if indexed: solicit.gateways = self.iterOverrides(gateways, indexed)
     else: solicit.gateways = gateways
Example #4
0
    def iterateGateways(self):
        '''
        Iterates all the custom database gateways.
        
        @return: Iterable(Gateway)
            The gateways for the custom database gateways.
        '''
        gateways = []
        for data in self.session().query(GatewayData).all():
            assert isinstance(data, GatewayData), 'Invalid data %s' % data

            gatewayData = json.loads(str(data.identifier, 'utf8'))
            gatewayData.update(json.loads(str(data.navigate, 'utf8')))
            gateways.append(copyContainer(gatewayData, Gateway()))

        return gateways
Example #5
0
 def processGateways(self, permissions, provider, encoder):
     '''
     Process the gateways for the provided permissions.
     
     @param permissions: Iterable(PermissionResource)
         The permissions to create the gateways for.
     @param provider: callable|None
         The callable used in solving the authenticated values.
     @param encoder: IEncoderPath
         The encoder path to be used for the gateways resource paths and patterns.
     @return: list[Gateway]
         The created gateways objects.
     '''
     assert isinstance(permissions, Iterable), 'Invalid permissions %s' % permissions
     assert isinstance(encoder, IEncoderPath), 'Invalid encoder path %s' % encoder
     
     gateways, gatewaysByPattern = [], {}
     for permission in permissions:
         assert isinstance(permission, PermissionResource), 'Invalid permission resource %s' % permission
         
         if PermissionResource.values in permission: values = permission.values
         else: values = None
         
         pattern, types = processPattern(permission.path, permission.invoker, encoder, values)
         filters = self.processFilters(types, permission.filters, provider, encoder)
         
         if PermissionResource.putHeaders in permission and permission.putHeaders is not None:
             putHeaders = [self.separatorHeader.join(item) for item in permission.putHeaders.items()]
         else: putHeaders = None
         
         if PermissionResource.navigate in permission: navigate = permission.navigate
         else: navigate = None
         
         gateway = gatewaysByPattern.get(pattern)
         if gateway and gateway.Filters == filters and gateway.PutHeaders == putHeaders and gateway.Navigate == navigate:
             gateway.Methods.append(TO_HTTP_METHOD[permission.method])
         else:
             gateway = Gateway()
             gateway.Methods = [TO_HTTP_METHOD[permission.method]]
             gateway.Pattern = pattern
             if filters: gateway.Filters = filters
             if putHeaders: gateway.PutHeaders = putHeaders
             if navigate: gateway.Navigate = navigate
             
             gatewaysByPattern[pattern] = gateway
             gateways.append(gateway)
     return gateways
Example #6
0
def gatewayFrom(config):
    '''
    Constructs a gateway from the provided configuration dictionary.
    
    @param config: dictionary{string, ...}
        The configurations dictionary to construct the gateway based on.
    @return: Gateway
        The constructed gateway.
    '''
    assert isinstance(config,
                      dict), 'Invalid gateway configuration %s' % config
    if __debug__: keys = set()
    gateway = Gateway()
    for key in ('Pattern', 'Headers', 'Methods', 'Filters', 'Errors', 'Host',
                'Protocol', 'Navigate'):
        value = config.get(key)
        if value is not None:
            if __debug__:
                if key == 'Pattern':
                    assert isinstance(value, str), 'Invalid Pattern %s' % value
                elif key == 'Headers':
                    assert isinstance(value,
                                      list), 'Invalid Headers %s' % value
                    for item in value:
                        assert isinstance(
                            item, str), 'Invalid Headers value %s' % item
                elif key == 'Methods':
                    assert isinstance(value,
                                      list), 'Invalid Methods %s' % value
                    for item in value:
                        assert isinstance(
                            item, str), 'Invalid Methods value %s' % item
                elif key == 'Filters':
                    assert isinstance(value,
                                      list), 'Invalid Filters %s' % value
                    for item in value:
                        assert isinstance(
                            item, str), 'Invalid Filters value %s' % item
                elif key == 'Errors':
                    assert isinstance(value, list), 'Invalid Errors %s' % value
                    for item in value:
                        assert isinstance(
                            item, int), 'Invalid Errors value %s' % item
                elif key == 'Host':
                    assert isinstance(value, str), 'Invalid Host %s' % value
                elif key == 'Protocol':
                    assert isinstance(value,
                                      str), 'Invalid Protocol %s' % value
                elif key == 'Navigate':
                    assert isinstance(value,
                                      str), 'Invalid Navigate %s' % value
                elif key == 'PutHeaders':
                    assert isinstance(value,
                                      list), 'Invalid PutHeaders %s' % value
                    for item in value:
                        assert isinstance(
                            item, str), 'Invalid PutHeaders value %s' % item

            setattr(gateway, key, value)
            assert keys.add(key) or True

    assert len(keys) == len(
        config), 'Invalid gateway configuration names: %s' % (', '.join(
            keys.difference(config)))
    return gateway
    def iterateGateways(self, permissions, rootURI=None, replacements=None):
        '''
        Iterate the gateways for permissions.
        '''
        assert isinstance(permissions,
                          Iterable), 'Invalid permissions %s' % permissions

        permissions = sorted(permissions, key=lambda perm: perm.access.Path)
        permissions.sort(key=lambda perm: perm.access.Priority)
        for perm in permissions:
            assert isinstance(perm, Permission), 'Invalid permission %s' % perm
            assert isinstance(
                perm.access,
                Access), 'Invalid permission access %s' % perm.access
            assert isinstance(
                perm.filters,
                dict), 'Invalid permission filters %s' % perm.filters
            assert isinstance(perm.access.Path,
                              str), 'Invalid access path %s' % perm.access.Path

            pattern = '%s[\\/]?(?:\\.|$)' % '([^\\/]+)'.join(
                re.escape(pitem) for pitem in perm.access.Path.split('*'))
            if rootURI:
                assert isinstance(rootURI,
                                  str), 'Invalid root URI %s' % rootURI
                pattern = '%s\/%s' % (re.escape(rootURI), pattern)

            gateway = Gateway()
            gateway.Pattern = '^%s' % pattern
            gateway.Methods = [perm.access.Method]

            filtersEntry = filtersProperty = None
            for pathsEntry, pathsProperty in perm.filters.values():
                assert isinstance(
                    pathsEntry,
                    dict), 'Invalid indexed path entries %s' % pathsEntry
                # If there is a group with no filters will automatically cancel all other groups filters.
                if filtersEntry is None: filtersEntry = pathsEntry
                elif filtersEntry:
                    nfilters = {}
                    for position, paths in pathsEntry.items():
                        assert isinstance(
                            paths, set), 'Invalid indexed paths %s' % paths
                        cpaths = filtersEntry.get(position)
                        if cpaths:
                            paths.update(cpaths)
                            nfilters[position] = paths
                    filtersEntry = nfilters

                if filtersProperty is None: filtersProperty = pathsProperty
                elif filtersProperty:
                    nfilters = {}
                    for name, paths in pathsProperty.items():
                        assert isinstance(
                            paths, set), 'Invalid indexed paths %s' % paths
                        cpaths = filtersProperty.get(name)
                        if cpaths:
                            paths.update(cpaths)
                            nfilters[position] = paths
                    filtersProperty = nfilters

                if not filtersEntry and not filtersProperty:
                    break  # There are no more filters to process.

            if filtersEntry:
                for position in sorted(filtersEntry):
                    for path in sorted(filtersEntry[position]):
                        if gateway.Filters is None: gateway.Filters = []
                        assert isinstance(path, str), 'Invalid path %s' % path
                        if replacements: path = path % replacements
                        if rootURI: path = '%s/%s' % (rootURI, path)
                        gateway.Filters.append('%s:%s' % (position, path))

            if filtersProperty:
                values = [PROPERTY_NAME]
                for name in sorted(filtersProperty):
                    paths = sorted(filtersProperty[name])
                    if rootURI:
                        for k, path in enumerate(paths):
                            if replacements: path = path % replacements
                            paths[k] = '%s/%s' % (rootURI, path)
                    values.append('%s=%s' % (name, '|'.join(paths)))
                if gateway.PutHeaders is None: gateway.PutHeaders = {}
                gateway.PutHeaders[HEADER_FILTER_INPUT] = ';'.join(values)

            if Permission.navigate in perm and perm.navigate:
                if replacements: path = perm.navigate % replacements
                else: path = perm.navigate
                if rootURI: path = '%s/%s' % (rootURI, path)
                gateway.Navigate = path

            yield gateway
 def iterateGateways(self, permissions, rootURI=None, replacements=None):
     '''
     Iterate the gateways for permissions.
     '''
     assert isinstance(permissions, Iterable), 'Invalid permissions %s' % permissions
     
     permissions = sorted(permissions, key=lambda perm: perm.access.Path)
     permissions.sort(key=lambda perm: perm.access.Priority)
     for perm in permissions:
         assert isinstance(perm, Permission), 'Invalid permission %s' % perm
         assert isinstance(perm.access, Access), 'Invalid permission access %s' % perm.access
         assert isinstance(perm.filters, dict), 'Invalid permission filters %s' % perm.filters
         assert isinstance(perm.access.Path, str), 'Invalid access path %s' % perm.access.Path
     
         pattern = '%s[\\/]?(?:\\.|$)' % '([^\\/]+)'.join(re.escape(pitem) for pitem in perm.access.Path.split('*'))
         if rootURI:
             assert isinstance(rootURI, str), 'Invalid root URI %s' % rootURI
             pattern = '%s\/%s' % (re.escape(rootURI), pattern)
         
         gateway = Gateway()
         gateway.Pattern = '^%s' % pattern
         gateway.Methods = [perm.access.Method]
         
         filtersEntry = filtersProperty = None
         for pathsEntry, pathsProperty in perm.filters.values():
             assert isinstance(pathsEntry, dict), 'Invalid indexed path entries %s' % pathsEntry
             # If there is a group with no filters will automatically cancel all other groups filters.
             if filtersEntry is None: filtersEntry = pathsEntry
             elif filtersEntry:
                 nfilters = {}
                 for position, paths in pathsEntry.items():
                     assert isinstance(paths, set), 'Invalid indexed paths %s' % paths
                     cpaths = filtersEntry.get(position)
                     if cpaths:
                         paths.update(cpaths)
                         nfilters[position] = paths
                 filtersEntry = nfilters
                 
             if filtersProperty is None: filtersProperty = pathsProperty
             elif filtersProperty:
                 nfilters = {}
                 for name, paths in pathsProperty.items():
                     assert isinstance(paths, set), 'Invalid indexed paths %s' % paths
                     cpaths = filtersProperty.get(name)
                     if cpaths:
                         paths.update(cpaths)
                         nfilters[position] = paths
                 filtersProperty = nfilters
             
             if not filtersEntry and not filtersProperty: break  # There are no more filters to process.
         
         if filtersEntry:
             for position in sorted(filtersEntry):
                 for path in sorted(filtersEntry[position]):
                     if gateway.Filters is None: gateway.Filters = []
                     assert isinstance(path, str), 'Invalid path %s' % path
                     if replacements: path = path % replacements
                     if rootURI: path = '%s/%s' % (rootURI, path)
                     gateway.Filters.append('%s:%s' % (position, path))
                     
         if filtersProperty:
             values = [PROPERTY_NAME]
             for name in sorted(filtersProperty):
                 paths = sorted(filtersProperty[name])
                 if rootURI:
                     for k, path in enumerate(paths): 
                         if replacements: path = path % replacements
                         paths[k] = '%s/%s' % (rootURI, path)
                 values.append('%s=%s' % (name, '|'.join(paths)))
             if gateway.PutHeaders is None: gateway.PutHeaders = {}
             gateway.PutHeaders[HEADER_FILTER_INPUT] = ';'.join(values)
             
         if Permission.navigate in perm and perm.navigate:
             if replacements: path = perm.navigate % replacements
             else: path = perm.navigate
             if rootURI: path = '%s/%s' % (rootURI, path)
             gateway.Navigate = path
             
         yield gateway
Example #9
0
    def processGateways(self, permissions, provider, encoder):
        '''
        Process the gateways for the provided permissions.
        
        @param permissions: Iterable(PermissionResource)
            The permissions to create the gateways for.
        @param provider: callable|None
            The callable used in solving the authenticated values.
        @param encoder: IEncoderPath
            The encoder path to be used for the gateways resource paths and patterns.
        @return: list[Gateway]
            The created gateways objects.
        '''
        assert isinstance(permissions,
                          Iterable), 'Invalid permissions %s' % permissions
        assert isinstance(encoder,
                          IEncoderPath), 'Invalid encoder path %s' % encoder

        gateways, gatewaysByPattern = [], {}
        for permission in permissions:
            assert isinstance(permission, PermissionResource
                              ), 'Invalid permission resource %s' % permission

            if PermissionResource.values in permission:
                values = permission.values
            else:
                values = None

            pattern, types = processPattern(permission.path,
                                            permission.invoker, encoder,
                                            values)
            filters = self.processFilters(types, permission.filters, provider,
                                          encoder)

            if PermissionResource.putHeaders in permission and permission.putHeaders is not None:
                putHeaders = [
                    self.separatorHeader.join(item)
                    for item in permission.putHeaders.items()
                ]
            else:
                putHeaders = None

            if PermissionResource.navigate in permission:
                navigate = permission.navigate
            else:
                navigate = None

            gateway = gatewaysByPattern.get(pattern)
            if gateway and gateway.Filters == filters and gateway.PutHeaders == putHeaders and gateway.Navigate == navigate:
                gateway.Methods.append(TO_HTTP_METHOD[permission.method])
            else:
                gateway = Gateway()
                gateway.Methods = [TO_HTTP_METHOD[permission.method]]
                gateway.Pattern = pattern
                if filters: gateway.Filters = filters
                if putHeaders: gateway.PutHeaders = putHeaders
                if navigate: gateway.Navigate = navigate

                gatewaysByPattern[pattern] = gateway
                gateways.append(gateway)
        return gateways