Add scratch mode

pym/cl_distr.py

@@ -25,7 +25,7 @@ from time import sleep
 import re
 import sys
 from cl_utils import runOsCommand,isMount,removeDir,typeFile,pathJoin
-from shutil import copyfile
+from shutil import copyfile,copytree
 from cl_template import _terms
 from subprocess import Popen,PIPE
 from cl_fill import fillVars
@@ -275,6 +275,8 @@ class DistributiveRepository:
 class Distributive(object):
     """Distributive object. Parent object for all distributive."""
     mountError = _("Cann't mount") + " %s:\n%s"
+    reLive = re.compile(r"^live[^.]*\.squashfs(\.(\d+))?$",re.S)
+
     def __init__(self, parent=None):
         self.childs = []
         # if specified parent
@@ -386,6 +388,13 @@ class Distributive(object):
             raise DistributiveError(_("Cann't copy") + " '%s' to '%s':\n%s"\
                                     %(infile,outfile,str(e)))
 
+    def _copytree(self,indir,outdir):
+        try:
+            copytree(indir,outdir,symlinks=True)
+        except (Exception,KeyboardInterrupt),e:
+            raise DistributiveError(_("Cann't copy") + " '%s' to '%s':\n%s"\
+                                    %(indir,outdir,str(e)))
+
     def getRunCommands(self):
         return map(lambda x:open('/proc/%s/cmdline'%x).read().strip(),
                    filter(lambda x:x.isdigit(),
@@ -427,6 +436,23 @@ class Distributive(object):
         return "".join([choice(string.ascii_letters+string.digits)
                     for i in xrange(0,8)])
 
+    def _getLastLive(self,directory):
+        """Get last live squashfs image from directory"""
+        curfile = None
+        curnum = -1
+        for file in os.listdir(directory):
+            res = self.reLive.search(file)
+            if res:
+                if res.groups()[1]:
+                    num = int(res.groups()[1])
+                else:
+                    num = 0
+                if num > curnum:
+                    curfile = file
+                    curnum = num
+        return curfile
+
+
     def _mountToDirectory(self,file,directory,mountopts=""):
         """Mount squashfs to directory"""
         if isMount(directory):
@@ -906,8 +932,6 @@ class SquashDistributive(Distributive):
         self.packToSquash(dFrom.directory, self.file)
 
 class IsoDistributive(Distributive):
-    reLive = re.compile(r"^live[^.]*\.squashfs(\.(\d+))?$",re.S)
-
     def __init__(self,file,parent=None,mdirectory="/mnt/cdrom",
             bdirectory="/var/calculate/tmp/iso"):
         Distributive.__init__(self,parent=parent)
@@ -923,21 +947,6 @@ class IsoDistributive(Distributive):
         self._umountDirectory(directory)
         self._removeDirectory(directory)
 
-    def _getLastLive(self,directory):
-        curfile = None
-        curnum = -1
-        for file in os.listdir(directory):
-            res = self.reLive.search(file)
-            if res:
-                if res.groups()[1]:
-                    num = int(res.groups()[1])
-                else:
-                    num = 0
-                if num > curnum:
-                    curfile = file
-                    curnum = num
-        return curfile
-
     def convertToSquash(self):
         mdirectory = self.mdirectory
         for child in self.childs:
@@ -1040,7 +1049,7 @@ class ScratchDistributive(Distributive):
         self._makeDirectory(target)
         self._mountToDirectory("none",target,
             mountopts="-t aufs "+\
-            "-o udba=relval,br:%(work)s=rw:%(delta)s=ro+wh:%(static)s=ro" %\
+            "-o udba=reval,br:%(work)s=rw:%(delta)s=ro+wh:%(static)s=ro" %\
                     {"work":pathjoin(source,"workspace"),
                      "delta":pathjoin(source,"delta"),
                      "static":pathjoin(source,"calculate")})
@@ -1062,11 +1071,13 @@ class ScratchDistributive(Distributive):
         mdirectory = self.mdirectory
         for child in self.childs:
             if isinstance(child,DirectoryDistributive) and \
-                kdirectory in child.directory:
+                mdirectory in child.directory:
                 return child
         mdirectory = self._getMntDirectory(mdirectory)
-        self._mountLiveImage(self.file,pathjoin(self.directory,"calculate"))
-        self._mountLayers(self.file,mdirectory)
+        liveFile = self._getLastLive(self.directory)
+        self._mountLiveImage(pathjoin(self.directory,liveFile),
+                pathjoin(self.directory,"calculate"))
+        self._mountLayers(self.directory,mdirectory)
         return DirectoryDistributive(mdirectory,parent=self)
 
     def releaseChild(self,child):
@@ -1109,14 +1120,22 @@ class ScratchPartitionDistributive(PartitionDistributive):
         for scrDirectory in ("calculate","delta","workspace"):
             self._makeDirectory(pathjoin(directory,scrDirectory))
 
+    def postinstallMountBind(self):
+        dirDistr = self.convertToDirectory().directory
+        scrDir = self.convertToScratch().directory
+        self._copytree(pathjoin(dirDistr,"boot"),
+                      pathjoin(scrDir,"boot"))
+
     def installFrom(self, source):
         """Install distributive to partition from source distributive"""
         # get currect partition as directory
-        distrTo = self.mountToDirectory()
-        scratchDirectory = distrTo().directory
+        distrTo = self.convertToScratch()
+        scratchDirectory = distrTo.directory
 
         try:
             # getting squash from source
+            if isinstance(source,IsoDistributive):
+                source = source.convertToSquash()
             if isinstance(source,SquashDistributive):
                 self._copyfile(source.file,
                     pathjoin(scratchDirectory,"livecd.squashfs"))
@@ -1127,7 +1146,7 @@ class ScratchPartitionDistributive(PartitionDistributive):
                 squashDistr.installFrom(distDirectory)
 
             # prepare scratch
-            self.prepareScratch(directory)
+            self.prepareScratch(scratchDirectory)
         except DistributiveError,e:
             self._removeDirectory(scratchDirectory)
             raise e

pym/cl_fill_install.py

@@ -362,6 +362,9 @@ class fillVars(object, glob_attr):
                                         self.Get('os_install_disk_format'),
                                         self.Get('os_install_disk_options'))),
                                  lambda x,y: cmp(x[1],y[1]))
+        if self.Get('os_install_scratch') == "on":
+            devicesForFstab = filter(lambda x:x[1] != "/", devicesForFstab)
+
         # rootLine one string, but it correct work if devicesForFstab is empty
         rootLine =  "\n".join(map(lambda x: "%s\t%s\t%s\t%s\t0 2" %
                                         (x[0],x[1],x[2],x[3]),

pym/cl_install.py

@@ -54,8 +54,8 @@ from cl_template import template
 from cl_datavars import DataVars
 from cl_print import color_print
 from cl_distr import PartitionDistributive,DistributiveRepository,\
-                DistributiveError, ScratchDistributive, MultiPartitions, \
-                Spinner
+                DistributiveError, ScratchPartitionDistributive, \
+                MultiPartitions, Spinner
 from cl_string import tableReport
 from time import sleep
 from subprocess import PIPE,STDOUT
@@ -726,12 +726,13 @@ class cl_install(color_print):
         self.installBootloader(targetDistr)
 
     def getTargetDistributive(self,disk,fileSystem="reiserfs",isFormat=False,
-                                systemId=None):
-        #if buildermode:
-            #return ScratchDistributive(disk,mdirectory="/mnt/install",
-                                    #check=True)
-        #else:
-        return PartitionDistributive(disk,mdirectory="/mnt/install",
+                                systemId=None,buildermode=False):
+        if buildermode:
+            return ScratchPartitionDistributive(disk,mdirectory="/mnt/install",
+                                    check=True, fileSystem=fileSystem,
+                                    isFormat=isFormat, systemId=systemId)
+        else:
+            return PartitionDistributive(disk,mdirectory="/mnt/install",
                                     check=True, fileSystem=fileSystem,
                                     isFormat=isFormat, systemId=systemId)
 
@@ -746,19 +747,6 @@ class cl_install(color_print):
         else:
             return dirsFiles
 
-    def _getTransferedBind(self,skipSrc,skipDest):
-        def list2binddict(l):
-            return {'srcMountPoint':l[0],
-                    'isFormat':False,
-                    'destMountPoint':l[1],
-                    'options':['bind'],
-                    'fileSystem':'none'}
-        return map(list2binddict,
-                   filter(lambda x: not x[0] in skipSrc and
-                                    not x[1] in skipDest,
-                          zip(self.clVars.Get('os_install_bind_dir'),
-                              self.clVars.Get('os_install_bind_mountpoint'))))
-
     def setInstallOptions(self, listDisks, listBinds, listSwaps, listUsers,
                           mbrDisk):
         """Set data for installation partitions"""
@@ -787,11 +775,18 @@ class cl_install(color_print):
                 self.printWARNING(_("See 'man mount' for file system") + " "+\
                 ", ".join(convObj.listFileSystemCorrupted))
             return False
+
         usedDevicesOnlyDisks = map(lambda x:x['dev'],listDisks)
         usedDevicesOnlySwap = map(lambda x:x['dev'],listSwaps)
         usedDevices = map(lambda x:x['dev'],listSwaps)+usedDevicesOnlyDisks
         usedMP = map(lambda x:x['mountPoint'],listDisks) + \
                  map(lambda x:x['destMountPoint'],listBinds)
+        if self.clVars.Get('os_install_scratch') == "on" and \
+            filter(lambda x: x != '/', usedMP):
+                self.printERROR(
+                    _("Builder mode is not support multipartition"))
+                return False
+
         # check specified devices
         wrongDevices = list(set(usedDevicesOnlyDisks) - \
                         set(self.clVars.Get('os_disk_dev')))
@@ -848,20 +843,29 @@ class cl_install(color_print):
             self.printERROR(_("Device '%s' is used twice")%dupDevices[0])
             return False
         # detect duplicate mount points
-        dupMP = list(set(filter(lambda x:usedMP.count(x)>1,
+        dupMP = list(set(filter(lambda x:usedMP.count(x)>1 and x != "none",
                                      usedMP)))
         if dupMP:
             self.printERROR(_("Mount point '%s' is used twice")%dupMP[0])
             return False
 
-        clearSwap = lambda data,isswap: data if len(listSwaps) == 0 or \
-                                        isswap != "swap" else ""
+        def clearParam(data,isswap):
+            if builderMode:
+                if len(listSwaps) == 0 and isswap == "swap":
+                    return data
+            else:
+                if len(listSwaps) == 0 or isswap != "swap":
+                    return data
+            return ""
+
+        builderMode = self.clVars.Get('os_install_scratch') == "on"
+        clearBuilder = lambda data,isswap: "" if builderMode and isswap != "swap" else data
         # get hash from current variables
         devMount = dict(map(lambda x:(x[0],
-                                      {'mountPoint':clearSwap(x[1],x[1]),
-                                       'fileSystem':x[2],
-                                       'options':clearSwap(x[3],x[1]),
-                                       'isFormat':""}),
+                              {'mountPoint':clearParam(x[1],x[1]),
+                               'fileSystem':x[2],
+                               'options':clearParam(x[3],x[1]),
+                               'isFormat':""}),
                             zip(self.clVars.Get('os_disk_dev'),
                                 self.clVars.Get('os_install_disk_mount'),
                                 self.clVars.Get('os_install_disk_format'),
@@ -893,10 +897,14 @@ class cl_install(color_print):
                 if isFormat:
                     devMount[dev]['isFormat'] = "yes"
 
-        bindDestSrc = dict(zip(self.clVars.Get('os_install_bind_mountpoint'),
-                               self.clVars.Get('os_install_bind_dir')))
-        bindSrcDest = dict(zip(self.clVars.Get('os_install_bind_dir'),
-                               self.clVars.Get('os_install_bind_mountpoint')))
+        if builderMode:
+            bindDestSrc = {}
+            bindSrcDest = {}
+        else:
+            bindDestSrc =dict(zip(self.clVars.Get('os_install_bind_mountpoint'),
+                                self.clVars.Get('os_install_bind_dir')))
+            bindSrcDest = dict(zip(self.clVars.Get('os_install_bind_dir'),
+                                self.clVars.Get('os_install_bind_mountpoint')))
 
         for bindData in listBinds:
             srcMountPoint = bindData['srcMountPoint']
@@ -979,6 +987,7 @@ class cl_install(color_print):
                 disk['systemId'] = updateIdDict[disk['dev']]
             else:
                 disk['systemId'] = None
+
         # use or not MBR
         bootDiskGrub = ""
         if mbrDisk == "off":
@@ -1305,7 +1314,8 @@ class cl_install(color_print):
                                  'boot',self.clVars.Get('os_install_initrd'))
         return InitRamFs(initrdPath).cleanInitRamFs()
 
-    def installSystem(self, force=False, bootDisk=None, stdinReadPwd=False):
+    def installSystem(self, force=False, bootDisk=None, stdinReadPwd=False,
+                      builder=False):
         """install System by current variable enviroment"""
         sourceDistr = None
         targetDistr = None
@@ -1337,6 +1347,7 @@ class cl_install(color_print):
                                 #%waittime)
             self.printInfo(sourceDistr,targetDistr)
             targetDistr = self.getTargetDistributive(rootPartdev,
+                                                  buildermode=builder,
                                                   fileSystem=rootPartFileSystem,
                                                   isFormat=rootPartIsFormat,
                                                   systemId=rootPartSystemId)
@@ -1430,6 +1441,10 @@ the system") + " (yes/no)"
                 targetDistr.installFrom(sourceDistr)
                 self.printByResult(True)
 
+                # optimize initrd
+                self.printMessageForTest(_("Creating new initrd file"))
+                self.printByResult(self.cleanInitrd())
+
                 # copy clt files from current system
                 self.printMessageForTest(_("Coping clt templates to new system"))
                 cltCpy = cltCopy(target=targetDistr.getDirectory())
@@ -1440,10 +1455,12 @@ the system") + " (yes/no)"
                 self.printMessageForTest(_("Updating config"))
                 self.applyTemplates(targetDistr.getDirectory())
                 # mount bind mount points 
-                targetDistr.postinstallMountBind()
 
                 self.writeInstallVars()
                 self.printByResult(True)
+                self.printMessageForTest(_("Post-install configuration"))
+                targetDistr.postinstallMountBind()
+                self.printByResult(True)
 
                 # migrate users
                 self.printSUCCESS(_("Migrate users"))
@@ -1455,9 +1472,6 @@ the system") + " (yes/no)"
                     self.printMessageForTest(_("Preparing system for reboot"))
                     self.prepareBoot(targetDistr)
                 self.printByResult(True)
-                # optimize initrd
-                self.printMessageForTest(_("Creating new initrd file"))
-                self.printByResult(self.cleanInitrd())
             else:
                 return False
         except (EOFError), e:

pym/cl_install_cmd.py

@@ -90,12 +90,10 @@ CMD_OPTIONS = [{'shortOption':"d",
                },
                {'longOption':"uninstall",
                 'help':_("configure the system to uninstall this package")
-               }
-               ]
-               #{'shortOption':"b",
-                #'longOption':"build",
-                #'help':_("installation for assembling")
-               #}]
+               },
+               {'longOption':"build",
+                'help':_("installation for assembling")
+               }]
 
 class install_cmd(share_cmd):
     """Class for work with cl_install by console"""
@@ -246,6 +244,10 @@ class install_cmd(share_cmd):
             self.logicObj.clVars.Set('cl_action','system',True)
         if options.s:
             self.logicObj.setLinuxName(options.s.upper())
+        if options.build:
+            self.logicObj.clVars.Set('os_install_scratch',"on",True)
+        else:
+            self.logicObj.clVars.Set('os_install_scratch',"off",True)
         return True
 
     def checkAndSetInstallOptions(self,diskOptions, swapOptions, bindOptions,
@@ -340,10 +342,11 @@ class install_cmd(share_cmd):
         else:
             return False
 
-    def installSystem(self, force=False, bootDisk=None, stdinReadPwd=False):
+    def installSystem(self, force=False, bootDisk=None, users=[],
+                      stdinReadPwd=False, builder=False):
         """Run install system"""
         if self.logicObj.installSystem(force=force, bootDisk=bootDisk,
-                                       stdinReadPwd=stdinReadPwd):
+                                    stdinReadPwd=stdinReadPwd, builder=builder):
             return True
         else:
             return False

scripts/cl-install

@@ -71,7 +71,7 @@ if __name__ == "__main__":
     else:
         forceOpions = options.f or options.P
         if not install.installSystem(force=forceOpions, bootDisk=options.mbr,
-                                     stdinReadPwd=options.P):
+		                stdinReadPwd=options.P,builder=options.build):
             sys.exit(1)
     #if not install.writeVars(options):
     #    sys.exit(1)