Ignore:
Timestamp:
01/04/10 14:54:25 (10 years ago)
Author:
pjkersha
Message:

Refactored functions package to enable dynamic creation of function classes for all the XACML primitive types for any given function e.g. equal module implements EqualBase? and dynamically creates the <type>-equal classes for all the types: string, AnyURI, Boolean etc.

Location:
TI12-security/trunk/NDG_XACML
Files:
3 added
1 deleted
17 edited

Legend:

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

    r6746 r6796  
    1010__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1111__revision__ = "$Id: $" 
    12 class XACMLError(Exception): 
     12class XacmlError(Exception): 
    1313    """Base class for XACML package exception types""" 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/apply.py

    r6753 r6796  
    1212from ndg.xacml.utils import TypedList 
    1313from ndg.xacml.core.expression import Expression 
     14from ndg.xacml.core.functions import FunctionMap 
     15from ndg.xacml.core.exceptions import (UnsupportedStdFunctionError, 
     16                                       UnsupportedFunctionError) 
    1417 
    1518 
     
    1922    FUNCTION_ID_ATTRIB_NAME = 'FunctionId' 
    2023     
    21     __slots__ = ('__functionId', '__expressions') 
     24    __slots__ = ( 
     25        '__functionId',  
     26        '__function',  
     27        '__functionMap', 
     28        '__loadFunctionFromId', 
     29        '__expressions' 
     30    ) 
    2231     
    2332    def __init__(self): 
    2433        super(Apply, self).__init__() 
    2534        self.__functionId = None 
     35        self.__function = None 
     36        self.__functionMap = FunctionMap.withLoadedMap() 
     37        self.__loadFunctionFromId = True 
    2638        self.__expressions = TypedList(Expression) 
     39       
     40    @property 
     41    def loadFunctionFromId(self): 
     42        """Set to False to stop the functionId property set method automatically 
     43        trying to load the corresponding function for the given functionId"""  
     44        return self.__loadFunctionFromId 
     45     
     46    @loadFunctionFromId.setter 
     47    def loadFunctionFromId(self, value): 
     48        if not isinstance(value, bool): 
     49            raise TypeError('Expecting %r type for "loadFunctionFromId" ' 
     50                            'attribute; got %r' % (bool, type(value))) 
     51             
     52        self.__functionId = value 
    2753         
    2854    def _get_functionId(self): 
     
    3460                            'attribute; got %r' % (basestring, type(value))) 
    3561             
    36         self.__functionId = value    
     62        self.__functionId = value 
     63         
     64        # Also retrieve function for this function ID if a map has been set 
     65        if self.__loadFunctionFromId: 
     66            self.setFunctionFromMap(self.__functionMap)    
    3767 
    3868    functionId = property(_get_functionId, _set_functionId, None,  
    3969                          "Apply type Function ID")  
     70         
     71    def setFunctionFromMap(self, functionMap): 
     72        """Set the function from a function map - a dictionary of function ID to 
     73        function mappings.  The function is looked up based on the "functionId" 
     74        attribute.  This method is automatically called when the functionId set 
     75        property method is invoked.  To switch off this behaviour set 
     76         
     77        loadFunctionFromId = False 
     78         
     79        @raise UnsupportedStdFunctionError: policy references a function type  
     80        which is in the XACML spec. but is not supported by this implementation 
     81        @raise UnsupportedFunctionError: policy references a function type which 
     82        is not supported by this implementation 
     83        """ 
     84        if self.functionId is None: 
     85            raise AttributeError('"functionId" attribute must be set in order ' 
     86                                 'to retrieve the required function') 
     87             
     88        # Get function for this <Apply> statement          
     89        func = functionMap.get(self.functionId) 
     90        if func is NotImplemented: 
     91            raise UnsupportedStdFunctionError('No match function ' 
     92                                              'implemented for MatchId="%s"' %  
     93                                              self.functionId) 
     94        elif func is None: 
     95            raise UnsupportedFunctionError('<Apply> function namespace %r is ' 
     96                                           'not recognised' %  
     97                                           self.functionId)  
     98             
     99        self.__function = func 
    40100     
     101    @property 
     102    def functionMap(self): 
     103        """functionMap object for PDP to retrieve functions from given XACML 
     104        function URNs""" 
     105        return self.__functionMap 
     106     
     107    @functionMap.setter 
     108    def functionMap(self, value): 
     109        '''functionMap object for PDP to retrieve functions from given XACML 
     110        function URNs''' 
     111        if not isinstance(value, FunctionMap): 
     112            raise TypeError('Expecting %r derived type for "functionMap" ' 
     113                            'input; got %r instead' % (FunctionMap,  
     114                                                       type(value))) 
     115        self.__functionMap = value 
     116           
     117    @property   
     118    def function(self): 
     119        "Function for this <Apply> instance" 
     120        return self.__function 
     121         
    41122    @property 
    42123    def expressions(self): 
    43124        """List of expression sub-elements""" 
    44125        return self.__expressions  
     126     
     127    def evaluate(self, context): 
     128        """Evaluate a given <Apply> statement in a rule condition 
     129         
     130        @param context: the request context 
     131        @type context: ndg.xacml.core.context.request.Request 
     132        @return: attribute value(s) resulting from execution of this expression 
     133        in a condition 
     134        @rtype: AttributeValue/NoneType 
     135        """  
     136         
     137        # Marshall inputs 
     138        funcInputs = ['']*len(self.expressions) 
     139 
     140        for i, expression in enumerate(self.expressions): 
     141            funcInputs[i] = expression.evaluate(context) 
     142             
     143        # Execute function on the retrieved inputs 
     144        result = func(funcInputs) 
     145         
     146        # Pass the result back to the parent <Apply> element 
     147        return result 
    45148           
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/attributedesignator.py

    r6792 r6796  
    1010__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1111__revision__ = "$Id: $" 
     12from ndg.xacml.utils import TypedList 
    1213from ndg.xacml.core.expression import Expression 
     14from ndg.xacml.core.attributevalue import AttributeValue 
     15from ndg.xacml.core.context.request import Request 
     16from ndg.xacml.core.context.exceptions import MissingAttributeError 
    1317 
    1418 
     
    6973             
    7074        self.__mustBePresent = value         
    71  
    72      
    73     def evaluate(self, context): 
    74         """Evaluate the result of the expression in a condition 
    75          
    76         TODO: implement this placeholder 
    77          
    78         @param context: the request context 
    79         @type context: ndg.xacml.core.context.request.Request 
    80         @return: attribute value(s) resulting from execution of this expression 
    81         in a condition 
    82         @rtype: AttributeValue/NoneType   
    83         """  
    84         return self.__value 
    85          
     75                 
    8676         
    8777class SubjectAttributeDesignator(AttributeDesignator): 
    8878    """XACML Subject Attribute Designator type""" 
    8979    ELEMENT_LOCAL_NAME = 'SubjectAttributeDesignator' 
     80 
     81    def evaluate(self, context): 
     82        """Evaluate the result of the SubjectAttributeDesignator in a condition 
     83         
     84        @param context: the request context 
     85        @type context: ndg.xacml.core.context.request.Request 
     86        @return: attribute value(s) resulting from execution of this expression 
     87        in a condition 
     88        @rtype: AttributeValue/NoneType   
     89        """  
     90        if not isinstance(context, Request): 
     91            raise TypeError('Expecting %r type for context input; got %r' % 
     92                            (Request, type(context))) 
     93         
     94        attributeValueBag = TypedList(AttributeValue) 
     95        dataType = self.dataType 
     96        attributeId = self.attributeId 
     97        issuer = self.issuer 
     98         
     99        if issuer is not None: 
     100            _issuerMatch = lambda _issuer: issuer == _issuer 
     101        else: 
     102            _issuerMatch = lambda _issuer: True 
     103         
     104        _attributeMatch = lambda attr: (attr.attributeId == attributeId and  
     105                                        attr.dataType == dataType and 
     106                                        _issuerMatch(attr.issuer)) 
     107                                         
     108        for subject in context.subjects:   
     109            for attr in subject.attributes: 
     110                if _attributeMatch(attr): 
     111                    attributeValueBag.extend([i for i in attr.attributeValues 
     112                                              if i.dataType == dataType]) 
     113                     
     114        if len(attributeValueBag) == 0 and self.mustBePresent: 
     115            raise MissingAttributeError('"MustBePresent" is set for %r but no ' 
     116                                        'match for attributeId=%r, dataType=%r ' 
     117                                        'and issuer=%r' %  
     118                                        (self.__class__.__name__, 
     119                                         self.attributeId, 
     120                                         self.dataType, 
     121                                         self.issuer))  
     122                         
     123        return attributeValueBag 
    90124         
    91125         
     
    94128    ELEMENT_LOCAL_NAME = 'ResourceAttributeDesignator' 
    95129     
     130    def evaluate(self, context): 
     131        """Evaluate the result of the ResourceAttributeDesignator in a condition 
     132         
     133        @param context: the request context 
     134        @type context: ndg.xacml.core.context.request.Request 
     135        @return: attribute value(s) resulting from execution of this expression 
     136        in a condition 
     137        @rtype: AttributeValue/NoneType   
     138        """  
     139        if not isinstance(context, Request): 
     140            raise TypeError('Expecting %r type for context input; got %r' % 
     141                            (Request, type(context))) 
     142         
     143        attributeValueBag = TypedList(AttributeValue) 
     144        dataType = self.dataType 
     145        attributeId = self.attributeId 
     146        issuer = self.issuer 
     147         
     148        if issuer is not None: 
     149            _issuerMatch = lambda _issuer: issuer == _issuer 
     150        else: 
     151            _issuerMatch = lambda _issuer: True 
     152         
     153        _attributeMatch = lambda attr: (attr.attributeId == attributeId and  
     154                                        attr.dataType == dataType and 
     155                                        _issuerMatch(attr.issuer)) 
     156                     
     157        for resource in context.resources: 
     158            for attr in resource.attributes: 
     159                if _attributeMatch(attr): 
     160                    attributeValueBag.extend([i for i in attr.attributeValueBag 
     161                                              if i.dataType == dataType]) 
     162                     
     163        if len(attributeValueBag) == 0 and self.mustBePresent: 
     164            raise MissingAttributeError('"MustBePresent" is set for %r but no ' 
     165                                        'match for attributeId=%r, dataType=%r ' 
     166                                        'and issuer=%r' %  
     167                                        (self.__class__.__name__, 
     168                                         self.attributeId, 
     169                                         self.dataType, 
     170                                         self.issuer))  
     171                         
     172        return attributeValueBag     
     173     
    96174         
    97175class ActionAttributeDesignator(AttributeDesignator): 
     
    99177    ELEMENT_LOCAL_NAME = 'ActionAttributeDesignator' 
    100178     
     179    def evaluate(self, context): 
     180        """Evaluate the result of the ActionAttributeDesignator in a condition 
     181         
     182        @param context: the request context 
     183        @type context: ndg.xacml.core.context.request.Request 
     184        @return: attribute value(s) resulting from execution of this expression 
     185        in a condition 
     186        @rtype: AttributeValue/NoneType   
     187        """  
     188        if not isinstance(context, Request): 
     189            raise TypeError('Expecting %r type for context input; got %r' % 
     190                            (Request, type(context))) 
     191         
     192        attributeValueBag = TypedList(AttributeValue) 
     193        dataType = self.dataType 
     194        attributeId = self.attributeId 
     195        issuer = self.issuer 
     196        action = context.action 
     197         
     198        if issuer is not None: 
     199            _issuerMatch = lambda _issuer: issuer == _issuer 
     200        else: 
     201            _issuerMatch = lambda _issuer: True 
     202         
     203        _attributeMatch = lambda attr: (attr.attributeId == attributeId and  
     204                                        attr.dataType == dataType and 
     205                                        _issuerMatch(attr.issuer)) 
     206                     
     207        for attr in action.attributes: 
     208            if _attributeMatch(attr): 
     209                attributeValueBag.extend([i for i in attr.attributeValues 
     210                                          if i.dataType == dataType]) 
     211                     
     212        if len(attributeValueBag) == 0 and self.mustBePresent: 
     213            raise MissingAttributeError('"MustBePresent" is set for %r but no ' 
     214                                        'match for attributeId=%r, dataType=%r ' 
     215                                        'and issuer=%r' %  
     216                                        (self.__class__.__name__, 
     217                                         self.attributeId, 
     218                                         self.dataType, 
     219                                         self.issuer))  
     220                         
     221        return attributeValueBag     
     222     
    101223     
    102224class EnvironmentAttributeDesignator(AttributeDesignator): 
    103225    """XACML Environment Attribute Designator type""" 
    104226    ELEMENT_LOCAL_NAME = 'EnvironmentAttributeDesignator' 
     227     
     228    def evaluate(self, context): 
     229        """Evaluate the result of the EnvironmentAttributeDesignator in a  
     230        condition 
     231         
     232        @param context: the request context 
     233        @type context: ndg.xacml.core.context.request.Request 
     234        @return: attribute value(s) resulting from execution of this expression 
     235        in a condition 
     236        @rtype: AttributeValue/NoneType   
     237        """  
     238        if not isinstance(context, Request): 
     239            raise TypeError('Expecting %r type for context input; got %r' % 
     240                            (Request, type(context))) 
     241         
     242        attributeValueBag = [] 
     243        dataType = self.dataType 
     244        attributeId = self.attributeId 
     245        issuer = self.issuer 
     246        environment = context.environment 
     247         
     248        if issuer is not None: 
     249            _issuerMatch = lambda _issuer: issuer == _issuer 
     250        else: 
     251            _issuerMatch = lambda _issuer: True    
     252         
     253        _attributeMatch = lambda attr: (attr.attributeId == attributeId and  
     254                                        attr.dataType == dataType and 
     255                                        _issuerMatch(attr.issuer)) 
     256                  
     257        for attr in environment.attributes: 
     258            if _attributeMatch(attr): 
     259                attributeValueBag.extend([i for i in attr.attributeValues 
     260                                          if i.dataType == dataType]) 
     261                     
     262        if len(attributeValueBag) == 0 and self.mustBePresent: 
     263            raise MissingAttributeError('"MustBePresent" is set for %r but no ' 
     264                                        'match for attributeId=%r, dataType=%r ' 
     265                                        'and issuer=%r' %  
     266                                        (self.__class__.__name__, 
     267                                         self.attributeId, 
     268                                         self.dataType, 
     269                                         self.issuer))  
     270                         
     271        return attributeValueBag  
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/attributeselector.py

    r6754 r6796  
    5858                            'attribute; got %r' % (bool, type(value))) 
    5959             
    60         self.__mustBePresent = value         
     60        self.__mustBePresent = value  
     61 
     62    def evaluate(self, context): 
     63        """Placeholder to override abstract method and enable this class to be 
     64        instantiated.  However, AttributeSelectors are not fully implemented so 
     65        this method raises a not implemented error. 
     66        """ 
     67        raise NotImplementedError('PDP evaluation for AttributeSelectors is ' 
     68                                  'not currently implemented') 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/condition.py

    r6770 r6796  
    1515 
    1616class Condition(XacmlCoreBase): 
    17     """XACML Rule Condition""" 
     17    """XACML 2.0 Rule Condition Note the difference to XACML 1.0: the Condition  
     18    element is its own type and not an Apply type.  It expects a single  
     19    Expression derived type child element 
     20    """ 
    1821    ELEMENT_LOCAL_NAME = 'Condition' 
    1922    APPLY_ELEMENT_LOCAL_NAME = 'Apply' 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/context/__init__.py

    r6790 r6796  
    2626                                      'type') 
    2727     
    28      
     28    
    2929class RequestChildBase(XacmlContextBase): 
    3030    """Base class for XACML Context Subject, Resource, Action and Environment 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/context/pdp.py

    r6792 r6796  
    1515import traceback 
    1616 
     17from ndg.xacml.core.context.exceptions import XacmlContextError 
    1718from ndg.xacml.core.context.pdpinterface import PDPInterface 
    1819from ndg.xacml.core.policy import Policy 
    1920from ndg.xacml.core.apply import Apply 
    20 from ndg.xacml.core.attributevalue import AttributeValue 
    21 from ndg.xacml.core.variablereference import VariableReference 
    22 from ndg.xacml.core.attributedesignator import (AttributeDesignator, 
    23                                                 SubjectAttributeDesignator, 
    24                                                 ResourceAttributeDesignator, 
    25                                                 ActionAttributeDesignator, 
    26                                                 EnvironmentAttributeDesignator) 
    27 from ndg.xacml.core.attributeselector import AttributeSelector 
    2821from ndg.xacml.core.context.request import Request 
    2922from ndg.xacml.core.context.response import Response 
     
    3326                             
    3427 
    35 class PDPError(Exception): 
     28class PDPError(XacmlContextError): 
    3629    """Base class for PDP class exceptions""" 
    37     def __init__(self, *arg, **kw): 
    38         super(PDPError, self).__init__(*arg, **kw) 
    39         self.__response = Response() 
    40         self.__response.results.append(Result.createInitialised()) 
    41          
    42         self.__response.results[0].decision = Decision.INDETERMINATE 
    43         if len(arg) > 0: 
    44             self.__response.results[0].status.statusMessage = arg[0] 
    45          
    46     @property 
    47     def response(self): 
    48         """Context response object associated with this exception 
    49         """ 
    50         return self.__response 
    51      
    52     @response.setter 
    53     def response(self, value): 
    54         if not isinstance(value, Response): 
    55             raise TypeError('Expecting %r type for "response" attribute; got ' 
    56                             '%r instead' % (Response, type(Response))) 
    57         self.__response = value 
    58  
    59   
    60 class UnsupportedFunctionError(PDPError): 
    61     """Encountered a function type that is not supported in this implementation 
    62     """ 
    63     def __init__(self, *arg, **kw): 
    64         super(UnsupportedFunctionError, self).__init__(*arg, **kw) 
    65         self.response.results[0].status.statusCode.value = \ 
    66                                                     StatusCode.PROCESSING_ERROR 
    67  
    68  
    69 class UnsupportedStdFunctionError(UnsupportedFunctionError):  
    70     """Encountered a function type that is not supported even though it is part 
    71     of the XACML spec.""" 
    72   
     30      
    7331     
    7432class UnsupportedElementError(PDPError): 
     
    8442    implementation"""   
    8543     
    86  
    87 class MissingAttributeError(PDPError): 
    88     """AttributeDesignator or AttributeSelector has specified MustBePresent 
    89     but the request context contains no match for required attribute XPath 
    90     respectively 
    91     """ 
    92      
    9344     
    9445class PDP(PDPInterface): 
     
    9647    single policy but not policy sets 
    9748    """ 
    98     __slots__ = ('__policy', '__functionMap', '__request') 
     49    __slots__ = ('__policy', '__request') 
    9950    TARGET_CHILD_ATTRS = ('subjects', 'resources', 'actions', 'environments') 
    10051     
     
    11061             
    11162        self.__functionMap = FunctionMap.withLoadedMap() 
     63             
    11264        self.__request = None 
    11365 
     
    13890                            '%r instead' % (Policy, type(value))) 
    13991        self.__policy = value 
    140      
    141     @property 
    142     def functionMap(self): 
    143         """functionMap object for PDP to retrieve functions from given XACML 
    144         function URNs""" 
    145         return self.__functionMap 
    146      
    147     @functionMap.setter 
    148     def functionMap(self, value): 
    149         '''functionMap object for PDP to retrieve functions from given XACML 
    150         function URNs''' 
    151         if not isinstance(value, FunctionMap): 
    152             raise TypeError('Expecting %r derived type for "functionMap" ' 
    153                             'input; got %r instead' % (FunctionMap,  
    154                                                        type(value))) 
    155         self.__functionMap = value 
    156  
    157      
     92 
    15893    @property 
    15994    def request(self): 
     
    350285             
    351286            # Get the match function from the Match ID 
    352             matchFunc = self.functionMap.get(childMatch.matchId) 
     287            matchFunc = self.__functionMap.get(childMatch.matchId) 
    353288            if matchFunc is NotImplemented: 
    354289                raise UnsupportedStdFunctionError('No match function ' 
     
    403338                                  'target', 
    404339                                  attribute.attributeId, 
    405                                   attribute.attributeValue.value) 
     340                                  [a.value for a in attribute.attributeValues]) 
    406341                         
    407342            matchStatus = all(attrMatchStatusValues) 
     
    465400                                          'implementation' % applyElem) 
    466401          
    467         result = self.evaluateApplyStatement(applyElem) 
    468                  
    469     def evaluateApplyStatement(self, applyElem): 
    470         """Evaluate a given Condition <Apply> statement""" 
    471          
    472         # Get function for this <Apply> statement          
    473         func = self.functionMap.get(applyElem.functionId) 
    474         if func is NotImplemented: 
    475             raise UnsupportedStdFunctionError('No match function ' 
    476                                               'implemented for MatchId="%s"' 
    477                                               % applyElem.functionId) 
    478         elif func is None: 
    479             raise UnsupportedFunctionError('<Apply> function namespace %r is ' 
    480                                            'not recognised' %  
    481                                            applyElem.functionId) 
    482              
    483         inputMarshallerMap = { 
    484             Apply: self.evaluateApplyStatement, 
    485             AttributeValue: self.evaluateAttributeValueStatement, 
    486             SubjectAttributeDesignator: self.evaluateAttributeDesignator, 
    487             AttributeSelector: NotImplemented, 
    488             VariableReference: NotImplemented 
    489         }    
    490          
    491         # Marshall inputs 
    492         funcInputs = ['',]*len(applyElem.expressions) 
    493         for i, expression in enumerate(applyElem.expressions): 
    494             marshaller = inputMarshallerMap.get(expression.__class__) 
    495             if marshaller is NotImplemented: 
    496                 raise UnsupportedStdElementError('%r type <Apply> sub-element ' 
    497                                                  'processing is not supported ' 
    498                                                  'in this implementation' %  
    499                                                  expression) 
    500             elif marshaller is None: 
    501                 raise UnsupportedElementError('%r type <Apply> sub-element ' 
    502                                               'processing is not supported in ' 
    503                                               'this implementation' %  
    504                                               expression) 
    505              
    506             funcInputs[i] = marshaller(expression) 
    507              
    508         # Execute function on the retrieved inputs 
    509         result = func(*tuple(funcInputs)) 
    510          
    511         # Pass the result back to the parent <Apply> element 
    512         return result 
    513              
    514     evaluateAttributeValueStatement = lambda self, attributeValue: ( 
    515         attributeValue.value 
    516     ) 
    517      
    518     def evaluateAttributeDesignator(self, attributeDesignator): 
    519         '''Retrieve string attribute bag for a given attribute designator 
    520         TODO: possible refactor as AttributeDesignator or ContextHandler method 
    521         ''' 
    522         attributeValues = [] 
    523         dataType = attributeDesignator.dataType 
    524          
    525         if isinstance(attributeDesignator, SubjectAttributeDesignator): 
    526             for i in self.request.subjects: 
    527                 for j in i.attributes: 
    528                     attributeValues.extend([k.value for k in j.attributeValues 
    529                                             if k.dataType == dataType]) 
    530  
    531         elif isinstance(attributeDesignator, ResourceAttributeDesignator): 
    532             for i in self.request.resources: 
    533                 for j in i.attributes: 
    534                     attributeValues.extend([k.value for k in j.attributeValues 
    535                                             if k.dataType == dataType]) 
    536  
    537         elif isinstance(attributeDesignator, ActionAttributeDesignator): 
    538             for j in i.attributes: 
    539                 attributeValues.extend([k.value for k in j.attributeValues 
    540                                         if k.dataType == dataType]) 
    541              
    542         elif isinstance(attributeDesignator, EnvironmentAttributeDesignator): 
    543             for j in i.attributes: 
    544                 attributeValues.extend([k.value for k in j.attributeValues 
    545                                         if k.dataType == dataType]) 
    546         else: 
    547             raise TypeError('Expecting %r derived type got %r' % 
    548                             (AttributeDesignator, type(attributeDesignator))) 
    549                 
    550         if len(attributeValues) == 0 and attributeDesignator.mustBePresent: 
    551             raise MissingAttributeError('No match for AttributeDesignator ' 
    552                                         'attributeId=%r, dataType=%r and ' 
    553                                         'issuer=%r' %  
    554                                         (attributeDesignator.attributeId, 
    555                                          attributeDesignator.dataType, 
    556                                          attributeDesignator.issuer))  
    557                          
    558         return attributeValues 
    559  
     402        result = applyElem.evaluate(self.request) 
     403 
     404 
     405 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/functions/__init__.py

    r6794 r6796  
    1414from ndg.xacml.utils import VettedDict 
    1515from ndg.xacml.utils.factory import callModuleObject 
     16 
     17from datetime import datetime, timedelta 
     18 
     19TYPE_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} 
    1635 
    1736 
     
    336355                functionNameParts = functionName.split('-') 
    337356                 
    338                 moduleName = '_'.join(functionNameParts[1:]).lower() 
     357                if len(functionNameParts) == 1: 
     358                    moduleName = functionNameParts[0] 
     359                else: 
     360                    moduleName = '_'.join(functionNameParts[1:]).lower() 
     361                     
    339362                className = ''.join([n[0].upper() + n[1:]  
    340363                                     for n in functionNameParts]) 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/functions/v1/at_least_one_member_of.py

    r6794 r6796  
    99__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1010__revision__ = '$Id: $' 
    11 from ndg.xacml.core.functions import AbstractFunction 
    12 from ndg.xacml.utils import TypedList 
     11import sys 
     12 
     13from ndg.xacml.core.functions import AbstractFunction, TYPE_MAP 
     14from ndg.xacml.core.context.exceptions import XacmlContextError 
     15from ndg.xacml.utils import TypedList as Bag 
    1316 
    1417 
    15 class StringAtLeastOneMemberOf(AbstractFunction): 
    16     """Check a string is contained in the given bag 
     18class AtLeastOneMemberOfBase(AbstractFunction): 
     19    """Base class implementation for at least one member of XACML function - 
     20    check an item of a given type is contained in a given bag 
    1721     
    18     urn:oasis:names:tc:xacml:1.0:function:string-at-least-one-member-of 
     22    urn:oasis:names:tc:xacml:1.0:function:<type>-at-least-one-member-of 
    1923    """ 
    20     FUNCTION_NS = \ 
    21         'urn:oasis:names:tc:xacml:1.0:function:string-at-least-one-member-of' 
     24    TYPE = None 
     25    FUNCTION_SUFFIX = 'AtLeastOneMemberOf' 
     26    FUNCTION_NS_SUFFIX = '-at-least-one-member-of' 
    2227     
    23     def evaluate(self, str, bag): 
    24         """Check input string is contained in the input bag 
     28    def evaluate(self, item, bag): 
     29        """Check input is contained in the bag 
    2530         
    26         @param str: check to see if this string is contained in the bag 
    27         @type str: basestring 
    28         @param bag: bag of string values 
    29         @type bag: TypedList(basestring) 
     31        @param item: check to see if this string is contained in the bag 
     32        @type item: type 
     33        @param bag: bag of <type> values 
     34        @type bag: TypedList(<type>) 
    3035        @return: True if str is in bag, False otherwise 
    3136        @rtype: bool 
    3237        """ 
    33         if not isinstance(str, basestring): 
    34             raise TypeError('Expecting %r derived type for "str"; got %r' % 
    35                             (basestring, type(str))) 
     38        if not isinstance(item, self.__class__.TYPE): 
     39            raise XacmlContextError('Expecting %r derived type for "str"; ' 
     40                                    'got %r' % (self.__class__.TYPE, type(str))) 
    3641             
    37         if not isinstance(bag, TypedList): 
    38             raise TypeError('Expecting %r derived type for "bag"; got %r' % 
    39                             (TypedList, type(bag))) 
     42        if not isinstance(bag, Bag): 
     43            raise XacmlContextError('Expecting %r derived type for "bag"; got ' 
     44                                    '%r' % (Bag, type(bag))) 
    4045             
     46        if bag.elementType != self.__class__.TYPE: 
     47            raise XacmlContextError('Expecting %r type elements for "bag"; ' 
     48                                    'got %r' % 
     49                                    (self.__class__.TYPE, bag.elementType))             
    4150        return str in bag 
     51     
     52 
     53_thisModule = sys.modules[__name__] 
     54 
     55for typeName, _type in TYPE_MAP.items(): 
     56    className = typeName + AtLeastOneMemberOfBase.FUNCTION_SUFFIX 
     57    classVars = { 
     58        'TYPE': _type, 
     59        'FUNCTION_NS': AbstractFunction.V1_0_FUNCTION_NS + typeName[0 
     60            ].lower() + typeName[1:] + AtLeastOneMemberOfBase.FUNCTION_NS_SUFFIX 
     61    } 
     62    setattr(_thisModule,  
     63            className,  
     64            type(className, (AtLeastOneMemberOfBase, ), classVars))  
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/functions/v1/bag.py

    r6794 r6796  
    99__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1010__revision__ = '$Id: $' 
    11 from ndg.xacml.core.functions import AbstractFunction 
     11import sys 
     12 
     13from ndg.xacml.utils import TypedList as Bag 
     14from ndg.xacml.core.functions import AbstractFunction, TYPE_MAP 
    1215 
    1316 
    14 class StringBag(AbstractFunction): 
    15     """String bag function - 
     17class BagBase(AbstractFunction): 
     18    """Abstract bag function for all types of bag function 
    1619     
    17     urn:oasis:names:tc:xacml:1.0:function:string-bag 
     20    urn:oasis:names:tc:xacml:1.0:function:<type>-bag 
    1821    """ 
    19     FUNCTION_NS = 'urn:oasis:names:tc:xacml:1.0:function:string-bag' 
     22    TYPE = None 
     23    FUNCTION_SUFFIX = 'Bag' 
     24    FUNCTION_NS_SUFFIX = '-bag' 
    2025     
    21     def evaluate(self, string1, string2): 
    22         """Match input strings 
     26    def evaluate(self, *args): 
     27        """return inputs into a bag 
    2328         
    24         @param string1: first of two strings to match 
    25         @type string1: basestring 
     29        @param *args: inputs to add to bag 
     30        @type args: tuple 
    2631        @param string2: second string 
    2732        @type string2: basestring 
     
    2934        @rtype: bool 
    3035        """ 
    31         if not isinstance(string1, basestring): 
    32             raise TypeError('Expecting %r derived type for "string1"; got %r' % 
    33                             (basestring, type(string1))) 
     36        bag = Bag(self.__class__.TYPE) 
     37        for i in args: 
     38            if not isinstance(i, basestring): 
     39                raise TypeError('Expecting %r derived type for bag element; ' 
     40                                'got %r' % (self.__class__.TYPE, type(i))) 
     41            bag.append(i) 
     42         
    3443             
    35         if not isinstance(string2, basestring): 
    36             raise TypeError('Expecting %r derived type for "string2"; got %r' % 
    37                             (basestring, type(string2))) 
    38              
    39         return string1 == string2 
     44        return bag 
    4045 
     46 
     47_thisModule = sys.modules[__name__] 
     48 
     49for typeName, _type in TYPE_MAP.items(): 
     50    className = typeName + BagBase.FUNCTION_SUFFIX 
     51    classVars = { 
     52        'TYPE': _type, 
     53        'FUNCTION_NS': AbstractFunction.V1_0_FUNCTION_NS + typeName[0 
     54                ].lower() + typeName[1:] + BagBase.FUNCTION_NS_SUFFIX 
     55    } 
     56    setattr(_thisModule, className, type(className, (BagBase, ), classVars))  
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/functions/v1/equal.py

    r6795 r6796  
    99__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1010__revision__ = '$Id: $' 
     11from datetime import datetime, timedelta 
    1112from ndg.xacml.core.functions import AbstractFunction 
    1213 
     
    3536             
    3637        return string1 == string2 
     38 
     39 
     40# Dynamically create classes for all the types 
     41FUNCTION_CLASS_MAP = { 
     42    'StringEqual': { 
     43        'TYPE': basestring,  
     44        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:string-equal' 
     45    }, 
     46         
     47    'AnyURIEqual': { 
     48        'TYPE': basestring,  
     49        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:anyURI-equal' 
     50    }, 
     51         
     52    'IntegerEqual': { 
     53        'TYPE': int,  
     54        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:integer-equal' 
     55    }, 
     56         
     57    'BooleanEqual': { 
     58        'TYPE': basestring,  
     59        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:boolean-equal' 
     60    }, 
     61         
     62    'DoubleEqual': { 
     63        'TYPE': float,  
     64        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:double-equal'   
     65    }, 
     66         
     67    'DateEqual': { 
     68        'TYPE': datetime,  
     69        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:date-equal' 
     70    }, 
     71         
     72    'DateTimeEqual': { 
     73        'TYPE': datetime,  
     74        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:dateTime-equal' 
     75    }, 
     76         
     77    'TimeEqual': { 
     78        'TYPE': datetime,  
     79        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:time-equal' 
     80    }, 
     81         
     82    'DayTimeDurationEqual': { 
     83        'TYPE': timedelta,  
     84        'FUNCTION_NS': \ 
     85            'urn:oasis:names:tc:xacml:1.0:function:dayTimeDuration-equal' 
     86    }, 
    3787     
     88    'YearMonthDurationEqual': { 
     89        'TYPE': timedelta,  
     90        'FUNCTION_NS': \ 
     91            'urn:oasis:names:tc:xacml:1.0:function:yearMonthDuration-equal' 
     92    }, 
    3893     
    39 class StringEqual(EqualBase): 
    40     """String equal matching function - 
     94    'X500NameEqual': { 
     95        # TODO: refactor - basestring type is inadequate for X.500 name  
     96        # comparison 
     97        'TYPE': basestring,  
     98        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:x500Name-equal' 
     99    }, 
    41100     
    42     urn:oasis:names:tc:xacml:1.0:function:string-equal 
    43     """ 
    44     FUNCTION_NS = 'urn:oasis:names:tc:xacml:1.0:function:string-equal' 
    45     TYPE = basestring 
     101    'Rfc822NameEqual': { 
     102        # TODO: refactor - basestring type is inadequate for RFC822 name  
     103        # comparison 
     104        'TYPE': basestring,  
     105        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:rfc822Name-equal' 
     106    }, 
    46107     
     108    'HexBinaryEqual': { 
     109        'TYPE': int,  
     110        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:hexBinary-equal' 
     111    }, 
     112     
     113    'Base64BinaryEqual': { 
     114        'TYPE': int,  
     115        'FUNCTION_NS': \ 
     116            'urn:oasis:names:tc:xacml:1.0:function:base64Binary-equal' 
     117    } 
     118} 
    47119 
    48 class AnyURIEqual(EqualBase): 
    49     """Any URI equal matching function - 
    50      
    51     urn:oasis:names:tc:xacml:1.0:function:anyURI-equal 
    52     """ 
    53     FUNCTION_NS = 'urn:oasis:names:tc:xacml:1.0:function:anyURI-equal' 
    54     TYPE = basestring 
     120import sys 
     121_thisModule = sys.modules[__name__] 
    55122 
     123for className, classVars in FUNCTION_CLASS_MAP.items(): 
     124    setattr(_thisModule, className, type(className, (EqualBase, ), classVars)) 
     125 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/functions/v1/one_and_only.py

    r6794 r6796  
    99__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1010__revision__ = '$Id: $' 
     11from datetime import datetime, timedelta 
     12 
    1113from ndg.xacml.core.functions import AbstractFunction 
    1214from ndg.xacml.utils import TypedList as Bag 
     
    2628        if not isinstance(bag, Bag): 
    2729            raise XacmlContextError('Expecting %r derived type for "bag"; ' 
     30                                    'got %r' % (Bag, type(bag))) 
     31             
     32        if bag.elementType != self.__class__.BAG_TYPE: 
     33            raise XacmlContextError('Expecting %r type elements for "bag"; ' 
    2834                                    'got %r' % 
    29                                     (self.__class__.BAG_TYPE, type(bag))) 
    30              
     35                                    (self.__class__.BAG_TYPE, bag.elementType)) 
     36                         
    3137        nBagElems = len(bag) 
    3238        if nBagElems != 1: 
     
    3743        return bag[0] 
    3844     
     45# Dynamically create classes for all the types 
     46FUNCTION_CLASS_MAP = { 
     47    'StringOneAndOnly': { 
     48        'BAG_TYPE': basestring,  
     49        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:string-equal' 
     50    }, 
     51         
     52    'AnyURIOneAndOnly': { 
     53        'BAG_TYPE': basestring,  
     54        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:anyURI-equal' 
     55    }, 
     56         
     57    'IntegerOneAndOnly': { 
     58        'BAG_TYPE': int,  
     59        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:integer-equal' 
     60    }, 
     61         
     62    'BooleanOneAndOnly': { 
     63        'BAG_BAG_TYPE': basestring,  
     64        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:boolean-equal' 
     65    }, 
     66         
     67    'DoubleOneAndOnly': { 
     68        'BAG_TYPE': float,  
     69        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:double-equal'   
     70    }, 
     71         
     72    'DateOneAndOnly': { 
     73        'BAG_TYPE': datetime,  
     74        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:date-equal' 
     75    }, 
     76         
     77    'DateTimeOneAndOnly': { 
     78        'BAG_TYPE': datetime,  
     79        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:dateTime-equal' 
     80    }, 
     81         
     82    'TimeOneAndOnly': { 
     83        'BAG_TYPE': datetime,  
     84        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:time-equal' 
     85    }, 
     86         
     87    'DayTimeDurationOneAndOnly': { 
     88        'BAG_TYPE': timedelta,  
     89        'FUNCTION_NS': \ 
     90            'urn:oasis:names:tc:xacml:1.0:function:dayTimeDuration-equal' 
     91    }, 
    3992     
    40 class StringOneAndOnly(OneAndOnlyBase): 
    41     """XACML string one and only function implementation""" 
    42     FUNCTION_NS = 'urn:oasis:names:tc:xacml:1.0:function:string-one-and-only' 
    43     BAG_TYPE = basestring 
     93    'YearMonthDurationOneAndOnly': { 
     94        'BAG_TYPE': timedelta,  
     95        'FUNCTION_NS': \ 
     96            'urn:oasis:names:tc:xacml:1.0:function:yearMonthDuration-equal' 
     97    }, 
     98     
     99    'X500NameOneAndOnly': { 
     100        # TODO: refactor - basestring type is inadequate for X.500 name  
     101        # comparison 
     102        'BAG_TYPE': basestring,  
     103        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:x500Name-equal' 
     104    }, 
     105     
     106    'Rfc822NameOneAndOnly': { 
     107        # TODO: refactor - basestring type is inadequate for RFC822 name  
     108        # comparison 
     109        'BAG_TYPE': basestring,  
     110        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:rfc822Name-equal' 
     111    }, 
     112     
     113    'HexBinaryOneAndOnly': { 
     114        'BAG_TYPE': int,  
     115        'FUNCTION_NS': 'urn:oasis:names:tc:xacml:1.0:function:hexBinary-equal' 
     116    }, 
     117     
     118    'Base64BinaryOneAndOnly': { 
     119        'BAG_TYPE': int,  
     120        'FUNCTION_NS': \ 
     121            'urn:oasis:names:tc:xacml:1.0:function:base64Binary-equal' 
     122    } 
     123} 
     124 
     125import sys 
     126_thisModule = sys.modules[__name__] 
     127 
     128for className, classVars in FUNCTION_CLASS_MAP.items(): 
     129    setattr(_thisModule,  
     130            className,  
     131            type(className, (OneAndOnlyBase, ), classVars))    
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/__init__.py

    r6777 r6796  
    1414from abc import ABCMeta, abstractmethod 
    1515 
    16 from ndg.xacml import XACMLError 
     16from ndg.xacml import XacmlError 
    1717from ndg.xacml.core import XacmlCoreBase 
    1818 
    1919     
    20 class XMLParseError(XACMLError): 
     20class XMLParseError(XacmlError): 
    2121    """XACML package XML Parsing error""" 
    2222 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/attributedesignatorreader.py

    r6754 r6796  
    2929            if attributeValue is None: 
    3030                raise XMLParseError('No "%s" attribute found in "%s" element' % 
    31                                     (attributeName, xacmlType.ELEMENT_LOCAL_NAME)) 
     31                                    (attributeName,  
     32                                     xacmlType.ELEMENT_LOCAL_NAME)) 
    3233                 
    3334            attributeValues.append(attributeValue) 
     
    3637               
    3738        # Optional attributes 
    38         issuer = elem.attrib.get(xacmlType.DATA_TYPE_ATTRIB_NAME) 
     39        issuer = elem.attrib.get(xacmlType.ISSUER_ATTRIB_NAME) 
    3940        if issuer is not None: 
    4041            attributeDesignator.issuer = issuer 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/conditionreader.py

    r6753 r6796  
    1818 
    1919class ConditionReader(ETreeAbstractReader): 
    20     '''ElementTree based XACML Condition parser 
     20    '''ElementTree based XACML 2.0 Condition parser.  Note the difference to 
     21    XACML 1.0: the Condition element is its own type and not an Apply type. 
     22    It expects a single Expression derived type child element 
    2123     
    2224    @cvar TYPE: XACML type to instantiate from parsed object 
     
    3840             
    3941        # Parse expression sub-element 
    40         if len(elem) != 1: 
    41             raise XMLParseError("No expression sub element found in " 
    42                                 "Condition element") 
     42        nSubElem = len(elem) 
     43        if nSubElem != 1: 
     44            raise XMLParseError('XACML 2.0 policy schema expects only one ' 
     45                                'expression sub-element in the Condition ' 
     46                                'element; policy file has %d' % nSubElem) 
    4347         
    4448        subElemlocalName = QName.getLocalPart(elem[0].tag) 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/test/ndg1.xml

    r6792 r6796  
    5858            case 'urn:siteA:security:authz:1.0:attr:staff' 
    5959        --> 
    60         <Condition FunctionId="urn:oasis:names:tc:xacml:1.0:function:string-at-least-one-member-of"> 
    61             <SubjectAttributeDesignator  
    62                 AttributeId="urn:ndg:security:authz:1.0:attr"  
    63                 DataType="http://www.w3.org/2001/XMLSchema#string"/> 
    64             <Apply FunctionId="urn:oasis:names:tc:xacml:1.0:function:string-bag"> 
    65                 <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">staff</AttributeValue> 
    66                 <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">admin</AttributeValue> 
    67                 <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">postdoc</AttributeValue> 
     60        <Condition> 
     61            <Apply FunctionId="urn:oasis:names:tc:xacml:1.0:function:string-at-least-one-member-of"> 
     62                <SubjectAttributeDesignator  
     63                    AttributeId="urn:ndg:security:authz:1.0:attr"  
     64                    DataType="http://www.w3.org/2001/XMLSchema#string"/> 
     65                <Apply FunctionId="urn:oasis:names:tc:xacml:1.0:function:string-bag"> 
     66                    <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">staff</AttributeValue> 
     67                    <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">admin</AttributeValue> 
     68                    <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">postdoc</AttributeValue> 
     69                </Apply> 
    6870            </Apply> 
    6971        </Condition> 
     
    8284            </Resources> 
    8385        </Target> 
    84         <Condition FunctionId="urn:oasis:names:tc:xacml:1.0:function:string-at-least-one-member-of"> 
    85             <SubjectAttributeDesignator  
    86                 AttributeId="urn:ndg:security:authz:1.0:attr"  
    87                 DataType="http://www.w3.org/2001/XMLSchema#string"/> 
    88             <Apply FunctionId="urn:oasis:names:tc:xacml:1.0:function:string-bag"> 
    89                 <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">forbidden</AttributeValue> 
    90                 <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">keepout</AttributeValue> 
     86        <Condition> 
     87            <Apply FunctionId="urn:oasis:names:tc:xacml:1.0:function:string-at-least-one-member-of"> 
     88                <SubjectAttributeDesignator  
     89                    AttributeId="urn:ndg:security:authz:1.0:attr"  
     90                    DataType="http://www.w3.org/2001/XMLSchema#string"/> 
     91                <Apply FunctionId="urn:oasis:names:tc:xacml:1.0:function:string-bag"> 
     92                    <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">forbidden</AttributeValue> 
     93                    <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">keepout</AttributeValue> 
     94                </Apply> 
    9195            </Apply> 
    9296        </Condition> 
  • TI12-security/trunk/NDG_XACML/setup.py

    r6746 r6796  
    11#!/usr/bin/env python 
    22 
    3 """Distribution Utilities setup program for NDG Security Package 
     3"""NDG XACML 
    44 
    5 NERC Data Grid Project 
     5NERC DataGrid Project 
    66""" 
    77__author__ = "P J Kershaw" 
    8 __date__ = "24/04/06" 
    9 __copyright__ = "(C) 2009 Science and Technology Facilities Council" 
     8__date__ = "16/03/10" 
     9__copyright__ = "(C) 2010 Science and Technology Facilities Council" 
    1010__license__ = "BSD - see LICENSE file in top-level directory" 
    1111__contact__ = "Philip.Kershaw@stfc.ac.uk" 
     
    1515from ez_setup import use_setuptools 
    1616use_setuptools() 
    17  
    1817from setuptools import setup, find_packages 
    1918 
    20 import os, sys 
     19_longDescription = """\ 
     20XACML 2.0 implementation for the NERC DataGrid / CEDA (the Centre for  
     21Environmental Data Archival) STFC, Rutherford Appleton Laboratory. 
    2122 
    22 # Packages needed for NDG Security 
    23 # Note commented out ones fail with PyPI - use explicit link instead 
    24 # TODO: subdivide these into server and client specific and comon dependencies 
    25 _pkgDependencies = [ 
    26     ] 
    27  
    28  
    29 _longDescription = """\ 
    30 XACML implementation for the NERC DataGrid 
     23Only the parts of the specification currently required for CEDA have been  
     24implemented: 
     25 * there is incomplete support for <AttributeSelector>s, <VariableReference>,  
     26   <VariableDefinition>. <Obligations> 
     27 * only a few of the standard functions: see ndg.xacml.core.functions 
     28 * ... and attribute types: see ndg.xacml.core.attribute 
     29 * includes and ElementTree based parser for Policies. No support for writing 
     30   out policies or read/write of XML representation of <Request> and <Response> 
     31    
     32The structure is easily extensible to include new parsers, add more of the  
     33standard functions and attribute types  
    3134""" 
    3235 
    3336setup( 
    34     name =                      'ndg_security_common', 
    35     version =                   '1.5.1', 
    36     description =           'XACML implementation for the NERC DataGrid', 
     37    name =                      'NDG_XACML', 
     38    version =                   '0.1', 
     39    description =           'XACML 2.0 implementation for the NERC DataGrid', 
    3740    long_description =          _longDescription, 
    3841    author =                    'Philip Kershaw', 
     
    4245    url =                       'http://proj.badc.rl.ac.uk/ndg/wiki/Security', 
    4346    license =               'BSD - See LICENCE file for details', 
    44     install_requires =          _pkgDependencies, 
     47#    install_requires =         [], 
    4548    dependency_links =          ["http://ndg.nerc.ac.uk/dist"], 
    4649    packages =                  find_packages(), 
Note: See TracChangeset for help on using the changeset viewer.