Ignore:
Timestamp:
16/04/10 15:15:05 (10 years ago)
Author:
pjkersha
Message:

Moved PDP evaluate content into Policy.evaluate

File:
1 edited

Legend:

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

    r6822 r6825  
    1 """NDG Security Policy Decision Point type definition 
     1"""NDG XACML Policy Decision Point type definition 
    22 
    33NERC DataGrid Project 
     
    1313log = logging.getLogger(__name__) 
    1414 
    15 import traceback 
    16  
    17 from ndg.xacml.core.context.exceptions import XacmlContextError 
    1815from ndg.xacml.core.context.pdpinterface import PDPInterface 
    1916from ndg.xacml.core.policy import Policy 
    20 from ndg.xacml.core.context.request import Request 
    21 from ndg.xacml.core.context.response import Response 
    22 from ndg.xacml.core.context.result import Result, Decision 
    23 from ndg.xacml.core.context.result import StatusCode 
    2417 
    2518 
    26 class PDPError(XacmlContextError): 
    27     """Base class for PDP class exceptions""" 
    28       
    29      
    30 class UnsupportedElementError(PDPError): 
    31     """Element type is not supported in this implementation""" 
    32     def __init__(self, *arg, **kw): 
    33         super(UnsupportedElementError, self).__init__(*arg, **kw) 
    34         self.response.results[0 
    35                             ].status.statusCode.value = StatusCode.SYNTAX_ERROR 
    36  
    37  
    38 class UnsupportedStdElementError(UnsupportedElementError): 
    39     """Element type is part of the XACML spec. but is not supported in this  
    40     implementation"""   
    41      
    42      
    4319class PDP(PDPInterface): 
    4420    """A XACML Policy Decision Point implementation.  It supports the use of a  
    4521    single policy but not policy sets 
    4622    """ 
    47     __slots__ = ('__policy', '__request') 
     23    __slots__ = ('__policy', ) 
    4824     
    4925    def __init__(self, policy=None): 
     
    8561                            '%r instead' % (Policy, type(value))) 
    8662        self.__policy = value 
    87  
    88     @property 
    89     def request(self): 
    90         """request context""" 
    91         return self.__request 
    92      
    93     @request.setter 
    94     def request(self, value): 
    95         '''request context''' 
    96         if not isinstance(value, Request): 
    97             raise TypeError('Expecting %r derived type for "request" ' 
    98                             'input; got %r instead' % (Request,  
    99                                                        type(value))) 
    100         self.__request = value 
    10163                                         
    10264    def evaluate(self, request): 
    10365        """Make an access control decision for the given request based on the 
    104         policy set 
     66        single policy provided 
    10567         
    10668        @param request: XACML request context 
     
    10971        @rtype: ndg.xacml.core.context.response.Response 
    11072        """ 
    111         response = Response() 
    112         result = Result.createInitialised(decision=Decision.NOT_APPLICABLE) 
    113         response.results.append(result) 
     73        response = self.policy.evaluate(request) 
    11474         
    115         try: 
    116             self.request = request 
    117              
    118         except AttributeError, e: 
    119             log.error(str(e)) 
    120             result.decision = Decision.INDETERMINATE 
    121             return response 
    122              
    123         # Exception block around all rule processing in order to set 
    124         # INDETERMINATE response from any exceptions raised 
    125         try: 
    126             log.debug('Checking policy %r target for match with request...', 
    127                       self.policy.policyId) 
    128              
    129             target = self.policy.target 
    130              
    131             # If no target is set, ALL requests are counted as matches 
    132             if target is not None: 
    133                 if not target.match(request): 
    134                     # The target didn't match so the whole policy does not apply 
    135                     # to this request 
    136                     log.debug('No match for policy target setting %r decision', 
    137                               Decision.NOT_APPLICABLE_STR) 
    138                      
    139                     result.decision = Decision.NOT_APPLICABLE 
    140                     return response 
    141              
    142             log.debug('Request matches the Policy %r target',  
    143                       self.policy.policyId) 
    144              
    145             # Check rules 
    146 #            ruleDecisions = [False]*len(self.policy.rules) 
    147 #            for i, rule in enumerate(self.policy.rules): 
    148 #                ruleDecisions[i] = rule.evaluate(request) 
    149                  
    150             # Apply the rule combining algorithm here combining the  
    151             # effects from the rules evaluated into an overall decision 
    152             result.decision = self.policy.ruleCombiningAlg.evaluate( 
    153                                                             self.policy.rules, 
    154                                                             request) 
    155         except PDPError, e: 
    156             log.error('Exception raised evaluating request context, returning ' 
    157                       '%r decision:%s',  
    158                       e.response.results[0].decision,  
    159                       traceback.format_exc()) 
    160              
    161             result = e.response.results[0] 
    162              
    163         except Exception: 
    164             # Catch all so that nothing is handled from within the scope of this 
    165             # method 
    166             log.error('No PDPError type exception raised evaluating request ' 
    167                       'context, returning %r decision:%s',  
    168                       Decision.INDETERMINATE_STR,  
    169                       traceback.format_exc())  
    170                         
    171             result.decision = Decision.INDETERMINATE 
    172             result.status.statusCode.value = StatusCode.PROCESSING_ERROR 
    173              
    17475        return response 
    17576 
Note: See TracChangeset for help on using the changeset viewer.