X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sfa%2Futil%2Fxrn.py;h=6198f83c7f57465cd6b22f8ed026372f07926ec7;hb=ecc85e0b923922cf7117d29b380f5284edb88f21;hp=f48a37732a713796ef316d8997ea7199d77aa741;hpb=5822ffb68c0d4cc5e29ec945e0dc21125294463f;p=sfa.git diff --git a/sfa/util/xrn.py b/sfa/util/xrn.py index f48a3773..6198f83c 100644 --- a/sfa/util/xrn.py +++ b/sfa/util/xrn.py @@ -32,9 +32,6 @@ 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: ########## basic tools on HRNs @@ -82,7 +79,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 +89,39 @@ class Xrn: return True return False + ########## basic tools on URNs URN_PREFIX = "urn:publicid:IDN" + URN_PREFIX_lower = "urn:publicid:idn" + + @staticmethod + def is_urn (text): + return text.lower().startswith(Xrn.URN_PREFIX_lower) - ########## basic tools on URNs @staticmethod def urn_full (urn): - if urn.startswith(Xrn.URN_PREFIX): return urn + if Xrn.is_urn(urn): return urn else: return Xrn.URN_PREFIX+urn @staticmethod def urn_meaningful (urn): - if urn.startswith(Xrn.URN_PREFIX): return urn[len(Xrn.URN_PREFIX):] + 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,18 +129,22 @@ class Xrn: # self.type # self.path # provide either urn, or (hrn + type) - def __init__ (self, xrn, type=None): + 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.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() else: self.urn=None self.hrn=xrn self.type=type self.hrn_to_urn() + self._normalize() # happens all the time .. # if not type: # debug_logger.debug("type-less Xrn's are not safe") @@ -143,7 +162,7 @@ class Xrn: def get_hrn_type(self): return (self.hrn, self.type) def _normalize(self): - if self.hrn is None: raise SfaAPIError, "Xrn._normalize" + 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 @@ -161,19 +180,38 @@ class Xrn: 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): + + 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(map(str, [self.get_urn(), slice_id, node_id, index])) - + + # 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) @@ -195,6 +233,10 @@ class Xrn: hrn = '.'.join([Xrn.escape(part).replace(':','.') for part in parts if part]) # dont replace ':' in the name section if 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) @@ -206,27 +248,34 @@ class Xrn: """ # 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)]) else: 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):