import repository from arizona
[raven.git] / our-sfa-build / sfa / util / xrn.py
1 import re
2
3 from sfa.util.faults import *
4 from sfa.util.sfalogging import sfa_logger
5
6 # for convenience and smoother translation - we should get rid of these functions eventually 
7 def get_leaf(hrn): return Xrn(hrn).get_leaf()
8 def get_authority(hrn): return Xrn(hrn).get_authority_hrn()
9 def urn_to_hrn(urn): xrn=Xrn(urn); return (xrn.hrn, xrn.type)
10 def hrn_to_urn(hrn,type): return Xrn(hrn, type=type).urn
11
12 class Xrn:
13
14     ########## basic tools on HRNs
15     # split a HRN-like string into pieces
16     # this is like split('.') except for escaped (backslashed) dots
17     # e.g. hrn_split ('a\.b.c.d') -> [ 'a\.b','c','d']
18     @staticmethod
19     def hrn_split(hrn):
20         return [ x.replace('--sep--','\\.') for x in hrn.replace('\\.','--sep--').split('.') ]
21
22     # e.g. hrn_leaf ('a\.b.c.d') -> 'd'
23     @staticmethod
24     def hrn_leaf(hrn): return Xrn.hrn_split(hrn)[-1]
25
26     # e.g. hrn_auth_list ('a\.b.c.d') -> ['a\.b', 'c']
27     @staticmethod
28     def hrn_auth_list(hrn): return Xrn.hrn_split(hrn)[0:-1]
29     
30     # e.g. hrn_auth ('a\.b.c.d') -> 'a\.b.c'
31     @staticmethod
32     def hrn_auth(hrn): return '.'.join(Xrn.hrn_auth_list(hrn))
33     
34     # e.g. escape ('a.b') -> 'a\.b'
35     @staticmethod
36     def escape(token): return re.sub(r'([^\\])\.', r'\1\.', token)
37     # e.g. unescape ('a\.b') -> 'a.b'
38     @staticmethod
39     def unescape(token): return token.replace('\\.','.')
40         
41     URN_PREFIX = "urn:publicid:IDN"
42
43     ########## basic tools on URNs
44     @staticmethod
45     def urn_full (urn):
46         if urn.startswith(Xrn.URN_PREFIX): return urn
47         else: return Xrn.URN_PREFIX+URN
48     @staticmethod
49     def urn_meaningful (urn):
50         if urn.startswith(Xrn.URN_PREFIX): return urn[len(Xrn.URN_PREFIX):]
51         else: return urn
52     @staticmethod
53     def urn_split (urn):
54         return Xrn.urn_meaningful(urn).split('+')
55
56     ####################
57     # the local fields that are kept consistent
58     # self.urn
59     # self.hrn
60     # self.type
61     # self.path
62     # provide either urn, or (hrn + type)
63     def __init__ (self, xrn, type=None):
64         # user has specified xrn : guess if urn or hrn
65         if xrn is not None:
66             if xrn.startswith(Xrn.URN_PREFIX):
67                 self.hrn=None
68                 self.urn=xrn
69                 self.urn_to_hrn()
70             else:
71                 self.urn=None
72                 self.hrn=xrn
73                 self.type=type
74                 self.hrn_to_urn()
75         else:
76             raise SfaAPIError,"Xrn.__init__"
77 # happens all the time ..
78 #        if not type:
79 #            sfa_logger().debug("type-less Xrn's are not safe")
80
81     def get_urn(self): return self.urn
82     def get_hrn(self): return self.hrn
83     def get_type(self): return self.type
84     def get_hrn_type(self): return (self.hrn, self.type)
85
86     def _normalize(self):
87         if self.hrn is None: raise SfaAPIError, "Xrn._normalize"
88         if not hasattr(self,'leaf'): 
89             self.leaf=Xrn.hrn_split(self.hrn)[-1]
90         # self.authority keeps a list
91         if not hasattr(self,'authority'): 
92             self.authority=Xrn.hrn_auth_list(self.hrn)
93
94     def get_leaf(self):
95         self._normalize()
96         return self.leaf
97
98     def get_authority_hrn(self): 
99         self._normalize()
100         return '.'.join( self.authority )
101     
102     def get_authority_urn(self): 
103         self._normalize()
104         return ':'.join( [Xrn.unescape(x) for x in self.authority] )
105     
106     def urn_to_hrn(self):
107         """
108         compute tuple (hrn, type) from urn
109         """
110         
111 #        if not self.urn or not self.urn.startswith(Xrn.URN_PREFIX):
112         if not self.urn.startswith(Xrn.URN_PREFIX):
113             raise SfaAPIError, "Xrn.urn_to_hrn"
114
115         parts = Xrn.urn_split(self.urn)
116         type=parts.pop(2)
117         # Remove the authority name (e.g. '.sa')
118         if type == 'authority': parts.pop()
119
120         # convert parts (list) into hrn (str) by doing the following
121         # 1. remove blank parts
122         # 2. escape dots inside parts
123         # 3. replace ':' with '.' inside parts
124         # 3. join parts using '.' 
125         hrn = '.'.join([Xrn.escape(part).replace(':','.') for part in parts if part]) 
126
127         self.hrn=str(hrn)
128         self.type=str(type)
129     
130     def hrn_to_urn(self):
131         """
132         compute urn from (hrn, type)
133         """
134
135 #        if not self.hrn or self.hrn.startswith(Xrn.URN_PREFIX):
136         if self.hrn.startswith(Xrn.URN_PREFIX):
137             raise SfaAPIError, "Xrn.hrn_to_urn, hrn=%s"%self.hrn
138
139         if self.type == 'authority':
140             self.authority = Xrn.hrn_split(self.hrn)
141             name = 'sa'   
142         else:
143             self.authority = Xrn.hrn_auth_list(self.hrn)
144             name = Xrn.hrn_leaf(self.hrn)
145
146         authority_string = self.get_authority_urn()
147
148         if self.type == None:
149             urn = "+".join(['',authority_string,name])
150         else:
151             urn = "+".join(['',authority_string,self.type,name])
152         
153         self.urn = Xrn.URN_PREFIX + urn
154
155     def dump_string(self):
156         result="-------------------- XRN\n"
157         result += "URN=%s\n"%self.urn
158         result += "HRN=%s\n"%self.hrn
159         result += "TYPE=%s\n"%self.type
160         result += "LEAF=%s\n"%self.get_leaf()
161         result += "AUTH(hrn format)=%s\n"%self.get_authority_hrn()
162         result += "AUTH(urn format)=%s\n"%self.get_authority_urn()
163         return result
164