X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sfa%2Futil%2Fxrn.py;h=692c80d85513e1d3be1972bd9adc0eb0816ae5c9;hb=HEAD;hp=26795129f3da501a8d211b96b6ceb0c121df3649;hpb=013d9db0fd63345c1d24b2b15b59d3dc5036bc18;p=sfa.git diff --git a/sfa/util/xrn.py b/sfa/util/xrn.py index 26795129..692c80d8 100644 --- a/sfa/util/xrn.py +++ b/sfa/util/xrn.py @@ -1,4 +1,4 @@ -#---------------------------------------------------------------------- +# ---------------------------------------------------------------------- # Copyright (c) 2008 Board of Trustees, Princeton University # # Permission is hereby granted, free of charge, to any person obtaining @@ -11,59 +11,79 @@ # 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 +# 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. -#---------------------------------------------------------------------- +# ---------------------------------------------------------------------- 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(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) +# for convenience and smoother translation - we should get rid of these +# functions eventually + + +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 ":".join(map(str, [urn, slice_id, node_id, index])) class Xrn: - ########## basic tools on HRNs + # basic tools on HRNs # split a HRN-like string into pieces # this is like split('.') except for escaped (backslashed) dots # e.g. hrn_split ('a\.b.c.d') -> [ 'a\.b','c','d'] @staticmethod def hrn_split(hrn): - return [ x.replace('--sep--','\\.') for x in hrn.replace('\\.','--sep--').split('.') ] + return [x.replace('--sep--', '\\.') + for x in hrn.replace('\\.', '--sep--').split('.')] # e.g. hrn_leaf ('a\.b.c.d') -> 'd' @staticmethod - def hrn_leaf(hrn): return Xrn.hrn_split(hrn)[-1] + def hrn_leaf(hrn): + return Xrn.hrn_split(hrn)[-1] # e.g. hrn_auth_list ('a\.b.c.d') -> ['a\.b', 'c'] @staticmethod - def hrn_auth_list(hrn): return Xrn.hrn_split(hrn)[0:-1] - + def hrn_auth_list(hrn): + return Xrn.hrn_split(hrn)[0:-1] + # e.g. hrn_auth ('a\.b.c.d') -> 'a\.b.c' @staticmethod - def hrn_auth(hrn): return '.'.join(Xrn.hrn_auth_list(hrn)) - + def hrn_auth(hrn): + return '.'.join(Xrn.hrn_auth_list(hrn)) + # e.g. escape ('a.b') -> 'a\.b' @staticmethod - def escape(token): return re.sub(r'([^\\])\.', r'\1\.', token) + def escape(token): + return re.sub(r'([^\\])\.', r'\1\.', token) # e.g. unescape ('a\.b') -> 'a.b' @staticmethod - def unescape(token): return token.replace('\\.','.') + 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'] @@ -72,9 +92,9 @@ class Xrn: parts = Xrn.hrn_auth_list(hrn) chain = [] for i in range(len(parts)): - chain.append('.'.join(parts[:i+1])) + chain.append('.'.join(parts[:i + 1])) # Include the HRN itself? - #chain.append(hrn) + # chain.append(hrn) return chain # Is the given HRN a true authority over the namespace of the other @@ -82,7 +102,7 @@ class Xrn: # 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 + # Also hrn_is_auth_for_hrn('a\.b.c.d', 'a\.b.c.d') -> True @staticmethod def hrn_is_auth_for_hrn(parenthrn, hrn): if parenthrn == hrn: @@ -92,21 +112,46 @@ class Xrn: return True return False + # basic tools on URNs URN_PREFIX = "urn:publicid:IDN" + URN_PREFIX_lower = "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 + def is_urn(text): + return text.lower().startswith(Xrn.URN_PREFIX_lower) + @staticmethod - def urn_meaningful (urn): - if urn.startswith(Xrn.URN_PREFIX): return urn[len(Xrn.URN_PREFIX):] - else: return urn + def urn_full(urn): + if Xrn.is_urn(urn): + return urn + else: + return Xrn.URN_PREFIX + urn + @staticmethod - def urn_split (urn): + def urn_meaningful(urn): + if Xrn.is_urn(urn): + return urn[len(Xrn.URN_PREFIX):] + else: + return urn + + @staticmethod + def urn_split(urn): return Xrn.urn_meaningful(urn).split('+') + @staticmethod + def filter_type(urns=None, type=None): + if urns is None: + urns = [] + urn_list = [] + if not type: + return urns + + for urn in urns: + xrn = Xrn(xrn=urn) + if (xrn.type == type): + # Xrn is probably a urn so we can just compare types + urn_list.append(urn) + return urn_list #################### # the local fields that are kept consistent # self.urn @@ -114,123 +159,168 @@ class Xrn: # self.type # self.path # provide either urn, or (hrn + type) - def __init__ (self, xrn, type=None): - if not xrn: xrn = "" - + + def __init__(self, xrn="", type=None, id=None): + if not xrn: + xrn = "" # user has specified xrn : guess if urn or hrn - if xrn.startswith(Xrn.URN_PREFIX): - self.hrn=None - self.urn=xrn + self.id = id + if Xrn.is_urn(xrn): + self.hrn = None + self.urn = xrn + if id: + self.urn = "%s:%s" % (self.urn, str(id)) self.urn_to_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.urn = None + self.hrn = xrn + self.type = type self.hrn_to_urn() - #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: -# debug_logger.debug("type-less Xrn's are not safe") + self._normalize() + + 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] + 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) - - + if not hasattr(self, 'authority'): + self.authority = Xrn.hrn_auth_list(self.hrn) + 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( self.authority ) - - def get_authority_urn(self): + return ':'.join([Xrn.unescape(x) for x in self.authority]) + + def set_authority(self, authority): + """ + update the authority section of an existing urn + """ + authority_hrn = self.get_authority_hrn() + if not authority_hrn.startswith(authority): + hrn = ".".join([authority, authority_hrn, self.get_leaf()]) + else: + hrn = ".".join([authority_hrn, self.get_leaf()]) + + self.hrn = hrn + self.hrn_to_urn() self._normalize() - return ':'.join( [Xrn.unescape(x) for x in self.authority] ) - + + # sliver_id_parts is list that contains the sliver's + # slice id and node id + def get_sliver_id_parts(self): + sliver_id_parts = [] + if self.type == 'sliver' or '-' in self.leaf: + sliver_id_parts = self.leaf.split('-') + return sliver_id_parts + def urn_to_hrn(self): """ compute tuple (hrn, type) from urn """ - + # if not self.urn or not self.urn.startswith(Xrn.URN_PREFIX): - if not self.urn.startswith(Xrn.URN_PREFIX): - raise SfaAPIError, "Xrn.urn_to_hrn" + if not Xrn.is_urn(self.urn): + raise SfaAPIError("Xrn.urn_to_hrn") parts = Xrn.urn_split(self.urn) - type=parts.pop(2) + type = parts.pop(2) # Remove the authority name (e.g. '.sa') 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 + # or completely change how record types are generated/stored if name != 'sa': type = type + "+" + name - name ="" + name = "" else: - name = parts.pop(len(parts)-1) + 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]) + 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) + parts = name.split(':') + if len(parts) > 1: + self.id = ":".join(parts[1:]) + name = parts[0] + hrn += '.%s' % Xrn.escape(name) + + self.hrn = str(hrn) + self.type = str(type) - self.hrn=str(hrn) - self.type=str(type) - def hrn_to_urn(self): """ compute urn from (hrn, type) """ # if not self.hrn or self.hrn.startswith(Xrn.URN_PREFIX): - if self.hrn.startswith(Xrn.URN_PREFIX): - raise SfaAPIError, "Xrn.hrn_to_urn, hrn=%s"%self.hrn + if Xrn.is_urn(self.hrn): + raise SfaAPIError("Xrn.hrn_to_urn, hrn=%s" % self.hrn) if self.type and self.type.startswith('authority'): - self.authority = Xrn.hrn_split(self.hrn) + self.authority = Xrn.hrn_auth_list(self.hrn) + leaf = self.get_leaf() + # if not self.authority: + # self.authority = [self.hrn] type_parts = self.type.split("+") self.type = type_parts[0] name = 'sa' if len(type_parts) > 1: name = type_parts[1] + auth_parts = [part for part in [ + self.get_authority_urn(), leaf] if part] + authority_string = ":".join(auth_parts) else: self.authority = Xrn.hrn_auth_list(self.hrn) name = Xrn.hrn_leaf(self.hrn) + authority_string = self.get_authority_urn() - authority_string = self.get_authority_urn() - - if self.type == None: - urn = "+".join(['',authority_string,Xrn.unescape(name)]) + if self.type is None: + urn = "+".join(['', authority_string, Xrn.unescape(name)]) else: - urn = "+".join(['',authority_string,self.type,Xrn.unescape(name)]) - + urn = "+".join(['', authority_string, + self.type, Xrn.unescape(name)]) + + if hasattr(self, 'id') and self.id: + urn = "%s:%s" % (urn, self.id) + self.urn = Xrn.URN_PREFIX + urn def dump_string(self): - result="-------------------- XRN\n" - result += "URN=%s\n"%self.urn - result += "HRN=%s\n"%self.hrn - result += "TYPE=%s\n"%self.type - result += "LEAF=%s\n"%self.get_leaf() - result += "AUTH(hrn format)=%s\n"%self.get_authority_hrn() - result += "AUTH(urn format)=%s\n"%self.get_authority_urn() + result = "-------------------- XRN\n" + result += "URN=%s\n" % self.urn + result += "HRN=%s\n" % self.hrn + result += "TYPE=%s\n" % self.type + result += "LEAF=%s\n" % self.get_leaf() + result += "AUTH(hrn format)=%s\n" % self.get_authority_hrn() + result += "AUTH(urn format)=%s\n" % self.get_authority_urn() return result -