source: TI12-security/trunk/NDGSecurity/python/ndg_security_common/ndg/security/common/authz/xacml/target.py @ 6734

'''
Created on 24 Feb 2010

@author: pjkersha
'''
from ndg.security.common.utils import TypedList
"""NDG Security Target type definition

NERC DataGrid Project
"""
__author__ = "P J Kershaw"
__date__ = "25/02/10"
__copyright__ = "(C) 2010 Science and Technology Facilities Council"
__contact__ = "Philip.Kershaw@stfc.ac.uk"
__license__ = "BSD - see LICENSE file in top-level directory"
__contact__ = "Philip.Kershaw@stfc.ac.uk"
__revision__ = "$Id: $"
from ndg.security.common.authz.xacml import PolicyComponent
from ndg.security.common.authz.xacml.action import Action
from ndg.security.common.authz.xacml.resource import Resource
from ndg.security.common.authz.xacml.subject import Subject
from ndg.security.common.authz.xacml.environment import Environment


class Target(PolicyComponent):
    ELEMENT_LOCAL_NAME = "Target"
    
    __slots__ = ('__actions', '__resources', '__actions', '__environments')
    
    def __init__(self):
        self.__actions = TypedList(Subject)
        self.__resources = TypedList(Resource)
        self.__actions = TypedList(Action)
        self.__environments = TypedList(Environment)
    
    @property
    def actions(self):
        return self.__actions
    
    @property
    def resources(self):
        return self.__resources
    
    @property
    def actions(self):
        return self.__actions
    
    @property
    def environments(self):
        return self.__environments
    
    
class _Target(PolicyComponent):
    """Define access behaviour for a resource match a given URI pattern"""
    URI_PATTERN_LOCALNAME = "URIPattern"
    ATTRIBUTES_LOCALNAME = "Attributes"
    ATTRIBUTE_AUTHORITY_LOCALNAME = "AttributeAuthority"
    
    __slots__ = (
        '__uriPattern',
        '__attributes',
        '__regEx'       
    )
      
    def __init__(self):
        super(Target, self).__init__()
        self.__uriPattern = None
        self.__attributes = []
        self.__regEx = None
        
    def getUriPattern(self):
        return self.__uriPattern

    def setUriPattern(self, value):
        if not isinstance(value, basestring):
            raise TypeError('Expecting string type for "uriPattern" '
                            'attribute; got %r' % type(value))
        self.__uriPattern = value

    uriPattern = property(getUriPattern, 
                          setUriPattern, 
                          doc="URI Pattern to match this target")

    def getAttributes(self):
        return self.__attributes

    def setAttributes(self, value):
        if (not isinstance(value, TypedList) and 
            not issubclass(value.elementType, Attribute.__class__)):
            raise TypeError('Expecting TypedList(Attribute) for "attributes" '
                            'attribute; got %r' % type(value))
        self.__attributes = value

    attributes = property(getAttributes, 
                          setAttributes,  
                          doc="Attributes restricting access to this target")

    def getRegEx(self):
        return self.__regEx

    def setRegEx(self, value):
        self.__regEx = value

    regEx = property(getRegEx, setRegEx, doc="RegEx's Docstring")
        
    def parse(self, root):
        
        self.xmlns = QName.getNs(root.tag)
        version1_0attributeAuthorityURI = None
        
        for elem in root:
            localName = QName.getLocalPart(elem.tag)
            if localName == Target.URI_PATTERN_LOCALNAME:
                self.uriPattern = elem.text.strip()
                self.regEx = re.compile(self.uriPattern)
                
            elif localName == Target.ATTRIBUTES_LOCALNAME:
                for attrElem in elem:
                    if self.xmlns == Target.VERSION_1_1_XMLNS:
                        self.attributes.append(Attribute.Parse(attrElem))
                    else:
                        attribute = Attribute()
                        attribute.name = attrElem.text.strip()
                        self.attributes.append(attribute)
                    
            elif localName == Target.ATTRIBUTE_AUTHORITY_LOCALNAME:
                # Expecting first element to contain the URI
                warnings.warn(
                        Target.ATTRIBUTE_AUTHORITY_LOCALNAME_DEPRECATED_MSG,
                        PendingDeprecationWarning)
                
                version1_0attributeAuthorityURI = elem[-1].text.strip()
            else:
                raise TargetParseError("Invalid Target attribute: %s" % 
                                       localName)
                
        if self.xmlns == Target.VERSION_1_0_XMLNS:
            msg = ("Setting all attributes with Attribute Authority "
                   "URI set read using Version 1.0 schema.  This will "
                   "be deprecated in future releases")
            
            warnings.warn(msg, PendingDeprecationWarning)
            log.warning(msg)
            
            if version1_0attributeAuthorityURI is None:
                raise TargetParseError("Assuming version 1.0 schema "
                                       "for Attribute Authority URI setting "
                                       "but no URI has been set")
                
            for attribute in self.attributes:
                attribute.attributeAuthorityURI = \
                    version1_0attributeAuthorityURI
    
    @classmethod
    def Parse(cls, root):
        resource = cls()
        resource.parse(root)
        return resource
    
    def __str__(self):
        return str(self.uriPattern)