Changeset 6797 for TI12-security


Ignore:
Timestamp:
01/04/10 16:38:01 (10 years ago)
Author:
pjkersha
Message:

Added AttributeValueFactory? to generate <type>AttributeValue? classes.

Location:
TI12-security/trunk/NDG_XACML/ndg/xacml
Files:
6 edited
1 moved

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/apply.py

    r6796 r6797  
    142142             
    143143        # Execute function on the retrieved inputs 
    144         result = func(funcInputs) 
     144        result = self.function.evaluate(*tuple(funcInputs)) 
    145145         
    146146        # Pass the result back to the parent <Apply> element 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/attributevalue.py

    r6792 r6797  
    1010__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1111__revision__ = "$Id: $" 
     12from datetime import datetime, timedelta 
     13 
     14from ndg.xacml.utils import VettedDict 
    1215from ndg.xacml.core.expression import Expression 
    1316     
     
    1619    """XACML Attribute Value type""" 
    1720    ELEMENT_LOCAL_NAME = 'AttributeValue' 
     21    CLASS_NAME_SUFFIX = 'AttributeValue' 
     22    IDENTIFIER_PREFIX = 'http://www.w3.org/2001/XMLSchema#' 
     23    IDENTIFIER = None 
     24    TYPE_MAP = { 
     25        'String': basestring, 
     26        'AnyURI': basestring, 
     27        'Integer': int, 
     28        'Boolean': bool, 
     29        'Double': float, 
     30        'Date': datetime, 
     31        'DateTime': datetime, 
     32        'Time': datetime, 
     33        'DayTimeDuration': timedelta, 
     34        'YearMonthDuration': timedelta, 
     35        'X500Name': basestring, 
     36        'Rfc822Name': basestring, 
     37        'HexBinary': int, 
     38        'Base64Binary': NotImplemented 
     39    } 
     40    TYPE = None 
     41     
    1842    __slots__ = ('__value',)  
    1943     
     
    2650 
    2751    def _set_value(self, value): 
    28         if not isinstance(value, basestring): 
     52        if not isinstance(value, self.__class__.TYPE): 
    2953            raise TypeError('Expecting %r type for "value" ' 
    30                             'attribute; got %r' % (basestring, type(value))) 
     54                            'attribute; got %r' % (self.__class__.TYPE,  
     55                                                   type(value))) 
    3156             
    3257        self.__value = value   
     
    4368        """  
    4469        return self.__value 
     70 
     71 
     72class AttributeValueClassMap(VettedDict): 
     73    """Specialised dictionary to hold mappings of XML attribute type URIs to  
     74    their equivalent classes 
     75    """ 
     76     
     77    def __init__(self): 
     78        """Force entries to derive from AttributeValue and IDs to 
     79        be string type 
     80        """         
     81        # Filters are defined as staticmethods but reference via self here to  
     82        # enable derived class to override them as standard methods without 
     83        # needing to redefine this __init__ method             
     84        super(AttributeValueClassMap, self).__init__(self.keyFilter,  
     85                                                     self.valueFilter) 
     86         
     87    @staticmethod 
     88    def keyFilter(key): 
     89        """Enforce string type keys""" 
     90        if not isinstance(key, basestring): 
     91            raise TypeError('Expecting %r type for key; got %r' %  
     92                            (basestring, type(key)))  
     93        return True  
     94     
     95    @staticmethod 
     96    def valueFilter(value): 
     97        """Enforce AttributeValue derived types for values""" 
     98 
     99        if not issubclass(value, AttributeValue): 
     100            raise TypeError('Expecting %r derived type for value; got %r' %  
     101                            (AttributeValue, type(value)))  
     102        return True  
     103 
     104 
     105# Dynamically Create classes based on AttributeValue for all the XACML primitive 
     106# types 
     107_IDENTIFIER2CLASS_MAP = AttributeValueClassMap() 
     108 
     109for typeName, _type in AttributeValue.TYPE_MAP.items(): 
     110    identifier = AttributeValue.IDENTIFIER_PREFIX + typeName[0 
     111                                                        ].lower() + typeName[1:] 
     112 
     113    className = typeName + AttributeValue.CLASS_NAME_SUFFIX                
     114    classVars = {'TYPE': _type, 'IDENTIFIER_NS': identifier} 
     115     
     116    attributeValueClass = type(className, (AttributeValue, ), classVars) 
     117    AttributeValue.register(attributeValueClass) 
     118    _IDENTIFIER2CLASS_MAP[identifier] = attributeValueClass 
     119     
     120     
     121class AttributeValueFactory(object): 
     122    """Create AttributeValue types based on the XML namespace identifier 
     123     
     124    Convenience wrapper for _IDENTIFIER2CLASS_MAP instance of  
     125    AttributeValueClassMap 
     126    """ 
     127    def __init__(self, classMap=None): 
     128        if classMap is None: 
     129            self.__classMap = _IDENTIFIER2CLASS_MAP 
     130        elif isinstance(classMap, AttributeValueClassMap): 
     131            self.__classMap = classMap 
     132        else: 
     133            raise TypeError('Expecting %r derived type for "map" input; got %r' 
     134                            % (AttributeValueClassMap, type(map))) 
     135             
     136    def __call__(self, identifier): 
     137        """Return <type>AttributeValue class for given identifier URI or None 
     138        if no match is found 
     139        """ 
     140        return self.__classMap.get(identifier) 
     141         
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/context/pdp.py

    r6796 r6797  
    2424from ndg.xacml.core.context.result import StatusCode 
    2525from ndg.xacml.core.functions import FunctionMap 
    26                              
     26from ndg.xacml.core.exceptions import (UnsupportedStdFunctionError, 
     27                                       UnsupportedFunctionError)      
     28        
    2729 
    2830class PDPError(XacmlContextError): 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/functions/__init__.py

    r6796 r6797  
    1616 
    1717from datetime import datetime, timedelta 
    18  
    19 TYPE_MAP = { 
    20     'String': basestring, 
    21     'AnyURI': basestring, 
    22     'Integer': int, 
    23     'Boolean': bool, 
    24     'Double': float, 
    25     'Date': datetime, 
    26     'DateTime': datetime, 
    27     'Time': datetime, 
    28     'DayTimeDuration': timedelta, 
    29     'YearMonthDuration': timedelta, 
    30     'X500Name': basestring, 
    31     'Rfc822Name': basestring, 
    32     'HexBinary': int, 
    33     'Base64Binary': NotImplemented 
    34 } 
    3518 
    3619 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/functions/v1/at_least_one_member_of.py

    r6796 r6797  
    3838        if not isinstance(item, self.__class__.TYPE): 
    3939            raise XacmlContextError('Expecting %r derived type for "str"; ' 
    40                                     'got %r' % (self.__class__.TYPE, type(str))) 
     40                                    'got %r' % (self.__class__.TYPE,  
     41                                                type(item))) 
    4142             
    4243        if not isinstance(bag, Bag): 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/functions/v2/regexp_match.py

    r6792 r6797  
    1010__revision__ = '$Id: $' 
    1111import re 
     12import sys 
    1213 
    1314from ndg.xacml.core.functions import AbstractFunction 
    1415 
    1516 
    16 class AnyURIRegexpMatch(AbstractFunction): 
    17     """Any URI Regular Expression matching function 
     17class RegexpMatchBase(AbstractFunction): 
     18    """XACML 2.0 Regular Expression matching base class function 
    1819    """ 
    19     FUNCTION_NS = 'urn:oasis:names:tc:xacml:2.0:function:anyURI-regexp-match' 
     20    FUNCTION_NS = None 
     21    FUNCTION_NS_SUFFIX = '-regexp-match' 
     22    CLASS_NAME_SUFFIX = 'RegexpMatch' 
     23    TYPE = None 
     24    TYPE_MAP = {}.fromkeys( 
     25        ('AnyURI',  
     26        'IpAddress',  
     27        'DnsName', 
     28        'Rfc822Name', 
     29        'X500Name'), 
     30        basestring) 
    2031     
    21     def evaluate(self, uriPat, uri): 
     32    def evaluate(self, pat, input): 
    2233        """Match URI against regular expression pattern 
    2334         
    24         @param uriPat: regular expression 
    25         @type uriPat: basestring 
    26         @param uri: URI to match 
    27         @type uri: basestring 
     35        @param pat: regular expression 
     36        @type pat: basestring 
     37        @param input: URI to match 
     38        @type input: type 
    2839        @return: True if URI matches pattern, False otherwise 
    2940        @rtype: bool 
    3041        """ 
    31         if not isinstance(uriPat, basestring): 
    32             raise TypeError('Expecting %r derived type for "uriPat"; got %r' % 
    33                             (basestring, type(uri1))) 
     42        if not isinstance(pat, basestring): 
     43            raise TypeError('Expecting %r derived type for "pat"; got %r' % 
     44                            (basestring, type(pat))) 
    3445             
    35         if not isinstance(uri, basestring): 
    36             raise TypeError('Expecting %r derived type for "uri"; got %r' % 
    37                             (basestring, type(uri))) 
     46        if not isinstance(input, self.__class__.TYPE): 
     47            raise TypeError('Expecting %r derived type for "input"; got %r' % 
     48                            (self.__class__.TYPE, type(input))) 
    3849             
    39         return bool(re.match(uriPat, uri)) 
     50        return bool(re.match(pat, input)) 
    4051     
    41 #AbstractFunction.register(AnyURIRegexpMatch) 
     52_thisModule = sys.modules[__name__] 
     53 
     54for typeName, _type in RegexpMatchBase.TYPE_MAP.items(): 
     55    className = typeName + RegexpMatchBase.CLASS_NAME_SUFFIX 
     56    classVars = { 
     57        'TYPE': _type, 
     58        'FUNCTION_NS': AbstractFunction.V2_0_FUNCTION_NS + typeName[0 
     59            ].lower() + typeName[1:] + RegexpMatchBase.FUNCTION_NS_SUFFIX 
     60    } 
     61    setattr(_thisModule,  
     62            className,  
     63            type(className, (RegexpMatchBase, ), classVars))  
  • TI12-security/trunk/NDG_XACML/ndg/xacml/test/test_context.py

    r6792 r6797  
    2222from ndg.xacml.core.context.handler import AbstractContextHandler 
    2323from ndg.xacml.core.attribute import Attribute 
    24 from ndg.xacml.core.attributevalue import AttributeValue 
     24from ndg.xacml.core.attributevalue import AttributeValueFactory, AttributeValue 
    2525from ndg.xacml.core.context.request import Request 
    2626from ndg.xacml.core.context.response import Response 
     
    6161        subject = Subject() 
    6262         
     63        attributeValueFactory = AttributeValueFactory() 
     64         
    6365        openidSubjectAttribute = Attribute() 
    6466        roleAttribute = Attribute() 
     
    6769        openidSubjectAttribute.dataType = \ 
    6870                                    'http://www.w3.org/2001/XMLSchema#anyURI' 
    69         openidSubjectAttribute.attributeValues.append(AttributeValue()) 
     71        class MyAttributeValue(AttributeValue): 
     72            """My test class""" 
     73        openidSubjectAttribute.attributeValues.append(MyAttributeValue) 
     74        openidSubjectAttribute.attributeValues.append( 
     75            attributeValueFactory('http://www.w3.org/2001/XMLSchema#anyURI')) 
    7076        openidSubjectAttribute.attributeValues[-1].dataType = \ 
    7177                                    'http://www.w3.org/2001/XMLSchema#anyURI' 
Note: See TracChangeset for help on using the changeset viewer.