X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sfa%2Futil%2Fxrn.py;h=a21b10c02d1b29f72f2d2fbfe0ea9296e2af6562;hb=3d51e29695f79b143974f5cf7b2e104d89626ba4;hp=a503e713e3bb642c442de65dedb3ff713e94f36d;hpb=ba2aaa438f939a4b5c697052e37b1c3218901319;p=sfa.git diff --git a/sfa/util/xrn.py b/sfa/util/xrn.py index a503e713..a21b10c0 100644 --- a/sfa/util/xrn.py +++ b/sfa/util/xrn.py @@ -1,13 +1,39 @@ -import re +#---------------------------------------------------------------------- +# Copyright (c) 2008 Board of Trustees, Princeton University +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and/or hardware specification (the "Work") to +# deal in the Work without restriction, including without limitation the +# rights to use, copy, modify, merge, publish, distribute, sublicense, +# and/or sell copies of the Work, and to permit persons to whom the Work +# is furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Work. +# +# THE WORK IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE WORK OR THE USE OR OTHER DEALINGS +# IN THE WORK. +#---------------------------------------------------------------------- -from sfa.util.faults import * -from sfa.util.sfalogging import sfa_logger +import re +import sys +from sfa.util.faults import SfaAPIError # for convenience and smoother translation - we should get rid of these functions eventually -def get_leaf(hrn): return Xrn(xrn=hrn).get_leaf() -def get_authority(hrn): return Xrn(xrn=hrn).get_authority_hrn() -def urn_to_hrn(urn): xrn=Xrn(xrn=urn); return (xrn.hrn, xrn.type) -def hrn_to_urn(hrn,type): return Xrn(hrn=hrn, type=type).urn +def get_leaf(hrn): return Xrn(hrn).get_leaf() +def get_authority(hrn): return Xrn(hrn).get_authority_hrn() +def urn_to_hrn(urn): xrn=Xrn(urn); return (xrn.hrn, xrn.type) +def hrn_to_urn(hrn,type): return Xrn(hrn, type=type).urn +def hrn_authfor_hrn(parenthrn, hrn): return Xrn.hrn_is_auth_for_hrn(parenthrn, hrn) + +def urn_to_sliver_id(urn, slice_id, node_id, index=0): + return Xrn(urn).get_sliver_id(slice_id, node_id, index) class Xrn: @@ -34,17 +60,45 @@ class Xrn: # e.g. escape ('a.b') -> 'a\.b' @staticmethod def escape(token): return re.sub(r'([^\\])\.', r'\1\.', token) + # e.g. unescape ('a\.b') -> 'a.b' @staticmethod def unescape(token): return token.replace('\\.','.') - + + # Return the HRN authority chain from top to bottom. + # e.g. hrn_auth_chain('a\.b.c.d') -> ['a\.b', 'a\.b.c'] + @staticmethod + def hrn_auth_chain(hrn): + parts = Xrn.hrn_auth_list(hrn) + chain = [] + for i in range(len(parts)): + chain.append('.'.join(parts[:i+1])) + # Include the HRN itself? + #chain.append(hrn) + return chain + + # Is the given HRN a true authority over the namespace of the other + # child HRN? + # A better alternative than childHRN.startswith(parentHRN) + # e.g. hrn_is_auth_for_hrn('a\.b', 'a\.b.c.d') -> True, + # but hrn_is_auth_for_hrn('a', 'a\.b.c.d') -> False + # Also hrn_is_uauth_for_hrn('a\.b.c.d', 'a\.b.c.d') -> True + @staticmethod + def hrn_is_auth_for_hrn(parenthrn, hrn): + if parenthrn == hrn: + return True + for auth in Xrn.hrn_auth_chain(hrn): + if parenthrn == auth: + return True + return False + URN_PREFIX = "urn:publicid:IDN" ########## basic tools on URNs @staticmethod def urn_full (urn): if urn.startswith(Xrn.URN_PREFIX): return urn - else: return Xrn.URN_PREFIX+URN + else: return Xrn.URN_PREFIX+urn @staticmethod def urn_meaningful (urn): if urn.startswith(Xrn.URN_PREFIX): return urn[len(Xrn.URN_PREFIX):] @@ -60,31 +114,31 @@ class Xrn: # self.type # self.path # provide either urn, or (hrn + type) - def __init__ (self, xrn=None, urn=None, hrn=None, type=None): + def __init__ (self, xrn, type=None): + if not xrn: xrn = "" + # user has specified xrn : guess if urn or hrn - if xrn is not None: - if xrn.startswith(Xrn.URN_PREFIX): - self.urn=xrn - self.urn_to_hrn() - else: - self.hrn=xrn - self.type=type - self.hrn_to_urn() - # user has specified urn, let's use it - elif urn is not None: - self.urn=urn + if xrn.startswith(Xrn.URN_PREFIX): + self.hrn=None + self.urn=xrn self.urn_to_hrn() - # user has specified hrn and type - elif hrn is not None and type is not None: - self.hrn=hrn + #print>>sys.stderr, " \r\n \r\n \t XRN.PY init xrn.startswith(Xrn.URN_PREFIX) hrn %s urn %s type %s" %( self.hrn, self.urn, self.type) + else: + self.urn=None + self.hrn=xrn self.type=type self.hrn_to_urn() - # what should we do ? - else: - raise SfaAPIError,"Xrn.__init__" + #print>>sys.stderr, " \r\n \r\n \t XRN.PY init ELSE hrn %s urn %s type %s" %( self.hrn, self.urn, self.type) # happens all the time .. # if not type: -# sfa_logger().debug("type-less Xrn's are not safe") +# debug_logger.debug("type-less Xrn's are not safe") + + def __repr__ (self): + result=">sys.stderr, " \r\n \r\n \t XRN.PY _normalize self.hrn %s ",self.hrn if self.hrn is None: raise SfaAPIError, "Xrn._normalize" if not hasattr(self,'leaf'): self.leaf=Xrn.hrn_split(self.hrn)[-1] # self.authority keeps a list if not hasattr(self,'authority'): self.authority=Xrn.hrn_auth_list(self.hrn) - + #print>>sys.stderr, " \r\n \r\n \t XRN.PY _normalize self.hrn %s leaf %s authority %s"%(self.hrn, self.leaf, self.authority) + + def get_leaf(self): self._normalize() return self.leaf - def get_authority_hrn(self): + def get_authority_hrn(self): self._normalize() return '.'.join( self.authority ) def get_authority_urn(self): self._normalize() return ':'.join( [Xrn.unescape(x) for x in self.authority] ) - + + def get_sliver_id(self, slice_id, node_id, index=0): + self._normalize() + return ":".join(map(str, [self.get_urn(), slice_id, node_id, index])) + def urn_to_hrn(self): """ compute tuple (hrn, type) from urn @@ -123,14 +184,24 @@ class Xrn: parts = Xrn.urn_split(self.urn) type=parts.pop(2) # Remove the authority name (e.g. '.sa') - if type == 'authority': parts.pop() - + if type == 'authority': + name = parts.pop() + # Drop the sa. This is a bad hack, but its either this + # or completely change how record types are generated/stored + if name != 'sa': + type = type + "+" + name + name ="" + else: + name = parts.pop(len(parts)-1) # convert parts (list) into hrn (str) by doing the following # 1. remove blank parts # 2. escape dots inside parts # 3. replace ':' with '.' inside parts - # 3. join parts using '.' - hrn = '.'.join([Xrn.escape(part).replace(':','.') for part in parts if part]) + # 3. join parts using '.' + hrn = '.'.join([Xrn.escape(part).replace(':','.') for part in parts if part]) + # dont replace ':' in the name section + if name: + hrn += '.%s' % Xrn.escape(name) self.hrn=str(hrn) self.type=str(type) @@ -144,9 +215,13 @@ class Xrn: if self.hrn.startswith(Xrn.URN_PREFIX): raise SfaAPIError, "Xrn.hrn_to_urn, hrn=%s"%self.hrn - if self.type == 'authority': + if self.type and self.type.startswith('authority'): self.authority = Xrn.hrn_split(self.hrn) - name = 'sa' + type_parts = self.type.split("+") + self.type = type_parts[0] + name = 'sa' + if len(type_parts) > 1: + name = type_parts[1] else: self.authority = Xrn.hrn_auth_list(self.hrn) name = Xrn.hrn_leaf(self.hrn) @@ -154,9 +229,9 @@ class Xrn: authority_string = self.get_authority_urn() if self.type == None: - urn = "+".join(['',authority_string,name]) + urn = "+".join(['',authority_string,Xrn.unescape(name)]) else: - urn = "+".join(['',authority_string,self.type,name]) + urn = "+".join(['',authority_string,self.type,Xrn.unescape(name)]) self.urn = Xrn.URN_PREFIX + urn