Changeset 6752


Ignore:
Timestamp:
19/03/10 10:39:33 (10 years ago)
Author:
pjkersha
Message:

Added parsing for Resource type and also a reader factory to return the reader class for a given XACML type.

Location:
TI12-security/trunk/NDG_XACML/ndg/xacml
Files:
6 added
13 edited

Legend:

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

    r6750 r6752  
    6868    """XACML Subject Attribute Designator type""" 
    6969    ELEMENT_LOCAL_NAME = 'SubjectAttributeDesignator' 
     70         
     71         
     72class ResourceAttributeDesignator(AttributeDesignator): 
     73    """XACML Resource Attribute Designator type""" 
     74    ELEMENT_LOCAL_NAME = 'ResourceAttributeDesignator' 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/actionreader.py

    r6747 r6752  
    1 ''' 
    2 Created on 16 Mar 2010 
     1"""NDG XACML ElementTree based parser for Action type 
    32 
    4 @author: pjkersha 
    5 ''' 
     3NERC DataGrid Project 
     4""" 
     5__author__ = "P J Kershaw" 
     6__date__ = "16/03/10" 
     7__copyright__ = "(C) 2010 Science and Technology Facilities Council" 
     8__contact__ = "Philip.Kershaw@stfc.ac.uk" 
     9__license__ = "BSD - see LICENSE file in top-level directory" 
     10__contact__ = "Philip.Kershaw@stfc.ac.uk" 
     11__revision__ = "$Id: $" 
     12from ndg.xacml.core.action import Action 
     13from ndg.xacml.parsers.etree.targetchildreader import TargetChildReader 
    614 
    7 class ActionReader: 
    8     pass 
     15 
     16class ActionReader(TargetChildReader): 
     17    '''ElementTree based parser for Action type 
     18    @cvar TYPE: XACML type to instantiate from parsed object 
     19    @type string: type 
     20    ''' 
     21    TYPE = Action     
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/attributedesignatorreader.py

    r6750 r6752  
    1111__revision__ = "$Id: $" 
    1212from ndg.xacml.utils import str2Bool 
    13 from ndg.xacml.core.attributedesignator import SubjectAttributeDesignator 
    1413from ndg.xacml.parsers import XMLParseError 
    1514from ndg.xacml.parsers.etree import QName 
     
    2221    def _parseExtension(self, elem, attributeDesignator): 
    2322        """Parse AttributeDesignator object""" 
    24         cls = self.__class__.TYPE 
     23        xacmlType = self.__class__.TYPE 
    2524         
    2625        # Unpack additional *required* attributes from top-level element 
    2726        attributeValues = [] 
    28         for attributeName in (cls.ATTRIBUTE_ID_ATTRIB_NAME,): 
     27        for attributeName in (xacmlType.ATTRIBUTE_ID_ATTRIB_NAME,): 
    2928            attributeValue = elem.attrib.get(attributeName) 
    3029            if attributeValue is None: 
    3130                raise XMLParseError('No "%s" attribute found in "%s" element' % 
    32                                     (attributeName, cls.ELEMENT_LOCAL_NAME)) 
     31                                    (attributeName, xacmlType.ELEMENT_LOCAL_NAME)) 
    3332                 
    3433            attributeValues.append(attributeValue) 
     
    3736               
    3837        # Optional attributes 
    39         issuer = elem.attrib.get(cls.DATA_TYPE_ATTRIB_NAME) 
     38        issuer = elem.attrib.get(xacmlType.DATA_TYPE_ATTRIB_NAME) 
    4039        if issuer is not None: 
    4140            attributeDesignator.issuer = issuer 
    4241              
    43         mustBePresent = elem.attrib.get(cls.DATA_TYPE_ATTRIB_NAME) 
     42        mustBePresent = elem.attrib.get(xacmlType.DATA_TYPE_ATTRIB_NAME) 
    4443        if mustBePresent is not None: 
    4544            attributeDesignator.mustBePresent = str2Bool(mustBePresent) 
     
    4746        return attributeDesignator 
    4847 
    49  
    50 class SubjectAttributeDesignatorReader(AttributeDesignatorReaderBase):  
    51     '''ElementTree based XACML Subject Attribute Designator type parser 
    52     ''' 
    53     TYPE = SubjectAttributeDesignator 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/conditionreader.py

    r6746 r6752  
    2323         
    2424        condition = Condition() 
    25         cls = Condition 
     25        xacmlType = Condition 
    2626         
    2727        localName = QName.getLocalPart(elem.tag) 
    28         if localName != cls.ELEMENT_LOCAL_NAME: 
     28        if localName != xacmlType.ELEMENT_LOCAL_NAME: 
    2929            raise XMLParseError("No \"%s\" element found" %  
    30                                 cls.ELEMENT_LOCAL_NAME) 
     30                                xacmlType.ELEMENT_LOCAL_NAME) 
    3131             
    3232        # Parse expression sub-element 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/expressionreader.py

    r6750 r6752  
    2727        elem = super(ExpressionReader, self)._parse(obj) 
    2828         
    29         cls = self.__class__.TYPE 
    30         expression = cls() 
     29        xacmlType = self.__class__.TYPE 
     30        expression = xacmlType() 
    3131         
    3232        localName = QName.getLocalPart(elem.tag) 
    33         if localName != cls.ELEMENT_LOCAL_NAME: 
     33        if localName != xacmlType.ELEMENT_LOCAL_NAME: 
    3434            raise XMLParseError("No \"%s\" element found" %  
    35                                 cls.ELEMENT_LOCAL_NAME) 
     35                                xacmlType.ELEMENT_LOCAL_NAME) 
    3636             
    3737        # Unpack *required* attributes from top-level element 
    3838        attributeValues = [] 
    39         for attributeName in (cls.DATA_TYPE_ATTRIB_NAME,): 
     39        for attributeName in (xacmlType.DATA_TYPE_ATTRIB_NAME,): 
    4040            attributeValue = elem.attrib.get(attributeName) 
    4141            if attributeValue is None: 
    4242                raise XMLParseError('No "%s" attribute found in "%s" element' % 
    43                                     (attributeName, cls.ELEMENT_LOCAL_NAME)) 
     43                                    (attributeName, xacmlType.ELEMENT_LOCAL_NAME)) 
    4444                 
    4545            attributeValues.append(attributeValue) 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/matchreader.py

    r6750 r6752  
    1111__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1212__revision__ = "$Id: $" 
    13 from ndg.xacml.core.match import SubjectMatch 
     13from ndg.xacml.core.attributevalue import AttributeValue 
    1414from ndg.xacml.core.attributeselector import AttributeSelector 
    1515from ndg.xacml.parsers import XMLParseError 
    1616from ndg.xacml.parsers.etree import QName 
    1717from ndg.xacml.parsers.etree.reader import ETreeAbstractReader 
    18 from ndg.xacml.parsers.etree.attributevaluereader import AttributeValueReader 
    19 from ndg.xacml.parsers.etree.attributedesignatorreader import ( 
    20     SubjectAttributeDesignatorReader) 
    21 from ndg.xacml.parsers.etree.attributeselectorreader import \ 
    22     AttributeSelectorReader 
     18from ndg.xacml.parsers.etree.factory import ReaderFactory 
    2319 
    2420 
     
    2723    action and environment match types 
    2824    ''' 
    29     ATTRIBUTE_DESIGNATOR_READER_TYPE = None 
     25    ATTRIBUTE_DESIGNATOR_TYPE = None 
    3026     
    3127    def __init__(self): 
    32         if self.__class__.ATTRIBUTE_DESIGNATOR_READER_TYPE is None: 
     28        if self.__class__.ATTRIBUTE_DESIGNATOR_TYPE is None: 
    3329            raise NotImplementedError('Extend this class setting the ' 
    34                                       '"ATTRIBUTE_DESIGNATOR_READER_TYPE" ' 
     30                                      '"ATTRIBUTE_DESIGNATOR_TYPE" ' 
    3531                                      'class variable') 
    3632             
     
    4137        elem = super(MatchReaderBase, self)._parse(obj) 
    4238         
    43         cls = self.__class__.TYPE 
    44         match = cls() 
     39        xacmlType = self.__class__.TYPE 
     40        match = xacmlType() 
    4541         
    4642        localName = QName.getLocalPart(elem.tag) 
    47         if localName != cls.ELEMENT_LOCAL_NAME: 
     43        if localName != xacmlType.ELEMENT_LOCAL_NAME: 
    4844            raise XMLParseError("No \"%s\" element found" %  
    49                                 cls.ELEMENT_LOCAL_NAME) 
     45                                xacmlType.ELEMENT_LOCAL_NAME) 
    5046         
    5147        # Unpack *required* attributes from top-level element 
    5248        attributeValues = [] 
    53         for attributeName in (cls.MATCH_ID_ATTRIB_NAME, ): 
     49        for attributeName in (xacmlType.MATCH_ID_ATTRIB_NAME, ): 
    5450            attributeValue = elem.attrib.get(attributeName) 
    5551            if attributeValue is None: 
    5652                raise XMLParseError('No "%s" attribute found in "%s" ' 
    5753                                    'element' % (attributeName, 
    58                                                  cls.ELEMENT_LOCAL_NAME)) 
     54                                                 xacmlType.ELEMENT_LOCAL_NAME)) 
    5955                 
    6056            attributeValues.append(attributeValue)  
     
    6359          
    6460        # Assign specific attribute designator type from derived class 
    65         attributeDesignatorReaderType = \ 
    66                                 self.__class__.ATTRIBUTE_DESIGNATOR_READER_TYPE  
    67         attributeDesignatorType = attributeDesignatorReaderType.TYPE 
    68  
     61        attributeDesignatorType = self.__class__.ATTRIBUTE_DESIGNATOR_TYPE 
     62        attributeDesignatorReaderType = ReaderFactory.getReader( 
     63                                                        attributeDesignatorType) 
     64      
    6965        # Parse match elements 
    7066        for childElem in elem: 
    7167            localName = QName.getLocalPart(childElem.tag) 
    7268             
    73             if localName == cls.ATTRIBUTE_VALUE_ELEMENT_LOCAL_NAME: 
     69            if localName == xacmlType.ATTRIBUTE_VALUE_ELEMENT_LOCAL_NAME: 
     70                AttributeValueReader = ReaderFactory.getReader(AttributeValue) 
    7471                match.attributeValue = AttributeValueReader.parse(childElem) 
    7572                 
     
    7875                    raise XMLParseError("XACML %r child element may only be " 
    7976                                        "either a %r or %r element NOT both" % 
    80                             (cls.ELEMENT_LOCAL_NAME, 
     77                            (xacmlType.ELEMENT_LOCAL_NAME, 
    8178                             attributeDesignatorType.ELEMENT_LOCAL_NAME, 
    8279                             AttributeSelector.ELEMENT_LOCAL_NAME)) 
     
    8986                    raise XMLParseError("XACML %r child element may only be " 
    9087                                        "either a %r or %r element NOT both" % 
    91                             (cls.ELEMENT_LOCAL_NAME, 
     88                            (xacmlType.ELEMENT_LOCAL_NAME, 
    9289                             attributeDesignatorType.ELEMENT_LOCAL_NAME, 
    9390                             AttributeSelector.ELEMENT_LOCAL_NAME)) 
    94  
     91                     
     92                AttributeSelectorReader = ReaderFactory.getReader( 
     93                                                            AttributeSelector) 
     94                 
    9595                match.attributeSelector = AttributeSelectorReader.parse( 
    9696                                                                    childElem) 
     
    9898                raise XMLParseError("XACML %r child element name %r not " 
    9999                                    "recognised" %  
    100                                     (cls.MATCH_TYPE.ELEMENT_LOCAL_NAME, 
     100                                    (xacmlType.MATCH_TYPE.ELEMENT_LOCAL_NAME, 
    101101                                     localName)) 
    102102                     
    103103        return match 
     104 
    104105     
     106         
    105107 
    106 class SubjectMatchReader(MatchReaderBase): 
    107     """ElementTree based parser for XACML SubjectMatch""" 
    108     TYPE = SubjectMatch 
    109     ATTRIBUTE_DESIGNATOR_READER_TYPE = SubjectAttributeDesignatorReader 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/policyreader.py

    r6751 r6752  
    1717from ndg.xacml.parsers.etree import QName 
    1818from ndg.xacml.parsers.etree.reader import ETreeAbstractReader 
    19 from ndg.xacml.parsers.etree.targetreader import TargetReader 
    20 from ndg.xacml.parsers.etree.rulereader import RuleReader 
     19from ndg.xacml.parsers.etree.factory import ReaderFactory 
    2120     
    2221     
     
    3231         
    3332        # XACML type to instantiate 
    34         cls = PolicyReader.TYPE 
    35         policy = cls() 
     33        xacmlType = PolicyReader.TYPE 
     34        policy = xacmlType() 
    3635         
    3736        localName = QName.getLocalPart(elem.tag) 
    38         if localName != cls.ELEMENT_LOCAL_NAME: 
     37        if localName != xacmlType.ELEMENT_LOCAL_NAME: 
    3938            raise XMLParseError("No \"%s\" element found" %  
    40                                 cls.ELEMENT_LOCAL_NAME) 
     39                                xacmlType.ELEMENT_LOCAL_NAME) 
    4140         
    4241        # Unpack *required* attributes from top-level element 
    4342        attributeValues = [] 
    44         for attributeName in (cls.POLICY_ID_ATTRIB_NAME, 
    45                               cls.RULE_COMBINING_ALG_ID_ATTRIB_NAME): 
     43        for attributeName in (xacmlType.POLICY_ID_ATTRIB_NAME, 
     44                              xacmlType.RULE_COMBINING_ALG_ID_ATTRIB_NAME): 
    4645            attributeValue = elem.attrib.get(attributeName) 
    4746            if attributeValue is None: 
     
    4948                                        'element' % 
    5049                                        (attributeName, 
    51                                          cls.ELEMENT_LOCAL_NAME)) 
     50                                         xacmlType.ELEMENT_LOCAL_NAME)) 
    5251                 
    5352            attributeValues.append(attributeValue)  
     
    5756        # Defaults to XACML version 1.0 
    5857        # TODO: version check 
    59         policy.version = (elem.attrib.get(cls.VERSION_ATTRIB_NAME) or  
    60                           cls.DEFAULT_XACML_VERSION) 
     58        policy.version = (elem.attrib.get(xacmlType.VERSION_ATTRIB_NAME) or  
     59                          xacmlType.DEFAULT_XACML_VERSION) 
    6160             
    6261        # Parse sub-elements 
     
    6463            localName = QName.getLocalPart(childElem.tag) 
    6564             
    66             if localName == cls.DESCRIPTION_LOCAL_NAME: 
     65            if localName == xacmlType.DESCRIPTION_LOCAL_NAME: 
    6766                if childElem.text is not None: 
    6867                    policy.description = childElem.text.strip() 
    6968                     
    70             elif localName == cls.POLICY_DEFAULTS_LOCAL_NAME: 
     69            elif localName == xacmlType.POLICY_DEFAULTS_LOCAL_NAME: 
    7170                raise NotImplementedError() 
    7271                    
    7372            elif localName == Target.ELEMENT_LOCAL_NAME: 
     73                TargetReader = ReaderFactory.getReader(Target) 
    7474                policy.target = TargetReader.parse(childElem) 
    7575              
    76             elif localName == cls.COMBINER_PARAMETERS_LOCAL_NAME: 
     76            elif localName == xacmlType.COMBINER_PARAMETERS_LOCAL_NAME: 
    7777                raise NotImplementedError() 
    7878              
    79             elif localName == cls.RULE_COMBINER_PARAMETERS_LOCAL_NAME: 
     79            elif localName == xacmlType.RULE_COMBINER_PARAMETERS_LOCAL_NAME: 
    8080                raise NotImplementedError() 
    8181             
    8282            elif localName == VariableDefinition.ELEMENT_LOCAL_NAME: 
     83                VariableDefinitionReader = ReaderFactory.getReader( 
     84                                                            VariableDefinition) 
    8385                variableDefinition = VariableDefinitionReader.parse(childElem) 
    8486                 
    8587            elif localName == Rule.ELEMENT_LOCAL_NAME: 
     88                RuleReader = ReaderFactory.getReader(Rule) 
    8689                policy.rules.append(RuleReader.parse(childElem)) 
    8790                    
    88             elif localName == cls.OBLIGATIONS_LOCAL_NAME: 
     91            elif localName == xacmlType.OBLIGATIONS_LOCAL_NAME: 
    8992                raise NotImplementedError() 
    9093             
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/reader.py

    r6750 r6752  
    1 ''' 
    2 Created on 15 Mar 2010 
    3  
    4 @author: pjkersha 
    5 ''' 
    6 import logging 
    7 log = logging.getLogger(__name__) 
    81"""NDG XACML ElementTree reader module containing reader base class  
    92 
     
    1710__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1811__revision__ = "$Id: $" 
     12import logging 
     13log = logging.getLogger(__name__) 
     14 
    1915from xml.etree import ElementTree 
    2016 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/resourcereader.py

    r6751 r6752  
    1111__revision__ = "$Id: $" 
    1212from ndg.xacml.core.resource import Resource 
    13 from ndg.xacml.parsers.etree.subjectreader import AbstractTargetChildReader 
     13from ndg.xacml.parsers.etree.subjectreader import TargetChildReader 
    1414 
    1515 
    16 class ResourceReader(AbstractTargetChildReader): 
     16class ResourceReader(TargetChildReader): 
    1717    '''ElementTree based XACML Rule parser 
    1818    @cvar TYPE: XACML type to instantiate from parsed object 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/rulereader.py

    r6751 r6752  
    1616from ndg.xacml.parsers.etree import QName 
    1717from ndg.xacml.parsers.etree.reader import ETreeAbstractReader 
    18 from ndg.xacml.parsers.etree.conditionreader import ConditionReader 
    19 from ndg.xacml.parsers.etree.targetreader import TargetReader 
     18from ndg.xacml.parsers.etree.factory import ReaderFactory 
    2019 
    2120 
     
    3231        elem = super(RuleReader, self)._parse(obj) 
    3332         
    34         cls = RuleReader.TYPE 
    35         rule = cls() 
     33        xacmlType = RuleReader.TYPE 
     34        rule = xacmlType() 
    3635         
    3736        localName = QName.getLocalPart(elem.tag) 
    38         if localName != cls.ELEMENT_LOCAL_NAME: 
     37        if localName != xacmlType.ELEMENT_LOCAL_NAME: 
    3938            raise XMLParseError("No \"%s\" element found" %  
    40                                 cls.ELEMENT_LOCAL_NAME) 
     39                                xacmlType.ELEMENT_LOCAL_NAME) 
    4140         
    4241        # Unpack *required* attributes from top-level element 
    4342        attributeValues = [] 
    44         for attributeName in (cls.RULE_ID_ATTRIB_NAME, cls.EFFECT_ATTRIB_NAME): 
     43        for attributeName in (xacmlType.RULE_ID_ATTRIB_NAME, xacmlType.EFFECT_ATTRIB_NAME): 
    4544            attributeValue = elem.attrib.get(attributeName) 
    4645            if attributeValue is None: 
     
    4847                                        'element' % 
    4948                                        (attributeName, 
    50                                          cls.ELEMENT_LOCAL_NAME)) 
     49                                         xacmlType.ELEMENT_LOCAL_NAME)) 
    5150                 
    5251            attributeValues.append(attributeValue)  
     
    5857            localName = QName.getLocalPart(childElem.tag) 
    5958             
    60             if localName == cls.DESCRIPTION_LOCAL_NAME: 
     59            if localName == xacmlType.DESCRIPTION_LOCAL_NAME: 
    6160                if childElem.text is not None: 
    6261                    rule.description = childElem.text.strip() 
    6362                     
    6463            elif localName == Condition.ELEMENT_LOCAL_NAME: 
     64                ConditionReader = ReaderFactory.getReader(Condition) 
    6565                rule.condition = ConditionReader.parse(childElem) 
    6666                                    
    6767            elif localName == Target.ELEMENT_LOCAL_NAME: 
     68                TargetReader = ReaderFactory.getReader(Target) 
    6869                rule.target = TargetReader.parse(childElem) 
    6970             
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/subjectreader.py

    r6751 r6752  
    1111__revision__ = "$Id: $" 
    1212from ndg.xacml.core.subject import Subject 
    13 from ndg.xacml.parsers import XMLParseError 
    14 from ndg.xacml.parsers.etree import QName 
    15 from ndg.xacml.parsers.etree.reader import ETreeAbstractReader 
    16 from ndg.xacml.parsers.etree.matchreader import SubjectMatchReader 
    17  
    18  
    19 class AbstractTargetChildReader(ETreeAbstractReader): 
    20     '''ElementTree based XACML generic target child element parser 
    21     @cvar TYPE: XACML type to instantiate from parsed object 
    22     @type string: type 
    23     ''' 
    24  
    25     def __call__(self, obj): 
    26         """Parse subject object""" 
    27         elem = super(AbstractTargetChildReader, self)._parse(obj) 
    28          
    29         cls = self.__class__.TYPE 
    30         targetChild = cls() 
    31          
    32         localName = QName.getLocalPart(elem.tag) 
    33         if localName != cls.ELEMENT_LOCAL_NAME: 
    34             raise XMLParseError("No \"%s\" element found" %  
    35                                 cls.ELEMENT_LOCAL_NAME) 
    36              
    37         # Parse match elements 
    38         for childElem in elem: 
    39             localName = QName.getLocalPart(childElem.tag) 
    40              
    41             if localName == cls.MATCH_TYPE.ELEMENT_LOCAL_NAME: 
    42                 targetChild.matches.append(self.__class__.parse(childElem)) 
    43              
    44             else: 
    45                 raise XMLParseError("XACML %r child element name %r not " 
    46                                     "recognised" % (cls.ELEMENT_LOCAL_NAME,  
    47                                                     localName)) 
    48                         
    49         return targetChild  
     13from ndg.xacml.parsers.etree.targetchildreader import TargetChildReader 
    5014     
    5115 
    52 class SubjectReader(AbstractTargetChildReader): 
     16class SubjectReader(TargetChildReader): 
    5317    '''ElementTree based XACML Rule parser 
    5418    @cvar TYPE: XACML type to instantiate from parsed object 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/targetreader.py

    r6750 r6752  
    1111__revision__ = "$Id: $" 
    1212from ndg.xacml.core.target import Target 
     13from ndg.xacml.core.subject import Subject 
     14from ndg.xacml.core.resource import Resource 
     15from ndg.xacml.core.action import Action 
     16from ndg.xacml.core.environment import Environment 
    1317from ndg.xacml.parsers import XMLParseError 
    1418from ndg.xacml.parsers.etree import QName 
    1519from ndg.xacml.parsers.etree.reader import ETreeAbstractReader 
    16 from ndg.xacml.parsers.etree.subjectreader import SubjectReader 
    17 from ndg.xacml.parsers.etree.actionreader import ActionReader 
    18 from ndg.xacml.parsers.etree.resourcereader import ResourceReader 
    19 from ndg.xacml.parsers.etree.environmentreader import EnvironmentReader 
     20from ndg.xacml.parsers.etree.factory import ReaderFactory 
    2021 
    2122 
     
    3031        elem = super(TargetReader, self)._parse(obj) 
    3132         
    32         cls = TargetReader.TYPE 
    33         target = cls() 
     33        xacmlType = TargetReader.TYPE 
     34        target = xacmlType() 
    3435         
    3536        localName = QName.getLocalPart(elem.tag) 
    36         if localName != cls.ELEMENT_LOCAL_NAME: 
     37        if localName != xacmlType.ELEMENT_LOCAL_NAME: 
    3738            raise XMLParseError('No "%s" element found' %  
    38                                 cls.ELEMENT_LOCAL_NAME) 
     39                                xacmlType.ELEMENT_LOCAL_NAME) 
    3940         
    4041        # Parse sub-elements 
     
    4243            localName = QName.getLocalPart(childElem.tag) 
    4344             
    44             if localName == cls.SUBJECTS_ELEMENT_LOCAL_NAME: 
     45            if localName == xacmlType.SUBJECTS_ELEMENT_LOCAL_NAME: 
    4546                for subjElem in childElem: 
     47                    SubjectReader = ReaderFactory.getReader(Subject) 
    4648                    target.subjects.append(SubjectReader.parse(subjElem)) 
    4749                                 
    48             elif localName == cls.RESOURCES_ELEMENT_LOCAL_NAME: 
     50            elif localName == xacmlType.RESOURCES_ELEMENT_LOCAL_NAME: 
    4951                for resourceElem in childElem: 
     52                    ResourceReader = ReaderFactory.getReader(Resource) 
    5053                    target.resources.append(ResourceReader.parse(resourceElem)) 
    5154                 
    52             elif localName == cls.ACTIONS_ELEMENT_LOCAL_NAME: 
     55            elif localName == xacmlType.ACTIONS_ELEMENT_LOCAL_NAME: 
    5356                for targetElem in childElem: 
     57                    ActionReader = ReaderFactory.getReader(Action) 
    5458                    target.actions.append(ActionReader.parse(targetElem)) 
    5559                 
    56             elif localName == cls.ENVIRONMENTS_ELEMENT_LOCAL_NAME: 
     60            elif localName == xacmlType.ENVIRONMENTS_ELEMENT_LOCAL_NAME: 
    5761                for environElem in childElem: 
     62                    EnvironmentReader = ReaderFactory.getReader(Environment) 
    5863                    target.environments.append(EnvironmentReader.parse( 
    5964                                                                environElem)) 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/test/test_xacml.py

    r6751 r6752  
    1313from os import path 
    1414 
    15 from ndg.xacml.parsers.etree.policyreader import PolicyReader 
     15from ndg.xacml.core.policy import Policy 
     16from ndg.xacml.parsers.etree.factory import ReaderFactory 
    1617 
    1718 
     
    2425    
    2526    def test01ETreeParseRule1Policy(self): 
     27        PolicyReader = ReaderFactory.getReader(Policy) 
    2628        policy = PolicyReader.parse(XACMLTestCase.XACML_TEST1_FILEPATH) 
    2729        self.assert_(policy) 
     
    7274          
    7375    def test02ETreeParseRule2Policy(self): 
     76        PolicyReader = ReaderFactory.getReader(Policy) 
    7477        policy = PolicyReader.parse(XACMLTestCase.XACML_TEST2_FILEPATH) 
    7578        self.assert_(policy) 
Note: See TracChangeset for help on using the changeset viewer.