Adding --virt overrides for many more additional fields that were found

in the profiles objects but not in the system objects.  This needs testing
in both the webui and command line.

5 files changed, 246 insertions, 167 deletions

diff --git a/cobbler/item_profile.py b/cobbler/item_profile.py
index a352ce1..b472b48 100644
--- a/cobbler/item_profile.py
+++ b/cobbler/item_profile.py
@@ -138,46 +138,7 @@ class Profile(item.Item):
         self.server = server
         return True
 
-    def set_repos(self,repos):
-
-        # WARNING: hack
-        repos = utils.fix_mod_python_select_submission(repos)
-
-
-        # allow the magic inherit string to persist
-        if repos == "<<inherit>>":
-            # FIXME: this is not inheritable in the WebUI presently ?
-            self.repos = "<<inherit>>"
-            return
-
-        # store as an array regardless of input type
-        if repos is None:
-            repolist = []
-        elif type(repos) != list:
-            # allow backwards compatibility support of string input
-            repolist = repos.split(None)
-        else:
-            repolist = repos
-
-        
-        # make sure there are no empty strings
-        try:
-	    repolist.remove('')
-        except:
-            pass
-
-        self.repos = []
-
-        # if any repos don't exist, fail the operation
-        ok = True
-        for r in repolist:
-            if self.config.repos().find(name=r) is not None:
-                self.repos.append(r)
-            else:
-                print _("warning: repository not found: %s" % r)
-
-        return True
-
+  
     def set_kickstart(self,kickstart):
         """
 	Sets the kickstart.  This must be a NFS, HTTP, or FTP URL.
@@ -192,108 +153,27 @@ class Profile(item.Item):
         raise CX(_("kickstart not found"))
 
     def set_virt_cpus(self,num):
-        """
-        For Virt only.  Set the number of virtual CPUs to give to the
-        virtual machine.  This is fed to virtinst RAW, so cobbler
-        will not yelp if you try to feed it 9999 CPUs.  No formatting
-        like 9,999 please :)
-        """
-        if num == "<<inherit>>":
-            self.virt_cpus = "<<inherit>>"
-            return True
-
-        try:
-            num = int(str(num))
-        except:
-            raise CX(_("invalid number of virtual CPUs"))
-
-        self.virt_cpus = num
-        return True
+        return utils.set_virt_cpus(self,num)
 
     def set_virt_file_size(self,num):
-        """
-	For Virt only.
-	Specifies the size of the virt image in gigabytes.  
-	Older versions of koan (x<0.6.3) interpret 0 as "don't care"
-        Newer versions (x>=0.6.4) interpret 0 as "no disks"
-        """
-        # num is a non-negative integer (0 means default)
-        # can also be a comma seperated list -- for usage with multiple disks
-
-        if num == "<<inherit>>":
-            self.virt_file_size = "<<inherit>>"
-            return True
-
-        if type(num) == str and num.find(",") != -1:
-            tokens = num.split(",")
-            for t in tokens:
-                # hack to run validation on each
-                self.set_virt_file_size(t)
-            # if no exceptions raised, good enough
-            self.virt_file_size = num
-            return True
-
-        try:
-            inum = int(num)
-            if inum != float(num):
-                return CX(_("invalid virt file size"))
-            if inum >= 0:
-                self.virt_file_size = inum
-                return True
-            raise CX(_("invalid virt file size"))
-        except:
-            raise CX(_("invalid virt file size"))
-
+        return utils.set_virt_file_size(self,num)
+ 
     def set_virt_ram(self,num):
-        """
-        For Virt only.
-        Specifies the size of the Virt RAM in MB.
-        0 tells Koan to just choose a reasonable default.
-        """
-
-        if num == "<<inherit>>":
-            self.virt_ram = "<<inherit>>"
-            return True
-
-        # num is a non-negative integer (0 means default)
-        try:
-            inum = int(num)
-            if inum != float(num):
-                return CX(_("invalid virt ram size"))
-            if inum >= 0:
-                self.virt_ram = inum
-                return True
-            return CX(_("invalid virt ram size"))
-        except:
-            return CX(_("invalid virt ram size"))
+        return utils.set_virt_ram(self,num)
 
     def set_virt_type(self,vtype):
-        """
-        Virtualization preference, can be overridden by koan.
-        """
-
-        if vtype == "<<inherit>>":
-            self.virt_type == "<<inherit>>"
-            return True
-
-        if vtype.lower() not in [ "qemu", "xenpv", "xenfv", "vmware", "auto" ]:
-            raise CX(_("invalid virt type"))
-        self.virt_type = vtype
-        return True
+        return utils.set_virt_Type(self,vtype)
 
     def set_virt_bridge(self,vbridge):
-        """
-        The default bridge for all virtual interfaces under this profile.
-        """
         self.virt_bridge = vbridge
         return True
 
     def set_virt_path(self,path):
-        """
-        Virtual storage location suggestion, can be overriden by koan.
-        """
-        self.virt_path = path
-        return True
+        return utils.set_virt_path(self,path)
+
+    def set_repos(self,repos):
+        return utils.set_repos(self,repos)
+
 
     def get_parent(self):
         """
@@ -375,6 +255,7 @@ class Profile(item.Item):
         buf = buf + _("owners          : %s\n") % self.owners
         return buf
 
+  
     def remote_methods(self):
         return {           
             'name'            :  self.set_name,
diff --git a/cobbler/item_system.py b/cobbler/item_system.py
index 1bcc111..a97cdf6 100644
--- a/cobbler/item_system.py
+++ b/cobbler/item_system.py
@@ -38,9 +38,15 @@ class System(item.Item):
         self.netboot_enabled = True
         self.depth           = 2
         self.kickstart       = "<<inherit>>"   # use value in profile
+        self.server          = "<<inherit>>"   # "" (or settings)
         self.virt_path       = "<<inherit>>"   # ""
         self.virt_type       = "<<inherit>>"   # "" 
-        self.server          = "<<inherit>>"   # "" (or settings)
+        self.virt_cpus       = "<<inherit>>"   # ""
+        self.virt_file_size  = "<<inherit>>"   # ""
+        self.virt_ram        = "<<inherit>>"   # ""
+        self.virt_type       = "<<inherit>>"   # ""
+        self.virt_path       = "<<inherit>>"   # ""
+        self.virt_bridge     = "<<inherit>>"   # ""
 
     def delete_interface(self,name):
         """
@@ -87,11 +93,19 @@ class System(item.Item):
         self.ks_meta         = self.load_item(seed_data, 'ks_meta', {})
         self.depth           = self.load_item(seed_data, 'depth', 2)        
         self.kickstart       = self.load_item(seed_data, 'kickstart', '<<inherit>>')
-        self.virt_path       = self.load_item(seed_data, 'virt_path', '<<inherit>>') 
-        self.virt_type       = self.load_item(seed_data, 'virt_type', '<<inherit>>')
         self.netboot_enabled = self.load_item(seed_data, 'netboot_enabled', True)
         self.server          = self.load_item(seed_data, 'server', '<<inherit>>')
 
+        # virt specific 
+        self.virt_path   = self.load_item(seed_data, 'virt_path', '<<inherit>>') 
+        self.virt_type   = self.load_item(seed_data, 'virt_type', '<<inherit>>')
+        self.virt_ram    = self.load_item(seed_data,'virt_ram','<<inherit>>')
+        self.virt_file_size  = self.load_item(seed_data,'virt_file_size','<<inherit>>')
+        self.virt_path   = self.load_item(seed_data,'virt_path','<<inherit>>')
+        self.virt_type   = self.load_item(seed_data,'virt_type','<<inherit>>')
+        self.virt_bridge = self.load_item(seed_data,'virt_bridge','<<inherit>>')
+        self.virt_cpus   = self.load_item(seed_data,'virt_cpus','<<inherit>>')
+
         # backwards compat, these settings are now part of the interfaces data structure
         # and will contain data only in upgrade scenarios.
 
@@ -276,21 +290,20 @@ class System(item.Item):
             return True
         raise CX(_("invalid profile name"))
 
-    def set_virt_path(self,path):
-        """
-        Virtual storage location suggestion, can be overriden by koan.
-        """
-        self.virt_path = path
-        return True
+    def set_virt_cpus(self,num):
+        return utils.set_virt_cpus(self,num)
+
+    def set_virt_file_size(self,num):
+        return utils.set_virt_file_size(self,num)
+ 
+    def set_virt_ram(self,num):
+        return utils.set_virt_ram(self,num)
 
     def set_virt_type(self,vtype):
-        """
-        Virtualization preference, can be overridden by koan.
-        """
-        if vtype.lower() not in [ "qemu", "xenpv", "xenfv", "vmware", "auto" ]:
-            raise CX(_("invalid virt type"))
-        self.virt_type = vtype
-        return True
+        return utils.set_virt_Type(self,vtype)
+
+    def set_virt_path(self,path):
+        return utils.set_virt_path(self,path)
 
     def set_netboot_enabled(self,netboot_enabled):
         """
@@ -347,19 +360,24 @@ class System(item.Item):
 
     def to_datastruct(self):
         return {
-           'name'            : self.name,
-           'owners'          : self.owners,
-           'profile'         : self.profile,
-           'kernel_options'  : self.kernel_options,
-           'ks_meta'         : self.ks_meta,
-           'netboot_enabled' : self.netboot_enabled,
-           'parent'          : self.parent,
-           'depth'           : self.depth,
-           'kickstart'       : self.kickstart,
-           'virt_type'       : self.virt_type,
-           'virt_path'       : self.virt_path,
-           'interfaces'      : self.interfaces,
-           'server'          : self.server
+           'name'             : self.name,
+           'kernel_options'   : self.kernel_options,
+           'depth'            : self.depth,
+           'interfaces'       : self.interfaces,
+           'ks_meta'          : self.ks_meta,
+           'kickstart'        : self.kickstart,
+           'netboot_enabled'  : self.netboot_enabled,
+           'owners'           : self.owners,
+           'parent'           : self.parent,
+           'profile'          : self.profile,
+           'server'           : self.server,
+	   'virt_cpus'        : self.virt_cpus,
+           'virt_bridge'      : self.virt_bridge,
+           'virt_file_size'   : self.virt_file_size,
+           'virt_path'        : self.virt_path,
+           'virt_ram'         : self.virt_ram,
+           'virt_type'        : self.virt_type
+
         }
 
     def printable(self):
@@ -370,8 +388,14 @@ class System(item.Item):
         
         buf = buf + _("netboot enabled? : %s\n") % self.netboot_enabled 
         buf = buf + _("kickstart        : %s\n") % self.kickstart
-        buf = buf + _("virt type        : %s\n") % self.virt_type
-        buf = buf + _("virt path        : %s\n") % self.virt_path
+
+        buf = buf + _("virt file size  : %s\n") % self.virt_file_size
+        buf = buf + _("virt ram        : %s\n") % self.virt_ram
+        buf = buf + _("virt type       : %s\n") % self.virt_type
+        buf = buf + _("virt path       : %s\n") % self.virt_path
+        buf = buf + _("virt bridge     : %s\n") % self.virt_bridge
+        buf = buf + _("virt cpus       : %s\n") % self.virt_cpus
+
         buf = buf + _("server           : %s\n") % self.server
         buf = buf + _("owners           : %s\n") % self.owners
 
@@ -419,6 +443,10 @@ class System(item.Item):
            'virt-type'        : self.set_virt_type,
            'modify-interface' : self.modify_interface,
            'delete-interface' : self.delete_interface,
+           'virt-path'        : self.set_virt_path,
+           'virt-type'        : self.set_virt_type,
+           'virt-bridge'      : self.set_virt_bridge,
+           'virt-cpus'        : self.set_virt_cpus,
            'server'           : self.set_server,
            'owners'           : self.set_owners
         }
diff --git a/cobbler/modules/cli_system.py b/cobbler/modules/cli_system.py
index 419b561..6e301d1 100644
--- a/cobbler/modules/cli_system.py
+++ b/cobbler/modules/cli_system.py
@@ -70,9 +70,13 @@ class SystemFunction(commands.CobblerFunction):
             p.add_option("--profile",         dest="profile",         help="name of cobbler profile (REQUIRED)")
             p.add_option("--server-override", dest="server_override", help="overrides server value in settings file")
             p.add_option("--subnet",          dest="subnet",          help="for static IP / templating usage")
-            p.add_option("--virt-bridge",     dest="virt_bridge",     help="ex: virbr0")
-            p.add_option("--virt-path",       dest="virt_path",       help="path, partition, or volume")
-            p.add_option("--virt-type",       dest="virt_type",       help="ex: xenpv, qemu, xenfv")
+
+            p.add_option("--virt-bridge",      dest="virt_bridge", help="ex: 'virbr0'")
+            p.add_option("--virt-cpus",        dest="virt_cpus", help="integer (default: 1)")
+            p.add_option("--virt-file-size",   dest="virt_file_size", help="size in GB")
+            p.add_option("--virt-path",        dest="virt_path", help="path, partition, or volume")
+            p.add_option("--virt-ram",         dest="virt_ram", help="size in MB")
+            p.add_option("--virt-type",        dest="virt_type", help="ex: 'xenpv', 'qemu'")
 
 
     def run(self):
@@ -89,8 +93,14 @@ class SystemFunction(commands.CobblerFunction):
         if self.options.kickstart:       obj.set_kickstart(self.options.kickstart)
         if self.options.netboot_enabled: obj.set_netboot_enabled(self.options.netboot_enabled)
         if self.options.server_override: obj.set_server(self.options.server_override)
-        if self.options.virt_path:       obj.set_virt_path(self.options.virt_path)
+
+        if self.options.virt_file_size:  obj.set_virt_file_size(self.options.virt_file_size)
+        if self.options.virt_ram:        obj.set_virt_ram(self.options.virt_ram)
+        if self.options.virt_bridge:     obj.set_virt_bridge(self.options.virt_bridge)
         if self.options.virt_type:       obj.set_virt_type(self.options.virt_type)
+        if self.options.virt_cpus:       obj.set_virt_cpus(self.options.virt_cpus)
+        if self.options.virt_path:       obj.set_virt_path(self.options.virt_path)
+
 
         if self.options.interface:
             my_interface = "intf%s" % self.options.interface
diff --git a/cobbler/utils.py b/cobbler/utils.py
index 14019e8..1b4b30a 100644
--- a/cobbler/utils.py
+++ b/cobbler/utils.py
@@ -631,6 +631,152 @@ def mkdir(path,mode=0777):
            print oe.errno
            raise CX(_("Error creating") % path)
 
+def set_repos(self,repos):
+   # WARNING: hack
+   repos = fix_mod_python_select_submission(repos)
+
+   # allow the magic inherit string to persist
+   if repos == "<<inherit>>":
+        # FIXME: this is not inheritable in the WebUI presently ?
+        self.repos = "<<inherit>>"
+        return
+
+   # store as an array regardless of input type
+   if repos is None:
+        repolist = []
+   elif type(repos) != list:
+        # allow backwards compatibility support of string input
+        repolist = repos.split(None)
+   else:
+        repolist = repos
+
+        
+   # make sure there are no empty strings
+   try:
+       repolist.remove('')
+   except:
+       pass
+
+   self.repos = []
+
+   # if any repos don't exist, fail the operation
+   ok = True
+   for r in repolist:
+        if self.config.repos().find(name=r) is not None:
+            self.repos.append(r)
+        else:
+            print _("warning: repository not found: %s" % r)
+
+   return True
+
+def set_virt_file_size(self,num):
+    """
+    For Virt only.
+    Specifies the size of the virt image in gigabytes.  
+    Older versions of koan (x<0.6.3) interpret 0 as "don't care"
+    Newer versions (x>=0.6.4) interpret 0 as "no disks"
+    """
+    # num is a non-negative integer (0 means default)
+    # can also be a comma seperated list -- for usage with multiple disks
+
+    if num == "<<inherit>>":
+        self.virt_file_size = "<<inherit>>"
+        return True
+
+    if type(num) == str and num.find(",") != -1:
+        tokens = num.split(",")
+        for t in tokens:
+            # hack to run validation on each
+            self.set_virt_file_size(t)
+        # if no exceptions raised, good enough
+        self.virt_file_size = num
+        return True
+
+    try:
+        inum = int(num)
+        if inum != float(num):
+            return CX(_("invalid virt file size"))
+        if inum >= 0:
+            self.virt_file_size = inum
+            return True
+        raise CX(_("invalid virt file size"))
+    except:
+        raise CX(_("invalid virt file size"))
+    return True
+
+def set_virt_ram(self,num):
+     """
+     For Virt only.
+     Specifies the size of the Virt RAM in MB.
+     0 tells Koan to just choose a reasonable default.
+     """
+
+     if num == "<<inherit>>":
+         self.virt_ram = "<<inherit>>"
+         return True
+
+     # num is a non-negative integer (0 means default)
+     try:
+         inum = int(num)
+         if inum != float(num):
+             return CX(_("invalid virt ram size"))
+         if inum >= 0:
+             self.virt_ram = inum
+             return True
+         return CX(_("invalid virt ram size"))
+     except:
+         return CX(_("invalid virt ram size"))
+     return True
+
+def set_virt_type(self,vtype):
+     """
+     Virtualization preference, can be overridden by koan.
+     """
+
+     if vtype == "<<inherit>>":
+         self.virt_type == "<<inherit>>"
+         return True
+
+     if vtype.lower() not in [ "qemu", "xenpv", "xenfv", "vmware", "auto" ]:
+         raise CX(_("invalid virt type"))
+     self.virt_type = vtype
+     return True
+
+def set_virt_bridge(self,vbridge):
+     """
+     The default bridge for all virtual interfaces under this profile.
+     """
+     self.virt_bridge = vbridge
+     return True
+
+def set_virt_path(self,path):
+     """
+     Virtual storage location suggestion, can be overriden by koan.
+     """
+     self.virt_path = path
+     return True
+
+def set_virt_cpus(self,num):
+     """
+     For Virt only.  Set the number of virtual CPUs to give to the
+     virtual machine.  This is fed to virtinst RAW, so cobbler
+     will not yelp if you try to feed it 9999 CPUs.  No formatting
+     like 9,999 please :)
+     """
+     if num == "<<inherit>>":
+         self.virt_cpus = "<<inherit>>"
+         return True
+
+     try:
+         num = int(str(num))
+     except:
+         raise CX(_("invalid number of virtual CPUs"))
+
+     self.virt_cpus = num
+     return True
+
+
+
 if __name__ == "__main__":
     # print redhat_release()
     print tftpboot_location()
diff --git a/cobbler/webui/CobblerWeb.py b/cobbler/webui/CobblerWeb.py
index 0951633..1b52b80 100644
--- a/cobbler/webui/CobblerWeb.py
+++ b/cobbler/webui/CobblerWeb.py
@@ -313,7 +313,8 @@ class CobblerWeb(object):
     def system_save(self,name=None,oldname=None,editmode="edit",profile=None,
                     new_or_edit=None,  
                     kopts=None, ksmeta=None, owners=None, server_override=None, netboot='n', 
-                    delete1=None, delete2=None, **args):
+                    virtpath=None,virtram=None,virttype=None,virtcpus=None,virtfilesize=None,delete1=None, delete2=None, **args):
+
 
         if not self.__xmlrpc_setup():
             return self.xmlrpc_auth_failure()
@@ -363,6 +364,19 @@ class CobblerWeb(object):
             if server_override:
                self.remote.modify_system(system, 'server', server_override, self.token)
 
+            if virtfilesize:
+               self.remote.modify_system(system, 'virt-file-size', virtfilesize, self.token)
+            if virtcpus:
+               self.remote.modify_system(system, 'virt-cpus', virtcpus, self.token)
+            if virtram:
+               self.remote.modify_system(system, 'virt-ram', virtram, self.token)
+            if virttype:
+               self.remote.modify_system(system, 'virt-type', virtype, self.token)
+
+            if virtpath:
+               self.remote.modify_system(system, 'virt-path', virtpath, self.token)
+
+
             for x in range(0,7):
                 interface = "intf%s" % x
                 macaddress = args.get("macaddress-%s" % interface, "")