from sfa.util.sfalogging import logger
 from sfa.util.defaultdict import defaultdict
 from sfa.util.sfatime import utcparse, datetime_to_string, datetime_to_epoch
-from sfa.util.xrn import Xrn, hrn_to_urn, get_leaf, urn_to_sliver_id
+from sfa.util.xrn import Xrn, hrn_to_urn, get_leaf 
 from sfa.openstack.osxrn import OSXrn, hrn_to_os_slicename, hrn_to_os_tenant_name
 from sfa.util.cache import Cache
 from sfa.trust.credential import Credential
             res['plos_created_at'] = datetime_to_string(utcparse(instance.created))    
             res['plos_boot_state'] = instance.status
             res['plos_sliver_type'] = self.shell.nova_manager.flavors.find(id=instance.flavor['id']).name 
-            sliver_id =  Xrn(slice_urn).get_sliver_id(instance.id)
+            sliver_id =  Xrn(slice_urn, id=instance.id).get_urn()
             res['geni_urn'] = sliver_id
 
             if instance.status.lower() == 'active':
 
         user_data += "\n"
     return user_data
 
-def instance_to_sliver(instance, slice_xrn=None):
-    sliver_id = None
+def instance_to_sliver(instance, xrn=None):
+    sliver_urn = None
     if slice_xrn:
-        xrn = Xrn(slice_xrn, 'slice')
-        sliver_id = xrn.get_sliver_id(instance.project_id, instance.hostname, instance.id)
+        sliver_xrn = Xrn(xrn=slice_xrn, type='slice', id=instance.id).get_urn()
 
-    sliver = Sliver({'slice_id': sliver_id,
+    sliver = Sliver({'slice_id': sliver_urn,
                      'name': instance.name,
                      'type': instance.name,
                      'cpus': str(instance.vcpus),
 
     def __init__(self, name=None, auth=None, **kwds):
         
         config = Config()
+        self.id = id
         if name is not None:
             if 'type' in kwds:
                 self.type = kwds['type']
         self._normalize()
         tenant_name = self.hrn.replace('\.', '')
         return tenant_name
-        
-        
-            
+       
 
 #!/usr/bin/python
-from sfa.util.xrn import Xrn, hrn_to_urn, urn_to_hrn, urn_to_sliver_id
+from sfa.util.xrn import Xrn, hrn_to_urn, urn_to_hrn
 from sfa.util.sfatime import utcparse, datetime_to_string
 from sfa.util.sfalogging import logger
 
 
         # sort slivers by node id    
         for node_id in slice['node_ids']:
-            sliver = Sliver({'sliver_id': urn_to_sliver_id(slice_urn, slice['slice_id'], node_id, authority=self.driver.hrn),
+            
+            id = ":".join(map(str, [slice['slice_id'], node_id]))
+            xrn = Xrn(slice_urn, id=id).get_urn()
+            xrn.set_authority(self.driver.hrn)
+            sliver_urn = xrn.get_urn()
+            sliver = Sliver({'sliver_id': sliver_urn,
                              'name': slice['name'],
                              'type': 'plab-vserver', 
                              'tags': []})
         for tag in tags:
             # most likely a default/global sliver attribute (node_id == None)
             if tag['node_id'] not in slivers:
-                sliver = Sliver({'sliver_id': urn_to_sliver_id(slice_urn, slice['slice_id'], ""),
+                sliver_urn = Xrn(slice_urn, id = slice['slice_id']).get_urn()
+                sliver = Sliver({'sliver_id': sliver_urn,
                                  'name': slice['name'],
                                  'type': 'plab-vserver',
                                  'tags': []})
 
 from sfa.util.sfalogging import logger
 from sfa.util.defaultdict import defaultdict
 from sfa.util.sfatime import utcparse, datetime_to_string, datetime_to_epoch
-from sfa.util.xrn import hrn_to_urn, get_leaf, urn_to_sliver_id
+from sfa.util.xrn import hrn_to_urn, get_leaf
 from sfa.util.cache import Cache
 
 # one would think the driver should not need to mess with the SFA db, but..
             if node['last_contact'] is not None:
                 
                 res['pl_last_contact'] = datetime_to_string(utcparse(node['last_contact']))
-            sliver_id = urn_to_sliver_id(slice_urn, slice['slice_id'], node['node_id'], authority=self.hrn) 
-            res['geni_urn'] = sliver_id
+            sliver_id = "%s:%s" % (slice['slice_id'], node['node_id'])
+            sliver_xrn = Xrn(slice_urn, id = sliver_id)
+            sliver_xrn.set_authority(self.hrn)
+            res['geni_urn'] = sliver_xrn.get_urn()
             if node['boot_state'] == 'boot':
                 res['geni_status'] = 'ready'
             else:
 
 from copy import deepcopy
 from StringIO import StringIO
-from sfa.util.xrn import Xrn, urn_to_sliver_id
+from sfa.util.xrn import Xrn
 from sfa.rspecs.version import RSpecVersion
 from sfa.rspecs.elements.versions.pgv2Link import PGv2Link
 from sfa.rspecs.elements.versions.pgv2Node import PGv2Node
                 # set the sliver id
                 #slice_id = sliver_info.get('slice_id', -1)
                 #node_id = sliver_info.get('node_id', -1)
-                #sliver_id = urn_to_sliver_id(sliver_urn, slice_id, node_id)
                 #node_elem.set('sliver_id', sliver_id)
 
             # add the sliver type elemnt    
 
+++ /dev/null
-import re
-from sfa.util.xrn import Xrn
-from sfa.util.config import Config
-
-class OSXrn(Xrn):
-
-    def __init__(self, name=None, type=None, **kwds):
-        
-        config = Config()
-        if name is not None:
-            self.type = type
-            self.hrn = config.SFA_INTERFACE_HRN + "." + name
-            self.hrn_to_urn()
-        else:
-            Xrn.__init__(self, **kwds)   
-         
-        self.name = self.get_name() 
-    
-    def get_name(self):
-        self._normalize()
-        leaf = self.leaf
-        sliver_id_parts = leaf.split(':')
-        name = sliver_id_parts[0]
-        name = re.sub('[^a-zA-Z0-9_]', '', name)
-        return name
-
-    
 
 def hrn_to_urn(hrn,type): return Xrn(hrn, type=type).urn\r
 def hrn_authfor_hrn(parenthrn, hrn): return Xrn.hrn_is_auth_for_hrn(parenthrn, hrn)\r
 \r
-def urn_to_sliver_id(urn, slice_id, node_id, index=0, authority=None):\r
-    return Xrn(urn).get_sliver_id(slice_id, node_id, index, authority)\r
-\r
 class Xrn:\r
 \r
     ########## basic tools on HRNs\r
     # self.type\r
     # self.path\r
     # provide either urn, or (hrn + type)\r
-    def __init__ (self, xrn, type=None):\r
+    def __init__ (self, xrn, type=None, id=None):\r
         if not xrn: xrn = ""\r
         # user has specified xrn : guess if urn or hrn\r
+        self.id = id\r
         if Xrn.is_urn(xrn):\r
             self.hrn=None\r
             self.urn=xrn\r
+            if id:\r
+                self.urn = "%s:%s" % (self.urn, str(id))\r
             self.urn_to_hrn()\r
         else:\r
             self.urn=None\r
         self._normalize()\r
         return ':'.join( [Xrn.unescape(x) for x in self.authority] )\r
 \r
-    def get_sliver_id(self, slice_id, node_id=None, index=0, authority=None):\r
+    def set_authority(self, authority):\r
+        """\r
+        update the authority section of an existing urn\r
+        """\r
+        authority_hrn = self.get_authority_hrn()\r
+        if not authority_hrn.startswith(authority):\r
+            hrn = ".".join([authority,authority_hrn, self.get_leaf()])\r
+        else:\r
+            hrn = ".".join([authority_hrn, self.get_leaf()])\r
+            \r
+        self.hrn = hrn \r
+        self.hrn_to_urn()\r
         self._normalize()\r
-        urn = self.get_urn()\r
-        if authority:\r
-            authority_hrn = self.get_authority_hrn()\r
-            if not authority_hrn.startswith(authority):\r
-                hrn = ".".join([authority,authority_hrn, self.get_leaf()])\r
-            else:\r
-                hrn = ".".join([authority_hrn, self.get_leaf()])\r
-            urn = Xrn(hrn, self.get_type()).get_urn()\r
-        parts = [part for part in [urn, slice_id, node_id, index] if part is not None]\r
-        return ":".join(map(str, [parts]))\r
-\r
+        \r
     def urn_to_hrn(self):\r
         """\r
         compute tuple (hrn, type) from urn\r
         hrn = '.'.join([Xrn.escape(part).replace(':','.') for part in parts if part])\r
         # dont replace ':' in the name section\r
         if name:\r
+            parts = name.split(':')\r
+            if len(parts) > 1:\r
+                self.id = ":".join(parts[1:])\r
+                name = parts[0]    \r
             hrn += '.%s' % Xrn.escape(name) \r
 \r
         self.hrn=str(hrn)\r
             urn = "+".join(['',authority_string,Xrn.unescape(name)])\r
         else:\r
             urn = "+".join(['',authority_string,self.type,Xrn.unescape(name)])\r
-        \r
+\r
+        if self.id:\r
+            urn = "%s:%s" % (urn, self.id)        \r
+\r
         self.urn = Xrn.URN_PREFIX + urn\r
 \r
     def dump_string(self):\r