source: TI12-security/trunk/ndg_xacml/ndg/xacml/core/apply.py @ 7100

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI12-security/trunk/ndg_xacml/ndg/xacml/core/apply.py@7100
Revision 7100, 7.8 KB checked in by pjkersha, 9 years ago (diff)

Incomplete - task 2: XACML-Security Integration

  • updating epydoc ready for release.
  • Property svn:keywords set to Id
Line 
1"""NDG Security Condition type definition
2
3NERC DataGrid
4"""
5__author__ = "P J Kershaw"
6__date__ = "19/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.utils import TypedList
13from ndg.xacml.core.expression import Expression
14from ndg.xacml.core.functions import FunctionMap
15from ndg.xacml.core.exceptions import (UnsupportedStdFunctionError,
16                                       UnsupportedFunctionError)
17
18
19class Apply(Expression):
20    """XACML Apply type
21   
22    @cvar ELEMENT_LOCAL_NAME: XML element local name
23    @type ELEMENT_LOCAL_NAME: string
24    @cvar FUNCTION_ID_ATTRIB_NAME: function ID XML attribute name
25    @type FUNCTION_ID_ATTRIB_NAME: string
26
27    @ivar __functionId: URN corresponding to function to be applied
28    @type __functionId: basestring/NoneType
29    @ivar __function: function to be applied
30    @type __function: ndg.xacml.core.functions.AbstractFunction derived type
31    @ivar __functionMap: function mapping object to map URNs to function class
32    implementations
33    @type __functionMap: ndg.xacml.core.functions.FunctionMap
34    @ivar __loadFunctionFromId: boolean determines whether or not to load
35    function classes for given function URN in functionId set property method
36    @type __loadFunctionFromId: bool
37    @ivar __expressions: list of expressions contained in the Apply statement
38    @type __expressions: ndg.xacml.utils.TypedList
39    """
40    ELEMENT_LOCAL_NAME = 'Apply'
41    FUNCTION_ID_ATTRIB_NAME = 'FunctionId'
42   
43    __slots__ = (
44        '__functionId', 
45        '__function', 
46        '__functionMap',
47        '__loadFunctionFromId',
48        '__expressions'
49    )
50   
51    def __init__(self):
52        """Initialise attributes"""
53        super(Apply, self).__init__()
54        self.__functionId = None
55        self.__function = None
56        self.__functionMap = FunctionMap()
57        self.__loadFunctionFromId = True
58        self.__expressions = TypedList(Expression)
59     
60    @property
61    def loadFunctionFromId(self):
62        """Set to False to stop the functionId property set method automatically
63        trying to load the corresponding function for the given functionId
64       
65        @return: flag setting
66        @rtype: bool""" 
67        return self.__loadFunctionFromId
68   
69    @loadFunctionFromId.setter
70    def loadFunctionFromId(self, value):
71        """Set to False to stop the functionId property set method automatically
72        trying to load the corresponding function for the given functionId
73       
74        @param value: flag setting
75        @type value: bool
76        @raise TypeError: incorrect input type
77        """ 
78        if not isinstance(value, bool):
79            raise TypeError('Expecting %r type for "loadFunctionFromId" '
80                            'attribute; got %r' % (bool, type(value)))
81           
82        self.__loadFunctionFromId = value
83       
84    def _get_functionId(self):
85        """Get function ID
86        @return: function ID for this Apply statement
87        @rtype: basestring/NoneType
88        """
89        return self.__functionId
90
91    def _set_functionId(self, value):
92        """Set function ID
93        @param value: function URN
94        @type value: basestring
95        @raise TypeError: incorrect input type
96        """ 
97        if not isinstance(value, basestring):
98            raise TypeError('Expecting %r type for "functionId" '
99                            'attribute; got %r' % (basestring, type(value)))
100           
101        self.__functionId = value
102       
103        # Also retrieve function for this function ID if a map has been set
104        if self.__loadFunctionFromId:
105            self.setFunctionFromMap(self.__functionMap)   
106
107    functionId = property(_get_functionId, _set_functionId, None, 
108                          "Apply type Function ID") 
109       
110    def setFunctionFromMap(self, functionMap):
111        """Set the function from a function map - a dictionary of function ID to
112        function mappings.  The function is looked up based on the "functionId"
113        attribute.  This method is automatically called when the functionId set
114        property method is invoked.  To switch off this behaviour set
115       
116        loadFunctionFromId = False
117   
118        @param functionMap: function mapping object to map URNs to function
119        class implementations
120        @type functionMap: ndg.xacml.core.functions.FunctionMap
121       
122        @raise UnsupportedStdFunctionError: policy references a function type
123        which is in the XACML spec. but is not supported by this implementation
124        @raise UnsupportedFunctionError: policy references a function type which
125        is not supported by this implementation
126        """
127        if self.functionId is None:
128            raise AttributeError('"functionId" attribute must be set in order '
129                                 'to retrieve the required function')
130           
131        # Get function class for this <Apply> statement         
132        functionClass = functionMap.get(self.functionId)
133        if functionClass is NotImplemented:
134            raise UnsupportedStdFunctionError('No match function class '
135                                              'implemented for MatchId="%s"' % 
136                                              self.functionId)
137        elif functionClass is None:
138            raise UnsupportedFunctionError('<Apply> function namespace %r is '
139                                           'not recognised' % 
140                                           self.functionId) 
141           
142        self.__function = functionClass()
143   
144    @property
145    def functionMap(self):
146        """functionMap object for PDP to retrieve functions from given XACML
147        function URNs
148        @return: function mapping object
149        @rtype: ndg.xacml.core.functions.FunctionMap
150        """
151        return self.__functionMap
152   
153    @functionMap.setter
154    def functionMap(self, value):
155        '''functionMap object for PDP to retrieve functions from given XACML
156        function URNs
157        @ivar value: function mapping object to map URNs to function
158        class implementations
159        @type value: ndg.xacml.core.functions.FunctionMap
160        @raise TypeError: incorrect type for input value
161        '''
162        if not isinstance(value, FunctionMap):
163            raise TypeError('Expecting %r derived type for "functionMap" '
164                            'input; got %r instead' % (FunctionMap, 
165                                                       type(value)))
166        self.__functionMap = value
167         
168    @property 
169    def function(self):
170        """Get Function for this <Apply> instance
171        @return: function to be applied
172        @rtype: ndg.xacml.core.functions.AbstractFunction derived type
173        """
174        return self.__function
175       
176    @property
177    def expressions(self):
178        """List of expression sub-elements
179        @return: list of expressions contained in the Apply statement
180        @rtype: ndg.xacml.utils.TypedList
181        """
182        return self.__expressions
183   
184    def evaluate(self, context):
185        """Evaluate a given <Apply> statement in a rule condition
186       
187        @param context: the request context
188        @type context: ndg.xacml.core.context.request.Request
189        @return: attribute value(s) resulting from execution of this expression
190        in a condition
191        @rtype: AttributeValue/NoneType
192        """ 
193       
194        # Marshall inputs
195        funcInputs = [None]*len(self.expressions)
196
197        for i, expression in enumerate(self.expressions):
198            funcInputs[i] = expression.evaluate(context)
199           
200        # Execute function on the retrieved inputs
201        result = self.function.evaluate(*tuple(funcInputs))
202       
203        # Pass the result back to the parent <Apply> element
204        return result
205         
Note: See TracBrowser for help on using the repository browser.