From be98a8d1548f13cbafe55b11034f54b635e6086e Mon Sep 17 00:00:00 2001 From: Mike Hiretsky Date: Tue, 26 Jul 2011 17:10:33 +0400 Subject: [PATCH] Update calculate-utilities rc2 --- sys-apps/calculate-install/ChangeLog | 7 + sys-apps/calculate-install/Manifest | 4 +- .../calculate-install-2.2.19-r3.ebuild | 41 + ...calculate-install-2.2.19_lvmraid_rc2.patch | 1604 +++++++++++++++++ sys-apps/calculate-lib/ChangeLog | 7 + sys-apps/calculate-lib/Manifest | 4 +- .../calculate-lib-2.2.19-r5.ebuild | 34 + .../calculate-lib-2.2.19_lvmraid_rc2.patch | 747 ++++++++ sys-apps/calculate-utilities/ChangeLog | 6 + sys-apps/calculate-utilities/Manifest | 3 +- .../calculate-utilities-2.2.19-r7.ebuild | 37 + 11 files changed, 2491 insertions(+), 3 deletions(-) create mode 100644 sys-apps/calculate-install/calculate-install-2.2.19-r3.ebuild create mode 100644 sys-apps/calculate-install/files/calculate-install-2.2.19_lvmraid_rc2.patch create mode 100644 sys-apps/calculate-lib/calculate-lib-2.2.19-r5.ebuild create mode 100644 sys-apps/calculate-lib/files/calculate-lib-2.2.19_lvmraid_rc2.patch create mode 100644 sys-apps/calculate-utilities/calculate-utilities-2.2.19-r7.ebuild diff --git a/sys-apps/calculate-install/ChangeLog b/sys-apps/calculate-install/ChangeLog index faf77d002..5725976a0 100644 --- a/sys-apps/calculate-install/ChangeLog +++ b/sys-apps/calculate-install/ChangeLog @@ -2,6 +2,13 @@ # Copyright 1999-2011 Gentoo Foundation; Distributed under the GPL v2 # $Header: $ +*calculate-install-2.2.19-r3 (26 Jul 2011) + + 26 Jul 2011; Mike Hiretsky (mhiretskiy) + calculate-install-2.2.19-r2.ebuild, +calculate-install-2.2.19-r3.ebuild, + +files/calculate-install-2.2.19_lvmraid_rc2.patch: + Update for raid lvm + *calculate-install-2.2.19-r2 (25 Jul 2011) 25 Jul 2011; Mike Hiretsky (mhiretskiy) diff --git a/sys-apps/calculate-install/Manifest b/sys-apps/calculate-install/Manifest index 508edba17..8dd00af62 100644 --- a/sys-apps/calculate-install/Manifest +++ b/sys-apps/calculate-install/Manifest @@ -3,6 +3,7 @@ AUX calculate-install-2.2.18-to_2.2.19_rc1.patch 2145 RMD160 ff0242bbf53e10e1cd0 AUX calculate-install-2.2.18-to_2.2.19_rc2.patch 3834 RMD160 5aeac0cc6ce8b889a50e70719592a86717a18f77 SHA1 56bf8ae25eefa1b72d639de66a433cf3853158b0 SHA256 b47e94a9bac6779f0a831ce275cad60f306a9939fa78407c905789186be01243 AUX calculate-install-2.2.19_2.2.20_rc1.patch 4197 RMD160 2173f292eb876ac8ad2f37b05eb2d29cd6c38989 SHA1 468a2c7ba8eff0ed3a4ad1510d571936ed6c3940 SHA256 bbb14bea93756f59fa3d000aa65776e44bcaa06c9926b257ed4a96e91a836543 AUX calculate-install-2.2.19_lvmraid_rc1.patch 71417 RMD160 d692c2d17a57ee98b0c9e095f75d8779e414daca SHA1 5cbbc69cd8ef4fe129a541e1d1bf15ab90b1fbe7 SHA256 5fa8e8a394d2590b399133b60dd068b964b92a300ef06f98f8531d3e1de6d6de +AUX calculate-install-2.2.19_lvmraid_rc2.patch 71669 RMD160 30934778ac315debbebb8aeb332473cf37b4144e SHA1 b065089df52cb6302e55cceb0789f8edab1eaaed SHA256 7eced47992fbd72b6ebea39eedc9da82384aaee032225ed04a0d0ce8b3d1d16e DIST calculate-install-2.2.18.tar.bz2 75850 RMD160 56b1058d1977957cc6ceb8322a049af4dbb8f0cc SHA1 4e990cf5bd6310942b54995293f1f7ea82726aa9 SHA256 2a1b9c3fa93a958f19f05af51f80adf25f5ee0867452fac0304ec721de19cd97 DIST calculate-install-2.2.19.tar.bz2 63943 RMD160 8c76315aea89d20239b11c7e6017766b5e5e93db SHA1 1127468d3b221333e820e142fc1b9afaef507ee3 SHA256 5dedcb4c3d42ca4d87b2a2fa0d72704be3748865907b991dddbeba493e0da80a EBUILD calculate-install-2.2.18-r1.ebuild 896 RMD160 ee093622c27d416e091dbe7d79f4937dec59b9ef SHA1 725ebcabb3fc63fde3a6e804d3912caacd121fa7 SHA256 9d08644a337cafe7a5744e4ffdf7f8ff549c785bf03acd33349c441aedb72de2 @@ -11,7 +12,8 @@ EBUILD calculate-install-2.2.18-r3.ebuild 971 RMD160 62ee16eb832645a3275da557a6f EBUILD calculate-install-2.2.18.ebuild 718 RMD160 6036a151e5e5f44dc88f05943483889aac3db500 SHA1 733eb52ed024192f39a93961b2af8b4f4d8b9ed7 SHA256 a10787adc974dd82ca0272b461ad9b593cd441f821fb1696b57d2b97e3f4297f EBUILD calculate-install-2.2.19-r1.ebuild 907 RMD160 ffc1169f89321fc9e94606a844ae559cf9298dda SHA1 18424b3c512a931e1946372d9db8698bb496ed1a SHA256 54a1e68243a55fe1dbe49385b52cb3728e2ddae3ecd295616bb3742224506189 EBUILD calculate-install-2.2.19-r2.ebuild 905 RMD160 e4825969e7fc0e4aca73e41353b4a0ff8a3719b9 SHA1 c65b23c3c3e1ca25a92307456c43a9488de0d789 SHA256 c4876a5ebf6ffd2e7696656e69cae42528c08674db1a9ed92920e6f50e0145c2 +EBUILD calculate-install-2.2.19-r3.ebuild 905 RMD160 1f9ca2bbc0f6fbe1ab614d067c1073bc2237d61a SHA1 956a812e79e13acf7fbcf91f04cd9fe191a120d6 SHA256 b29ebbbb50b754b4576b33ad8e41e9a50229f5785e4a751a5a8a269f57022eae EBUILD calculate-install-2.2.19.ebuild 774 RMD160 d551b0b0a6e51b5ecfd9bd6310aeaba6b0a04620 SHA1 0493b095e1009496ed991229e86c80f9abcb898c SHA256 465794cf6ba461260664d9ca06238655c2e41e1f4eb65b170ffef22f5b163aff EBUILD calculate-install-2.2.9999.ebuild 595 RMD160 8f9b9a14fed39ded9c2a9d9343aa4e892d620172 SHA1 09aff28bdaa486868e2caddc7911732a905336ee SHA256 534e6c6e465177e269ce7beed96dab08a124878591088c1bf38095e855ca1180 -MISC ChangeLog 23763 RMD160 c8472dd55fce7714790c28ed11b299536a5003b0 SHA1 9a1b9c43c40ec2623ec763cc82115d0f057c4bae SHA256 679441b7126aa6017d3480b3ec21bd5dc456684d49471a3c0d9f8f7c17bb11c9 +MISC ChangeLog 24018 RMD160 8a734bee88ef177444bd7e015867c06199d65205 SHA1 533d22e94b895bb44aa18a03464fa02f891cc7a6 SHA256 5290157641fc0b48ec0d5efb8d4d3e4875974642be6a53d4373c7ce401669352 MISC metadata.xml 310 RMD160 769e4f17a9354da6b168b72a5d65d978f65bf6dd SHA1 83aaae376052d69c7327e880cf028ebc0dea608b SHA256 c29d3efc676d8308872920db5223c78469db86ac236b5d45c3ee98ceb8fca846 diff --git a/sys-apps/calculate-install/calculate-install-2.2.19-r3.ebuild b/sys-apps/calculate-install/calculate-install-2.2.19-r3.ebuild new file mode 100644 index 000000000..f4d7ea856 --- /dev/null +++ b/sys-apps/calculate-install/calculate-install-2.2.19-r3.ebuild @@ -0,0 +1,41 @@ +# Copyright 1999-2011 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header: $ + +EAPI="3" + +inherit distutils eutils + +SRC_URI="ftp://ftp.calculate.ru/pub/calculate/calculate2/${PN}/${P}.tar.bz2" + +DESCRIPTION="The program of installation Calculate Linux" +HOMEPAGE="http://www.calculate-linux.org/main/en/calculate2" +LICENSE="Apache-2.0" +SLOT="0" +KEYWORDS="amd64 x86" +IUSE="minimal" + +DEPEND="~sys-apps/calculate-templates-2.2.19 + ~sys-apps/calculate-lib-2.2.19 + app-portage/layman + !app-misc/livecd-tools + !minimal? ( sys-boot/grub + sys-apps/gptfdisk + sys-fs/dosfstools + sys-fs/squashfs-tools + sys-block/parted )" + +RDEPEND="${DEPEND}" + +src_unpack() { + unpack "${A}" + cd "${S}" + + # update to raidlvm + epatch "${FILESDIR}/calculate-install-2.2.19_lvmraid_rc2.patch" +} + +pkg_postinst() { + einfo "For configure calculate-install perform:" + einfo " cl-install --install" +} diff --git a/sys-apps/calculate-install/files/calculate-install-2.2.19_lvmraid_rc2.patch b/sys-apps/calculate-install/files/calculate-install-2.2.19_lvmraid_rc2.patch new file mode 100644 index 000000000..8446bc282 --- /dev/null +++ b/sys-apps/calculate-install/files/calculate-install-2.2.19_lvmraid_rc2.patch @@ -0,0 +1,1604 @@ +diff --git data/calculate data/calculate +index d720d40..32eda6a 100755 +--- data/calculate ++++ data/calculate +@@ -6,60 +6,6 @@ depend() { + use swap hostname + } + +-xorg_video_driver() +-{ +- local xorgFile="/etc/X11/xorg.conf" +- if [[ -f $xorgFile ]] +- then +- cat /etc/X11/xorg.conf | grep Driver | cut -d\" -f2 +- fi +-} +- +-cmdline_video_driver() +-{ +- local cmdline=`cat /proc/cmdline` +- for x in $cmdline +- do +- case $x in +- # parse cmdline param calculate +- calculate\=*) +- local value=`echo "$x" | cut -d\= -f2-` +- # if calculate specified in new format +- if [[ "$value" =~ : ]] +- then +- for i in ${value//,/ } +- do +- case ${i} in +- video:*) +- local value=`echo "$i" | cut -d: -f2-` +- if [[ -n "$value" ]] +- then +- echo "$value" +- return 0 +- fi +- ;; +- esac +- done +- # if calculate specified in old format +- else +- local videodrv=`echo "$value" | cut -d, -f5` +- if [[ -n $videodrv ]] +- then +- echo "$videodrv" +- return 0 +- fi +- fi +- ;; +- esac +- done +- return 1 +-} +- +-video_driver() +-{ +- cmdline_video_driver || xorg_video_driver +-} +- + check_install_ability() + { + local pkg=$1 +@@ -92,7 +38,7 @@ variable_value() + install_video_driver() + { + ebegin "Checking video drivers" +- case `video_driver` in ++ case `variable_value os_install_x11_video_drv` in + fglrx) + local drv="x11-drivers/ati-drivers" + ;; +diff --git pym/cl_distr.py pym/cl_distr.py +index e9d8603..4c718c3 100644 +--- pym/cl_distr.py ++++ pym/cl_distr.py +@@ -25,7 +25,8 @@ import sys + import operator + from cl_utils import runOsCommand,isMount,removeDir,typeFile,pathJoin, \ + process,getRunCommands,getTupleVersion,cmpVersion, \ +- detectDeviceForPartition, getProgPath,listDirectory ++ detectDeviceForPartition, getProgPath,listDirectory, \ ++ checkUtils,STDOUT,getUdevDeviceInfo, countPartitions + from cl_vars_share import varsShare + from shutil import copyfile,copytree + from cl_template import _terms +@@ -103,6 +104,8 @@ class DistributiveError(Exception): + class DistributiveRepository: + varsShare = varsShare() + ++ contentCache = {} ++ + marches = ['i686','x86_64'] + + extensiton = ['iso','tar.bz2','tar.gz','tar.7z','tar.lzma'] +@@ -129,17 +132,21 @@ class DistributiveRepository: + else: + return {} + +- def _getfromcontent(self,filename): ++ def _getfromcontent(self,filename,addFunc=None): + """Get info from content""" ++ origfilename = filename ++ if filename in DistributiveRepository.contentCache: ++ return DistributiveRepository.contentCache[filename] + varsShare = self.varsShare + distr = None + # may be directory is isodir (directory which contains iso image) + extname = "isodir" + try: +- if filename.startswith('/dev'): ++ distr = IsoDistributive(filename) ++ if not distr.probe() and filename.startswith('/dev'): ++ distr.close() ++ distr = None + distr = PartitionDistributive(filename) +- else: +- distr = IsoDistributive(filename) + filename = distr.convertToDirectory().directory + except Exception,e: + extname = "dir" +@@ -172,15 +179,18 @@ class DistributiveRepository: + d['build'] = os_linux_build[-1] + else: + d['build'] = "" ++ if addFunc: ++ d = addFunc(filename,d) + if distr: + distr.close() ++ DistributiveRepository.contentCache[origfilename] = d + return d + + def _getdistrinfo(self,filename): + """Get information by distributive""" + varsShare = self.varsShare + # if filename is directory +- if path.isdir(filename): ++ if not path.isfile(filename): + return self._getfromcontent(filename) + else: + match = self.reDistName.match(filename) +@@ -229,6 +239,8 @@ class DistributiveRepository: + return [pathname] + elif path.exists(path.join(pathname,'livecd')): + return [pathname] ++ elif pathname.startswith('/dev/'): ++ return [pathname] + else: + # discard inner directories + return filter(lambda x:not path.isdir( path.join(pathname,x)), +@@ -248,8 +260,10 @@ class DistributiveRepository: + def getDistributiveByFile(self,filename): + """Get Distributive object by filename""" + # MAGIC_COMPRESS 0x000004 Check inside compressed files +- tf = typeFile(magic=0x4) ++ tf = typeFile(magic=0x6) + ftype = tf.getMType(filename) ++ if "block special" in ftype: ++ return IsoDistributive(filename) + if "ISO 9660 CD-ROM" in ftype: + return IsoDistributive(filename) + elif "7-zip" in ftype or \ +@@ -512,18 +526,18 @@ class Distributive(object, SignalInterrupt): + " '%s' " %fromdir + _("to") +\ + " '%s':\n%s" %(todir,errmes)) + +- def _mountToBind(self,srcDirectory,destDirectory,mountopts="-o bind"): ++ def _mountToBind(self,srcDirectory,destDirectory): + """Mount srcDirectory to destDirectory""" +- res,errmes = self.runOsCommand("/bin/mount %s %s %s"% +- (mountopts,srcDirectory,destDirectory)) +- if res == 0: ++ mount = process('/bin/mount',"-o","bind",srcDirectory,destDirectory, ++ stderr=STDOUT) ++ if mount.success(): + return True + else: + try: + os.rmdir(destDirectory) + except: + pass +- raise DistributiveError(self.mountError%(srcDirectory,errmes)) ++ raise DistributiveError(self.mountError%(srcDirectory,mount.read())) + + def performFormat(self): + pass +@@ -557,27 +571,29 @@ class Distributive(object, SignalInterrupt): + if isMount(directory): + raise DistributiveError(_("Cann't mount to directory: %s\n")\ + %directory+ _("Directory already mounted")) +- res,errmes = self.runOsCommand("/bin/mount %s %s %s"% +- (mountopts,file,directory)) +- if res == 0: ++ mountopts = filter(lambda x:x, ++ mountopts.split(" ")) ++ mountProcess = process('/bin/mount',file,directory,*mountopts, ++ stderr=STDOUT) ++ if mountProcess.success(): + return True + else: + try: + self._removeDirectory(directory) + except: + pass +- raise DistributiveError(self.mountError%(file,errmes)) ++ raise DistributiveError(self.mountError%(file,mountProcess.read())) + + def _umountDirectory(self,directory): + """Umount directory""" + if isMount(directory): + for wait in [0,0.5,2,5]: + sleep(wait) +- res,errmes = self.runOsCommand("/bin/umount %s"%directory) +- if res == 0: ++ processUmount = process('/bin/umount',directory,stderr=STDOUT) ++ if processUmount.success(): + return True + raise DistributiveError(_("Cann't umount") + " %s:\n%s"% +- (directory,errmes)) ++ (directory,processUmount.read())) + else: + return True + +@@ -680,7 +696,7 @@ class MultiPartitions: + return map(lambda x: x.systemId, self.listPartitions) + + def getPartitionTable(self): +- """Get systemID for change [msdos,gpt,...]""" ++ """Get systemID for change [dos,gpt,...]""" + return map(lambda x: x.partitionTable, self.listPartitions) + + def getIsFormat(self): +@@ -771,7 +787,7 @@ class PartitionDistributive(Distributive): + if "ntfs" in opts: + source_dir = isMount(partition) + if source_dir: +- self._mountToDirectory(source_dir,directory,"-o bind") ++ self._mountToBind(source_dir,directory) + return + self._mountToDirectory(partition,directory,opts) + +@@ -850,6 +866,8 @@ class PartitionDistributive(Distributive): + + def formatAllPartitions(self): + """Format all partitions""" ++ FS,DEV,NEEDFORMAT,NEWID,PARTTABLE = 0,1,2,3,4 ++ # get all information to matrix + dataPartitions = zip(self.multipartition.getFileSystems() +\ + [self.fileSystem], + self.multipartition.getPartitions() + \ +@@ -860,21 +878,24 @@ class PartitionDistributive(Distributive): + [self.systemId], + self.multipartition.getPartitionTable() + \ + [self.partitionTable]) +- formatPartitions = map(lambda x: (x[0],x[1]), +- filter(lambda x: x[2] and x[0]!="bind", +- dataPartitions)) ++ # get partition which need format ++ formatPartitions = map(lambda x: (x[FS],x[DEV]), ++ filter(lambda x: x[NEEDFORMAT] and x[FS]!="bind", ++ dataPartitions)) ++ # format all get partition + for fileSystem, dev in formatPartitions: + if fileSystem=="swap": + self.formatSwapPartition(dev) + else: + if dev == self.partition: + self.formatPartition(dev, format=fileSystem, +- label=self.rootLabel) ++ label=self.rootLabel) + else: + self.formatPartition(dev, format=fileSystem) +- changeidPartitions = map(lambda x: (x[3],x[1],x[4]), +- filter(lambda x: x[3], +- dataPartitions)) ++ # change system id for partitions ++ changeidPartitions = map(lambda x: (x[NEWID],x[DEV],x[PARTTABLE]), ++ filter(lambda x: x[NEWID], ++ dataPartitions)) + for systemid, dev, partTable in changeidPartitions: + self.changeSystemID(dev,systemid,partTable) + return True +@@ -919,53 +940,42 @@ class PartitionDistributive(Distributive): + label=self.rootLabel) + + def changeSystemID(self,dev,systemid,parttable): +- parentDir = path.split(dev)[0] +- reDeviceSplit = re.compile("^(.*/)?(.*?)(\d+)$") +- ++ """Change partition id, specified by systemid""" + deviceName = detectDeviceForPartition(dev) + if deviceName is None: +- raise DistributiveError(_("Can not determine parent device for %s")%dev) +- fdiskProg = getProgPath("/sbin/fdisk") +- gdiskProg = getProgPath("/usr/sbin/gdisk") +- for prog,name in [(fdiskProg,"fdisk"),(gdiskProg,"gdisk")]: +- if not prog: +- raise DistributiveError(_("Can not find '%s'")%name) +- if parttable == "msdos": +- pipe = Popen([fdiskProg, +- path.join('/dev',deviceName)], ++ raise DistributiveError( ++ _("Can not determine parent device for %s")%dev) ++ # device hasn't any partition ++ elif deviceName == "": ++ return True ++ fdiskProg, gdiskProg = checkUtils('/sbin/fdisk','/usr/sbin/gdisk') ++ partitionNumber = getUdevDeviceInfo(name=dev).get('ID_PART_ENTRY_NUMBER','') ++ devicePartitionCount = countPartitions(deviceName) ++ if deviceName and not partitionNumber: ++ raise DistributiveError( ++ _("Can not determine partition number for %s")%dev) ++ if parttable == "dos": ++ fdisk = process(fdiskProg,deviceName,stderr=STDOUT) ++ pipe = Popen([fdiskProg,deviceName], + stdin=PIPE, stdout=PIPE,stderr=PIPE) +- if len(filter(lambda x: deviceName in x and deviceName != x, +- listDirectory('/dev'))) > 1: +- numPart = reDeviceSplit.search(dev) +- if numPart: +- numPart = numPart.groups()[-1] +- else: +- pipe.stdin.close() +- raise DistributiveError( +- _("Can not determine partition number for %s")%dev) +- pipe.stdin.write("t\n%s\n%s\nw\n"%(numPart,systemid)) ++ if devicePartitionCount > 1: ++ pipe.stdin.write("t\n%s\n%s\nw\n"%(partitionNumber, ++ systemid)) + else: + pipe.stdin.write("t\n%s\nw\n"%systemid) + pipe.stdin.close() + pipe.wait() +- if parttable == "gpt": +- pipe = Popen([gdiskProg, +- path.join('/dev',deviceName)], ++ elif parttable == "gpt": ++ pipe = Popen([gdiskProg,deviceName], + stdin=PIPE, stdout=PIPE,stderr=PIPE) +- if len(filter(lambda x: deviceName in x and deviceName != x, +- listDirectory('/dev'))) > 1: +- numPart = reDeviceSplit.search(dev) +- if numPart: +- numPart = numPart.groups()[-1] +- else: +- pipe.stdin.close() +- raise DistributiveError( +- _("Can not determine partition number for %s")%dev) +- pipe.stdin.write("t\n%s\n%s\nw\ny\n"%(numPart,systemid)) ++ if devicePartitionCount > 1: ++ pipe.stdin.write("t\n%s\n%s\nw\ny\n"%(devicePartitionCount, ++ systemid)) + else: +- pipe.stdin.write("t\n%s\nw\n\y"%systemid) ++ pipe.stdin.write("t\n%s\nw\ny\n"%systemid) + pipe.stdin.close() + pipe.wait() ++ return True + + def formatSwapPartition(self, dev): + """Format swap partition""" +@@ -1159,6 +1169,15 @@ class IsoDistributive(Distributive): + self.exclude = [] if not exclude else exclude + self.compress = compress + ++ def probe(self): ++ """Check directory for iso content""" ++ try: ++ pathname = self.getIsoContentDirectory() ++ except: ++ return False ++ return path.exists(path.join(pathname,"syslinux")) and \ ++ path.exists(path.join(pathname,"isolinux")) ++ + def _mountIso(self,file,directory): + if self.file != self.mdirectory: + self._makeDirectory(directory) +diff --git pym/cl_fill_install.py pym/cl_fill_install.py +index 1b2e27b..bc86572 100644 +--- pym/cl_fill_install.py ++++ pym/cl_fill_install.py +@@ -23,9 +23,12 @@ from cl_datavars import glob_attr + from os import path + from os import readlink,access,R_OK + from cl_utils import isMount,typeFile,getTupleVersion,pathJoin,isFstabMount,\ +- listDirectory, getAvailableX11Drivers, getUUIDDict, \ ++ listDirectory, getAvailableVideo, getUUIDDict, \ ++ getUdevDeviceInfo, getPartitionDevice, getPartitionSize, \ + isPkgInstalled, process, checkUtils, readLinesFile, \ +- lspci, getPartitionSize ++ FStab, lspci, getInstalledVideo,getDeviceType, \ ++ getPartitionType, getOsProberHash, getProgPath, \ ++ getRaidPartitions, getLvmPartitions, getLvmGroups + from cl_distr import DistributiveRepository,PartitionDistributive + from cl_fill import clLocale + from operator import itemgetter +@@ -45,6 +48,8 @@ class fillVars(object, glob_attr): + "/opt", "/proc", "/sbin", + "/sys", "/usr", "/var"] + ++ reWrongDevice = re.compile("|".join(['^fd','^ram','^loop'])) ++ + def removeFloppy(self): + """Remove floopy device and return floppyData""" + floppyPath = '/dev/fd1' +@@ -225,6 +230,10 @@ class fillVars(object, glob_attr): + listInterfacesInfo)) + + def get_os_device_hash(self): ++ def onlyDisk(devpath): ++ prop = getUdevDeviceInfo(devpath) ++ return prop.get("ID_TYPE","")=="disk" and \ ++ prop.get("DEVTYPE","")=="disk" + diskIdPath = '/dev/disk/by-id' + if path.exists(diskIdPath): + usbdevices = \ +@@ -232,34 +241,23 @@ class fillVars(object, glob_attr): + filter(lambda x: x.startswith('usb-'),listDirectory(diskIdPath))) + else: + usbdevices = [] +- reWrongDevice = re.compile("|".join(['sr','fd','ram','loop'])) +- devices = filter( lambda x: not reWrongDevice.search(x), +- listDirectory('/sys/block')) ++ sysBlockPath = '/sys/block' ++ devices = map(lambda x:path.join(sysBlockPath,x), ++ filter(lambda x: onlyDisk(path.join(sysBlockPath,x)), ++ filter(lambda x: not self.reWrongDevice.search(x), ++ listDirectory(sysBlockPath)))) + device_hash = {} +- execParted = self.getProgPath("/usr/sbin/parted") +- if not execParted: +- cl_overriding.printERROR(_("Command not found '%s'")%"parted") +- cl_overriding.exit(1) + for mapnum,device in enumerate(sorted(devices,key=self.separateDevice)): +- if device.startswith('cciss'): +- device = device.replace('!','/') ++ props = getUdevDeviceInfo(device) ++ if not "DEVNAME" in props: ++ continue ++ device = props['DEVNAME'] + device_hash[device] = {} ++ device_hash[device]['table'] = props.get('ID_PART_TABLE_TYPE','') + device_hash[device]['map'] = mapnum +- device_hash[device]['table'] = None +- execStr = '%(prog)s %(device)s print'% \ +- {'prog':execParted, +- 'device':"/dev/%s"%device} +- floppyData = self.removeFloppy() +- res = self._runos(execStr,env={"LANG":"C"}) +- self.restoreFloppy(floppyData) +- if res: +- res = map(lambda x:x.rpartition("Partition Table:")[2], +- filter(lambda x:x.startswith("Partition Table:"), +- res)) +- if res: +- device_hash[device]['table'] = res[-1].strip() +- if device in usbdevices: +- removablePath = '/sys/block/%s/removable'%device ++ ++ if path.basename(device) in usbdevices: ++ removablePath = '/sys/block/%s/removable'%path.basename(device) + if os.access(removablePath,R_OK) and \ + open(removablePath,'r').read().strip() == "1": + devtype = "flash" +@@ -271,170 +269,80 @@ class fillVars(object, glob_attr): + return device_hash + + def get_os_disk_hash(self): +- # check command existing +- for util in ("/sbin/fdisk","/usr/sbin/gdisk","/sbin/blkid", +- "/usr/sbin/parted"): +- utilPath = self.getProgPath(util) +- if not utilPath: +- cl_overriding.printERROR(_("Command not found '%s'")% +- path.basename(util)) +- cl_overriding.exit(1) +- +- reSdaPart = \ +- re.compile("^/dev/(sd[a-z])(\d+)|/dev/(cciss/c\dd\d+)p(\d+)$") ++ """Get information about disk, which use for installation""" ++ def selfOrPartition(devpath): ++ """Return self device or partitions if it has them""" ++ # search partition in device ++ partitions = \ ++ filter(lambda x:x.startswith(path.basename(devpath)), ++ listDirectory(devpath)) ++ if partitions: ++ return filter(lambda x:x, ++ map(lambda x:selfOrPartition(path.join(devpath,x)), ++ partitions)) ++ else: ++ return devpath ++ ++ # refresh LVM ++ vgscan = getProgPath('/sbin/vgscan') ++ vgchange = getProgPath('/sbin/vgchange') ++ lvchange = getProgPath('/sbin/lvchange') ++ if vgscan and vgchange and lvchange: ++ process(vgscan).success() ++ process(vgchange,'-ay','--refresh').success() ++ for group in getLvmGroups(): ++ process(lvchange,'-ay','--refresh',group).success() + devicesHash = self.Get('os_device_hash') +- devices = devicesHash.keys() +- disksDevs = reduce( lambda x,y: x + +- map( lambda x: ["/dev/%s"%x.replace('!','/'),y], +- filter(lambda x: y in x.replace('!','/'), +- listDirectory('/sys/block/%s'%y.replace('/','!')))), +- devices, [] ) +- disks = map(lambda x:x[0],disksDevs) +- +- disksDevs = dict(disksDevs) ++ sysBlockPath = '/sys/block' ++ new_disks = reduce(lambda x,y:x+ ([y] if type(y) == str else y), ++ map(lambda x:selfOrPartition(path.join(sysBlockPath,x)), ++ filter(lambda x: not self.reWrongDevice.search(x), ++ listDirectory(sysBlockPath))),[]) + disk_hash = {} +- # fill grub info +- for dev in sorted(disks): +- disk_hash[dev] = {} +- match = reSdaPart.match(dev) +- if match: +- if match.groups()[0] and match.groups()[0] in devicesHash: +- disk_hash[dev]['grub'] = "%d,%d" % \ +- (int(devicesHash[match.groups()[0]]['map']), +- int(match.groups()[1])-1) +- elif match.groups()[2] in devicesHash: +- disk_hash[dev]['grub'] = "%d,%d" % \ +- (int(devicesHash[match.groups()[2]]['map']), +- int(match.groups()[3])-1) +- curDevice = None +- +- execFdisk = self.getProgPath("/sbin/fdisk") +- execGdisk = self.getProgPath("/usr/sbin/gdisk") +- # getting id +- for device in devices: +- if devicesHash[device]['table'] == 'msdos': +- execStr = '%s -l %s'%(execFdisk,"/dev/%s"%device) +- res = self._runos(execStr,env={"LANG":"C"}) +- if res is False: +- cl_overriding.printERROR(_("Cann't execute '%s'")%execStr) +- cl_overriding.exit(1) +- partedLines = filter(lambda x: x.startswith('/dev/'),res or [] ) +- partedMatrix = map(lambda x: filter(lambda y: y and y!="*", +- x.split())[:6], +- partedLines) +- for part,nm,nm,nm,sysid,nm in \ +- filter(lambda x:len(x)>5,partedMatrix): +- if not part in disk_hash: +- disk_hash[part] = {} +- disk_hash[part]['id'] = sysid +- disk_hash[part]['table'] = 'msdos' +- elif devicesHash[device]['table'] == 'gpt': +- execStr = '%s -l %s'%(execGdisk,"/dev/%s"%device) +- res = self._runos(execStr,env={"LANG":"C"}) +- if res is False: +- cl_overriding.printERROR(_("Cann't execute '%s'")%execStr) +- cl_overriding.exit(1) +- partTemplate = "/dev/%sp%s" if "cciss" in device else "/dev/%s%s" +- for dev,partid in filter(lambda x:x[0] in disk_hash, +- map(lambda x:[partTemplate%(device,x[0]),x[1]], +- map(lambda x:x.split()[0:6:5], +- reduce(lambda x,y:x+[y] \ +- if x or y.startswith("Number") else x, +- res,[])[1:]))): +- disk_hash[dev]['id'] = partid +- disk_hash[dev]['table'] = 'gpt' +- +- # parse all parted lines started with Disk and started with number +- floppyData = self.removeFloppy() +- execProg = self.getProgPath("/usr/sbin/parted") +- execStr = '%s -l'%execProg +- res = self._runos(execStr,env={"LANG":"C"}) +- self.restoreFloppy(floppyData) +- +- if res is False: +- cl_overriding.printERROR(_("Cann't execute '%s'")%execStr) +- cl_overriding.exit(1) +- partedLines = filter(lambda x: x.startswith("Disk") or +- x.strip()[:1].isdigit(), res ) +- for line in partedLines: +- # split data +- parts = filter(lambda x: x, line.strip().split(' ')) +- # if start device description +- if parts[0] == "Disk": +- curDevice = parts[1][:-1] ++ ++ fstab = FStab('/etc/fstab') ++ raidUsedDisks = [] ++ lvmUsedDisks = [] ++ for disk in new_disks: ++ props = getUdevDeviceInfo(disk) ++ if not "DEVNAME" in props: + continue +- # if first part is number then it is partition description +- if parts[0].isdigit(): +- # part name it is devicename + partition number +- if "cciss" in curDevice: +- partition = "%sp%s"%(curDevice,parts[0]) +- else: +- partition = curDevice + parts[0] +- # create entry if hash hasn't it +- if not partition in disk_hash: +- disk_hash[partition] = {} +- if disk_hash[partition].get('table',None) == "gpt": +- disk_hash[partition]['part'] = "gpt" +- if len(parts)>4 and "swap" in parts[4]: +- disk_hash[partition]['format'] = 'swap' +- else: +- disk_hash[partition]['part'] = parts[4] +- if len(parts)>5 and "swap" in parts[5]: +- disk_hash[partition]['format'] = 'swap' +- disk_hash[partition]['size'] = getPartitionSize(partition) +- # fill format, name and uuid +- execStr = self.getProgPath('/sbin/blkid') +- res = self._runos(execStr) +- if res is False: +- cl_overriding.printERROR(_("Cann't execute '%s'")%execStr) +- cl_overriding.exit(1) +- # map attribute name of blkid to disk_hash +- blkid_hash = {'LABEL':'name', +- 'UUID':'uuid', +- 'TYPE':'format'} +- for line in res: +- # split line and discard empty elements +- parts = filter(lambda x: x, line.strip().split(' ')) +- if len(parts)>1 and parts[0][:-1] in disks: +- dev = parts[0][:-1] +- for i in parts[1:]: +- key,op,value = i.partition('=') +- if key in blkid_hash: +- key = blkid_hash[key] +- disk_hash[dev][key] = value[1:-1] +- mapUuidDev = getUUIDDict() +- mapDevUuid = dict(zip(mapUuidDev.values(),mapUuidDev.keys())) +- mountOptionsList = \ +- filter(lambda x: x.strip() and not x.strip().startswith('#'), +- open("/etc/fstab").readlines()) +- # split all string by columns and discard string which has less that 4 +- # columns +- mountOptionsList = \ +- map(lambda x:[mapUuidDev.get(x[0],x[0])]+x[1:4], +- filter(lambda x: len(x)>=4, +- map(lambda x: filter(lambda x: x , +- x.replace('\t',' ').split(' ')), +- mountOptionsList))) +- # get dev which has ntfs filesystem +- mountFormatList = \ +- filter(lambda x: x[0] in disk_hash.keys() \ +- and x[1] in ("ntfs","ntfs-3g"), +- map(lambda y: (y[0],y[2]), mountOptionsList)) +- # split options and discard rw opt +- mountOptionsList = \ +- filter(lambda x: x[0] in disk_hash.keys(), +- map(lambda y: (y[0],filter(lambda z: z!="rw", +- y[3].split(','))), +- mountOptionsList)) +- +- dictOptionList = dict(mountOptionsList) +- dictFormatList = dict(mountFormatList) +- for dev in disk_hash.keys(): +- if dev in dictOptionList: +- disk_hash[dev]['options'] = ",".join(dictOptionList[dev]) +- if dev in dictFormatList and "format" in disk_hash[dev] and \ +- disk_hash[dev]['format'] in ("ntfs","ntfs-3g"): +- disk_hash[dev]['format'] = dictFormatList[dev] ++ devName = props['DEVNAME'] ++ dev_hash = {} ++ dev_hash['uuid'] = props.get('ID_FS_UUID','') ++ dev_hash['format'] = props.get('FSTAB_TYPE') or \ ++ fstab.getBy(what=fstab.TYPE,eq=devName) or \ ++ props.get('ID_FS_TYPE','') ++ dev_hash['name'] = props.get('ID_FS_LABEL','') ++ dev_hash['table'] = props.get('ID_PART_ENTRY_SCHEME','') ++ dev_hash['type'] = getDeviceType(disk) ++ dev_hash['id'] =props.get('ID_PART_ENTRY_TYPE','').partition("x")[2] ++ devParent = getPartitionDevice(disk) ++ dev_hash['parent'] = devParent ++ dev_hash['part'] = getPartitionType(props) ++ dev_hash['options'] = fstab.getBy(what=fstab.OPTS,eq=devName) or "" ++ dev_hash['size'] = getPartitionSize(disk) ++ if devParent in devicesHash and 'ID_PART_ENTRY_NUMBER' in props: ++ dev_hash['grub'] = "%s,%d"%(devicesHash[devParent]['map'], ++ int(props['ID_PART_ENTRY_NUMBER'])-1) ++ else: ++ dev_hash['grub'] = "" ++ disk_hash[devName] = dev_hash ++ if "raid" in dev_hash['type']: ++ raidUsedDisks.extend(map(lambda x:(devName,x),getRaidPartitions(disk))) ++ if dev_hash['type'].endswith("lvm"): ++ prop = getUdevDeviceInfo(path=disk) ++ lvmUsedDisks.extend(map(lambda x:(devName,x), ++ getLvmPartitions(prop.get('DM_VG_NAME',''), ++ prop.get('DM_LV_NAME','')))) ++ for disk,part in raidUsedDisks: ++ if part in disk_hash: ++ disk_hash[part]['type'] = "%s-raidmember(%s)"%( ++ disk_hash[part]['type'],disk) ++ for disk,part in lvmUsedDisks: ++ if part in disk_hash: ++ disk_hash[part]['type'] = "%s-lvmmember(%s)"%( ++ disk_hash[part]['type'],disk) + return disk_hash + + def separateDevice(self,device): +@@ -456,7 +364,7 @@ class fillVars(object, glob_attr): + """List id for partition after installation""" + diskHash = self.Get('os_disk_hash') + def getIdByFS(fs,parttable,oldid): +- if parttable == "msdos": ++ if parttable == "dos": + return PartitionDistributive.formatId.get(fs,oldid) + elif parttable == "gpt": + return PartitionDistributive.formatIdGpt.get(fs,oldid) +@@ -489,18 +397,10 @@ class fillVars(object, glob_attr): + return self.Get('os_disk_dev') + + def get_os_install_disk_uuid(self): +- """List uudi for partition devices""" +- devuuid = '/dev/disk/by-uuid' ++ """List uuid for partition devices""" + diskDev = self.Get('os_disk_dev') +- if path.exists(devuuid): +- hashUUID = dict( +- map(lambda x:(path.normpath(path.join(devuuid,os.readlink(x))), +- path.basename(x)), +- filter(path.islink, +- map(lambda x:path.join(devuuid,x), +- listDirectory(devuuid))))) +- return map(lambda x:hashUUID.get(x,""),diskDev) +- return [""]*len(diskDev) ++ hashUUID = getUUIDDict(revers=True) ++ return map(lambda x:hashUUID.get(x,"")[5:],diskDev) + + def get_os_install_disk_options(self): + """List mount options for partition devices of installed os""" +@@ -510,27 +410,32 @@ class fillVars(object, glob_attr): + """List mounted points for installed system""" + rootdev = self.Get('os_install_root_dev') + disk_hash = self.Get('os_disk_hash') +- fstabHasSwap = isFstabMount('swap') ++ fstab = FStab('/etc/fstab') ++ fstabHasSwap = bool(fstab.isExists(what=FStab.TYPE,eq="swap")) + def getMountPoint(disk): ++ """Get mount point for disk. If fstab not contains swap then ++ for swap use all swap formated partition""" + if disk == rootdev: + return "/" + elif not fstabHasSwap and "format" in disk_hash[disk] and \ + "swap" in disk_hash[disk]['format']: + return "swap" + else: +- mount_point = isFstabMount(disk) ++ mount_point = fstab.getBy(eq=disk) + if mount_point in self.nonTransferedDirs: + return "" + else: + return mount_point + return map(lambda x: getMountPoint(x), +- sorted(self.Get('os_disk_hash').keys(), +- key=self.separateDevice)) ++ sorted( ++ self.Get('os_disk_hash').keys(),key=self.separateDevice)) + + def get_os_disk_mount(self): + """List mounted points for current operation system""" + disk_hash = self.Get('os_disk_hash') +- return map(lambda x: isFstabMount(x) or "", ++ fstab = FStab('/etc/fstab') ++ rootdev = self.Get('os_root_dev') ++ return map(lambda x: '/' if x == rootdev else fstab.getBy(eq=x) or "", + sorted(self.Get('os_disk_hash').keys(), + key=self.separateDevice)) + +@@ -577,6 +482,10 @@ class fillVars(object, glob_attr): + """Type of partition devices (primary, extended or logical)""" + return self.getAttributeFromHash('os_disk_hash','part') + ++ def get_os_disk_table(self): ++ """Partition table for this partition""" ++ return self.getAttributeFromHash('os_disk_hash','table') ++ + def get_os_install_disk_perform_format(self): + """Needformat partitions""" + return self.getAttributeFromHash('os_disk_hash','needformat') +@@ -585,6 +494,43 @@ class fillVars(object, glob_attr): + """Partition size""" + return self.getAttributeFromHash('os_disk_hash','size') + ++ def get_os_disk_type(self): ++ """Partition type""" ++ return self.getAttributeFromHash('os_disk_hash','type') ++ ++ def get_os_disk_content(self): ++ """Partition content""" ++ distrRep = DistributiveRepository() ++ osProberHash = getOsProberHash(getContentFunc=distrRep._getfromcontent) ++ devicesHash = self.Get('os_device_hash') ++ def detectContent(devName,devType,devParent,mountPoint): ++ if mountPoint == '/': ++ return "{short}-{march}{build}".format( ++ short=self.Get('os_linux_shortname'), ++ march=self.Get('os_arch_machine'), ++ build="-%s"%(self.Get('os_linux_build') if ++ self.Get('os_linux_build') else ++ self.Get('os_linux_ver'))) ++ content = osProberHash.get(devName,'') ++ if not content and ((devParent in devicesHash and \ ++ devicesHash[devParent]['type'] == "flash") or ++ "cdrom" in devType): ++ dataInfo = distrRep._getfromcontent(devName) ++ if "build" in dataInfo and dataInfo['build']: ++ if "cdrom" in devType: ++ dataInfo['livetype'] = "cd" ++ else: ++ dataInfo['livetype'] = "usb" ++ content = \ ++ "{name}-{march}-{build} live{livetype}".format( ++ **dataInfo) ++ return content ++ return map(lambda x:detectContent(x[0],x[1],x[2],x[3]), ++ zip(self.Get('os_disk_dev'), ++ self.Get('os_disk_type'), ++ self.getAttributeFromHash('os_disk_hash','parent'), ++ self.Get('os_disk_mount'))) ++ + def get_os_disk_name(self): + """Label of partitions""" + return self.getAttributeFromHash('os_disk_hash','name') +@@ -602,10 +548,14 @@ class fillVars(object, glob_attr): + """Map number for grub""" + return self.getAttributeFromHash('os_device_hash','map') + ++ def get_os_device_table(self): ++ """Table on device""" ++ return self.getAttributeFromHash('os_device_hash','table') ++ + def get_os_install_grub_devicemap_conf(self): + """Content of device.map file for grub""" + rootType = self.Get('os_install_root_type') +- return "\n".join(map(lambda x: "(hd%s) /dev/%s" % (x[0],x[1]), ++ return "\n".join(map(lambda x: "(hd%s) %s" % (x[0],x[1]), + filter(lambda x:x[2] == rootType, + zip(self.Get('os_device_map'), + self.Get('os_device_dev'), +@@ -735,13 +685,31 @@ class fillVars(object, glob_attr): + return res.groups()[0] + return "cfq" + ++ def get_os_install_lvm_set(self): ++ """Using lvm""" ++ typeRoot = \ ++ self.selectVar("os_disk_type",where="os_install_disk_mount", ++ eq="/") ++ return "on" if "lvm" in typeRoot else "off" ++ ++ def get_os_install_mdadm_set(self): ++ """Using mdadm""" ++ typeRoot = \ ++ self.selectVar("os_disk_type",where="os_install_disk_mount", ++ eq="/") ++ return "on" if "raid" in typeRoot else "off" ++ + def get_os_install_kernel_attr(self): + """Kernel attributes""" + # on usb-hdd install must be "delay=5" ++ attr = "" + if self.Get('os_install_root_type') == 'usb-hdd': +- return "delay=5" +- else: +- return "" ++ attr = " scandelay=5" ++ if self.Get('os_install_mdadm_set') == 'on': ++ attr += " domdadm" ++ if self.Get('os_install_lvm_set') == 'on': ++ attr += " dolvm" ++ return attr + + def get_os_install_kernel_resume(self): + """install kernel resume parameter""" +@@ -765,6 +733,11 @@ class fillVars(object, glob_attr): + livedistr = ['/mnt/cdrom'] + else: + livedistr = [] ++ livedistr += \ ++ map(lambda x:x[0], ++ filter(lambda x:" live" in x[1], ++ zip(self.Get('os_disk_dev'), ++ self.Get('os_disk_content')))) + return ['/var/calculate/remote/linux', '/var/calculate/linux', + '/usr/calculate/share/linux'] + livedistr + +@@ -775,7 +748,9 @@ class fillVars(object, glob_attr): + discardType = ["dir"] + else: + discardType = [] +- distRep = DistributiveRepository(self.Get('cl_image_path')) ++ if type(imagePath) == str: ++ imagePath = [imagePath] ++ distRep = DistributiveRepository(imagePath) + return distRep.getBestDistributive(march=archMachine, + shortname=shortName.lower(), + discardType=discardType, +@@ -957,15 +932,14 @@ class fillVars(object, glob_attr): + def get_os_install_x11_video_drv(self): + """Video driver used by xorg""" + if self.Get('os_install_root_type') == 'usb-hdd': +- available_drivers = \ +- getAvailableX11Drivers(prefix=self.Get('cl_chroot_path')) ++ prefix = self.Get('cl_chroot_path') + videoVal = self.getValueFromCmdLine("calculate","video") + videoVal = {'i915':'intel'}.get(videoVal,videoVal) + if not isPkgInstalled('xorg-server', + prefix=self.Get('cl_chroot_path')) or \ +- videoVal in available_drivers: ++ videoVal in getAvailableVideo(prefix=prefix): + return videoVal +- return self.getVideoByDefault(available_drivers) ++ return self.getVideoByDefault(getInstalledVideo(prefix=prefix)) + else: + return self.Get('os_x11_video_drv') + +@@ -1154,10 +1128,12 @@ class fillVars(object, glob_attr): + def get_os_install_root_type(self): + """Type of device for install""" + rootdev = self.Get('os_install_root_dev') ++ devicetype = getPartitionDevice( ++ getUdevDeviceInfo(name=rootdev).get('DEVPATH','')) + devicetype = map(lambda x: x[1], +- filter(lambda x:x[0] in rootdev, +- zip(self.Get('os_device_dev'), +- self.Get('os_device_type')))) ++ filter(lambda x:x[0] == devicetype, ++ zip(self.Get('os_device_dev'), ++ self.Get('os_device_type')))) + if devicetype: + return devicetype[0] + else: +@@ -1392,8 +1368,7 @@ class fillVars(object, glob_attr): + return self.Get('cl_autoupdate_set') + + def get_cl_install_kernel_uid(self): +- mapDevUuid = getUUIDDict(revers=True) +- return mapDevUuid.get(self.Get('os_install_root_dev'),"")[5:13] ++ return self.getKernelUid(self.Get('os_install_root_dev')) + + def get_os_nvidia_mask(self): + nvidiaeclass = pathJoin(self.Get('cl_chroot_path'), +@@ -1449,10 +1424,6 @@ class fillVars(object, glob_attr): + return build + return "" + +- def get_os_device_partition(self): +- """Get partition table list""" +- return self.getAttributeFromHash('os_device_hash','table') +- + def get_os_install_fb_resolution(self): + """Get current framebuffer resolution""" + textLines = self._runos("/sbin/fbres 2>&1") +diff --git pym/cl_install.py pym/cl_install.py +index 68adab1..778cf6a 100644 +--- pym/cl_install.py ++++ pym/cl_install.py +@@ -26,7 +26,8 @@ from cl_utils import runOsCommand,appendProgramToEnvFile, \ + removeProgramToEnvFile,pathJoin, \ + scanDirectory,process,getTupleVersion, \ + detectDeviceForPartition,listDirectory, \ +- cmpVersion,STDOUT ++ cmpVersion,STDOUT,getUdevDeviceInfo, \ ++ getLvmPartitions + from cl_vars_share import varsShare + + from cl_kernel_utils import KernelConfig,InitRamFs +@@ -602,6 +603,9 @@ class convertDictOpt: + dictOptions.update(optProperties) + return dictOptions + optDevice = optProperties["dev"] ++ optProperties["dev"] = \ ++ getUdevDeviceInfo(name=optDevice).get('DEVNAME',optDevice) ++ optDevice = optProperties["dev"] + dataPart = filter(lambda x: x[0]==optDevice, self.varDiskData) + if not dataPart: + dataPart = [["",False,"","","",""]] +@@ -815,6 +819,12 @@ class cl_install(color_print, SignalInterrupt): + return instnextres + return curnextres + ++ def printAllPartitonsTable(self): ++ """Print install report""" ++ title, headerList, dataList = self.generateTableAllPartitionData() ++ tableObj = tableReport("", headerList, dataList) ++ tableObj.printReport(False) ++ + def printLocationTables(self): + """Print install report""" + title, headerList, dataList = self.generateTableMountData() +@@ -851,7 +861,7 @@ class cl_install(color_print, SignalInterrupt): + open(pathModel,'r').read().strip()) + else: + addonMbrInfo = "" +- mbrdisk = "/dev/%s%s"%(clGet('os_install_mbr'),addonMbrInfo) ++ mbrdisk = "%s%s"%(clGet('os_install_mbr'),addonMbrInfo) + else: + mbrdisk = _("not changed") + +@@ -939,8 +949,21 @@ class cl_install(color_print, SignalInterrupt): + + if update: + cmpres = self.cmpInstallVersion() +- if self.clVars.Get('cl_image') and ( not update or cmpres > 0): +- self.printSUCCESS(_("Found update")+": %s %s%s%s\n"% ++ image = self.clVars.Get('cl_image') ++ if image and ( not update or cmpres > 0): ++ deviceName = "" ++ if image.startswith('/dev'): ++ deviceImage = \ ++ map(lambda x:x[1].rpartition(" ")[2], ++ filter(lambda x:x[0]==image, ++ self.clVars.zipVars("os_disk_dev","os_disk_content"))) ++ if deviceImage: ++ if deviceImage[0] == "livecd": ++ deviceName = " " + _("on")+" CDROM (%s)"%image ++ else: ++ deviceName = " " + _("on")+" USB Flash (%s)"%image ++ ++ self.printSUCCESS(_("Found update")+deviceName+": %s %s%s%s\n"% + (self.clVars.Get('os_install_linux_name'), + self.clVars.Get('os_install_linux_ver'), + subname,build)) +@@ -973,11 +996,7 @@ class cl_install(color_print, SignalInterrupt): + """Get target distributive by params""" + rootLabelName = "%s-%s"%(self.clVars.Get('os_install_linux_shortname'), + self.clVars.Get('os_install_linux_ver')) +- mapDevice = self.clVars.Get('os_device_hash') +- mapPartPT = dict( +- map(lambda x:[x,mapDevice.get(detectDeviceForPartition(x), +- {'table':None})['table']], +- self.clVars.Get('os_disk_dev'))) ++ mapPartPT = dict(self.clVars.zipVars("os_disk_dev","os_disk_table")) + if buildermode: + return ScratchPartitionDistributive(disk,mdirectory="/mnt/install", + check=True, fileSystem=fileSystem, +@@ -1298,10 +1317,65 @@ class cl_install(color_print, SignalInterrupt): + self.clVars.Get('os_disk_dev')))) + usingExtPart = list(set(usedDevices)&set(extendedPartitions)) + if usingExtPart: +- self.printERROR(_("Can not use extended partition %s")% ++ self.printERROR( ++ _("Imposible to use extended partition %s for installation")% + usingExtPart[0]) + return False + ++ # detect using CDROM disks ++ cdromPartitions = map(lambda x: x[1], ++ filter(lambda x: "cdrom" in x[0], ++ zip(self.clVars.Get('os_disk_type'), ++ self.clVars.Get('os_disk_dev')))) ++ usingCdromPart = list(set(usedDevices)&set(cdromPartitions)) ++ if usingCdromPart: ++ self.printERROR(_("Imposible to use CDROM %s for installation")% ++ usingCdromPart[0]) ++ return False ++ ++ # detect using RAID member disks ++ raidMemberData = filter(lambda x: "raidmember" in x[0], ++ zip(self.clVars.Get('os_disk_type'), ++ self.clVars.Get('os_disk_dev'))) ++ raidMemberPartitions = map(lambda x:x[1],raidMemberData) ++ usingRaidMemberPart = list(set(usedDevices)&set(raidMemberPartitions)) ++ if usingRaidMemberPart: ++ raidMemberData = filter(lambda x:x[1] in usingRaidMemberPart, ++ raidMemberData)[0][0] ++ raidMemberData = raidMemberData.rpartition("raidmember(")[2] ++ raidMemberData = raidMemberData.partition(")")[0] ++ self.printERROR(_("Imposible to use active {typepart} member" ++ " {part} for installation").format( ++ typepart="RAID",part=usingRaidMemberPart[0])) ++ self.printERROR( ++ _("For using this partition need to stop RAID %s")% ++ raidMemberData) ++ self.printERROR(" mdadm -S %s"%raidMemberData) ++ return False ++ ++ # detect using LVM member disks ++ lvmMemberData = filter(lambda x: "lvmmember" in x[0], ++ zip(self.clVars.Get('os_disk_type'), ++ self.clVars.Get('os_disk_dev'))) ++ lvmMemberPartitions = map(lambda x:x[1],lvmMemberData) ++ usingLvmMemberPart = list(set(usedDevices)&set(lvmMemberPartitions)) ++ if usingLvmMemberPart: ++ lvmMemberData = filter(lambda x:x[1] in usingLvmMemberPart[0], ++ lvmMemberData)[0][0] ++ lvmMemberData = lvmMemberData.rpartition("lvmmember(")[2] ++ lvmMemberData = lvmMemberData.partition(")")[0] ++ prop = getUdevDeviceInfo(name=lvmMemberData) ++ vgName = prop.get('DM_VG_NAME','') ++ self.printERROR(_("Imposible to use active {typepart} member" ++ " {part} for installation").format( ++ typepart="LVM",part=usingLvmMemberPart[0])) ++ self.printERROR( ++ _("For using this partition need to remove LVM %s")% ++ lvmMemberData) ++ self.printERROR(" vgremove %s"%vgName) ++ self.printERROR(" pvremove %s"%usingLvmMemberPart[0]) ++ return False ++ + srcMountPoints = map(lambda x:x['srcMountPoint'],listBinds) + destMountPoints = map(lambda x:x['destMountPoint'],listBinds) + wrongBind = filter(lambda x:x in destMountPoints,srcMountPoints) +@@ -1372,10 +1446,11 @@ class cl_install(color_print, SignalInterrupt): + 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':clearParam(x[1],x[1]), +- 'fileSystem':x[2], +- 'options':clearParam(x[3],x[1]), ++ DEV,MOUNT,FS,OPTS = 0,1,2,3 ++ devMount = dict(map(lambda x:(x[DEV], ++ {'mountPoint':clearParam(x[MOUNT],x[MOUNT]), ++ 'fileSystem':x[FS], ++ 'options':clearParam(x[OPTS],x[MOUNT]), + 'isFormat':""}), + zip(self.clVars.Get('os_disk_dev'), + self.clVars.Get('os_install_disk_mount'), +@@ -1493,6 +1568,24 @@ class cl_install(color_print, SignalInterrupt): + ('os_install_disk_options',new_options), + ('os_install_bind_path',new_bind_src), + ('os_install_bind_mountpoint',new_bind_dest))) ++ if not self.clVars.Get('os_grub2_path'): ++ if not self.checkForLegacyGrub(): ++ return False ++ return True ++ ++ def checkForLegacyGrub(self): ++ """Check current disk configuration for installation for install ++ legacy grub""" ++ bootDiskType = self.varSelect("os_disk_type", ++ where="os_install_disk_mount", eq="/boot") ++ rootDiskType = self.varSelect("os_disk_type", ++ where="os_install_disk_mount", eq="/") ++ bootDiskType = bootDiskType or rootDiskType ++ if "lvm" in bootDiskType or "raid" in bootDiskType: ++ self.printERROR( ++ _("Legacy grub not support boot from raid or lvm without" ++ " separate /boot partition")) ++ return False + return True + + def setUsers(self,listUsers): +@@ -1504,19 +1597,16 @@ class cl_install(color_print, SignalInterrupt): + self.clVars.Set('cl_migrate_user', migrateUsers, force=True) + return True + +- def setMBR(self, mbrDisk): +- """Set mbr by param or get from variables""" ++ def setBR(self, mbrDisk): ++ """Set boot record on disk by param or get from variables""" + bootDiskGrub = "" + if mbrDisk == "off": + self.clVars.Set('os_install_mbr',"",force=True) ++ return True + elif mbrDisk: +- listbootDiskGrub = map(lambda x: x[0], +- filter(lambda x: "/dev/"+x[0]==mbrDisk, +- zip(self.clVars.Get('os_device_dev'), +- self.clVars.Get('os_device_map')))) +- if filter(lambda x: "/dev/%s"%x == mbrDisk, ++ if filter(lambda x: x == mbrDisk, + self.clVars.Get('os_device_dev')): +- self.clVars.Set('os_install_mbr',mbrDisk[5:], force=True) ++ self.clVars.Set('os_install_mbr', mbrDisk, force=True) + else: + self.printERROR(_("Cann't found disk '%s'")%mbrDisk) + return False +@@ -1566,12 +1656,12 @@ class cl_install(color_print, SignalInterrupt): + return True + + def setInstallOptions(self, listDisks, listBinds, listSwaps, listUsers, +- mbrDisk): +- """Set install options (set users, disks and mbr""" ++ brDisk): ++ """Set install options (set users, disks and boot record""" + try: + if self.setUsers(listUsers) and \ + self.setDisks(listDisks,listBinds,listSwaps) and \ +- self.setMBR(mbrDisk): ++ self.setBR(brDisk): + return self.createListOptions() + else: + return False +@@ -1601,7 +1691,7 @@ class cl_install(color_print, SignalInterrupt): + return "" + + def setActivePartition(self,partition): +- """TODO: don't work with GPT""" ++ """TODO: don't work with GPT. Don't work must be rewrite!!!!!""" + reActive = re.compile('^%s\s*[*]'%partition) + device = filter(lambda x:x in partition, + self.clVars.Get('os_device_dev')) +@@ -1609,7 +1699,7 @@ class cl_install(color_print, SignalInterrupt): + raise DistributiveError(_("Cann't get parent device")) + device = device[0] + +- fdiskProcess = process("/sbin/fdisk","-l","/dev/%s"%device) ++ fdiskProcess = process("/sbin/fdisk","-l",device) + if fdiskProcess.failed(): + raise DistributiveError(_("Cann't get device information\n%s")% + fdiskProcess.read()) +@@ -1617,13 +1707,13 @@ class cl_install(color_print, SignalInterrupt): + grubDisk = self.getFieldByField("grub","mount","/", + secondPrefix="os_install_disk") + if grubDisk and grubDisk.rpartition(',')[2].isdigit(): +- fdiskProcess = process("/sbin/fdisk", "/dev/%s"%device) ++ fdiskProcess = process("/sbin/fdisk", device) + fdiskProcess.write("a\n%d\nw\n"% + (int(grubDisk.rpartition(',')[2])+1)) + if fdiskProcess.success(): + return True + if filter(reActive.search,process("/sbin/fdisk", +- "-l","/dev/%s"%device)): ++ "-l",device)): + return True + raise DistributiveError(_("Cann't set active partition")) + else: +@@ -1635,7 +1725,7 @@ class cl_install(color_print, SignalInterrupt): + Perform syslinux installation to flash. + """ + ddProcess = process("/bin/dd","if=/usr/share/syslinux/mbr.bin", +- "of=/dev/%s"%self.clVars.Get('os_install_mbr'), ++ "of=%s"%self.clVars.Get('os_install_mbr'), + stderr=STDOUT) + if ddProcess.failed(): + raise DistributiveError(_("Cann't write master boot record\n%s")% +@@ -1674,7 +1764,7 @@ class cl_install(color_print, SignalInterrupt): + deviceName = self.varSelect("os_device_dev",where="os_device_map", + eq=int(deviceNumber)) + if deviceName: +- return ("/dev/%s"%deviceName,partitionNumber) ++ return (deviceName,partitionNumber) + return (False,False) + + def setBiosGrubForBootPartition(self): +@@ -1711,7 +1801,7 @@ class cl_install(color_print, SignalInterrupt): + process("sync").success() + grubProcess = process(cmdGrubInstall, + "--boot-directory=%s"%target.getBootDirectory(), +- "/dev/%s"%mbrDisk, "-f", stderr=STDOUT) ++ mbrDisk, "-f", stderr=STDOUT,envdict=os.environ) + if grubProcess.failed(): + raise DistributiveError(_("Cann't install bootloader")) + +@@ -1744,6 +1834,59 @@ class cl_install(color_print, SignalInterrupt): + if grubProcess.failed(): + raise DistributiveError(_("Cann't install bootloader")) + ++ def generateTableAllPartitionData(self): ++ """Generate table for all partitions""" ++ def convertTypeToScheme(data): ++ diskScheme, driveType = data ++ res = "" ++ if "raid-lvm" in diskScheme: ++ return _("LVM on RAID") ++ elif "disk-partition" == diskScheme and driveType == "flash": ++ return _("Partition on flash") ++ elif "disk-partition" == diskScheme and driveType == "usb-hdd": ++ return _("Partition on USB-HDD") ++ elif "disk-partition" == diskScheme: ++ return _("Partition on disk") ++ elif "raid-partition" == diskScheme: ++ return _("Partition on RAID") ++ elif "raidmember" in diskScheme: ++ diskScheme = diskScheme.rpartition("raidmember(")[2] ++ diskScheme = diskScheme.partition(")")[0] ++ return _("RAID %s member")%diskScheme ++ elif "lvmmember" in diskScheme: ++ lvms = [] ++ while "lvmmember" in diskScheme: ++ diskScheme,op,data = diskScheme.rpartition("lvmmember(") ++ lvms.append(data.partition(")")[0]) ++ return _("LVM %s member")%",".join(lvms) ++ elif "disk" == diskScheme: ++ return _("Disk without partitions") ++ elif "lvm" in diskScheme: ++ return _("LVM") ++ elif "raid" in diskScheme: ++ return _("RAID") ++ elif "cdrom" in diskScheme: ++ return _("CDROM") ++ else: ++ return _("Partition") ++ ++ title = _("Available partitions") ++ headerList = [_("Size"),_("Device"),_("Label"),_("Mount point"), ++ _("File system"), _("Type"),_("OS")] ++ deviceHash = self.clVars.Get('os_device_hash') ++ diskHash = self.clVars.Get('os_disk_hash') ++ getTypeByDevice = lambda x: \ ++ deviceHash.get(diskHash[x].get('parent',{}),{}).get('type','') ++ return title, headerList, zip(self.clVars.Get('os_disk_size'), ++ self.clVars.Get('os_disk_dev'), ++ self.clVars.Get('os_disk_name'), ++ self.clVars.Get('os_disk_mount'), ++ self.clVars.Get('os_disk_format'), ++ map(convertTypeToScheme, ++ zip(self.clVars.Get('os_disk_type'), ++ map(getTypeByDevice,self.clVars.Get('os_disk_dev')))), ++ self.clVars.Get('os_disk_content')) ++ + def generateTableMountData(self): + """Get data from print table""" + title = _("Location") +@@ -2171,6 +2314,17 @@ class cl_install(color_print, SignalInterrupt): + raise InstallError(_("Can not migrate users to new system")) + self.printByResult(True) + ++ def checkCorrectBootRecordDisk(self): ++ """Check boot record disk""" ++ mbr = self.clVars.Get('os_install_mbr') ++ tableOnBootDisk = self.varSelect('os_device_table', ++ where="os_device_dev",eq=mbr) ++ if not tableOnBootDisk: ++ self.printERROR(_("Disk '%s' without partition table cann't " ++ "contains boot record")%mbr) ++ return False ++ return True ++ + def installSystem(self, force=False, bootDisk=None, stdinReadPwd=False, + builder=False, flagSpinner=True, update=False): + """install System by current variable enviroment""" +@@ -2178,6 +2332,8 @@ class cl_install(color_print, SignalInterrupt): + targetDistr = None + error = None + distrCopy = False ++ if not self.checkCorrectBootRecordDisk(): ++ return False + try: + rootPartdev = self.clVars.Get('os_install_root_dev') + rootPartCmdList = filter(lambda x: x['dev']==rootPartdev, +@@ -2407,3 +2563,17 @@ the system") + " (yes/no)" + self.printERROR(_("Package uninstallation failed")) + return False + return True ++ ++ def setIso(self,isoimage): ++ """Set iso image for installation""" ++ imageData = DistributiveRepository()._getfromcontent(isoimage) ++ if "name" in imageData and imageData.get('build','') and \ ++ "march" in imageData: ++ self.clVars.Set('os_install_arch_machine', ++ imageData['march'],True) ++ self.setLinuxName(imageData['name'].upper()) ++ self.clVars.Set('cl_image',True) ++ return True ++ else: ++ self.printERROR(_("Wrong image file")) ++ return False +diff --git pym/cl_install_cmd.py pym/cl_install_cmd.py +index d1424d3..ff2a050 100644 +--- pym/cl_install_cmd.py ++++ pym/cl_install_cmd.py +@@ -36,14 +36,9 @@ CMD_OPTIONS = [{'shortOption':"d", + 'optVal':"DISK[:[DIR:FILESYSTEM:OPTIONS]]", + 'action':'append', + 'help':_("the DISK for installation, which mounted to DIR") + +- ". " +- +_("DIR with value 'none' will cancels the mount point transfer") +- }, +- {'shortOption':"b", +- 'longOption':"bind", +- 'optVal':"SRC_DIR:DEST_DIR", +- 'action':'append', +- 'help':_("bind mount point for instalation") ++ ". " + ++ _("DIR with value 'none' will cancels the mount point transfer") ++ + ". " +_("For creating bind mount point need specify source directory as DISK") + }, + {'shortOption':"w", + 'longOption':"swap", +@@ -62,6 +57,9 @@ CMD_OPTIONS = [{'shortOption':"d", + 'choices':['flash','hdd','usb-hdd'], + 'help':_("device type for installed system") + }, ++ {'longOption':'iso', ++ 'optVal':"ISO", ++ 'help':_("ISO image for installation")}, + {'shortOption':"s", + 'longOption':"os", + 'optVal':"SYSTEM", +@@ -152,7 +150,11 @@ CMD_OPTIONS = [{'shortOption':"d", + {'shortOption':"P", + 'help':_("use passwords for the users accounts \ + (from standard input)") +- }] ++ }, ++ {'shortOption':'p', ++ 'longOption':"show-partitions", ++ 'help':_("display all partitions")} ++ ] + + class OptException(Exception): + pass +@@ -197,6 +199,14 @@ class install_cmd(share_cmd): + self.optobj.error(_("incompatible options")+":"+" %s"\ + %self.getStringIncompatibleOptions(incompatible+["live"])) + ++ def checkIncompatibleDhcp(self): ++ """Check incompatible options for option --dchp""" ++ incompatible = list(set(self._getNamesAllSetOptions()) & ++ set(self.optionsDhcpIncompatible)) ++ if incompatible: ++ self.optobj.error(_("incompatible options")+":"+" %s"\ ++ %self.getStringIncompatibleOptions(incompatible+["dhcp"])) ++ + def checkIncompatibleInstallUninstall(self): + """Check incompatible options for options --install and --uninstall""" + opts = self._getNamesAllSetOptions() +@@ -212,6 +222,8 @@ class install_cmd(share_cmd): + self.checkIncompatibleInstallUninstall() + if values.live: + self.checkIncompatibleLive() ++ if values.dhcp: ++ self.checkIncompatibleDhcp() + if not values.v: + if values.filter: + errMsg = _("incorrect option") + ":" + " %s" %"--filter" +\ +@@ -242,9 +254,10 @@ class install_cmd(share_cmd): + " " + _("route specifing error: '{route}'" + "(example: '{example}'").format( + route=route, +- example="10.0.0.0/24:192.168.1.1:eth0")) ++ example="default:192.168.1.1")) + if not (values.install or values.uninstall or values.live): + if values.v is False and \ ++ not values.p and \ + values.d is None and \ + not self.logicObj.clVars.Get('os_install_dev_from'): + self.optobj.error(_("need specify disk by '-d' option")) +@@ -256,15 +269,6 @@ class install_cmd(share_cmd): + self.optobj.error(_("option %s:") %"d" +\ + " " + _("disk specifing error: '%s'")\ + %", ".join(wrongValue)) +- # check syntax SRC_DIR:DEST_DIR +- if values.b: +- reTrueBind = re.compile("^[^:]+:[^:]+$") +- wrongValue = filter(lambda x: not reTrueBind.match(x),values.b) +- if wrongValue: +- self.optobj.error(_("option %s:") %"b" +\ +- " " + _("mount bind specifing error: '%s'")\ +- %", ".join(wrongValue)) +- + # check syntax SWAP_DISK + if values.w: + reTrueBind = re.compile("^[^:]+$") +@@ -354,7 +358,7 @@ class install_cmd(share_cmd): + self.logicObj.clVars.Set('cl_action', + "merge" if live else "system",True) + +- def checkAndSetInstallOptions(self,diskOptions, swapOptions, bindOptions, ++ def checkAndSetInstallOptions(self,diskOptions, swapOptions, + usersOptions): + """Check and set disk, swap and bind cmd options""" + if self.optobj.values.s: +@@ -372,6 +376,10 @@ class install_cmd(share_cmd): + self.logicObj.clVars.Set('os_install_root_type', + self.optobj.values.type, True) + ++ if self.optobj.values.iso: ++ if not self.logicObj.setIso(self.optobj.values.iso): ++ return False ++ + listDiskOptions = [] + listBindOptions = [] + listSwapOptions = [] +@@ -379,8 +387,7 @@ class install_cmd(share_cmd): + listDiskOptions = self._parseOptDisk(diskOptions) + if listDiskOptions is False: + return False +- if bindOptions: +- listBindOptions = self._parseOptBind(bindOptions) ++ listBindOptions = self._parseOptBind(diskOptions) + if listBindOptions is False: + return False + if swapOptions: +@@ -413,6 +420,7 @@ class install_cmd(share_cmd): + + def _parseOptBind(self, listOpt): + """Parse value cmd option --bind""" ++ listOpt = filter(lambda x:not x.startswith('/dev/'),listOpt) + listNameOptions = ["srcMountPoint", "destMountPoint"] + lenOptions = len(listNameOptions) + itemOptions = map(lambda x: (x,''), listNameOptions) +@@ -435,6 +443,7 @@ class install_cmd(share_cmd): + + def _parseOptDisk(self, listOpt): + """Parse value cmd option --disk""" ++ listOpt = filter(lambda x:x.startswith('/dev/'),listOpt) + listNameOptions = ["dev","mountPoint","fileSystem","options"] + lenOptions = len(listNameOptions) + itemOptions = map(lambda x: (x,''), listNameOptions) +@@ -468,12 +477,17 @@ class install_cmd(share_cmd): + if self.logicObj.installSystem(force=force, bootDisk=bootDisk, + stdinReadPwd=stdinReadPwd, builder=builder, + flagSpinner=flagSpinner,update=update): +- self.defaultPrint("\n") +- self.defaultPrint(_("To apply changes you have to reboot")+".\n") ++ if self.logicObj.clVars.Get('os_install_root_type') != "flash": ++ self.defaultPrint("\n") ++ self.defaultPrint(_("To apply changes you have to reboot")+ ++ ".\n") + return True + else: + return False + ++ def showPartitions(self): ++ self.logicObj.printAllPartitonsTable() ++ + def configureSystem(self): + """Run configure system""" + if self.logicObj.configureSystem(): +diff --git pym/cl_vars_install.py pym/cl_vars_install.py +index 5238f7b..fdcb803 100644 +--- pym/cl_vars_install.py ++++ pym/cl_vars_install.py +@@ -61,9 +61,15 @@ class Data: + # list mounted points for current operation system + os_disk_mount = {} + ++ # partition content ++ os_disk_content = {} ++ + # list filesystem for partition devices + os_disk_format = {} + ++ # list type (lvm,raid,partition,disk) ++ os_disk_type = {} ++ + # install list filesystem for partition devices + os_install_disk_format = {} + +@@ -99,6 +105,9 @@ class Data: + # type of partition devices (primary, extended or logical) + os_disk_part = {} + ++ # partition table on parent device ++ os_disk_table = {} ++ + # partition size + os_disk_size = {} + +@@ -114,12 +123,12 @@ class Data: + # device type (hdd,cdrom,usb-flash) + os_device_type = {} + +- # device partition table +- os_device_partition = {} +- + # map number for grub + os_device_map = {} + ++ # table for device ++ os_device_table = {} ++ + # content of device.map file for grub + os_install_grub_devicemap_conf = {} + +@@ -315,6 +324,12 @@ class Data: + # type of device for install + os_install_root_type = {'mode':'w'} + ++ # using lvm ++ os_install_lvm_set = {} ++ ++ # using mdadm ++ os_install_mdadm_set = {} ++ + # proxy server for system + os_install_proxy = {'mode':'w', + 'value':''} +diff --git scripts/cl-install scripts/cl-install +index ce0cdac..92e9d76 100644 +--- scripts/cl-install ++++ scripts/cl-install +@@ -52,13 +52,16 @@ if __name__ == "__main__": + # check and set installed options + install.setAction(options.live) + if not (options.live or options.install or options.uninstall): +- if not install.checkAndSetInstallOptions(options.d,options.w,options.b, ++ if not install.checkAndSetInstallOptions(options.d,options.w, + options.u): + sys.exit(1) + # print variables + if options.v or options.filter or options.xml: + install.printVars(options) + sys.exit(0) ++ if options.p: ++ install.showPartitions() ++ sys.exit(0) + # check root + if not install.isRoot(): + sys.exit(1) diff --git a/sys-apps/calculate-lib/ChangeLog b/sys-apps/calculate-lib/ChangeLog index a3ed35192..dcc5acdc2 100644 --- a/sys-apps/calculate-lib/ChangeLog +++ b/sys-apps/calculate-lib/ChangeLog @@ -2,6 +2,13 @@ # Copyright 1999-2011 Gentoo Foundation; Distributed under the GPL v2 # $Header: $ +*calculate-lib-2.2.19-r5 (26 Jul 2011) + + 26 Jul 2011; Mike Hiretsky (mhiretskiy) + +calculate-lib-2.2.19-r5.ebuild, + +files/calculate-lib-2.2.19_lvmraid_rc2.patch: + Update for raid lvm + *calculate-lib-2.2.19-r1 (20 Jul 2011) 20 Jul 2011; Mike Hiretsky (mhiretskiy) diff --git a/sys-apps/calculate-lib/Manifest b/sys-apps/calculate-lib/Manifest index 7193df9c3..558c7dc76 100644 --- a/sys-apps/calculate-lib/Manifest +++ b/sys-apps/calculate-lib/Manifest @@ -3,6 +3,7 @@ AUX calculate-lib-2.2.18-to_2.2.19_rc1.patch 3700 RMD160 29b1ff4dee8ebff2f9a131e AUX calculate-lib-2.2.19_2.2.20_rc1.patch 6312 RMD160 dc9ea8d0964ecdca54449f00e71a3e385efe36e5 SHA1 ed1168d158236d03f79686aeaf8ce635871fad60 SHA256 ec39ee91efd7d9f43f3c14e13200a4ff6578270e4985743523be8b6074ce15b9 AUX calculate-lib-2.2.19_fix_detect_video.patch 1265 RMD160 7080753d4f7937cb4ff1b0fa9135719911fd9231 SHA1 bd2c56488511338962c8f2a9bb3e1ed045c466f4 SHA256 8d2815dcbb99576b27b8a8c3efdd5ae84bc2acff1abe7b3ffaa68f68b4d4bc83 AUX calculate-lib-2.2.19_lvmraid_rc1.patch 29023 RMD160 3f2778691e38b151a3677a545e906e290e083f28 SHA1 e2f1a74247016ddecbb88572e4c2f0707b1edeaa SHA256 b24055f0d670b778505fe52559529651dc612597648a6a7cc035b60acefb07f6 +AUX calculate-lib-2.2.19_lvmraid_rc2.patch 29724 RMD160 aac416459d263c52db23e67bc0388d2944338e68 SHA1 2b298afaa57a239600a491adf402fa3c0f98b868 SHA256 50523f213ffced8eff86e95911ce58bd8db1ce36e04f8fa8f1e0e823f5ba03b5 DIST calculate-lib-2.1.11.tar.bz2 61687 RMD160 93ca4f84ff2cd7018addfd4de162959d78e51f78 SHA1 53149951c346fea7709cb43b4d8ebefe63acb0fd SHA256 62976c08d4fb4810389ace6f5a99abb5a962f6c8d9053ff943d0669480fb5599 DIST calculate-lib-2.1.8.tar.bz2 61178 RMD160 4a4ed063a9b4d3b82723f5f6eb046c97ad9fcda1 SHA1 93eb20057afff6e98c409388e1259a3ad078bb7a SHA256 ef8e315001663da7a45e69b82dc7c158fb0e10bd567efa95bf8a654ed441144a DIST calculate-lib-2.2.18.tar.bz2 111559 RMD160 294326d180c3de46ef1f5c56d4da10313e123d87 SHA1 e6340c81573421eca1f8b882f4a4929830df8bdd SHA256 8e8c0124ab9e2efa270fba9529c36a4dd12aa6d616d005e35945bbd999b6a3a5 @@ -17,8 +18,9 @@ EBUILD calculate-lib-2.2.19-r1.ebuild 768 RMD160 46ff73396ecc8e2edc58a77103b037e EBUILD calculate-lib-2.2.19-r2.ebuild 768 RMD160 46ff73396ecc8e2edc58a77103b037e0212ec2bc SHA1 4d733b8cb2e3245d395251f0e8840f2b78b35f15 SHA256 abf627bbfa04b1e4ea3cc705cc683fd0d9398dd7f952ffa0082899437d99d542 EBUILD calculate-lib-2.2.19-r3.ebuild 854 RMD160 8825d51df1c6ca570f7fd9b9b91c0967a4a272e5 SHA1 19b7f0025d0fcb278fb0065b1bd0980f3dba2a94 SHA256 415868961950664d85220a6d242cc5ad3e5ffe238c05978832d9007530e0319b EBUILD calculate-lib-2.2.19-r4.ebuild 766 RMD160 3ecf0c49ba379ccc98493549b8c226fe1548fc00 SHA1 fceffdd13b176028ace38782acc3a766982d088e SHA256 d142cd85e128642cbeaccea41c181486d74c4f5ea501d67620c95d26d0c6c3be +EBUILD calculate-lib-2.2.19-r5.ebuild 793 RMD160 5784660046ff341b4ae1bda6bb88049fae05de08 SHA1 e662dad4e80f281e80cb5c399c1ede0c505cf16a SHA256 ccaf03b638bb894192782b1ec1067e8fa989dd41909c59b3ecf8bb650ec0d1f9 EBUILD calculate-lib-2.2.19.ebuild 639 RMD160 d2dda2492b257947c88e37acdfdcffd30266ef29 SHA1 c0fee75613aa560848d32f7314737bc094d0dceb SHA256 bafff10516a4b7557c379e20592026a684be9b34dd38b381e136bd457c2c1dc0 EBUILD calculate-lib-2.2.9999.ebuild 726 RMD160 6dce718f317825c712f7c9595a3e712ef6222cf9 SHA1 42e1607a36e826310ef5ed317d717c5aa8acc2bf SHA256 dce73aafa346ea1fd88b6e99d8f6184a562de56e3eb871c1b5849890b13c34c2 EBUILD calculate-lib-9999.ebuild 476 RMD160 3df165f011b324fa8dc37d0443e941263943dd61 SHA1 069ab864dc83f32c69c4349d807d25e1196756ee SHA256 07a628ede4f47849908dd543f879ab8b40a5ca887b892fa0f5cf6c1ef2a24cab -MISC ChangeLog 23345 RMD160 c2cd3750c273d5e9592432bdaf97b010cc5c9bbc SHA1 cf45d395761507b5f748ad431647e88beb72fc80 SHA256 19a08f1c4902462468512839a084748042c05cdb5d2fae5bc029df4f0655e2c0 +MISC ChangeLog 23552 RMD160 1fabde1e932fbfb3985d61a8a94251355ed49fb0 SHA1 aae2d72ef971a06c76ec6dd21ecda968da0a807c SHA256 150edef3927d2b86ee9b5f004d50601ecbc7920487f7f0d2aa498f8fe15caef1 MISC metadata.xml 303 RMD160 774b65ed76939d6878496ad6ef6451849bdced05 SHA1 7d08569697a290ede98c88ab59db3cdc3037bd15 SHA256 181519d9679fd9aee9a7a9806733a50728d3da0b1e0ad54f31499200f7f5c6ec diff --git a/sys-apps/calculate-lib/calculate-lib-2.2.19-r5.ebuild b/sys-apps/calculate-lib/calculate-lib-2.2.19-r5.ebuild new file mode 100644 index 000000000..831b32458 --- /dev/null +++ b/sys-apps/calculate-lib/calculate-lib-2.2.19-r5.ebuild @@ -0,0 +1,34 @@ +# Copyright 1999-2011 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header: $ + +EAPI="3" + +inherit distutils eutils + +SRC_URI="ftp://ftp.calculate.ru/pub/calculate/calculate2/${PN}/${P}.tar.bz2" + +DESCRIPTION="The library for Calculate 2" +HOMEPAGE="http://www.calculate-linux.org/main/en/calculate2" +LICENSE="Apache-2.0" +SLOT="2.2" +KEYWORDS="amd64 x86" +IUSE="minimal" +DEPEND="!=dev-python/pyxml-0.8 + sys-apps/iproute2 + sys-fs/lvm2 + sys-fs/mdadm + sys-apps/file[python]" +RDEPEND="${DEPEND}" + +src_unpack() { + unpack "${A}" + cd "${S}" + + # update to lvmraid + epatch "${FILESDIR}/calculate-lib-2.2.19_lvmraid_rc2.patch" +} diff --git a/sys-apps/calculate-lib/files/calculate-lib-2.2.19_lvmraid_rc2.patch b/sys-apps/calculate-lib/files/calculate-lib-2.2.19_lvmraid_rc2.patch new file mode 100644 index 000000000..2ed820f57 --- /dev/null +++ b/sys-apps/calculate-lib/files/calculate-lib-2.2.19_lvmraid_rc2.patch @@ -0,0 +1,747 @@ +diff --git pym/cl_fill.py pym/cl_fill.py +index a846970..082b67e 100644 +--- pym/cl_fill.py ++++ pym/cl_fill.py +@@ -23,8 +23,10 @@ import cl_overriding + from cl_vars_share import varsShare, clLocale + from os.path import exists as pathexists + from os import path +-from cl_utils import isMount, genpassword, getAvailableX11Drivers, \ +- listDirectory,isPkgInstalled,lspci ++from cl_utils import isMount, genpassword, \ ++ getAvailableVideo, process, \ ++ listDirectory,isPkgInstalled,lspci, readLinesFile, \ ++ getUdevDeviceInfo + from utils import ip + from encrypt import getHash + +@@ -186,22 +188,24 @@ class fillVars(varsShare): + rootparam=re_res.group(1) + # check root for /dev/sd view + if re.match("^\/dev\/[a-z]+.*$", rootparam): +- return rootparam ++ return getUdevDeviceInfo( ++ name=rootparam.strip()).get('DEVNAME','') + # check root set by uuid +- uuidpath = '/dev/disk/by-uuid' +- if os.access(uuidpath,os.R_OK): +- uuidDevs = filter(path.islink, +- map(lambda x: path.join(uuidpath,x), +- os.listdir(uuidpath))) +- mapUuidDev = dict(map(lambda x:(path.basename(x), +- path.normpath(path.join(uuidpath, +- os.readlink(x)))), uuidDevs)) +- else: +- mapUuidDev = {} + if re.match("^UUID=.*$",rootparam): +- uuid = rootparam[5:] +- if uuid in mapUuidDev: +- return mapUuidDev[uuid] ++ uuid = rootparam[5:].strip("\"'") ++ blkidProcess = process('/sbin/blkid','-c','/dev/null','-U', ++ uuid) ++ if blkidProcess.success(): ++ return getUdevDeviceInfo( ++ name=blkidProcess.read().strip()).get('DEVNAME','') ++ # check root set by label ++ if re.match("^LABEL=.*$",rootparam): ++ uuid = rootparam[6:].strip("\"'") ++ blkidProcess = process('/sbin/blkid','-c','/dev/null','-L', ++ uuid) ++ if blkidProcess.success(): ++ return getUdevDeviceInfo( ++ name=blkidProcess.read().strip()).get('DEVNAME','') + # get device mounted to root + dfLines = self._runos("LANG=C df /") + if not dfLines: +@@ -388,23 +392,25 @@ class fillVars(varsShare): + xorg_conf = '/etc/X11/xorg.conf' + # Try analize Xorg.{DISPLAY}.log + display = os.environ.get('DISPLAY') +- list_avialable_drivers = \ +- getAvailableX11Drivers(prefix=self.Get('cl_chroot_path')) +- if display and list_avialable_drivers: ++ list_available_drivers = \ ++ getAvailableVideo(prefix=self.Get('cl_chroot_path')) ++ if display and list_available_drivers: + reDriver = re.compile('|'.join(map(lambda x: "%s_drv.so"%x, +- list_avialable_drivers))) +- display_number = re.search(r':(\d+)\..*', display) ++ list_available_drivers))) ++ display_number = re.search(r':(\d+)(\..*)?', display) ++ reDriverName = re.compile(r'([^/]+)_drv.so') + if display_number: + xorg_log_file = '/var/log/Xorg.%s.log' % \ + display_number.group(1) + if path.exists(xorg_log_file): +- matchStrs = [i for i in open(xorg_log_file) +- if "drv" in i and reDriver.search(i)] ++ matchStrs = \ ++ map(lambda x:x.group(1), ++ filter(lambda x:x, ++ map(reDriverName.search, ++ filter(lambda x:"drv" in x and reDriver.search(x), ++ readLinesFile(xorg_log_file))))) + if matchStrs: +- resDriver = re.search(r'([^/]+)_drv.so', +- matchStrs[-1]) +- if resDriver: +- return resDriver.group(1) ++ return matchStrs[-1] + + # analize /etc/X11/xorg.conf + if path.exists(xorg_conf): +@@ -413,19 +419,15 @@ class fillVars(varsShare): + if matchSect: + resDriver = re.search(r'^\S*Driver\s*"([^"]+)"', + matchSect.group(0),re.S) +- if resDriver and resDriver.group(1) in list_avialable_drivers: ++ if resDriver and resDriver.group(1) in list_available_drivers: + return resDriver.group(1) + + videoVal = self.getValueFromCmdLine("calculate","video") + videoVal = {'i915':'intel'}.get(videoVal,videoVal) + if not isPkgInstalled('xorg-server') or \ +- videoVal in list_avialable_drivers: ++ videoVal in list_available_drivers: + return videoVal +- workedModules = map(lambda x:x[0], +- filter(lambda x:x[1].isdigit() and int(x[1])>0, +- map(lambda x:x.split()[:3:2], +- open('/proc/modules','r')))) +- return self.getVideoByDefault(list_avialable_drivers) ++ return self.getVideoByDefault(list_available_drivers) + + def get_os_x11_height(self): + """Get screen height in pixeles""" +@@ -559,19 +561,7 @@ class fillVars(varsShare): + + def get_cl_kernel_uid(self): + """Get UID of symlink kernel, initramfs and System.map""" +- uuidpath = '/dev/disk/by-uuid' +- if not os.access(uuidpath,os.R_OK): +- return "" +- uuidDevs = filter(path.islink,map(lambda x: path.join(uuidpath,x), +- os.listdir(uuidpath))) +- mapDevUuid = dict(map(lambda x:(path.normpath(path.join(uuidpath, +- os.readlink(x))), +- path.basename(x)), +- uuidDevs)) +- if self.Get('os_root_dev') in mapDevUuid: +- return mapDevUuid[self.Get('os_root_dev')][:8] +- else: +- return "" ++ return self.getKernelUid(self.Get('os_root_dev')) + + def get_cl_chroot_status(self): + """Detect chroot mode by mtab content""" +diff --git pym/cl_opt.py pym/cl_opt.py +index 833677e..52b414a 100644 +--- pym/cl_opt.py ++++ pym/cl_opt.py +@@ -282,7 +282,7 @@ class opt(optparse.OptionParser): + }] + variable_view = \ + [{'shortOption':"v", +- 'longOption':"vars", ++ 'longOption':"show-variables", + 'action':'count', + 'help':_("print variables, if the two options is verbose " + "(added print hidden variables)") +@@ -290,11 +290,11 @@ class opt(optparse.OptionParser): + {'longOption':"filter", + 'optVal':"FILTER", + 'help':_("filtered variables (as a regular expression is used *), \ +-is used in conjunction with the options '-v --vars'") ++is used in conjunction with the options '-v --show-variables'") + }, + {'longOption':"xml", + 'help':_("output variables in the format of XML, \ +-is used in conjunction with the option '-v --vars'") ++is used in conjunction with the option '-v --show-variables'") + }] + variable_control = variable_set + variable_view + +diff --git pym/cl_utils.py pym/cl_utils.py +index 5d4d51a..d2e6231 100644 +--- pym/cl_utils.py ++++ pym/cl_utils.py +@@ -221,7 +221,10 @@ class process: + else: + stdin=kwarg["stdin"].getStdout + self.stdout = kwarg.get("stdout",PIPE) +- self.envdict = kwarg.get("envdict",None) ++ self.envdict = kwarg.get("envdict",{}) ++ if "lang" in kwarg: ++ self.envdict["LANG"] = kwarg.get('lang') ++ self.langc = "langc" in kwarg + + self.stderr = kwarg.get("stderr",PIPE) + self.command = [command] + list(params) +@@ -364,7 +367,7 @@ class processProgress(process): + pass + + def runOsCommand(cmd,in_str=None, env_dict=None): +- """Выполняет внешнюю программу ++ """Run system command + + Параметры: + cmd внешняя программа +@@ -392,30 +395,17 @@ def runOsCommand(cmd,in_str=None, env_dict=None): + return retcode, res + + def genpassword(passlen=9): +- '''Вернуть случайный набор символов указанной длины +- +- Параметры: +- passlen длина пароля который нужно сгенерировать +- +- Возвращаемые параметры: +- Сгенерированный пароль указанной длины +- ''' +- res=''.join([choice(string.ascii_letters+string.digits)\ +- for i in xrange(passlen)]) +- return res ++ """Return random charset specified lenght (passlen)""" ++ return ''.join(map(lambda x:choice(string.ascii_letters+string.digits), ++ xrange(0,passlen))) + + def getpathenv(): +- """Вернуть пути для запуска утилит""" +- bindir=['/sbin','/bin','/usr/sbin','/usr/bin'] ++ """Return path for run utilities""" ++ bindir=set(filter(path.exists, ++ ['/sbin','/bin','/usr/sbin','/usr/bin'])) + env=os.environ +- if env and env.has_key('PATH'): +- lpath=env['PATH'].split(":") +- npath=[] +- for dirname in bindir: +- if path.exists(dirname) and dirname not in lpath: +- npath.append(dirname) +- lpath=npath+lpath +- return ":".join(lpath) ++ envPath = set(env.get('PATH','').split(":")) | bindir ++ return ":".join(envPath) + + class MultiReplace: + """MultiReplace function object +@@ -627,7 +617,6 @@ def isFstabMount(pathname,mapDevUuid={},listFstab=[]): + absPath = "swap" + else: + absPath = path.abspath(pathname) +- devuuid = '/dev/disk/by-uuid' + if not mapDevUuid: + mapDevUuid.update(getUUIDDict()) + # convert fstab to +@@ -649,6 +638,69 @@ def isFstabMount(pathname,mapDevUuid={},listFstab=[]): + filter(lambda x: absPath in x and x[1] != "none", + listFstab),[""]))[0] + ++class SingletonParam(type): ++ def __init__(cls, name, bases, dict): ++ super(SingletonParam, cls).__init__(name, bases, dict) ++ cls.instance = {} ++ ++ def __call__(cls,*args,**kw): ++ keyarg = args[0] if args else "" ++ if not keyarg in cls.instance: ++ cls.instance[keyarg] = super(SingletonParam, cls).__call__(*args, **kw) ++ return cls.instance[keyarg] ++ ++class FStab(object): ++ """Data reader for fstab""" ++ __metaclass__ = SingletonParam ++ fstab_file = '/etc/fstab' ++ NAME, DIR, TYPE, OPTS, FREQ, PASSNO = range(0,6) ++ ++ def __init__(self,fstab_file=None): ++ if fstab_file: ++ self.fstab_file = fstab_file ++ self.cache = [] ++ self.rotateCache = [] ++ self.dictUUID = getUUIDDict() ++ self.rebuildCache() ++ ++ def rebuildCache(self): ++ """Rebuild cache from fstab file""" ++ self.cache = \ ++ map(lambda x:map(lambda y:y.strip(),x.split()), ++ filter(lambda x:x and not x.lstrip().startswith("#"), ++ open(self.fstab_file,'r').read().split('\n'))) ++ for data in self.cache: ++ convertDev = lambda x: path.realpath(x) if x.startswith('/') else x ++ data[0] = getUdevDeviceInfo( ++ name=convertDev(self.dictUUID.get(data[0],data[0])) ++ ).get('DEVNAME','') ++ data[1] = data[1] if data[2] != "swap" else "swap" ++ self.rotateCache = zip(*self.cache) ++ ++ def getBy(self,what=DIR,where=NAME,eq=None,noteq=None,allentry=False): ++ """Get data from fstab""" ++ if not eq is None: ++ filterfunc = lambda x: x[where] == eq ++ else: ++ filterfunc = lambda x: x[where] != noteq ++ res = map(lambda x:x[what],filter(filterfunc,self.cache)) ++ if allentry: ++ return res ++ else: ++ return "" if not res else res[-1] ++ ++ def getFields(self,*fields): ++ """Get all data by specifie fields""" ++ return zip(*reduce(lambda x,y:x+[self.rotateCache[y]],fields,[])) ++ ++ def isExists(self,what=DIR,eq=None,noteq=None): ++ """Field with condition exist in fstab""" ++ if not eq is None: ++ filterfunc = lambda x: x[what] == eq ++ else: ++ filterfunc = lambda x: x[what] != noteq ++ return bool(filter(filterfunc,self.cache)) ++ + def isMount(pathname): + """В случае монтирования директории выдает другой примонтированный путь""" + absPath = path.abspath(pathname) +@@ -805,6 +857,27 @@ def listDirectory(directory,fullPath=False): + pass + return [] + ++def getInstalledVideo(prefix="/"): ++ """Get installed video drivers""" ++ x11Drivers = path.join(prefix,"usr/lib/xorg/modules/drivers") ++ return map(lambda x:x[:-7], ++ filter(lambda x:x.endswith('_drv.so'), ++ listDirectory(x11Drivers))) ++ ++def getDistfilesVideo(prefix="/"): ++ """Get video drivers from distfiles""" ++ distFiles = path.join(prefix,"usr/portage/distfiles") ++ return list(set( ++ map(lambda x:'fglrx' if x.startswith('ati-driver') else "nvidia", ++ filter(lambda x:x.startswith('ati-driver-installer') or ++ x.startswith('NVIDIA-Linux'), ++ listDirectory(distFiles))))) ++ ++def getAvailableVideo(prefix="/"): ++ """Get available video drivers (installed and maybe installed)""" ++ return list(set(getInstalledVideo(prefix=prefix) + \ ++ getDistfilesVideo(prefix=prefix))) ++ + def readLinesFile(filename): + """Read file by line""" + try: +@@ -823,38 +896,34 @@ def readFile(filename): + return open(filename,'r').read() + except (OSError,IOError): + pass +- finally: +- return "" ++ return "" + + def getUUIDDict(revers=False): + """Get dict UUID -> dev""" +- devuuid = '/dev/disk/by-uuid' +- datafunc = lambda x,y: (x,y) ++ blkidProcess = process("/sbin/blkid","-s","UUID","-c","/dev/null") + if revers: + datafunc = lambda x,y: (y,x) ++ else: ++ datafunc = lambda x,y: (x,y) ++ DEV,UUID = 0,1 ++ reSplit = re.compile('^([^:]+):.*UUID="([^"]+)"',re.S) + return dict( +- map(lambda x:datafunc("UUID=%s"%path.basename(x), +- path.normpath(path.join(devuuid,os.readlink(x)))), +- filter(path.islink, +- listDirectory(devuuid,fullPath=True)))) ++ map(lambda x:datafunc("UUID=%s"%x[UUID], ++ getUdevDeviceInfo(name=x[DEV]).get('DEVNAME',x[DEV])), ++ map(lambda x:x.groups(), ++ filter(lambda x:x, ++ map(reSplit.search, ++ blkidProcess))))) + + def detectDeviceForPartition(dev): +- """Detect parent device for partition by /sys/block (sysfs)""" +- reDeviceSplit = re.compile("^(.*/)?(.*?)(\d+)$") +- device = map(lambda x:filter(lambda x:x in dev, +- x[1]), +- os.walk('/sys/block')) +- if device: +- device = device[0] +- parentdevices = \ +- filter(lambda x: path.split(dev)[-1] in \ +- reduce(lambda y,z:y+z[1], +- os.walk(path.join('/sys/block',x)),[]), device) +- if parentdevices: +- return parentdevices[0] +- res = reDeviceSplit.search(dev) +- if res: +- return res.groups()[1] ++ """Detect parent device for partition by udev and return property""" ++ prop = getUdevDeviceInfo(name=dev) ++ if prop.get('DEVTYPE','') != 'partition': ++ return '' ++ parentpath = path.dirname(prop.get('DEVPATH','')) ++ if parentpath: ++ devProp = getUdevDeviceInfo(path=parentpath) ++ return devProp.get('DEVNAME','') + return None + + def getProgPath(progname): +@@ -872,7 +941,7 @@ def getProgPath(progname): + return False + + def checkUtils(*utils): +- """Check utils and exit if it not found""" ++ """Check utils, exit if it not found and return fullpath""" + retval = [] + for util in utils: + utilPath = getProgPath(util) +@@ -965,8 +1034,97 @@ def getSquashList(): + return map(lambda x:{"lzma":"xz"}.get(x,x), + list(set(usesSquashFs) & wantMethod)) + ++def addUdevInfo(prop): ++ """Function for compatibility with util-linux with version less ++ that 2.18 ++ TODO: need realization, now only stub ++ ++ ID_PART_TABLE_TYPE ++ ID_PART_ENTRY_TYPE ++ ID_PART_ENTRY_NUMBER ++ """ ++ return prop ++ ++def getUdevDeviceInfo(path="",name=""): ++ """Get device info by syspath of name""" ++ udevadmCmd = getProgPath('/sbin/udevadm') ++ typeQuery = "--path" if path else "--name" ++ value = path if path else name ++ return addUdevInfo(dict( ++ filter(lambda x:x[0], ++ map(lambda x:x.partition("=")[0::2], ++ process(udevadmCmd,"info","--query","property", ++ typeQuery,value).read().split("\n"))))) ++ ++def countPartitions(devname): ++ """Count partition for specified device""" ++ syspath = getUdevDeviceInfo(name=devname).get('DEVPATH','') ++ if not syspath: ++ return 0 ++ deviceName = path.basename(syspath) ++ if not syspath.startswith("/sys"): ++ syspath = pathJoin("/sys",syspath) ++ return len(filter(lambda x:x.startswith(deviceName), ++ listDirectory(syspath))) ++ ++def getLvmGroups(): ++ """Get LVM groups""" ++ pvdisplayCmd = getProgPath('/sbin/pvdisplay') ++ pvdata = process(pvdisplayCmd,"-C","-o", "vg_name","--noh") ++ return filter(lambda x:x,pvdata.read().split()) ++ ++def getLvmPartitions(vg_name,lv_name,cache=[]): ++ """Get lvm partitions""" ++ if not cache: ++ pvdisplayCmd = getProgPath('/sbin/pvdisplay') ++ pvdata = process(pvdisplayCmd,"-C","-o", ++ "vg_name,lv_name,pv_name","--noh") ++ if pvdata.success(): ++ cache.extend( ++ filter(lambda x:x and len(x)==3, ++ map(lambda x:x.split(), ++ pvdata.read().split('\n')))) ++ if cache: ++ res = map(lambda x:x[2], ++ filter(lambda x:x[0]==vg_name and x[1]==lv_name,cache)) ++ if res: ++ return res ++ return [] ++ ++def getPartitionDevice(syspath): ++ """Get real parent device by partition,lvm,mdraid""" ++ prop = getUdevDeviceInfo(path=syspath) ++ # real device ++ if prop.get('ID_TYPE',"") == "disk" and \ ++ prop.get('DEVTYPE',"") == "disk": ++ return prop.get('DEVNAME',"") ++ # partition ++ if prop.get('DEVTYPE') == "partition": ++ return getPartitionDevice(path.dirname(syspath)) ++ # md raid ++ if prop.get('MD_LEVEL',"").startswith("raid"): ++ if not syspath.startswith('/sys'): ++ syspathpath = pathJoin('/sys',syspath) ++ syspath = pathJoin(syspath,"md") ++ for rd in filter(lambda x:path.basename(x).startswith('rd'), ++ listDirectory(syspath,fullPath=True)): ++ rdBlockPath = path.join(rd,"block") ++ if path.exists(rdBlockPath): ++ return getPartitionDevice(path.realpath(rdBlockPath)) ++ else: ++ return "" ++ # lvm ++ if prop.get('DM_LV_NAME',"") != "": ++ parts = getLvmPartitions(prop.get('DM_VG_NAME',''), ++ prop.get('DM_LV_NAME','')) ++ if parts: ++ propPartLvm = getUdevDeviceInfo(name=parts[0]) ++ if 'DEVPATH' in propPartLvm: ++ return getPartitionDevice(propPartLvm['DEVPATH']) ++ return "" ++ + def getAvailableX11Drivers(prefix="/"): +- """Get available x11 drivers""" ++ """Get available x11 drivers (Depricated Function)""" + xorg_modules_dir = path.join(prefix,'usr/lib/xorg/modules/drivers') + return map(lambda x: x[:-7], + filter(lambda x:x.endswith('_drv.so'), +@@ -1002,32 +1160,149 @@ def lspci(filtername=None,shortInfo=False): + 'name':sfunc(device[3])} + return retData + +-def getUdevDeviceInfo(path="",name=""): +- """Get device info by syspath of name""" +- udevadmCmd = getProgPath('/sbin/udevadm') +- typeQuery = "--path" if path else "--name" +- value = path if path else name +- return dict( +- filter(lambda x:x[0], +- map(lambda x:x.partition("=")[0::2], +- process(udevadmCmd,"info","--query","property", +- typeQuery,value).read().split("\n")))) +- + def getPartitionSize(dev): + """Get partition size""" + SECTORSIZE=512 +- syspath = getUdevDeviceInfo(name=dev).get('DEVPATH','') +- if syspath: +- sizeFile = pathJoin("/sys",syspath,"size") +- if path.exists(sizeFile): +- size = float(open(sizeFile,'r').read().strip())*SECTORSIZE +- suffix = ((1024**0,""), +- (1024**1,"KiB"), +- (1024**2,"MiB"), +- (1024**3,"GiB"), +- (1024**4,"TiB"), +- (1024**5,"PiB")) +- suffix = filter(lambda x:size >=x[0],suffix)[-1] +- if suffix: +- return "%.1f %s"%(size/suffix[0],suffix[1]) ++ sizeFile = pathJoin(dev,"size") ++ if path.exists(sizeFile): ++ size = float(open(sizeFile,'r').read().strip())*SECTORSIZE ++ suffix = ((1024**0,""), ++ (1024**1,"KiB"), ++ (1024**2,"MiB"), ++ (1024**3,"GiB"), ++ (1024**4,"TiB"), ++ (1024**5,"PiB")) ++ suffix = filter(lambda x:size >=x[0],suffix) ++ if suffix: ++ suffix = suffix[-1] ++ return "%.1f %s"%(size/suffix[0],suffix[1]) + return "0" ++ ++def getDeviceType(syspath): ++ """Get device type (disk,partition,lvm,raid)""" ++ prop = getUdevDeviceInfo(path=syspath) ++ # real device ++ if prop.get('ID_CDROM',""): ++ return "cdrom" ++ if prop.get('ID_TYPE',"") == "disk" and \ ++ prop.get('DEVTYPE',"") == "disk": ++ return "disk" ++ # partition ++ if prop.get('DEVTYPE') == "partition": ++ return getDeviceType(path.dirname(syspath))+"-partition" ++ # md raid ++ if prop.get('MD_LEVEL',"").startswith("raid"): ++ if not syspath.startswith('/sys'): ++ syspathpath = pathJoin('/sys',syspath) ++ syspath = pathJoin(syspath,"md") ++ for rd in filter(lambda x:path.basename(x).startswith('rd'), ++ listDirectory(syspath,fullPath=True)): ++ rdBlockPath = path.join(rd,"block") ++ if path.exists(rdBlockPath): ++ return getDeviceType(path.realpath(rdBlockPath))+"-raid" ++ else: ++ return "loop" ++ # lvm ++ if prop.get('DM_LV_NAME',"") != "": ++ parts = getLvmPartitions(prop.get('DM_VG_NAME',''), ++ prop.get('DM_LV_NAME','')) ++ if parts: ++ propPartLvm = getUdevDeviceInfo(name=parts[0]) ++ if 'DEVPATH' in propPartLvm: ++ return getDeviceType(propPartLvm['DEVPATH'])+"-lvm" ++ return "loop" ++ ++def getRaidPartitions(raidpath): ++ """Get raid partitions""" ++ prop = getUdevDeviceInfo(path=raidpath) ++ raidParts = [] ++ if prop.get('MD_LEVEL',"").startswith("raid"): ++ if not raidpath.startswith('/sys'): ++ raidpath = pathJoin('/sys',raidpath) ++ raidpath = pathJoin(raidpath,"md") ++ for rd in filter(lambda x:path.basename(x).startswith('rd'), ++ listDirectory(raidpath,fullPath=True)): ++ rdpath = path.join(raidpath,rd,"block") ++ if path.exists(rdpath): ++ raidParts.append( ++ getUdevDeviceInfo(path=path.realpath(rdpath)).get( ++ "DEVNAME",'')) ++ return filter(lambda x:x,raidParts) ++ ++ ++def getPartitionType(prop): ++ """Get type of dos part table (primary,extended or logical)""" ++ if prop.get('ID_PART_TABLE_TYPE') == 'dos': ++ partId = prop.get('ID_PART_ENTRY_TYPE','') ++ partNumber = prop.get('ID_PART_ENTRY_NUMBER','') ++ if partId and partNumber: ++ if partId == "0x5": ++ return "extended" ++ elif int(partNumber)>4: ++ return "logical" ++ else: ++ return "primary" ++ return prop.get('ID_PART_TABLE_TYPE','') ++ ++def detectBuild(pathname,dictInfo): ++ """Detect build by root passwd 'root'""" ++ shadowPath = pathJoin(pathname,'/etc/shadow') ++ if r"root:$1$JMvNh5xg$VnV1DyJdTcwuZ0hp5YiJG0:14349:0:::::" in \ ++ readFile(shadowPath): ++ dictInfo['type'] = ' assemble' ++ elif path.exists(pathJoin(pathname,"delta")) and \ ++ path.exists(pathJoin(pathname,"workspace")): ++ dictInfo['type'] = " builder" ++ issue = readFile(pathJoin(pathname,'etc/gentoo-release')) ++ if "Server" in issue: ++ if "Scratch" in issue: ++ dictInfo['name'] = "CSS" ++ else: ++ dictInfo['name'] = "CDS" ++ elif "Desktop" in issue: ++ if "XFCE" in issue: ++ dictInfo['name'] = "CLDX" ++ elif "KDE" in issue: ++ dictInfo['name'] = "CLD" ++ elif "GNOME" in issue: ++ dictInfo['name'] = "CLDG" ++ elif "Scratch" in issue: ++ dictInfo['name'] = "CLS" ++ else: ++ dictInfo['type'] = '' ++ return dictInfo ++ ++def getOsProberHash(getContentFunc=None): ++ """Get partition content by os-prober""" ++ os_prober = getProgPath('/usr/bin/os-prober') ++ if os_prober: ++ DEV,LONG,SHORT,TYPE = 0,1,2,3 ++ osProberList = \ ++ map(lambda x:[getUdevDeviceInfo(name=x[DEV]).get('DEVNAME',''), ++ x[LONG],x[SHORT],x[TYPE]], ++ filter(lambda x:len(x)>=4, ++ map(lambda x:x.split(":"), ++ process(os_prober)))) ++ for osRecord in osProberList: ++ if "Gentoo" in osRecord[SHORT] and getContentFunc: ++ osDescr = getContentFunc(osRecord[DEV],addFunc=detectBuild) ++ if "name" in osDescr and "march" in osDescr and \ ++ "build" in osDescr and "ver" in osDescr and \ ++ (osDescr["ver"] != "0" or osDescr["build"]): ++ if osDescr['build']: ++ osDescr['build'] = "-%s"%osDescr['build'] ++ else: ++ osDescr['build'] = "-%s"%osDescr['ver'] ++ osRecord[SHORT] = \ ++ "{name}-{march}{build}{type}".format(**osDescr) ++ else: ++ osRecord[SHORT] = "Gentoo" ++ elif "Gentoo" in osRecord[SHORT] and "Calculate" in osRecord[LONG]: ++ osRecord[SHORT] = "Calculate" ++ osProberHash = \ ++ dict( ++ map(lambda x:(x[DEV],x[SHORT]), ++ osProberList)) ++ else: ++ osProberHash = {} ++ return osProberHash +diff --git pym/cl_vars_share.py pym/cl_vars_share.py +index 755ae89..29274c5 100644 +--- pym/cl_vars_share.py ++++ pym/cl_vars_share.py +@@ -16,7 +16,7 @@ + + import os + import sys +-from cl_utils import getpathenv, runOsCommand, typeFile ++from cl_utils import getpathenv, runOsCommand, typeFile,process + import re + from os import path, R_OK + try: +@@ -528,6 +528,16 @@ class varsShare: + if reRes: + return reRes[0] + ++ def selectVar(self,selField,where="",eq=""): ++ """Select value from matrix variables ++ ++ Example: ++ selectVar("os_disk_dev",where="os_disk_mount",eq="/")""" ++ res = filter(lambda x:x[1] == eq, ++ zip(self.Get(selField), ++ self.Get(where))) or [("","")] ++ return res[0][0] ++ + def getVersionFromGentooFiles(self,systemroot): + """Get version from gentoo files""" + gentooFile = path.join(systemroot,"etc/gentoo-release") +@@ -582,16 +592,22 @@ class varsShare: + filter(lambda x:x[1].isdigit() and int(x[1])>0, + map(lambda x:x.split()[:3:2], + open('/proc/modules','r')))) +- if "nvidia" in drivers_list: +- defaultNvidia = "nvidia" +- elif "nouveau" in workedModules: ++ if "nouveau" in workedModules: + defaultNvidia = "nouveau" ++ elif "nvidia" in drivers_list: ++ defaultNvidia = "nvidia" + else: + defaultNvidia = "nv" ++ if "radeon" in workedModules: ++ defaultAti = "radeon" ++ elif "fglrx" in drivers_list: ++ defaultAti = "fglrx" ++ else: ++ defaultAti = "radeon" + defaultDriver = { + 'vesa':'vesa', + 'nvidia':defaultNvidia, +- 'ati':'fglrx' if "fglrx" in drivers_list else "radeon", ++ 'ati':defaultAti, + 'intel':'intel', + 'via':'via', + 'vmware':'vmware'} +@@ -601,3 +617,13 @@ class varsShare: + return defaultDriver[hr_video] + else: + return "vesa" ++ ++ def getKernelUid(self,device): ++ """Get Kernel UID by UUID of device""" ++ blkidProcess = process('/sbin/blkid','-c','/dev/null','-s','UUID', ++ '-o','value',device) ++ res = blkidProcess.read().strip() ++ if res: ++ return res[:8] ++ else: ++ return "no_uid" diff --git a/sys-apps/calculate-utilities/ChangeLog b/sys-apps/calculate-utilities/ChangeLog index bfbebb8c7..d33637117 100644 --- a/sys-apps/calculate-utilities/ChangeLog +++ b/sys-apps/calculate-utilities/ChangeLog @@ -2,6 +2,12 @@ # Copyright 1999-2011 Gentoo Foundation; Distributed under the GPL v2 # $Header: $ +*calculate-utilities-2.2.19-r7 (26 Jul 2011) + + 26 Jul 2011; Mike Hiretsky (mhiretskiy) + +calculate-utilities-2.2.19-r7.ebuild: + Update for install and lib + *calculate-utilities-2.2.19-r6 (25 Jul 2011) 25 Jul 2011; Mike Hiretsky (mhiretskiy) diff --git a/sys-apps/calculate-utilities/Manifest b/sys-apps/calculate-utilities/Manifest index 14919b76f..ea9c74f2a 100644 --- a/sys-apps/calculate-utilities/Manifest +++ b/sys-apps/calculate-utilities/Manifest @@ -9,6 +9,7 @@ EBUILD calculate-utilities-2.2.19-r3.ebuild 880 RMD160 263f3de7fbf855f7a95233fcf EBUILD calculate-utilities-2.2.19-r4.ebuild 880 RMD160 83485c42c30986ffef19cb80a1eff0be4cbbb88e SHA1 956b0083676c70e9b148d86efef0ca66d391cfc9 SHA256 96f15b3a44799a2634234ac467178d5749f2c5e2bf711f997cc56f3f8477955d EBUILD calculate-utilities-2.2.19-r5.ebuild 880 RMD160 8f303ba90fe206f3c036bf3e1648d39767c35ca0 SHA1 4d1d2327077e9112c78b43320acae734e85711e4 SHA256 bc0d62b93d4f214a9eb7b3d10e0e247809e4bb0c528846036f0784d18a97e49f EBUILD calculate-utilities-2.2.19-r6.ebuild 880 RMD160 3c01a3a3aff9230589c70ab2367d6c63f2a7e745 SHA1 89773dad25ce7e58705f979ce3bc2dfd7a5e726a SHA256 64ca5ae1dfdce7fe42a001a492fdcec0b4c3326acb0f12a4d288f46d89bdb86f +EBUILD calculate-utilities-2.2.19-r7.ebuild 880 RMD160 be5b601ad2b663467d9b5076d9ef8277ebbe86a4 SHA1 acd4974cc618785598619b9f7bfcbeccde8fe1fc SHA256 919c6618eb85f6ac6b34b3b928d4ea96942d0542c5adf2fd196f2a1517517299 EBUILD calculate-utilities-2.2.19.ebuild 862 RMD160 3c63622728c5486252332890f946fb29bc5af5ca SHA1 1d923fbbb9959dbfed1fbe3f08e530e2e365d940 SHA256 881356df9ab4e47bff03ca9eed44656b38702b1f60055c4b1c446ba49e7f4040 EBUILD calculate-utilities-2.2.9999.ebuild 840 RMD160 0c7324a9ed480118ac19f62b162c9ee62c25f964 SHA1 7dadab1430ed147334ed7e9b4fcc86dc99e25d56 SHA256 f3ee28f9f765e7302c83eb4a15a09bdf066f09e6b40e34f6d52157a946df5e66 -MISC ChangeLog 16722 RMD160 b77e260456b17bf2bcc6eff4418050475b34edc5 SHA1 f07562e301566bafb2b59443868864afbf01b2a3 SHA256 6b5cabbcf9c01ab419eb07d7c33af7583ec10bd84b63d3ce6ab0675d4f22010c +MISC ChangeLog 16899 RMD160 a37707a5e25ce85885494d0368dd74112ee408e3 SHA1 b46877c9bb4610895e35f02dd05274c07847939a SHA256 1f32f8db8be1e7628c950ba47411375e54fc35cdb7c3e3c207433ad82b53a69a diff --git a/sys-apps/calculate-utilities/calculate-utilities-2.2.19-r7.ebuild b/sys-apps/calculate-utilities/calculate-utilities-2.2.19-r7.ebuild new file mode 100644 index 000000000..c20ef8aac --- /dev/null +++ b/sys-apps/calculate-utilities/calculate-utilities-2.2.19-r7.ebuild @@ -0,0 +1,37 @@ +# Copyright 1999-2011 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header: $ + +EAPI=3 + +DESCRIPTION="Calculate Utilities meta package" +HOMEPAGE="http://www.calculate-linux.org/main/en/calculate2" +SRC_URI="" + +LICENSE="Apache-2.0" +SLOT="0" +KEYWORDS="amd64 x86" +IUSE=" +cl_assemble +cl_builder +cl_client +cl_desktop +cl_installgui +cl_server +" + +RDEPEND="${RDEPEND} + =sys-apps/calculate-install-2.2.19-r3 + =sys-apps/calculate-templates-2.2.19-r4 + =sys-apps/calculate-lib-2.2.19-r5 + =sys-apps/calculate-i18n-2.2.19-r2 + + cl_assemble? ( =sys-apps/calculate-assemble-2.2.19-r1 ) + cl_builder? ( =sys-apps/calculate-builder-2.2.19-r1 ) + cl_client? ( =sys-apps/calculate-client-2.2.19 ) + cl_desktop? ( =sys-apps/calculate-desktop-2.2.19 ) + cl_installgui? ( =app-misc/calculate-install-gui-2.2.19 ) + + cl_server? ( =sys-apps/calculate-server-2.1.14-r6 ) +" +