Merge branch 'master' of git.calculate.ru:calculate-install

Conflicts:
	pym/cl_fill_install.py
	pym/cl_vars_install.py

pym/cl_distr.py

@@ -13,7 +13,6 @@ import sys
 from cl_utils import runOsCommand,isMount,removeDir,typeFile
 from shutil import copyfile
 from cl_template import _terms
-from subprocess import Popen,PIPE
 
 
 class DistributiveError(Exception):
@@ -228,9 +227,6 @@ class Distributive(object):
             raise DistributiveError("Cann't copy file from '%s' to '%s':\n%s"%
                     (fromdir,todir,errmes))
 
-    def installBootloader(self):
-        pass
-
     def formatPartition(self,format=""):
         pass
 
@@ -299,8 +295,6 @@ class DirectoryDistributive(Distributive):
             self.copy(dFrom.directory,self.directory)
 
 class PartitionDistributive(Distributive):
-    reRightPartition = re.compile(r"^/dev/(sd[a-z]\d+|cciss/c\d+d\d+)$")
-
     def __init__(self,partition,parent=None,mdirectory="/mnt/calculate",
                     check=False,multipartition=None):
         """Initialize partition distributive
@@ -312,10 +306,6 @@ class PartitionDistributive(Distributive):
         Distributive.__init__(self,parent=parent)
         self.partition = partition
         self.mdirectory = mdirectory
-        if check and not partition is None and \
-            (not self.reRightPartition.match(partition) or \
-            not pathexists(partition)):
-            raise DistributiveError("Wrong partition name '%s'"%partition)
 
     def _mountPartition(self,partition,directory):
         """Mount partition to directory"""
@@ -346,47 +336,46 @@ class PartitionDistributive(Distributive):
         self._mountPartition(self.partition,mdirectory)
         return DirectoryDistributive(mdirectory,parent=self)
 
-    def formatPartition(self,format=""):
+    # TODO: need node value for ext2 ext3
+    formatUtilities = { 'ext2':'/sbin/mkfs.ext2 %s',
+                        'ext3':'/sbin/mkfs.ext3 %s',
+                        'ext4':'/sbin/mkfs.ext4 %s',
+                        'jfs':'/sbin/mkfs.jfs -f %s',
+                        'reiserfs':'/sbin/mkfs.reiserfs -f %s',
+                        'xfs':'/sbin/mkfs.xfs -f %s',
+                        'vfat':'/sbin/mkfs.vfat -F 32 %s',
+    }
+
+    formatId = { 'ext2' : '83',
+                 'ext3' : '83',
+                 'ext4' : '83',
+                 'reiserfs' : '83',
+                 'jfs' : '83',
+                 'xfs' : '83',
+                 'vfat' : 'b',
+    }
+
+    def formatPartition(self,format="reiserfs"):
         """Format partition"""
-        if isMount(self.partition) == '/':
+        if not format in self.formatUtilities:
             raise DistributiveError(
-                "Cann't format root partition %s" %
-                self.partition)
+                "Specified '%s' format inn't supported" % format)
         if isMount(self.partition):
             raise DistributiveError(
                 "Cann't format partition %s, because it is mounted" %
                 self.partition)
-        # TODO: need multipartition formating
-        res,errmes = self.runOsCommand("/sbin/mkfs.reiserfs -f %s" %
-            self.partition)
+        if not os.access(self.partition,os.W_OK):
+            raise DistributiveError("Cann't format partition %s:\n%s"%
+                    (self.partition,_("Permission denied")))
+        # TODO: need multipartition formating ????
+        res,errmes = self.runOsCommand(self.formatUtilities[format] %
+                                        self.partition)
         if res == 0:
             return True
         else:
             raise DistributiveError("Cann't format partition %s:\n%s"%
                     (self.partition,errmes))
 
-    def installBootloader(self):
-        # TODO: need detect HP hdd which has name c[0-9]d[0-9]
-        rePartition = re.compile("sd([a-z])(\d+)",re.S)
-        res = rePartition.search(self.partition)
-        if res:
-            hddNum = ord(res.groups()[0])-ord('a')
-            partitionNum = int(res.groups()[1])
-        else:
-            raise DistributiveError("Wrong partition name '%s'"%self.partition)
-        pipe = Popen(["/sbin/grub",
-               "--device-map=%s/boot/grub/device.map"%self.getDirectory(),
-               "--no-floppy",
-               "--batch"], stdin=PIPE,stdout=PIPE)
-        # TODO: change hd0 for bootloader install to other disks
-        pipe.stdin.write("root (hd%d,%d)\n"%(hddNum,partitionNum))
-        pipe.stdin.write("setup (hd0)\n")
-        pipe.stdin.write("quit\n")
-        pipe.stdin.close()
-        # TODO: break if command is hang
-        if pipe.wait() != 0:
-            raise DistributiveError("Cann't install bootloader")
-
     def installFrom(self, source):
         """Install distributive to partition from source distributive"""
         # get currect partition as directory

pym/cl_fill_install.py

@@ -217,21 +217,101 @@ class fillVars(object, glob_attr):
 
     def get_os_grub_info(self):
         """Part of current grub.conf"""
-        pass
+        
 
     def get_os_grub_devicemap_info(self):
         """Content of device.map file for grub"""
-        pass
+        return "\n".join(map(lambda x: "(hd%s)   /dev/%s" % (x[0],x[1]),
+                                filter(lambda x:x[2] != "flash",
+                                zip(self.Get('os_device_map'),
+                                    self.Get('os_device_dev'),
+                                    self.Get('os_device_type')))))
 
     def get_os_fstab_mount_info(self):
         """Information about mount points for fstab"""
+        devicesForFstab = sorted( 
+                                 filter(lambda x: x[1] != "" and x[1] != "swap",
+                                        zip(self.Get('os_disk_dev'),
+                                        self.Get('os_disk_install'),
+                                        self.Get('os_disk_format'))),
+                                 lambda x,y: cmp(x[1],y[1]))
+        # rootLine one string, but it correct work if devicesForFstab is empty
+        rootLine =  "\n".join(map(lambda x: "%s\t%s\t%s\tnoatime\t0 2" %
+                                        (x[0],x[1],x[2]),devicesForFstab[:1]))
+        otherLines  ="\n".join(map(lambda x: "%s\t%s\t%s\tnoatime\t0 0" %
+                                        (x[0],x[1],x[2]),devicesForFstab[1:]))
+        return "\n".join([rootLine,otherLines])
+
+    def get_os_net_config_info(self):
+        """Content of /etc/conf.d/net.* file"""
         pass
 
     def get_os_fstab_swap_info(self):
         """Information about swap for fstab"""
-        pass
+        return "\n".join(map(lambda x: "%s\tnone\tswap\tsw\t0 0"%x[0],
+                                filter(lambda x: x[1] == "swap",
+                                    zip(self.Get('os_disk_dev'),
+                                        self.Get('os_disk_install')))))
+
+    def get_os_linux_system(self):
+        """Get linux system (server or desktop)"""
+        mapNameSystem = {'CDS':'server',
+                         'CLD':'desktop',
+                         'CLDG':'desktop',
+                         'CLDX':'desktop',
+                         'CLS':'desktop',
+                         'CSS':'server'
+                        }
+        shortName = self.Get('os_linux_shortname')
+        if shortName in mapNameSystem:
+            return mapNameSystem[shortName]
+        else:
+            return ""
+
+    def get_os_kernel_scheduler(self):
+        """Get scheduler for root device"""
+        root_dev = filter(lambda x: x[1] == '/',
+                            zip(self.Get('os_disk_dev'),
+                                self.Get('os_disk_install')))
+        if root_dev:
+            root_dev = root_dev[0][0]
+            root_dev = filter(lambda x: x in root_dev,
+                              self.Get('os_device_dev'))
+            if root_dev:
+                root_dev = root_dev[0]
+                pathScheduler = '/sys/block/%s/queue/scheduler'%root_dev
+                if access(pathScheduler,R_OK):
+                    res = re.search("\[([^\]]+)\]",
+                                    open(pathScheduler).read(),re.S)
+                    if res:
+                        return res.groups()[0]
+        return "cfq"
+
+    def get_os_kernel_attr(self):
+        """Kernel attributes"""
+        # TODO: on usb-hdd install must be "delay=5"
+        return ""
+
+    def get_os_kernel_resume(self):
+        """Kernel resume parameter"""
+        for dev, install in zip(self.Get('os_disk_dev'),
+                                self.Get('os_disk_install')):
+            if install == "swap":
+                return "resume=%s"%dev
+        return ""
+
+    def get_os_grub_info(self):
+        pathGrubConf = "/boot/grub/grub.conf"
+        if access(pathGrubConf,R_OK):
+            reRemoveComments = re.compile("(^|\n)\s*#[^\n]*?(?=\n|$)", re.S)
+            reGrubEntry = re.compile("title.*?(?=title|$)", re.S | re.I )
+            grubconf = reRemoveComments.sub("",open(pathGrubConf,'r').read())
+            roothd = filter(lambda x: x[1] == '/',
+                            zip(self.Get('os_disk_grub'),
+                                self.Get('os_disk_install')))
+            if roothd:
+                roothd = "root (hd%s)" % roothd[0][0]
+                return ("".join(filter(lambda x: not roothd in x,
+                                      reGrubEntry.findall(grubconf)))).strip()
+        return ""
 
-    def get_os_net_config_info(self):
-        """Content of /etc/conf.d/net.* file"""
-        pass
-        

pym/cl_install.py

@@ -21,24 +21,33 @@ import os
 import re
 import sys
 
+import cl_overriding
+
+install_errors = ""
+def installExit(*args,**kwars):
+    raise InstallError(globals()["install_errors"])
+
+def overprintERROR(s):
+    globals()["install_errors"] += s +"\n"
+
+cl_overriding.exit = installExit
+cl_overriding.printERROR = overprintERROR
+
 from cl_lang import lang
-from cl_template import template
 from cl_fill import clLocale
+from cl_template import template
 from cl_datavars import DataVars
 from cl_print import color_print
 from cl_distr import PartitionDistributive,DistributiveRepository,\
                 DistributiveError, ScratchDistributive
 from time import sleep
-import cl_overriding
+from subprocess import Popen,PIPE
 
 tr = lang()
 tr.setGlobalDomain('cl_install')
 tr.setLanguage(sys.modules[__name__])
 
-def installExit(*args,**kwars):
-    raise InstallError("Processing template error")
 
-cl_overriding.exit = installExit
 
 class InstallError(Exception):
     """Installation Error"""
@@ -63,7 +72,7 @@ class cl_install(color_print):
 
     def __init__(self):
         self.clVars = None
-        self.clTemp = None
+        self.clTempl = None
         self.color = True
 
     def colorPrint(self,*argv,**kwarg):
@@ -85,10 +94,10 @@ class cl_install(color_print):
     def applyTemplatesForSystem(self):
         """Apply templates for root of system."""
         self.clVars.Set("cl_root_path","/", True)
-        self.clTemp = template(self.clVars)
-        dirsFiles = self.clTemp.applyTemplates()
-        if self.clTemp.getError():
-            self.printERROR(self.clTemp.getError())
+        self.clTempl = template(self.clVars)
+        dirsFiles = self.clTempl.applyTemplates()
+        if self.clTempl.getError():
+            self.printERROR(self.clTempl.getError())
             return False
         else:
             return dirsFiles
@@ -124,11 +133,8 @@ class cl_install(color_print):
                 self.clVars.Get('os_clock_timezone'))
         
         self.defaultPrint(_("Location\n"))
-        workingVol = filter(lambda x: x[1] == '/',
-                        zip(self.clVars.Get('os_disk_dev'),
-                            self.clVars.Get('os_disk_load'))) or [("unknown",)]
         self.printSUCCESS(_("Working volume")+": %s"%
-                workingVol[0][0])
+            self.getDeviceByField("load",'/') or "unknown" )
         self.printSUCCESS(_("Installation volume")+": %s"%
                 self.clVars.Get('os_root_dev'))
         self.printSUCCESS(_("File system")+": %s"%
@@ -146,7 +152,10 @@ class cl_install(color_print):
         self.printSUCCESS(_("Authentification")+": %s"%
                 "<needed>")
 
-        self.printSUCCESS("Found update: %s"%self.clVars.Get('os_linux_name'))
+        self.printSUCCESS("Found update: %s %s %s"%
+            (self.clVars.Get('os_linux_name'),
+            self.clVars.Get('os_linux_subname'),
+            self.clVars.Get('os_linux_ver')))
 
     def wait(self,sec=10):
         self.printSUCCESS(_("Press %s to cancel")%"Ctrl+C"+"...  %d"%sec, printBR=False)
@@ -156,7 +165,7 @@ class cl_install(color_print):
         self.defaultPrint("\b\b  \n")
 
     def prepareBoot(self,targetDistr):
-        targetDistr.installBootloader()
+        self.installBootloader(targetDistr)
 
     def getTargetDistributive(self,disk,buildermode):
         if buildermode:
@@ -169,14 +178,70 @@ class cl_install(color_print):
     def applyTemplates(self,directory):
         """Apply templates for root of system."""
         self.clVars.Set("cl_root_path",directory, True)
-        self.clTemp = template(self.clVars)
-        dirsFiles = self.clTemp.applyTemplates()
-        if self.clTemp.getError():
-            self.printERROR(self.clTemp.getError())
-            return False
+        self.clTempl = template(self.clVars)
+        dirsFiles = self.clTempl.applyTemplates()
+        if self.clTempl.getError():
+            raise InstallError(self.clTempl.getError())
         else:
             return dirsFiles
 
+    def setInstallDisk(self,disk):
+        if not disk in self.clVars.Get('os_disk_dev'):
+            raise InstallError(_("Wrong target drive name %s"%disk))
+        else:
+            osdiskload = \
+                filter(lambda x: (x[1] or x[2] == "extended") and x[0] == disk,
+                                    zip(self.clVars.Get('os_disk_dev'),
+                                        self.clVars.Get('os_disk_load'),
+                                        self.clVars.Get('os_disk_part')))
+            if len(osdiskload) > 0:
+                if osdiskload[0][2] == "extended":
+                    raise InstallError(
+                        _("Specified drive '%s' is extended"%disk))
+                else:
+                    raise InstallError(
+                        _("Specified drive '%s' mounted to '%s'")%
+                                (disk,osdiskload[0][1]))
+            else:
+                self.clVars.Set('os_root_dev',disk,True)
+
+    def getDeviceByField(self,field,value):
+        """Get device by fields (install load format uuid grub part name)"""
+        return self.getFieldByField('dev',field,value)
+
+    def getFieldByField(self,resfield,field,value):
+        res = filter(lambda x: x[1] == value,
+                zip(self.clVars.Get('os_disk_%s'%resfield),
+                    self.clVars.Get('os_disk_%s'%field))) or [("","")]
+        return res[0][0]
+
+    def getFieldByDevice(self,field,device):
+        """Get value of field by device"""
+        device_hash = self.clVars.Get('os_disk_hash')
+        if device in device_hash and field in device_hash[device]:
+            return device_hash[device][field]
+        else:
+            return ""
+
+    def installBootloader(self,target):
+        """Install boot loader
+        
+        Perform grub installation to disk, which has root partition
+        """
+        pipe = Popen(["/sbin/grub",
+               "--device-map=%s/boot/grub/device.map"%target.getDirectory(),
+               "--batch"], stdin=PIPE, stdout=PIPE,stderr=PIPE)
+        pipe.stdin.write("root (hd%s)\n"%
+                self.getFieldByField("grub","install","/"))
+        # TODO: change hd0 for bootloader install to other disks
+        #       may be another parameters
+        pipe.stdin.write("setup (hd0)\n")
+        pipe.stdin.write("quit\n")
+        pipe.stdin.close()
+        # TODO: break if command is hang (KeyboardInterrupt is supported)
+        if pipe.wait() != 0:
+            raise DistributiveError("Cann't install bootloader")
+
     def installSystem(self,buildermode=False):
         """install System by current variable enviroment"""
         sourceDistr = None
@@ -199,7 +264,8 @@ class cl_install(color_print):
                 self.wait(waittime)
                 # format partition if needed
                 self.printSUCCESS(_("Formating partition"))
-                targetDistr.formatPartition("reiserfs")
+                targetDistr.formatPartition(
+                    self.getFieldByField("format","install","/") or "reiserfs")
                 # install distributive
                 self.printSUCCESS(_("Unpacking system image into target"))
                 targetDistr.installFrom(sourceDistr)
@@ -221,16 +287,20 @@ class cl_install(color_print):
             self.printWARNING("Interrupting the installation")
             error = _("Installation manually interrupt")
         try:
+            if self.clTempl:
+                self.clTempl.closeFiles()
             if sourceDistr:
                 self.printSUCCESS(_("Releasing source distributive"))
                 sourceDistr.close()
             if targetDistr:
                 self.printSUCCESS(_("Unmount target system volume"))
                 targetDistr.close()
+        except (InstallError,DistributiveError),e:
+            error = "%s\n%s" % (str(error),_("Unmouting error"))
         except KeyboardInterrupt,e:
             pass
         if error:
-            for line in str(error).split('\n'):
+            for line in filter(lambda x: x,str(error).split('\n')):
                 self.printERROR(line)
             return False
         self.printSUCCESS(_("System successfully installed"))

pym/cl_install_cmd.py

@@ -105,21 +105,13 @@ class install_cmd(cl_install,opt,share_cmd):
                         self.printERROR(_('variable %s not found')%k)
                         return False
         if options.d:
-            if not options.d in self.clVars.Get('os_disk_dev'):
-                self.error(_("Wrong target drive name %s"%options.d))
-            else:
-                osdiskload = filter(lambda x: x[1] and x[0] == options.d,
-                        zip(self.clVars.Get('os_disk_dev'),
-                            self.clVars.Get('os_disk_load')))
-                if len(osdiskload) > 0:
-                    self.error(
-                        _("Specified drive '%s' mounted to '%s' on loaded system"%
-                                (options.d,osdiskload[0][1])))
-                else:
-                    self.clVars.Set('os_root_dev',options.d,True)
+            try:
+                self.setInstallDisk(options.d)
+            except InstallError,e:
+                self.error(str(e))
+        self.old_os_linux_name = self.clVars.Get('os_linux_shortname')
+        self.old_os_linux_ver = self.clVars.Get('os_linux_ver')
         if options.s:
-            self.old_os_linux_name = self.clVars.Get('os_linux_shortname')
-            self.old_os_linux_ver = self.clVars.Get('os_linux_ver')
             self.clVars.Set('os_linux_shortname',options.s.upper(),True)
         return True
 

pym/cl_vars_install.py

@@ -93,4 +93,17 @@ class Data:
     os_fstab_swap_info = {}
 
     # content of /etc/conf.d/net.* file
-    os_net_config_info = {}
+    os_net_config_info = {}
+
+    # system: server or desktop
+    os_linux_system = {}
+
+    # scheduler
+    os_kernel_scheduler = {}
+
+    # kernel attributes
+    os_kernel_attr = {}
+
+    # kernel resume
+    os_kernel_resume = {}
+

templates/install/grub/device.map

@@ -0,0 +1 @@
+#-os_grub_devicemap_info-#

templates/install/grub/grub.conf

@@ -0,0 +1,38 @@
+timeout 5
+default 0
+fallback 1
+#?os_linux_ver<9.8#
+splashimage=(hd#-disk(/boot,grub)-#)/boot/grub/calculate.xpm.gz
+#os_linux_ver#
+#?os_linux_ver>=9.8#
+splashimage=(hd#-disk(/boot,grub)-#)/boot/grub/grub-calculate.xpm.gz
+#os_linux_ver#
+
+#?os_linux_system==desktop&&os_linux_subname!=#
+title #-os_linux_name-# #-os_arch_machine-# #-os_linux_ver-# #-os_linux_subname-#
+#os_linux_system#
+#?os_linux_system==desktop&&os_linux_subname==#
+title #-os_linux_name-# #-os_arch_machine-# #-os_linux_ver-#
+#os_linux_system#
+#?os_linux_system==server#
+title #-os_linux_name-# #-os_arch_machine-# #-os_linux_ver-#
+#os_linux_system#
+root (hd#-disk(/boot,grub)-#)
+#?os_linux_system==desktop#
+kernel /boot/vmlinuz root=#-os_root_dev-# video=uvesafb:ywrap,1024x768-32@60,mtrr:3,splash=silent,theme:tty1 CONSOLE=/dev/tty1 udev quiet #-os_kernel_resume-# elevator=#-os_kernel_scheduler-# doscsi#-os_kernel_attr-#
+#os_linux_system#
+#?os_linux_system==server&&os_linux_shortname!=CSS#
+kernel /boot/vmlinuz root=#-os_root_dev-# video=uvesafb:ywrap,1024x768-32@60,mtrr:3,splash=silent,theme:tty1 CONSOLE=/dev/tty1 udev quiet #-os_kernel_resume-# elevator=#-os_kerenl_scheduler-# doscsi#-os_kernel_attr-#
+#os_linux_system#
+#?os_linux_shortname==CSS#
+kernel /boot/vmlinuz root=#-os_root_dev-# video=uvesafb:ywrap,1024x768-32@60,mtrr:3 udev quiet #-os_kernel_resume-# elevator=#-os_kernel_scheduler-# doscsi#-os_kernel_attr-#
+#os_linux_shortname#
+initrd /boot/initrd
+
+#-os_grub_info-#
+
+# Uncomment if you have Windows on hard disk
+# title Microsoft Windows
+# rootnoverify (hd0,0)
+# chainloader +1
+

templates/install/openrc/.calculate_directory

@@ -1,2 +1,2 @@
-# Calculate belong()!=&&pkg(sys-apps/openrc)!= append=skip
+# Calculate belong()!=&&pkg(sys-apps/openrc)!= name=etc
 

templates/install/openrc/conf.d/.calculate_directory

@@ -1 +1 @@
-# Calculate path=/etc
+# Calculate

templates/install/openrc/fstab

@@ -0,0 +1,6 @@
+#-os_fstab_mount_info-#
+
+#-os_fstab_swap_info-#
+
+proc		/proc		proc	defaults		0 0
+shm		/dev/shm	tmpfs	nodev,nosuid,noexec	0 0