0721f81835caabd352aee9c3a09f8c0061bb3289
[sfa.git] / sfa / util / xrn.py
1 #----------------------------------------------------------------------\r
2 # Copyright (c) 2008 Board of Trustees, Princeton University\r
3 #\r
4 # Permission is hereby granted, free of charge, to any person obtaining\r
5 # a copy of this software and/or hardware specification (the "Work") to\r
6 # deal in the Work without restriction, including without limitation the\r
7 # rights to use, copy, modify, merge, publish, distribute, sublicense,\r
8 # and/or sell copies of the Work, and to permit persons to whom the Work\r
9 # is furnished to do so, subject to the following conditions:\r
10 #\r
11 # The above copyright notice and this permission notice shall be\r
12 # included in all copies or substantial portions of the Work.\r
13 #\r
14 # THE WORK IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS \r
15 # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF \r
16 # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND \r
17 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT \r
18 # HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, \r
19 # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, \r
20 # OUT OF OR IN CONNECTION WITH THE WORK OR THE USE OR OTHER DEALINGS \r
21 # IN THE WORK.\r
22 #----------------------------------------------------------------------\r
23 \r
24 import re\r
25 \r
26 from sfa.util.faults import SfaAPIError\r
27 \r
28 # for convenience and smoother translation - we should get rid of these functions eventually \r
29 def get_leaf(hrn): return Xrn(hrn).get_leaf()\r
30 def get_authority(hrn): return Xrn(hrn).get_authority_hrn()\r
31 def urn_to_hrn(urn): xrn=Xrn(urn); return (xrn.hrn, xrn.type)\r
32 def hrn_to_urn(hrn,type): return Xrn(hrn, type=type).urn\r
33 def hrn_authfor_hrn(parenthrn, hrn): return Xrn.hrn_is_auth_for_hrn(parenthrn, hrn)\r
34 \r
35 class Xrn:\r
36 \r
37     ########## basic tools on HRNs\r
38     # split a HRN-like string into pieces\r
39     # this is like split('.') except for escaped (backslashed) dots\r
40     # e.g. hrn_split ('a\.b.c.d') -> [ 'a\.b','c','d']\r
41     @staticmethod\r
42     def hrn_split(hrn):\r
43         return [ x.replace('--sep--','\\.') for x in hrn.replace('\\.','--sep--').split('.') ]\r
44 \r
45     # e.g. hrn_leaf ('a\.b.c.d') -> 'd'\r
46     @staticmethod\r
47     def hrn_leaf(hrn): return Xrn.hrn_split(hrn)[-1]\r
48 \r
49     # e.g. hrn_auth_list ('a\.b.c.d') -> ['a\.b', 'c']\r
50     @staticmethod\r
51     def hrn_auth_list(hrn): return Xrn.hrn_split(hrn)[0:-1]\r
52     \r
53     # e.g. hrn_auth ('a\.b.c.d') -> 'a\.b.c'\r
54     @staticmethod\r
55     def hrn_auth(hrn): return '.'.join(Xrn.hrn_auth_list(hrn))\r
56     \r
57     # e.g. escape ('a.b') -> 'a\.b'\r
58     @staticmethod\r
59     def escape(token): return re.sub(r'([^\\])\.', r'\1\.', token)\r
60 \r
61     # e.g. unescape ('a\.b') -> 'a.b'\r
62     @staticmethod\r
63     def unescape(token): return token.replace('\\.','.')\r
64 \r
65     # Return the HRN authority chain from top to bottom.\r
66     # e.g. hrn_auth_chain('a\.b.c.d') -> ['a\.b', 'a\.b.c']\r
67     @staticmethod\r
68     def hrn_auth_chain(hrn):\r
69         parts = Xrn.hrn_auth_list(hrn)\r
70         chain = []\r
71         for i in range(len(parts)):\r
72             chain.append('.'.join(parts[:i+1]))\r
73         # Include the HRN itself?\r
74         #chain.append(hrn)\r
75         return chain\r
76 \r
77     # Is the given HRN a true authority over the namespace of the other\r
78     # child HRN?\r
79     # A better alternative than childHRN.startswith(parentHRN)\r
80     # e.g. hrn_is_auth_for_hrn('a\.b', 'a\.b.c.d') -> True,\r
81     # but hrn_is_auth_for_hrn('a', 'a\.b.c.d') -> False\r
82     # Also hrn_is_auth_for_hrn('a\.b.c.d', 'a\.b.c.d') -> True\r
83     @staticmethod\r
84     def hrn_is_auth_for_hrn(parenthrn, hrn):\r
85         if parenthrn == hrn:\r
86             return True\r
87         for auth in Xrn.hrn_auth_chain(hrn):\r
88             if parenthrn == auth:\r
89                 return True\r
90         return False\r
91 \r
92     ########## basic tools on URNs\r
93     URN_PREFIX = "urn:publicid:IDN"\r
94     URN_PREFIX_lower = "urn:publicid:idn"\r
95 \r
96     @staticmethod\r
97     def is_urn (text):\r
98         return text.lower().startswith(Xrn.URN_PREFIX_lower)\r
99 \r
100     @staticmethod\r
101     def urn_full (urn):\r
102         if Xrn.is_urn(urn): return urn\r
103         else: return Xrn.URN_PREFIX+urn\r
104     @staticmethod\r
105     def urn_meaningful (urn):\r
106         if Xrn.is_urn(urn): return urn[len(Xrn.URN_PREFIX):]\r
107         else: return urn\r
108     @staticmethod\r
109     def urn_split (urn):\r
110         return Xrn.urn_meaningful(urn).split('+')\r
111 \r
112     ####################\r
113     # the local fields that are kept consistent\r
114     # self.urn\r
115     # self.hrn\r
116     # self.type\r
117     # self.path\r
118     # provide either urn, or (hrn + type)\r
119     def __init__ (self, xrn="", type=None, id=None):\r
120         if not xrn: xrn = ""\r
121         # user has specified xrn : guess if urn or hrn\r
122         self.id = id\r
123         if Xrn.is_urn(xrn):\r
124             self.hrn=None\r
125             self.urn=xrn\r
126             if id:\r
127                 self.urn = "%s:%s" % (self.urn, str(id))\r
128             self.urn_to_hrn()\r
129         else:\r
130             self.urn=None\r
131             self.hrn=xrn\r
132             self.type=type\r
133             self.hrn_to_urn()\r
134         self._normalize()\r
135 # happens all the time ..\r
136 #        if not type:\r
137 #            debug_logger.debug("type-less Xrn's are not safe")\r
138 \r
139     def __repr__ (self):\r
140         result="<XRN u=%s h=%s"%(self.urn,self.hrn)\r
141         if hasattr(self,'leaf'): result += " leaf=%s"%self.leaf\r
142         if hasattr(self,'authority'): result += " auth=%s"%self.authority\r
143         result += ">"\r
144         return result\r
145 \r
146     def get_urn(self): return self.urn\r
147     def get_hrn(self): return self.hrn\r
148     def get_type(self): return self.type\r
149     def get_hrn_type(self): return (self.hrn, self.type)\r
150 \r
151     def _normalize(self):\r
152         if self.hrn is None: raise SfaAPIError, "Xrn._normalize"\r
153         if not hasattr(self,'leaf'): \r
154             self.leaf=Xrn.hrn_split(self.hrn)[-1]\r
155         # self.authority keeps a list\r
156         if not hasattr(self,'authority'): \r
157             self.authority=Xrn.hrn_auth_list(self.hrn)\r
158 \r
159     def get_leaf(self):\r
160         self._normalize()\r
161         return self.leaf\r
162 \r
163     def get_authority_hrn(self):\r
164         self._normalize()\r
165         return '.'.join( self.authority )\r
166     \r
167     def get_authority_urn(self): \r
168         self._normalize()\r
169         return ':'.join( [Xrn.unescape(x) for x in self.authority] )\r
170 \r
171     def set_authority(self, authority):\r
172         """\r
173         update the authority section of an existing urn\r
174         """\r
175         authority_hrn = self.get_authority_hrn()\r
176         if not authority_hrn.startswith(authority):\r
177             hrn = ".".join([authority,authority_hrn, self.get_leaf()])\r
178         else:\r
179             hrn = ".".join([authority_hrn, self.get_leaf()])\r
180             \r
181         self.hrn = hrn \r
182         self.hrn_to_urn()\r
183         self._normalize()\r
184         \r
185     def urn_to_hrn(self):\r
186         """\r
187         compute tuple (hrn, type) from urn\r
188         """\r
189         \r
190 #        if not self.urn or not self.urn.startswith(Xrn.URN_PREFIX):\r
191         if not Xrn.is_urn(self.urn):\r
192             raise SfaAPIError, "Xrn.urn_to_hrn"\r
193 \r
194         parts = Xrn.urn_split(self.urn)\r
195         type=parts.pop(2)\r
196         # Remove the authority name (e.g. '.sa')\r
197         if type == 'authority':\r
198             name = parts.pop()\r
199             # Drop the sa. This is a bad hack, but its either this\r
200             # or completely change how record types are generated/stored   \r
201             if name != 'sa':\r
202                 type = type + "+" + name\r
203             name =""\r
204         else:\r
205             name = parts.pop(len(parts)-1)\r
206         # convert parts (list) into hrn (str) by doing the following\r
207         # 1. remove blank parts\r
208         # 2. escape dots inside parts\r
209         # 3. replace ':' with '.' inside parts\r
210         # 3. join parts using '.'\r
211         hrn = '.'.join([Xrn.escape(part).replace(':','.') for part in parts if part])\r
212         # dont replace ':' in the name section\r
213         if name:\r
214             parts = name.split(':')\r
215             if len(parts) > 1:\r
216                 self.id = ":".join(parts[1:])\r
217                 name = parts[0]    \r
218             hrn += '.%s' % Xrn.escape(name) \r
219 \r
220         self.hrn=str(hrn)\r
221         self.type=str(type)\r
222     \r
223     def hrn_to_urn(self):\r
224         """\r
225         compute urn from (hrn, type)\r
226         """\r
227 \r
228 #        if not self.hrn or self.hrn.startswith(Xrn.URN_PREFIX):\r
229         if Xrn.is_urn(self.hrn):\r
230             raise SfaAPIError, "Xrn.hrn_to_urn, hrn=%s"%self.hrn\r
231 \r
232         if self.type and self.type.startswith('authority'):\r
233             self.authority = Xrn.hrn_auth_list(self.hrn)\r
234             leaf = self.get_leaf()\r
235             #if not self.authority:\r
236             #    self.authority = [self.hrn]\r
237             type_parts = self.type.split("+")\r
238             self.type = type_parts[0]\r
239             name = 'sa'\r
240             if len(type_parts) > 1:\r
241                 name = type_parts[1]\r
242             auth_parts = [part for part in [self.get_authority_urn(), leaf] if part]\r
243             authority_string = ":".join(auth_parts)\r
244         else:\r
245             self.authority = Xrn.hrn_auth_list(self.hrn)\r
246             name = Xrn.hrn_leaf(self.hrn)\r
247             authority_string = self.get_authority_urn()\r
248 \r
249         if self.type == None:\r
250             urn = "+".join(['',authority_string,Xrn.unescape(name)])\r
251         else:\r
252             urn = "+".join(['',authority_string,self.type,Xrn.unescape(name)])\r
253 \r
254         if hasattr(self, 'id') and self.id:\r
255             urn = "%s:%s" % (urn, self.id)        \r
256 \r
257         self.urn = Xrn.URN_PREFIX + urn\r
258 \r
259     def dump_string(self):\r
260         result="-------------------- XRN\n"\r
261         result += "URN=%s\n"%self.urn\r
262         result += "HRN=%s\n"%self.hrn\r
263         result += "TYPE=%s\n"%self.type\r
264         result += "LEAF=%s\n"%self.get_leaf()\r
265         result += "AUTH(hrn format)=%s\n"%self.get_authority_hrn()\r
266         result += "AUTH(urn format)=%s\n"%self.get_authority_urn()\r
267         return result\r
268         \r