Browse Source

Поддрежка builder и assemble для утилит 3.2

tags/2.2.32
Mike Hiretsky 7 years ago
parent
commit
d6fc09c4b0
2 changed files with 192 additions and 1 deletions
  1. +3
    -1
      pym/cl_distr.py
  2. +189
    -0
      pym/tools.py

+ 3
- 1
pym/cl_distr.py View File

@@ -1202,9 +1202,10 @@ class SquashDistributive(Distributive):
class IsoDistributive(Distributive):
def __init__(self,file,parent=None,mdirectory="/mnt/cdrom",
bdirectory="/var/calculate/tmp/iso",exclude=None,
compress="gzip"):
compress="gzip", volid="CALCULATE"):
Distributive.__init__(self,parent=parent)
self.file = file
self.volid = volid
if path.isdir(self.file):
self.mdirectory = self.file
else:
@@ -1294,6 +1295,7 @@ class IsoDistributive(Distributive):
if os.path.exists(os.path.join(directory,efiImage)):
params = ["-J","-R","-l","-no-emul-boot","-boot-load-size 4",
"-udf","-boot-info-table","-b isolinux/isolinux.bin",
"-V %s"%self.volid,
"-c isolinux/boot.cat","-eltorito-alt-boot",
"-no-emul-boot","-eltorito-platform efi",
"-eltorito-boot %s"%efiImage]


+ 189
- 0
pym/tools.py View File

@@ -0,0 +1,189 @@
#-*- coding: utf-8 -*-

# Copyright 2014 Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from collections import Mapping
from functools import total_ordering

import os
from os import path
import bz2
import re
try:
from calculate.lib.utils.files import readFile, listDirectory, pathJoin
from calculate.lib.datavars import SimpleDataVars
except ImportError:
from cl_utils import readFile, listDirectory, pathJoin

from cl_datavars import DataVars

class SimpleRepositoryMapper(Mapping):
"""
Определение пути до репозитория
"""
map_repository = {'gentoo': '/usr/portage',
'calculate': '/var/lib/layman/calculate'}
layman_path = '/var/lib/layman'

def __init__(self, prefix='/'):
self.prefix = prefix

def __getitem__(self, item):
if item in self.map_repository:
return pathJoin(self.prefix, self.map_repository[item])
return pathJoin(self.prefix, self.layman_path, item)

def __iter__(self):
return iter(self.map_repository)

def __len__(self):
return len(self.map_repository)


class EbuildInfoError(Exception):
pass


class EbuildInfo(object):
"""
Информация о ebuild (DEPEND) из metadata
"""
map_repository = SimpleRepositoryMapper()
meta_suffix_path = 'metadata/md5-cache'
support_keys = ('DEPEND', 'RDEPEND', 'PDEPEND')

def __init__(self, atom, repository):
meta_path = path.join(self.map_repository[repository],
self.meta_suffix_path)
self._meta_info_path = path.join(meta_path, atom)
if not path.exists(self._meta_info_path):
raise EbuildInfoError("Package is not found")
self._info = self._get_info()

def _get_info(self):
with open(self._meta_info_path, 'r') as f:
return {k.strip(): v.strip() for k, v in (line.partition('=')[::2]
for line in f.readlines())
if k in self.support_keys}

def __getitem__(self, item):
if item in self.support_keys:
return self._info.get(item,'')
raise KeyError(item)

@classmethod
def set_repository_mapper(cls, mapper):
cls.map_repository = mapper

def __eq__(self, other):
return all(other[k] == self[k] for k in self.support_keys)

def __ne__(self, other):
return any(other[k] != self[k] for k in self.support_keys)


class InstalledPackageInfoError(Exception):
pass


class InstalledPackageInfo(object):
"""
Информация об установленном пакете (DEPEND) из /var/db/pkg
"""
pkg_dir = '/var/db/pkg'
depend_pattern = 'declare (?:-x )?({0})="([^"]+)"'
re_depend = re.compile(depend_pattern.format("RDEPEND|PDEPEND|DEPEND"),
re.DOTALL)
re_multispace = re.compile("\s+", re.DOTALL)

def __init__(self, atom):
self.atom = atom
self._pkg_path = path.join(self.pkg_dir, atom)
if not path.exists(self._pkg_path):
raise InstalledPackageInfoError("Package is not found")
self._info = self._get_info()

def _get_info(self):
info = {k: "" for k in ("RDEPEND", "DEPEND", "PDEPEND")}
env_path = path.join(self._pkg_path, 'environment.bz2')
if path.exists(env_path):
with bz2.BZ2File(env_path, 'r') as f:
for r in self.re_depend.finditer(f.read()):
key, value = r.groups()
value = self.re_multispace.sub(" ", value)
info[key] = value.strip()
rep_path = path.join(self._pkg_path, 'repository')
info['repository'] = readFile(rep_path).strip()
return info

def __getitem__(self, item):
return self._info[item]

@classmethod
def get_install_packages(cls):
for category in listDirectory(cls.pkg_dir):
for pkg in listDirectory(path.join(cls.pkg_dir, category)):
yield InstalledPackageInfo("%s/%s" % (category, pkg))

def __str__(self):
return self.atom

def __repr__(self):
return "InstalledPackageInfo(%s)" % self.atom

class SimpleVariable(object):
def __init__(self, varname, fallback_value="", section="main", type="string"):
self.varname = varname
self.fallback_value = fallback_value
self.section = section
self.type = type

def get(self):
return self.fallback_value

def getVariableName(self):
return self.varname

class ArchVariable(SimpleVariable):
def __init__(self, varname, fallback_value="", section="main", type="string", prefix="/"):
self.varname = varname
self.fallback_value = fallback_value
self.section = section
self.type = type
self.prefix = prefix

def get(self):
if path.lexists(path.join(self.prefix,'lib64')):
return 'x86_64'
elif path.lexists(path.join(self.prefix,'lib')):
return 'i686'
else:
d['os_arch_machine'] = ''

class ProfileVariable(SimpleVariable):
def __init__(self, varname, fallback_value="", section="main", type="string", prefix="/"):
self.varname = varname
self.fallback_value = fallback_value
self.section = section
self.type = type
self.prefix = prefix

def get(self):
for profile in ('etc/portage/make.profile',
'etc/make.profile'):
profile = path.join(self.prefix, profile)
if path.exists(profile):
return os.readlink(profile)
return ""

Loading…
Cancel
Save