Cache connection URI in objects

crobinso · crobinso · commit 2402e0339a3e · 2011-07-15T14:44:59.000-04:00
Rather than fetch it numerous times throughout our objects
diff --git a/virt-install b/virt-install
@@ -408,7 +408,7 @@ def check_option_collisions(options, guest):
         if options.cdrom or options.livecd:
             fail(_("Paravirtualized guests cannot install off cdrom media."))
 
-    if options.location and virtinst.util.is_uri_remote(guest.conn.getURI()):
+    if options.location and guest.is_remote():
         fail(_("--location can not be specified for remote connections."))
 
     if not options.location and options.extra:
@@ -564,14 +564,14 @@ def start_install(guest, continue_inst, options):
                          virtinst.VirtualGraphics.TYPE_SPICE]:
                 logging.debug("Launching virt-viewer for graphics type '%s'" %
                               gtype)
-                return vnc_console(dom, guest.conn.getURI())
+                return vnc_console(dom, guest.get_uri())
             else:
                 logging.debug("No viewer to launch for graphics type '%s'" %
                               gtype)
                 return None # SDL needs no viewer app
         else:
             logging.debug("Connecting to text console")
-            return txt_console(dom, guest.conn.getURI())
+            return txt_console(dom, guest.get_uri())
 
     # There are two main cases we care about:
     #
diff --git a/virtinst/DistroInstaller.py b/virtinst/DistroInstaller.py
@@ -99,8 +99,7 @@ def set_location(self, val):
         is_tuple = False
         validated = True
         self._location_is_path = True
-        is_local = (not self.conn or
-                    not _util.is_uri_remote(self.conn.getURI()))
+        is_local = (not self.conn or not self.is_remote())
 
         # Basic validation
         if type(val) is not str and (type(val) is not tuple and len(val) != 2):
@@ -157,7 +156,7 @@ def set_location(self, val):
 
         if (not self._location_is_path and val.startswith("nfs:") and not
             User.current().has_priv(User.PRIV_NFS_MOUNT,
-                                    (self.conn and self.conn.getURI()))):
+                                    (self.conn and self.get_uri()))):
             raise ValueError(_('Privilege is required for NFS installations'))
 
         self._location = val
diff --git a/virtinst/VirtualDisk.py b/virtinst/VirtualDisk.py
@@ -1064,7 +1064,7 @@ def __get_default_driver(self):
         drvtype = self._driverType
 
         if self.conn:
-            is_qemu = _util.is_qemu(self.conn)
+            is_qemu = self.is_qemu()
             if is_qemu and not drvname:
                 drvname = self.DRIVER_QEMU
 
@@ -1166,7 +1166,7 @@ def __validate_params(self):
         storage_capable = bool(self.conn and
                                _util.is_storage_capable(self.conn))
 
-        if self._is_remote():
+        if self.is_remote():
             if not storage_capable:
                 raise ValueError(_("Connection doesn't support remote "
                                    "storage."))
@@ -1436,7 +1436,7 @@ def _get_xml_config(self, disknode=None):
                 drvxml += " io='%s'" % self.driver_io
 
             if drvxml and self.driver_name is None:
-                if _util.is_qemu(self.conn):
+                if self.is_qemu():
                     self.driver_name = "qemu"
 
             if not self.driver_name is None:
@@ -1557,7 +1557,7 @@ def _support_selinux(self):
             #      our label guesses are built with svirt in mind
             return False
 
-        elif self._is_remote():
+        elif self.is_remote():
             return False
 
         elif not _util.have_selinux():
diff --git a/virtinst/VirtualHostDevice.py b/virtinst/VirtualHostDevice.py
@@ -23,7 +23,6 @@
 import libvirt
 
 from virtinst import support
-from virtinst import _util
 from virtinst import _virtinst as _
 from XMLBuilderDomain import _xml_property
 
@@ -99,7 +98,7 @@ def __init__(self, conn, nodedev=None,
             return
 
         self.managed = True
-        if _util.get_uri_driver(self.conn.getURI()).lower() == "xen":
+        if self.is_xen():
             self.managed = False
 
 
diff --git a/virtinst/VirtualNetworkInterface.py b/virtinst/VirtualNetworkInterface.py
@@ -315,7 +315,7 @@ def is_conflict_net(self, conn, mac=None):
             return (False, None)
 
         # Not supported for remote connections yet
-        if self._is_remote():
+        if self.is_remote():
             return (False, None)
 
         vms, inactive_vm = _util.fetch_all_guests(conn)
diff --git a/virtinst/XMLBuilderDomain.py b/virtinst/XMLBuilderDomain.py
@@ -331,18 +331,15 @@ def __init__(self, conn=None, parsexml=None, parsexmlnode=None,
         @param parsexmlnode: Option xpathNode to use
         @param caps: Capabilities() instance
         """
-        if conn:
-            if not isinstance(conn, libvirt.virConnect):
-                raise ValueError(_("'conn' must be a virConnect instance"))
-        self._conn = conn
-
+        self._conn = None
+        self._conn_uri = None
+        self.__remote = False
         self.__caps = None
-        self.__remote = None
         self._xml_node = None
         self._xml_ctx = None
 
-        if self.conn:
-            self.__remote = _util.is_uri_remote(self.conn.getURI())
+        if conn:
+            self.set_conn(conn)
 
         if caps:
             if not isinstance(caps, CapabilitiesParser.Capabilities):
@@ -358,20 +355,26 @@ def set_conn(self, val):
         if not isinstance(val, libvirt.virConnect):
             raise ValueError(_("'conn' must be a virConnect instance."))
         self._conn = val
+        self._conn_uri = self._conn.getURI()
+        self.__remote = _util.is_uri_remote(self._conn_uri)
     conn = property(get_conn, set_conn)
 
+    def get_uri(self):
+        return self._conn_uri
+
     def _get_caps(self):
         if not self.__caps and self.conn:
             self.__caps = CapabilitiesParser.parse(self.conn.getCapabilities())
         return self.__caps
 
-    def _is_remote(self):
+    def is_remote(self):
         return bool(self.__remote)
-
-    def _get_uri(self):
-        if self.conn:
-            return self.conn.getURI()
-        return None
+    def is_qemu(self):
+        return _util.is_qemu(self.conn, self.get_uri())
+    def is_qemu_system(self):
+        return _util.is_qemu_system(self.conn, self.get_uri())
+    def is_xen(self):
+        return _util.is_xen(self.conn, self.get_uri())
 
     def _check_bool(self, val, name):
         if val not in [True, False]:
diff --git a/virtinst/_util.py b/virtinst/_util.py
@@ -399,8 +399,19 @@ def default_bridge2(conn=None):
 
     return None
 
-def is_qemu_system(conn):
-    if not conn:
+def _get_uri_to_split(conn, uri):
+    if not conn and not uri:
+        return None
+
+    if type(conn) is str:
+        uri = conn
+    elif uri is None:
+        uri = conn.getURI()
+    return uri
+
+def is_qemu_system(conn, uri=None):
+    uri = _get_uri_to_split(conn, uri)
+    if not uri:
         return False
 
     (scheme, ignore, ignore,
@@ -409,18 +420,22 @@ def is_qemu_system(conn):
         return True
     return False
 
-def is_qemu(conn):
-    if not conn:
+def is_qemu(conn, uri=None):
+    uri = _get_uri_to_split(conn, uri)
+    if not uri:
         return False
 
-    if type(conn) is str:
-        uri = conn
-    else:
-        uri = conn.getURI()
-
     scheme = uri_split(uri)[0]
     return scheme.startswith("qemu")
 
+def is_xen(conn, uri=None):
+    uri = _get_uri_to_split(conn, uri)
+    if not uri:
+        return False
+
+    scheme = uri_split(uri)[0]
+    return scheme.startswith("xen")
+
 def parse_node_helper(xml, root_name, callback, exec_class=ValueError):
     """
     Parse the passed XML, expecting root as root_name, and pass the
diff --git a/virtinst/cli.py b/virtinst/cli.py
@@ -457,7 +457,7 @@ def nice_exit():
     sys.exit(0)
 
 def virsh_start_cmd(guest):
-    return ("virsh --connect %s start %s" % (guest.conn.getURI(), guest.name))
+    return ("virsh --connect %s start %s" % (guest.get_uri(), guest.name))
 
 def install_fail(guest):
     virshcmd = virsh_start_cmd(guest)
@@ -835,10 +835,10 @@ def get_cpuset(cpuset, mem, guest):
 
     return
 
-def _default_network_opts(conn):
+def _default_network_opts(guest):
     opts = ""
-    if User.current().has_priv(User.PRIV_CREATE_NETWORK, conn.getURI()):
-        net = _util.default_network(conn)
+    if User.current().has_priv(User.PRIV_CREATE_NETWORK, guest.get_uri()):
+        net = _util.default_network(guest.conn)
         opts = "%s=%s" % (net[0], net[1])
     else:
         opts = "user"
@@ -868,7 +868,7 @@ def padlist(l, padsize):
 
     for idx in range(len(networks)):
         if networks[idx] is None:
-            networks[idx] = _default_network_opts(guest.conn)
+            networks[idx] = _default_network_opts(guest)
 
     return networks, macs
 
diff --git a/virtinst/support.py b/virtinst/support.py
@@ -318,15 +318,14 @@ def _local_lib_ver():
     return libvirt.getVersion()
 
 # Version of libvirt library/daemon on the connection (could be remote)
-def _daemon_lib_ver(conn, force_version, minimum_libvirt_version):
+def _daemon_lib_ver(conn, uri, force_version, minimum_libvirt_version):
     # Always force the required version if it's after the version which
     # has getLibVersion
     if force_version or minimum_libvirt_version >= 7004:
         default_ret = 0
     else:
         default_ret = 100000000000
 
-    uri = conn.getURI()
     if not _util.is_uri_remote(uri):
         return _local_lib_ver()
 
@@ -339,8 +338,8 @@ def _daemon_lib_ver(conn, force_version, minimum_libvirt_version):
     return conn.getLibVersion()
 
 # Return the hypervisor version
-def _hv_ver(conn):
-    drv_type = _util.get_uri_driver(conn.getURI())
+def _hv_ver(conn, uri):
+    drv_type = _util.get_uri_driver(uri)
     args = ()
 
     cmd = _get_command("getVersion", obj=conn)
@@ -396,7 +395,8 @@ def get_value(key):
             key_list.remove(key)
         return support_info.get(key)
 
-    drv_type = _util.get_uri_driver(conn.getURI())
+    uri = conn.getURI()
+    drv_type = _util.get_uri_driver(uri)
     is_rhel6 = _get_rhel6()
     force_version = get_value("force_version") or False
 
@@ -418,9 +418,9 @@ def get_value(key):
     flag = get_value("flag")
 
     actual_lib_ver = _local_lib_ver()
-    actual_daemon_ver = _daemon_lib_ver(conn, force_version,
+    actual_daemon_ver = _daemon_lib_ver(conn, uri, force_version,
                                         minimum_libvirt_version)
-    actual_drv_ver = _hv_ver(conn)
+    actual_drv_ver = _hv_ver(conn, uri)
 
     # Make sure there are no keys left in the key_list. This will
     # ensure we didn't mistype anything above, or in the support_dict
