2013-03-18 01:06:52 +04:00
#
# Base class for all VM devices
#
# Copyright 2008 Red Hat, Inc.
# Cole Robinson <crobinso@redhat.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA.
import copy
2013-07-12 23:16:29 +04:00
import os
2013-03-18 01:06:52 +04:00
import libxml2
2013-04-11 03:48:07 +04:00
from virtinst import util
2013-03-18 01:06:52 +04:00
2013-08-09 04:47:17 +04:00
2013-07-15 17:49:46 +04:00
# pylint: disable=W0212
# This whole file is calling around into non-public functions that we
# don't want regular API users to touch
2013-03-18 01:06:52 +04:00
2013-07-12 23:16:29 +04:00
_trackprops = bool ( " VIRTINST_TEST_TRACKPROPS " in os . environ )
_allprops = [ ]
_seenprops = [ ]
2013-07-10 16:05:08 +04:00
class _DocCleanupWrapper ( object ) :
def __init__ ( self , doc ) :
self . _doc = doc
def __del__ ( self ) :
self . _doc . freeDoc ( )
2013-03-18 01:06:52 +04:00
2013-04-12 00:48:39 +04:00
2013-07-14 04:47:19 +04:00
class _CtxCleanupWrapper ( object ) :
def __init__ ( self , ctx ) :
self . _ctx = ctx
def __del__ ( self ) :
self . _ctx . xpathFreeContext ( )
self . _ctx = None
def __getattr__ ( self , attrname ) :
return getattr ( self . _ctx , attrname )
2013-07-18 01:58:24 +04:00
def _indent ( xmlstr , level ) :
xml = " "
if not xmlstr :
return xml
if not level :
return xmlstr
return " \n " . join ( ( " " * level + l ) for l in xmlstr . splitlines ( ) )
2013-07-25 19:02:56 +04:00
def _make_xml_context ( node ) :
doc = node . doc
ctx = _CtxCleanupWrapper ( doc . xpathNewContext ( ) )
ctx . setContextNode ( node )
return ctx
2013-04-12 00:48:39 +04:00
def _tuplify_lists ( * args ) :
"""
Similar to zip ( ) , but use None if lists aren ' t long enough, and
don ' t skip any None list entry
"""
args = [ util . listify ( l ) for l in args ]
maxlen = max ( [ len ( l ) for l in args ] )
ret = [ ]
for idx in range ( maxlen ) :
tup = tuple ( )
for l in args :
tup + = ( idx > = len ( l ) and ( None , ) or ( l [ idx ] , ) )
ret . append ( tup )
return ret
2013-03-18 01:06:52 +04:00
def _sanitize_libxml_xml ( xml ) :
# Strip starting <?...> line
if xml . startswith ( " <? " ) :
ignore , xml = xml . split ( " \n " , 1 )
if not xml . endswith ( " \n " ) and xml . count ( " \n " ) :
xml + = " \n "
return xml
2013-04-13 22:34:52 +04:00
2013-07-24 20:35:03 +04:00
def _get_xpath_node ( ctx , xpath ) :
2013-03-18 01:06:52 +04:00
node = ctx . xpathEval ( xpath )
2013-07-24 20:35:03 +04:00
return ( node and node [ 0 ] or None )
2013-03-18 01:06:52 +04:00
2013-04-13 22:34:52 +04:00
2013-03-18 01:06:52 +04:00
def _build_xpath_node ( ctx , xpath , addnode = None ) :
"""
Build all nodes required to set an xpath . If we have XML < foo / > , and want
to set xpath / foo / bar / baz @booyeah , we create node ' bar ' and ' baz '
returning the last node created .
"""
parentpath = " "
parentnode = None
def prevSibling ( node ) :
parent = node . get_parent ( )
if not parent :
return None
prev = None
for child in parent . children :
if child == node :
return prev
prev = child
return None
def make_node ( parentnode , newnode ) :
# Add the needed parent node, try to preserve whitespace by
# looking for a starting TEXT node, and copying it
def node_is_text ( n ) :
return bool ( n and n . type == " text " and not n . content . count ( " < " ) )
sib = parentnode . get_last ( )
if not node_is_text ( sib ) :
# This case is when we add a child element to a node for the
# first time, like:
#
# <features/>
# to
# <features>
# <acpi/>
# </features>
prevsib = prevSibling ( parentnode )
if node_is_text ( prevsib ) :
sib = libxml2 . newText ( prevsib . content )
else :
2013-07-15 17:49:46 +04:00
sib = libxml2 . newText ( " \n " )
2013-03-18 01:06:52 +04:00
parentnode . addChild ( sib )
2013-07-15 17:49:46 +04:00
# This case is adding a child element to an already properly
2013-03-18 01:06:52 +04:00
# spaced element. Example:
# <features>
2013-07-15 17:49:46 +04:00
# <acpi/>
2013-03-18 01:06:52 +04:00
# </features>
# to
# <features>
2013-07-15 17:49:46 +04:00
# <acpi/>
# <apic/>
2013-03-18 01:06:52 +04:00
# </features>
sib = parentnode . get_last ( )
content = sib . content
sib = sib . addNextSibling ( libxml2 . newText ( " " ) )
txt = libxml2 . newText ( content )
sib . addNextSibling ( newnode )
newnode . addNextSibling ( txt )
return newnode
nodelist = xpath . split ( " / " )
for idx in range ( len ( nodelist ) ) :
nodename = nodelist [ idx ]
if not nodename :
continue
# If xpath is a node property, set it and move on
if nodename . startswith ( " @ " ) :
nodename = nodename . strip ( " @ " )
parentnode = parentnode . setProp ( nodename , " " )
continue
if not parentpath :
parentpath = nodename
else :
parentpath + = " / %s " % nodename
# Node found, nothing to create for now
node = _get_xpath_node ( ctx , parentpath )
if node :
parentnode = node
continue
if not parentnode :
raise RuntimeError ( " Could not find XML root node " )
# Remove conditional xpath elements for node creation
if nodename . count ( " [ " ) :
nodename = nodename [ : nodename . index ( " [ " ) ]
newnode = libxml2 . newNode ( nodename )
parentnode = make_node ( parentnode , newnode )
if addnode :
parentnode = make_node ( parentnode , addnode )
return parentnode
2013-04-13 22:34:52 +04:00
2013-07-29 18:45:37 +04:00
def _remove_xpath_node ( ctx , xpath , dofree = True , unlinkroot = True ) :
2013-03-18 01:06:52 +04:00
"""
Remove an XML node tree if it has no content
"""
curxpath = xpath
while curxpath :
is_orig = ( curxpath == xpath )
node = _get_xpath_node ( ctx , curxpath )
if curxpath . count ( " / " ) :
curxpath , ignore = curxpath . rsplit ( " / " , 1 )
else :
curxpath = None
if not node :
continue
if node . type not in [ " attribute " , " element " ] :
continue
if node . type == " element " and ( node . children or node . properties ) :
# Only do a deep unlink if it was the original requested path
if not is_orig :
continue
# Look for preceding whitespace and remove it
white = node . get_prev ( )
if white and white . type == " text " and not white . content . count ( " < " ) :
white . unlinkNode ( )
white . freeNode ( )
2013-07-29 18:45:37 +04:00
if not unlinkroot and node == ctx :
# Don't unlink the root node. This is usually a programming error,
# but the error usually cascades to a different spot and is hard
# to pin down. With this we usually get invalid XML which is
# easier to debug.
2013-07-17 00:24:24 +04:00
break
2013-03-18 01:06:52 +04:00
node . unlinkNode ( )
if dofree :
node . freeNode ( )
2013-07-14 02:56:09 +04:00
class XMLProperty ( property ) :
2013-07-18 01:58:24 +04:00
def __init__ ( self , doc = None , xpath = None , name = None ,
set_converter = None , validate_cb = None ,
make_getter_xpath_cb = None , make_setter_xpath_cb = None ,
2013-07-24 20:51:53 +04:00
is_bool = False , is_int = False , is_yesno = False ,
2013-07-15 18:57:16 +04:00
clear_first = None , default_cb = None , default_name = None ) :
2013-07-14 01:54:46 +04:00
"""
Set a XMLBuilder class property that represents a value in the
< domain > XML . For example
2013-07-14 02:56:09 +04:00
name = XMLProperty ( get_name , set_name , xpath = " /domain/name " )
2013-07-14 01:54:46 +04:00
When building XML from scratch ( virt - install ) , name is a regular
class property . When parsing and editting existing guest XML , we
use the xpath value to map the name property to the underlying XML
definition .
@param doc : option doc string for the property
@param xpath : xpath string which maps to the associated property
in a typical XML document
2013-07-14 06:13:13 +04:00
@param name : Just a string to print for debugging , only needed
if xpath isn ' t specified.
2013-07-14 01:54:46 +04:00
@param set_converter : optional function for converting the property
value from the virtinst API to the guest XML . For example ,
2013-07-14 07:07:01 +04:00
the Guest . memory API was once in MB , but the libvirt domain
memory API is in KB . So , if xpath is specified , on a ' get '
operation we convert the XML value with int ( val ) / 1024.
2013-07-18 01:58:24 +04:00
@param validate_cb : Called once when value is set , should
raise a RuntimeError if the value is not proper .
@param make_getter_xpath_cb :
@param make_setter_xpath_cb : Not all props map cleanly to a
static xpath . This allows passing functions which generate
an xpath for getting or setting .
2013-07-14 01:54:46 +04:00
@param is_bool : Whether this is a boolean property in the XML
2013-07-14 05:49:32 +04:00
@param is_int : Whethere this is an integer property in the XML
2013-07-16 21:04:24 +04:00
@param is_yesno : Whethere this is a yes / no property in the XML
2013-07-14 01:54:46 +04:00
@param clear_first : List of xpaths to unset before any ' set ' operation .
For those weird interdependent XML props like disk source type and
path attribute .
2013-07-15 01:02:42 +04:00
@param default_cb : If building XML from scratch , and this property
is never explicitly altered , this function is called for setting
a default value in the XML , and for any ' get ' call before the
first explicit ' set ' .
2013-07-15 18:57:16 +04:00
@param default_name : If the user does a set and passes in this
value , instead use the value of default_cb ( )
2013-07-14 01:54:46 +04:00
"""
2013-07-12 23:16:29 +04:00
self . _xpath = xpath
2013-07-14 06:13:13 +04:00
self . _name = name or xpath
if not self . _name :
raise RuntimeError ( " XMLProperty: name or xpath must be passed. " )
2013-07-12 23:16:29 +04:00
2013-07-24 20:51:53 +04:00
self . _is_bool = is_bool
2013-07-14 05:49:32 +04:00
self . _is_int = is_int
2013-07-16 21:04:24 +04:00
self . _is_yesno = is_yesno
2013-07-14 01:54:46 +04:00
2013-07-18 01:58:24 +04:00
self . _xpath_for_getter_cb = make_getter_xpath_cb
self . _xpath_for_setter_cb = make_setter_xpath_cb
2013-07-14 01:54:46 +04:00
2013-07-18 01:58:24 +04:00
self . _validate_cb = validate_cb
2013-07-14 01:54:46 +04:00
self . _convert_value_for_setter_cb = set_converter
self . _setter_clear_these_first = clear_first or [ ]
2013-07-15 01:02:42 +04:00
self . _default_cb = default_cb
2013-07-15 18:57:16 +04:00
self . _default_name = default_name
2013-07-15 01:02:42 +04:00
2013-07-17 17:57:15 +04:00
if sum ( [ int ( bool ( i ) ) for i in
[ self . _is_bool , self . _is_int , self . _is_yesno ] ] ) > 1 :
2013-07-15 01:02:42 +04:00
raise RuntimeError ( " Conflict property converter options. " )
2013-07-14 01:54:46 +04:00
2013-07-15 18:57:16 +04:00
if self . _default_name and not self . _default_cb :
raise RuntimeError ( " default_name requires default_cb. " )
2013-07-18 01:58:24 +04:00
if _trackprops :
_allprops . append ( self )
2013-07-14 01:54:46 +04:00
2013-07-18 01:58:24 +04:00
property . __init__ ( self , fget = self . getter , fset = self . setter )
2013-07-16 17:14:37 +04:00
self . __doc__ = doc
2013-07-14 01:54:46 +04:00
2013-07-12 23:16:29 +04:00
def __repr__ ( self ) :
2013-07-14 06:13:13 +04:00
return " <XMLProperty %s %s > " % ( str ( self . _name ) , id ( self ) )
2013-07-12 23:16:29 +04:00
2013-07-14 01:54:46 +04:00
####################
# Internal helpers #
####################
def _findpropname ( self , xmlbuilder ) :
"""
Map the raw property ( ) instance to the param name it ' s exposed
as in the XMLBuilder class . This is just for debug purposes .
"""
2013-07-16 17:14:37 +04:00
for key , val in xmlbuilder . all_xml_props ( ) . items ( ) :
2013-07-14 01:54:46 +04:00
if val is self :
2013-07-12 18:49:15 +04:00
return key
raise RuntimeError ( " Didn ' t find expected property " )
2013-07-14 01:54:46 +04:00
def _xpath_for_getter ( self , xmlbuilder ) :
2013-07-14 06:13:13 +04:00
ret = self . _xpath
2013-07-14 01:54:46 +04:00
if self . _xpath_for_getter_cb :
2013-07-14 06:13:13 +04:00
ret = self . _xpath_for_getter_cb ( xmlbuilder )
if ret is None :
raise RuntimeError ( " %s : didn ' t generate any setter xpath. " % self )
2013-07-24 16:46:55 +04:00
return xmlbuilder . fix_relative_xpath ( ret )
2013-07-14 01:54:46 +04:00
def _xpath_for_setter ( self , xmlbuilder ) :
2013-07-14 06:13:13 +04:00
ret = self . _xpath
2013-07-14 01:54:46 +04:00
if self . _xpath_for_setter_cb :
2013-07-14 06:13:13 +04:00
ret = self . _xpath_for_setter_cb ( xmlbuilder )
if ret is None :
raise RuntimeError ( " %s : didn ' t generate any setter xpath. " % self )
2013-07-24 16:46:55 +04:00
return xmlbuilder . fix_relative_xpath ( ret )
2013-07-15 17:49:46 +04:00
2013-07-14 01:54:46 +04:00
def _build_node_list ( self , xmlbuilder , xpath ) :
"""
Build list of nodes that the passed xpaths reference
"""
2013-07-25 19:02:56 +04:00
nodes = _get_xpath_node ( xmlbuilder . _xmlstate . xml_ctx , xpath )
2013-07-14 01:54:46 +04:00
return util . listify ( nodes )
2013-07-24 20:35:03 +04:00
def _build_clear_list ( self , xmlbuilder , setternode ) :
2013-07-14 01:54:46 +04:00
"""
Build a list of nodes that we should erase first before performing
a set operation . But we don ' t want to unset a node that we are
just going to ' set ' on top of afterwards , so skip those ones .
"""
clear_nodes = [ ]
for cpath in self . _setter_clear_these_first :
2013-07-24 16:46:55 +04:00
cpath = xmlbuilder . fix_relative_xpath ( cpath )
2013-07-25 19:02:56 +04:00
cnode = _get_xpath_node ( xmlbuilder . _xmlstate . xml_ctx , cpath )
2013-07-14 01:54:46 +04:00
if not cnode :
continue
2013-07-24 20:35:03 +04:00
if setternode and setternode . nodePath ( ) == cnode . nodePath ( ) :
2013-07-14 01:54:46 +04:00
continue
clear_nodes . append ( cnode )
return clear_nodes
2013-07-24 20:51:53 +04:00
def _convert_get_value ( self , val ) :
if self . _default_name and val == self . _default_name :
ret = val
elif self . _is_bool :
ret = bool ( val )
2013-07-15 00:05:59 +04:00
elif self . _is_int and val is not None :
2013-07-16 05:52:18 +04:00
intkwargs = { }
2013-07-15 17:49:46 +04:00
if " 0x " in str ( val ) :
2013-07-16 05:52:18 +04:00
intkwargs [ " base " ] = 16
2013-07-17 17:57:15 +04:00
ret = int ( val , * * intkwargs )
2013-07-16 21:04:24 +04:00
elif self . _is_yesno and val is not None :
2013-07-17 17:57:15 +04:00
ret = bool ( val == " yes " )
else :
ret = val
return ret
2013-07-14 05:04:27 +04:00
2013-07-24 22:37:07 +04:00
def _convert_set_value ( self , xmlbuilder , val ) :
if self . _default_name and val == self . _default_name :
val = self . _default_cb ( xmlbuilder )
2013-07-25 23:27:42 +04:00
elif self . _is_yesno and val is not None :
val = bool ( val ) and " yes " or " no "
elif self . _is_int and val is not None :
intkwargs = { }
if " 0x " in str ( val ) :
intkwargs [ " base " ] = 16
val = int ( val , * * intkwargs )
2013-07-24 22:37:07 +04:00
if self . _convert_value_for_setter_cb :
val = self . _convert_value_for_setter_cb ( xmlbuilder , val )
return val
2013-07-18 01:58:24 +04:00
def _prop_is_unset ( self , xmlbuilder ) :
2013-07-14 17:31:14 +04:00
propname = self . _findpropname ( xmlbuilder )
2013-07-25 19:02:56 +04:00
return ( propname not in xmlbuilder . _propstore )
2013-07-18 01:58:24 +04:00
2013-07-24 22:37:07 +04:00
def _default_get_value ( self , xmlbuilder ) :
"""
Return ( can use default , default value )
"""
ret = ( False , - 1 )
2013-07-25 20:34:37 +04:00
if not xmlbuilder . _xmlstate . is_build :
return ret
2013-07-24 22:37:07 +04:00
if not self . _prop_is_unset ( xmlbuilder ) :
return ret
if not self . _default_cb :
return ret
if self . _default_name :
return ( True , self . _default_name )
return ( True , self . _default_cb ( xmlbuilder ) )
2013-07-18 01:58:24 +04:00
def _set_default ( self , xmlbuilder ) :
"""
Encode the property default into the XML and propstore , but
only if a default is registered , and only if the property was
not already explicitly set by the API user .
This is called during the get_xml_config process and shouldn ' t
be called from outside this file .
"""
2013-07-24 22:37:07 +04:00
candefault , val = self . _default_get_value ( xmlbuilder )
if not candefault :
2013-07-18 01:58:24 +04:00
return
2013-07-24 22:37:07 +04:00
self . setter ( xmlbuilder , val , validate = False )
2013-07-14 17:31:14 +04:00
2013-07-18 01:58:24 +04:00
def _nonxml_fset ( self , xmlbuilder , val ) :
2013-07-14 17:31:14 +04:00
"""
2013-07-18 01:58:24 +04:00
This stores the value in XMLBuilder . _propstore
2013-07-14 17:31:14 +04:00
dict as propname - > value . This saves us from having to explicitly
track every variable .
"""
2013-07-25 19:02:56 +04:00
propstore = xmlbuilder . _propstore
proporder = xmlbuilder . _proporder
2013-07-14 17:31:14 +04:00
if _trackprops and self not in _seenprops :
_seenprops . append ( self )
propname = self . _findpropname ( xmlbuilder )
propstore [ propname ] = val
if propname in proporder :
proporder . remove ( propname )
proporder . append ( propname )
2013-07-18 01:58:24 +04:00
def _nonxml_fget ( self , xmlbuilder ) :
"""
The flip side to nonxml_fset , fetch the value from
XMLBuilder . _propstore
"""
2013-07-24 22:37:07 +04:00
candefault , val = self . _default_get_value ( xmlbuilder )
if candefault :
return val
2013-07-18 01:58:24 +04:00
propname = self . _findpropname ( xmlbuilder )
2013-07-25 19:02:56 +04:00
return xmlbuilder . _propstore . get ( propname , None )
2013-07-18 01:58:24 +04:00
def _clear ( self , xmlbuilder ) :
2013-07-24 20:35:03 +04:00
self . setter ( xmlbuilder , None )
2013-07-24 22:37:07 +04:00
self . _set_xml ( xmlbuilder , None )
2013-07-14 17:31:14 +04:00
##################################
# The actual getter/setter impls #
##################################
2013-07-18 01:58:24 +04:00
def getter ( self , xmlbuilder ) :
2013-07-25 19:02:56 +04:00
"""
Fetch value at user request . If we are parsing existing XML and
the user hasn ' t done a ' set ' yet, return the value from the XML,
otherwise return the value from propstore
2013-07-25 20:34:37 +04:00
If this is a built from scratch object , we never pull from XML
since it ' s known to the empty, and we may want to return
a ' default ' value
2013-07-25 19:02:56 +04:00
"""
2013-07-25 20:34:37 +04:00
if ( self . _prop_is_unset ( xmlbuilder ) and
not xmlbuilder . _xmlstate . is_build ) :
2013-07-24 22:37:07 +04:00
val = self . _get_xml ( xmlbuilder )
else :
val = self . _nonxml_fget ( xmlbuilder )
ret = self . _convert_get_value ( val )
return ret
2013-07-14 01:54:46 +04:00
2013-07-24 22:37:07 +04:00
def _get_xml ( self , xmlbuilder ) :
2013-07-25 19:02:56 +04:00
"""
Actually fetch the associated value from the backing XML
"""
2013-07-14 01:54:46 +04:00
xpath = self . _xpath_for_getter ( xmlbuilder )
2013-07-25 19:02:56 +04:00
node = _get_xpath_node ( xmlbuilder . _xmlstate . xml_ctx , xpath )
2013-07-24 20:35:03 +04:00
if not node :
2013-07-24 22:37:07 +04:00
return None
2013-07-15 00:05:59 +04:00
2013-07-24 20:35:03 +04:00
content = node . content
if self . _is_bool :
content = True
2013-07-24 22:37:07 +04:00
return content
2013-03-18 01:06:52 +04:00
2013-07-24 22:37:07 +04:00
def setter ( self , xmlbuilder , val , validate = True ) :
2013-07-25 19:02:56 +04:00
"""
Set the value at user request . This just stores the value
in propstore . Setting the actual XML is only done at
get_xml_config time .
"""
2013-07-24 22:37:07 +04:00
if validate and self . _validate_cb :
self . _validate_cb ( xmlbuilder , val )
self . _nonxml_fset ( xmlbuilder ,
self . _convert_set_value ( xmlbuilder , val ) )
2013-03-18 01:06:52 +04:00
2013-07-24 22:37:07 +04:00
def _set_xml ( self , xmlbuilder , setval , root_node = None ) :
2013-07-25 19:02:56 +04:00
"""
Actually set the passed value in the XML document
"""
2013-07-24 22:37:07 +04:00
if root_node is None :
2013-07-25 19:02:56 +04:00
root_node = xmlbuilder . _xmlstate . xml_node
2013-07-14 01:54:46 +04:00
xpath = self . _xpath_for_setter ( xmlbuilder )
2013-07-25 19:02:56 +04:00
node = _get_xpath_node ( xmlbuilder . _xmlstate . xml_ctx , xpath )
2013-07-24 20:35:03 +04:00
clearlist = self . _build_clear_list ( xmlbuilder , node )
2013-03-18 01:06:52 +04:00
2013-07-13 18:09:00 +04:00
node_map = [ ]
2013-07-14 01:54:46 +04:00
if clearlist :
node_map + = _tuplify_lists ( clearlist , None , " " )
2013-07-24 20:35:03 +04:00
node_map + = [ ( node , setval , xpath ) ]
2013-07-14 02:04:49 +04:00
2013-07-12 18:49:15 +04:00
for node , val , use_xpath in node_map :
2013-03-18 01:06:52 +04:00
if node :
2013-07-12 18:49:15 +04:00
use_xpath = node . nodePath ( )
2013-03-18 01:06:52 +04:00
2013-07-15 00:01:38 +04:00
if val is None or val is False :
2013-07-29 18:45:37 +04:00
_remove_xpath_node ( root_node , use_xpath , unlinkroot = False )
2013-07-15 00:01:38 +04:00
continue
if not node :
node = _build_xpath_node ( root_node , use_xpath )
if val is True :
# Boolean property, creating the node is enough
continue
node . setContent ( util . xml_escape ( str ( val ) ) )
2013-04-13 22:34:52 +04:00
2013-07-25 19:02:56 +04:00
class _XMLState ( object ) :
def __init__ ( self , xpath , parsexml , parsexmlnode ) :
if xpath is None or not xpath . startswith ( " / " ) :
raise RuntimeError ( " xpath= %s must start with / " % xpath )
self . orig_root_xpath = xpath
self . root_name = xpath . split ( " / " ) [ - 1 ]
self . indent = ( xpath . count ( " / " ) - 1 ) * 2
self . dump_xpath = xpath
self . root_xpath = " "
self . xml_ctx = None
self . xml_node = None
self . xml_root_doc = None
self . is_build = False
if not ( parsexml or parsexmlnode ) :
parsexml = self . make_xml_stub ( )
self . is_build = True
self . _parse ( parsexml , parsexmlnode )
def _parse ( self , xml , node ) :
if xml :
doc = libxml2 . parseDoc ( xml )
self . xml_root_doc = _DocCleanupWrapper ( doc )
self . xml_node = doc . children
self . xml_node . virtinst_is_build = self . is_build
self . dump_xpath = " . "
# This just stores a reference to our root doc wrapper in
# the root node, so when the node goes away it triggers
# auto free'ing of the doc
self . xml_node . virtinst_root_doc = self . xml_root_doc
else :
self . xml_node = node
self . is_build = ( getattr ( node , " virtinst_is_build " , False ) or
self . is_build )
self . dump_xpath = self . orig_root_xpath
self . xml_ctx = _make_xml_context ( self . xml_node )
def make_xml_stub ( self ) :
return _indent ( ( " < %s /> " % self . root_name ) , self . indent )
def set_root_xpath ( self , xpath ) :
self . root_xpath = xpath or " "
self . dump_xpath = xpath or self . orig_root_xpath
def fix_relative_xpath ( self , xpath ) :
if not self . root_xpath :
return xpath
return " %s %s " % ( self . root_xpath , xpath . strip ( " . " ) )
def get_node_xml ( self , ctx = None ) :
if ctx is None :
ctx = self . xml_ctx
node = _get_xpath_node ( ctx , self . dump_xpath )
if not node :
return " "
return _sanitize_libxml_xml ( node . serialize ( ) )
2013-07-14 02:56:09 +04:00
class XMLBuilder ( object ) :
2013-03-18 01:06:52 +04:00
"""
Base for all classes which build or parse domain XML
"""
2013-07-16 20:48:52 +04:00
# Order that we should apply values to the XML. Keeps XML generation
# consistent with what the test suite expects.
2013-07-15 17:49:46 +04:00
_XML_PROP_ORDER = [ ]
2013-07-24 20:02:37 +04:00
# Absolute xpath this object is rooted at
_XML_ROOT_XPATH = None
2013-07-18 01:58:24 +04:00
2013-07-06 22:12:13 +04:00
def __init__ ( self , conn , parsexml = None , parsexmlnode = None ) :
2013-03-18 01:06:52 +04:00
"""
Initialize state
@param conn : libvirt connection to validate device against
2013-07-05 16:59:58 +04:00
@type conn : VirtualConnection
2013-03-18 01:06:52 +04:00
@param parsexml : Optional XML string to parse
@type parsexml : C { str }
@param parsexmlnode : Option xpathNode to use
"""
2013-07-24 16:46:55 +04:00
self . conn = conn
2013-03-18 01:06:52 +04:00
2013-07-12 18:49:15 +04:00
self . _propstore = { }
self . _proporder = [ ]
2013-07-25 19:02:56 +04:00
self . _xmlstate = None
2013-07-24 22:37:07 +04:00
self . _parsexml ( parsexml , parsexmlnode )
2013-03-18 01:06:52 +04:00
2013-07-25 19:02:56 +04:00
########################
# Public XML Internals #
########################
2013-07-15 02:31:33 +04:00
2013-03-18 01:06:52 +04:00
def copy ( self ) :
2013-07-25 19:02:56 +04:00
"""
Do a shallow copy of the device
"""
2013-07-14 05:04:27 +04:00
ret = copy . copy ( self )
ret . _propstore = ret . _propstore . copy ( )
ret . _proporder = ret . _proporder [ : ]
return ret
2013-03-18 01:06:52 +04:00
2013-07-24 16:46:55 +04:00
def set_root_xpath ( self , xpath ) :
2013-07-25 19:02:56 +04:00
"""
Change the absolute root xpath that this device points to in its
backing node . This is used by Guest when devices are reordered ,
for example we may need to tell the device it now points at
/ domain / devices / disk [ 1 ] instead of . . . [ 2 ]
"""
self . _xmlstate . set_root_xpath ( xpath )
for p in self . _all_subelement_props ( ) :
p . set_root_xpath ( xpath )
2013-07-24 16:46:55 +04:00
def get_root_xpath ( self ) :
2013-07-25 19:02:56 +04:00
return self . _xmlstate . root_xpath
2013-07-24 16:46:55 +04:00
def fix_relative_xpath ( self , xpath ) :
2013-07-25 19:02:56 +04:00
return self . _xmlstate . fix_relative_xpath ( xpath )
def all_xml_props ( self ) :
"""
Return a list of all XMLProperty instances that this class has .
"""
ret = { }
for c in reversed ( type . mro ( self . __class__ ) [ : - 1 ] ) :
for key , val in c . __dict__ . items ( ) :
if val . __class__ is XMLProperty :
ret [ key ] = val
return ret
############################
# Public XML managing APIs #
############################
2013-07-24 16:46:55 +04:00
2013-07-24 19:32:30 +04:00
def get_xml_config ( self ) :
2013-07-25 19:02:56 +04:00
"""
Return XML string of the object
"""
2013-07-24 16:46:55 +04:00
data = self . _prepare_get_xml ( )
try :
2013-07-24 20:02:37 +04:00
return self . _do_get_xml_config ( )
2013-07-24 16:46:55 +04:00
finally :
self . _finish_get_xml ( data )
def clear ( self ) :
2013-07-25 19:02:56 +04:00
"""
Wipe out all properties of the object
"""
2013-07-24 16:46:55 +04:00
for prop in self . all_xml_props ( ) . values ( ) :
prop . _clear ( self )
2013-03-18 01:06:52 +04:00
2013-07-25 19:02:56 +04:00
def validate ( self ) :
"""
Validate any set values and raise an exception if there ' s
a problem
"""
pass
2013-07-15 02:31:33 +04:00
2013-07-25 19:02:56 +04:00
def set_defaults ( self ) :
"""
Encode any default values if needed
"""
pass
2013-07-15 02:31:33 +04:00
###################
# Child overrides #
###################
2013-07-18 01:58:24 +04:00
def _prepare_get_xml ( self ) :
2013-07-25 19:02:56 +04:00
"""
Subclasses can override this to do any pre - get_xml_config setup .
Returns data to pass to finish_get_xml
"""
2013-07-18 01:58:24 +04:00
return None
2013-07-25 19:02:56 +04:00
2013-07-18 01:58:24 +04:00
def _finish_get_xml ( self , data ) :
2013-07-25 19:02:56 +04:00
"""
Called after get_xml_config . Data is whatever was returned by
_prepare_get_xml
"""
2013-07-18 01:58:24 +04:00
ignore = data
2013-07-25 19:02:56 +04:00
def _parsexml ( self , xml , node ) :
"""
Subclasses hook here to do things like parse < devices > into
internal state
"""
self . _xmlstate = _XMLState ( self . _XML_ROOT_XPATH , xml , node )
2013-07-15 02:31:33 +04:00
2013-07-25 19:02:56 +04:00
################
# Internal API #
################
_xml_node = property ( lambda s : s . _xmlstate . xml_node )
def _all_subelement_props ( self ) :
"""
Return a list of all sub element properties this class tracks .
A sub element is an XMLBuilder that is tracked explicitly in
a parent class , which alters the parent XML .
VirtualDevice . address is an example .
"""
xmlprops = self . all_xml_props ( )
ret = [ ]
for propname in self . _XML_PROP_ORDER :
if propname not in xmlprops :
ret . extend ( util . listify ( getattr ( self , propname ) ) )
return ret
def _add_child ( self , dev ) :
"""
Insert the passed XMLBuilder object into our XML document at the
specified path
"""
2013-07-25 20:34:37 +04:00
if not dev . _xmlstate . is_build :
2013-07-25 19:02:56 +04:00
newnode = libxml2 . parseDoc ( dev . get_xml_config ( ) ) . children
_build_xpath_node ( self . _xmlstate . xml_ctx ,
dev . get_root_xpath ( ) , newnode )
dev . _xmlstate . _parse ( None , self . _xmlstate . xml_node )
def _remove_child ( self , dev ) :
"""
Remove the passed XMLBuilder object from our XML document , but
ensure it ' s data isn ' t altered .
"""
xpath = dev . get_root_xpath ( )
xml = dev . get_xml_config ( )
dev . set_root_xpath ( None )
dev . _xmlstate . _parse ( xml , None )
if xpath :
_remove_xpath_node ( self . _xmlstate . xml_ctx , xpath , dofree = False )
2013-07-24 22:37:07 +04:00
2013-07-25 19:02:56 +04:00
#################################
# Private XML building routines #
#################################
2013-07-24 22:37:07 +04:00
def _do_get_xml_config ( self ) :
2013-07-25 19:02:56 +04:00
xmlstub = self . _xmlstate . make_xml_stub ( )
2013-07-24 22:37:07 +04:00
try :
node = None
ctx = None
2013-07-25 20:34:37 +04:00
if self . _xmlstate . is_build :
2013-07-25 19:02:56 +04:00
node = self . _xmlstate . xml_node . docCopyNodeList (
self . _xmlstate . xml_node . doc )
ctx = _make_xml_context ( node )
2013-07-24 22:37:07 +04:00
ret = self . _add_parse_bits ( node , ctx )
finally :
if node :
node . freeNode ( )
if ret == xmlstub :
ret = " "
2013-07-25 19:02:56 +04:00
if ( ret and
self . _xmlstate . root_name == " domain " and
not ret . endswith ( " \n " ) ) :
2013-07-24 22:37:07 +04:00
ret + = " \n "
return ret
2013-07-25 19:02:56 +04:00
def _add_parse_bits ( self , node , ctx ) :
2013-07-24 16:46:55 +04:00
"""
2013-07-25 19:02:56 +04:00
Callback that adds the implicitly tracked XML properties to
the backing xml .
2013-07-24 16:46:55 +04:00
"""
2013-07-25 19:02:56 +04:00
origproporder = self . _proporder [ : ]
origpropstore = self . _propstore . copy ( )
try :
return self . _do_add_parse_bits ( node , ctx )
finally :
self . _proporder = origproporder
self . _propstore = origpropstore
2013-03-18 01:06:52 +04:00
2013-07-24 22:37:07 +04:00
def _do_add_parse_bits ( self , node , ctx ) :
2013-07-18 01:58:24 +04:00
# Set all defaults if the properties have one registered
2013-07-16 17:14:37 +04:00
xmlprops = self . all_xml_props ( )
2013-07-12 18:49:15 +04:00
2013-07-25 20:34:37 +04:00
for prop in xmlprops . values ( ) :
prop . _set_default ( self )
2013-07-15 01:02:42 +04:00
# Set up preferred XML ordering
do_order = self . _proporder [ : ]
2013-07-15 17:49:46 +04:00
for key in reversed ( self . _XML_PROP_ORDER ) :
2013-07-15 01:02:42 +04:00
if key in do_order :
do_order . remove ( key )
do_order . insert ( 0 , key )
2013-07-18 01:58:24 +04:00
elif key not in xmlprops :
do_order . insert ( 0 , key )
2013-07-15 01:02:42 +04:00
# Alter the XML
for key in do_order :
2013-07-18 01:58:24 +04:00
if key in xmlprops :
2013-07-24 22:37:07 +04:00
xmlprops [ key ] . _set_xml ( self , self . _propstore [ key ] , node )
continue
2013-07-18 01:58:24 +04:00
2013-07-24 22:37:07 +04:00
for obj in util . listify ( getattr ( self , key ) ) :
2013-07-25 19:02:56 +04:00
if self . _xmlstate . root_xpath and not obj . _xmlstate . root_xpath :
obj . _xmlstate . root_xpath = self . _xmlstate . root_xpath
2013-07-24 22:37:07 +04:00
obj . _add_parse_bits ( node , ctx )
2013-07-14 23:06:40 +04:00
2013-07-25 19:02:56 +04:00
return self . _xmlstate . get_node_xml ( ctx )