TG-293

правка переменной cl_update_use_migration_host

.gitignore

@@ -0,0 +1,6 @@
+revert_changes_to_vmachine
+push_to_vmachine*
+.vscode
+*.pyc
+*.pyo
+*.bak

data/cl-git-wrapper

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+# если выполняется обновление уже полученного репозитория
+if [[ $1 == "pull" ]] || [[ $1 == "remote" ]]
+then
+    # получить название репозитория
+    if [[ -f profiles/repo_name ]]
+    then
+        repo_name=$(/bin/cat profiles/repo_name)
+    else
+        repo_name=$(/bin/basename `pwd`)
+    fi
+elif [[ $1 == "clone" ]]
+then
+    repo_name=$(/bin/basename $3)
+fi
+
+# получить список репозиториев дистрибутива
+native_reps=,$(/usr/libexec/calculate/cl-variable --value  update.cl_update_rep_name),
+# если обновляемый репозиторий от дистрибутива
+if echo $native_reps | grep -q ,${repo_name},
+then
+    if [[ $1 == "pull" ]]
+    then
+        # отбновить репозиторий через утилиты Calculate
+        /usr/sbin/cl-core --method update --rep $repo_name --sync-only on --skip-eix-update -T none
+    fi
+else
+    # выполнить обновление через git
+    /usr/bin/git $*
+fi
+

pym/update/datavars.py

@@ -1,6 +1,6 @@
-#-*- coding: utf-8 -*-
+# -*- coding: utf-8 -*-
 
-# Copyright 2012-2013 Calculate Ltd. http://www.calculate-linux.org
+# Copyright 2012-2016 Mir Calculate. 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.
@@ -13,16 +13,15 @@
 #  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.
-
 __app__ = 'calculate-update'
-__version__ = '3.1.7'
+__version__ = '3.4.1'
 
-import os
 import sys
 from calculate.lib.datavars import DataVars
 
 from calculate.lib.cl_lang import setLocalTranslate
-setLocalTranslate('cl_update3',sys.modules[__name__])
+
+setLocalTranslate('cl_update3', sys.modules[__name__])
 
 class DataVarsUpdate(DataVars):
     """Variable class for desktop package"""

pym/update/emerge_parser.py

@@ -0,0 +1,859 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2015-2016 Mir Calculate. 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.
+
+import hashlib
+
+import os
+from os import path
+
+import re
+import sys
+from calculate.lib.utils.colortext.palette import TextState
+from calculate.lib.utils.tools import ignore
+from calculate.lib.utils.git import Git, GitError
+from calculate.lib.utils.portage import (EmergePackage, PackageList,
+                                         EmergeUpdateInfo,
+                                         EmergeRemoveInfo)
+
+Colors = TextState.Colors
+import pexpect
+from calculate.lib.utils.files import (getProgPath, readLinesFile,
+                                       listDirectory,
+                                       writeFile, readFile)
+from calculate.lib.utils.colortext.output import XmlOutput
+from calculate.lib.utils.colortext.converter import (ConsoleCodes256Converter,
+                                                     XmlConverter)
+from calculate.lib.cl_log import log
+
+from calculate.lib.cl_lang import setLocalTranslate, getLazyLocalTranslate, _
+
+setLocalTranslate('cl_update3', sys.modules[__name__])
+__ = getLazyLocalTranslate(_)
+
+linux_term_env = {'TERM': 'linux'}
+
+class EmergeError(Exception):
+    """
+    Ошибка при сборке пакетов
+    """
+
+
+class EmergeNeedRootError(EmergeError):
+    pass
+
+
+class CommandExecutor():
+    """
+    Запуск программы для объекта Emerge
+    """
+    logfile = '/var/log/calculate/lastcommand.log'
+
+    def __init__(self, cmd, params, env=None, cwd=None, logfile=None):
+        self.cwd = cwd
+        self.env = env or dict(os.environ)
+        self.env.update({'EINFO_QUIET': 'NO'})
+        self.env.update(linux_term_env)
+        self.cmd = cmd
+        self.params = params
+        self.child = None
+        if logfile:
+            self.logfile = logfile
+
+    def get_command(self):
+        return [self.cmd] + list(self.params)
+
+    #TODO make sure pexpect encoding doesn't mess up anything
+    #if it does, instead put log file as binary maybe?
+    def execute(self):
+        if self.child is None:
+            command_data = self.get_command()
+            self.child = pexpect.spawn(command_data[0], command_data[1:],
+                                       logfile=open(self.logfile, 'w'),
+                                       env=self.env, cwd=self.cwd, timeout=None,
+                                       encoding="UTF-8", codec_errors='ignore')
+        return self.child
+
+    def close(self):
+        if self.child is not None:
+            try:
+                self.child.close()
+            except pexpect.ExceptionPexpect:
+                self.child.close(force=True)
+            self.child = None
+
+    def success(self):
+        if self.child:
+            self.child.read()
+            if self.child.isalive():
+                self.child.wait()
+            return self.child.exitstatus == 0
+        return False
+
+    def failed(self):
+        return not self.success()
+
+    def send(self, s):
+        if self.child:
+            self.child.send(s)
+
+
+class EmergeCommand(CommandExecutor):
+    """
+    Запуск emerge для последующего анализирования
+    """
+    # параметры по умолчанию
+    default_params = ["-av", "--color=y", "--nospinner"]
+    emerge_cmd = getProgPath("/usr/bin/emerge")
+
+    def __init__(self, packages, extra_params=None, env=None, cwd=None,
+                 logfile=None, emerge_default_opts=None, env_update=None,
+                 use=""):
+        extra_params = extra_params or []
+        if env is None:
+            if emerge_default_opts is None:
+                env = {'CLEAN_DELAY': '0'}
+            else:
+                env = {
+                    'CLEAN_DELAY': '0',
+                    'EMERGE_DEFAULT_OPTS': re.sub(
+                        r'(?:^|\s)(--columns)(?=\s|$)', '',
+                        emerge_default_opts)
+                }
+                if use:
+                    env["USE"] = use
+            env.update(os.environ)
+        if env_update is not None:
+            env.update(env_update)
+
+        params = self.default_params + extra_params + packages
+        super().__init__(self.emerge_cmd, params=params,
+                                            env=env, cwd=cwd, logfile=logfile)
+
+
+def Chroot(chroot_path, obj):
+    """
+    Преобразовать команду (экземпляр объекта) в chroot
+    :param obj: экземпляр команды
+    :param chroot_path: путь для chroot
+    :return:
+    """
+    old_get_command = obj.get_command
+
+    def get_command():
+        chrootCmd = '/usr/bin/chroot'
+        bashCmd = '/bin/bash'
+        bash_command = (
+            "env-update &>/dev/null;"
+            "source /etc/profile &>/dev/null;"
+            "{cmd}".format(cmd=" ".join(old_get_command())))
+        return [chrootCmd, chroot_path, bashCmd, "-c", bash_command]
+    obj.get_command = get_command
+    return obj
+
+
+def Linux32(obj):
+    """
+    Преобразовать команду (экземпляр объекта) в вызов под linux32
+    :param obj: экземпляр команды
+    :return:
+    """
+    old_get_command = obj.get_command
+
+    def get_command():
+        return ["/usr/bin/linux32"] + old_get_command()
+    obj.get_command = get_command
+    return obj
+
+
+class InfoBlockInterface():
+    """
+    Интерфейс для информационного блока
+    """
+    action = None
+    token = None
+    result = None
+    text_converter = ConsoleCodes256Converter(XmlOutput())
+
+    def get_block(self, child):
+        pass
+
+    def add_element(self, element):
+        """
+        :type element: InfoBlockInterface
+        """
+        pass
+
+
+class EmergeInformationBlock(InfoBlockInterface):
+    _color_block = "(?:\033\[[^m]+?m)?"
+    _new_line = "(?:\r*\n)"
+    end_token = ["\n"]
+    re_block = None
+    re_match_type = type(re.match("", ""))
+    re_type = type(re.compile(""))
+
+    def __init__(self, parent):
+        """
+        :type parent: InfoBlockInterface
+        """
+        self.result = None
+        self.text_converter = parent.text_converter
+        self.parent = parent
+        self.parent.add_element(self)
+        self.children = []
+
+    def add_element(self, element):
+        """
+        :type element: InfoBlockInterface
+        """
+        self.children.append(element)
+
+    def __str__(self):
+        if type(self.result) == self.re_match_type:
+            return self.result.group()
+        else:
+            return self.result or ""
+
+    def __nonzero__(self):
+        return bool(self.result)
+
+    def __len__(self):
+        if self.result is None:
+            return 0
+        else:
+            return len(self.result)
+
+    def __contains__(self, item):
+        if self.result is None:
+            return False
+        else:
+            return item in str(self)
+
+    def _get_text(self, result):
+        """
+        Получить результат из регулярки и преобразовать его через self.converter
+        """
+        if result:
+            return self.text_converter.transform(result.rstrip())
+        return ""
+
+    def get_block(self, child):
+        try:
+            token = child.match
+            if type(self.end_token) == self.re_type:
+                child.expect(self.end_token)
+                match = child.match.group()
+            else:
+                child.expect_exact(self.end_token)
+                match = child.match
+            self.get_data(self.re_block.search(
+                token + child.before + match))
+        except pexpect.EOF:
+            child.buffer = "".join(
+                [x for x in (child.before, child.after, child.buffer)
+                 if type(x) == str])
+
+    def get_data(self, match):
+        self.result = self._get_text(match.group(1))
+
+
+class InstallPackagesBlock(EmergeInformationBlock):
+    """
+    Блок emerge содержащий список пакетов для установки
+    """
+    list = PackageList([])
+    remove_list = PackageList([])
+    block_packages = False
+    _new_line = EmergeInformationBlock._new_line
+    _color_block = EmergeInformationBlock._color_block
+    token = "\n["
+    end_token = ["\r\n\r", "\n\n"]
+
+    re_block = re.compile(r"((?:^\[.*?{nl})+)".format(nl=_new_line),
+                          re.MULTILINE)
+    re_blocks = re.compile(r"\[{c}blocks{c} {c}b".format(c=_color_block))
+
+    def get_data(self, match):
+        super().get_data(match)
+        list_block = XmlConverter().transform(self.result).split('\n')
+        self.list = PackageList(map(EmergeUpdateInfo, list_block))
+        self.remove_list = PackageList(map(EmergeRemoveInfo, list_block))
+        self.block_packages = any(self.re_blocks.search(x) for x in list_block)
+
+
+class UninstallPackagesBlock(EmergeInformationBlock):
+    """
+    Блок emerge содержащий список удаляемых пакетов
+    """
+    list = PackageList([])
+    verbose_result = ""
+    _new_line = EmergeInformationBlock._new_line
+    _color_block = EmergeInformationBlock._color_block
+    token = ["Calculating removal order",
+             "These are the packages that would be unmerged"]
+    end_token = re.compile("All selected packages:.*\n")
+    re_block = re.compile(
+        r"(?:{token}).*?{nl}(.*){nl}All selected packages: (.*?){nl}".
+        format(token="|".join(token),
+               nl=_new_line, c=_color_block), re.DOTALL)
+
+    def get_data(self, match):
+        re_clean = re.compile(
+            "^.*?({token}).*?{c}{nl}".format(token="|".join(self.token),
+                                             nl=self._new_line,
+                                             c=self._color_block), re.DOTALL)
+        verbose_result = re_clean.sub("", match.group(1))
+        self.verbose_result = self._get_text(verbose_result)
+        self.result = self._get_text(match.group(2))
+        list_block = XmlConverter().transform(self.result).split()
+        self.list = PackageList(map(EmergePackage, list_block))
+
+
+class GroupEmergeInformationBlock(EmergeInformationBlock):
+    """
+    Группа блоков
+    """
+    def get_block(self, child):
+        self.children_get_block(child)
+        self.result = True
+
+    def children_get_block(self, child):
+        for block in self.children:
+            block.get_block(child)
+
+    def children_action(self, child):
+        for block in (x for x in self.children if x.result and x.action):
+            if block.action(child) is False:
+                return False
+
+    def action(self, child):
+        self.children_action(child)
+        return False
+
+
+class FinishEmergeGroup(GroupEmergeInformationBlock):
+    """
+    Блок завершения команды
+    """
+    token = pexpect.EOF
+    # регуляреное выражение, определяющее содержит ли блок
+    # сообщения об ошибках
+    re_failed = re.compile(
+        r"Fetch instructions for \S+:|"
+        r"The following.*are necessary to proceed|"
+        r"!!! Multiple package .* slot have been pulled|"
+        r"no ebuilds to satisfy|"
+        r"Dependencies could not be completely resolved due to",
+        re.MULTILINE)
+
+    def get_block(self, child):
+        if child.isalive():
+            child.wait()
+        if child.exitstatus != 0 or self.re_failed.search(child.before):
+            self.children_get_block(child)
+        else:
+            self.result = True
+
+
+class PrepareErrorBlock(EmergeInformationBlock):
+    """
+    Блок информации с ошибками при получении списка устанавливаемых пакетов
+    """
+    token = None
+
+    re_drop = re.compile("news items need reading|"
+                         "Use eselect news|"
+                         "Calculating dependencies|"
+                         "to read news items|"
+                         "Local copy of remote index is up-to-date|"
+                         "These are the packages that would be merged|"
+                         "Process finished with exit code")
+    re_multi_empty_line = re.compile("(?:<br/>){3,}", re.DOTALL)
+    re_strip_br = re.compile("^(?:<br/>)+|(?:<br/>)+$", re.DOTALL)
+
+    def remove_needless_data(self, data):
+        return "\n".join([x for x in data.split('\n')
+                          if not self.re_drop.search(x)])
+
+    def strip_br(self, data):
+        return self.re_strip_br.sub(
+            "",
+            self.re_multi_empty_line.sub("<br/><br/>", data))
+
+    def get_block(self, child):
+        self.result = self.strip_br(
+            self._get_text(self.remove_needless_data(child.before)))
+
+    def action(self, child):
+        raise EmergeError(_("Emerge failed"))
+
+
+class DownloadSizeBlock(EmergeInformationBlock):
+    """
+    Размер скачиваемых обновлений
+    """
+    token = "Size of downloads:"
+
+    re_block = re.compile(r"Size of downloads:\s(\S+\s\S+)")
+
+    def __str__(self):
+        if self.result:
+            return self.result
+        else:
+            return "0 kB"
+
+class SkippedPackagesBlock(EmergeInformationBlock):
+    """
+    Размер скачиваемых обновлений
+    """
+    token = "The following update has been skipped"
+    end_token = ["For more information, see the MASKED"]
+
+    re_block = re.compile(
+        r"(The following update has.*?)(?=For more information)", re.S)
+
+    def __str__(self):
+        if self.result:
+            return self.result
+        else:
+            return ""
+
+class QuestionGroup(GroupEmergeInformationBlock):
+    """
+    Группа блоков разбора вопросов от emerge
+    """
+    token = "Would you like"
+    end_token = ["]", "\n"]
+    _color_block = EmergeInformationBlock._color_block
+    re_block = re.compile(
+        "(Would you.*)\[{c}Yes{c}/{c}No{c}".format(c=_color_block))
+
+    def get_block(self, child):
+        try:
+            before = child.before
+            token = child.match
+            if type(self.end_token) == self.re_type:
+                child.expect(self.end_token)
+                match = child.match.group()
+            else:
+                child.expect_exact(self.end_token)
+                match = child.match
+            data = token + child.before + match
+            child.before = before
+            for block in self.children:
+                child.match = re.search(block.token, data)
+                block.get_block(child)
+                if block.result:
+                    break
+        except pexpect.EOF:
+            child.buffer = "".join(
+                [x for x in (child.before, child.after, child.buffer)
+                 if type(x) == str])
+
+class QuestionChangeConfigBlock(GroupEmergeInformationBlock):
+    """
+    Вопрос об изменении конфигурационных файлов
+    """
+    token = "Would you like to add these changes to your config files"
+
+    def get_block(self, child):
+        if child.match:
+            self.result = self.token
+            self.children_get_block(child)
+
+    def action(self, child):
+        if self.result:
+            child.send("no\n")
+            if child.isalive():
+                child.wait()
+            self.children_action(child)
+
+
+class QuestionBlock(EmergeInformationBlock):
+    """
+    Блок вопроса
+    """
+    default_answer = "yes"
+    token = "Would you"
+
+    def get_block(self, child):
+        if child.match:
+            self.result = self.token
+
+    def action(self, child):
+        if self.result:
+            child.send("%s\n" % self.default_answer)
+            return False
+
+
+class NeedRootBlock(EmergeInformationBlock):
+    """
+    Пользователь не явеляется root
+    """
+    token = "This action requires superuser access"
+
+    def get_data(self, child):
+        self.result = True
+
+    def action(self, child):
+        raise EmergeNeedRootError(_("This action requires superuser access"))
+
+
+class NotifierInformationBlock(EmergeInformationBlock):
+    """
+    Информационный блок поддерживающий observing
+    """
+    def __init__(self, parent):
+        super().__init__(parent)
+        self.observers = []
+
+    def get_data(self, match):
+        self.result = match
+
+    def add_observer(self, f):
+        self.observers.append(f)
+
+    def clear_observers(self):
+        self.observers = []
+
+    def remove_observer(self, f):
+        if f in self.observers:
+            self.observers.remove(f)
+
+    def notify(self, observer, groups):
+        observer(groups)
+
+    def action(self, child):
+        if self.result and self.observers:
+            groups = self.result.groups()
+            for observer in self.observers:
+                self.notify(observer, groups)
+
+
+class EmergingPackage(NotifierInformationBlock):
+    """
+    Запуск устанавливаемого пакета
+
+    ObserverFunc: (package, num=number, max_num=number, binary=binary)
+    """
+    _color_block = EmergeInformationBlock._color_block
+    token = ">>> Emerging "
+    re_block = re.compile(
+        "Emerging (binary )?\({c}(\d+){c} "
+        "of {c}(\d+){c}\) {c}([^\s\033]+){c}".format(c=_color_block))
+
+    def notify(self, observer, groups):
+        observer(EmergePackage(groups[3]), num=groups[1], max_num=groups[2],
+                 binary=bool(groups[0]))
+
+
+class UnemergingPackage(NotifierInformationBlock):
+    """
+    Запуск устанавливаемого пакета
+
+    ObserverFunc: (package, num=number, max_num=number)
+    """
+    _color_block = EmergeInformationBlock._color_block
+    token = ">>> Unmerging"
+    re_block = re.compile(
+        r"Unmerging (?:\({c}(\d+){c} "
+        r"of {c}(\d+){c}\) )?(\S+)\.\.\.".format(c=_color_block))
+
+    def notify(self, observer, groups):
+        observer(EmergePackage(groups[2]), num=groups[0], max_num=groups[1])
+
+
+class FetchingTarball(NotifierInformationBlock):
+    """
+    Происходит скачивание архивов
+    """
+    token = "Saving to:"
+    re_block = re.compile("Saving to:\s*[‘'](\S+)?['’]")
+
+    def notify(self, observer, groups):
+        observer(groups[0])
+
+
+class InstallingPackage(NotifierInformationBlock):
+    """
+    Запуск устанавливаемого пакета
+
+    ObserverFunc: (package, binary=binary)
+    """
+    _color_block = EmergeInformationBlock._color_block
+    binary = None
+
+    token = ">>> Installing "
+    re_block = re.compile(
+        "Installing \({c}(\d+){c} "
+        "of {c}(\d+){c}\) {c}([^\s\033]+){c}".format(c=_color_block))
+
+    def notify(self, observer, groups):
+        strpkg = str(EmergePackage(groups[2]))
+        binary = bool(self.binary and strpkg in self.binary)
+        observer(EmergePackage(groups[2]), binary=binary)
+
+    def mark_binary(self, package):
+        if self.binary is None:
+            self.binary = []
+        self.binary.append(str(package))
+
+
+class EmergeingErrorBlock(EmergeInformationBlock):
+    """
+    Блок содержит информацию об ошибке во время сборки пакета
+    """
+    token = ["* ERROR: ", " * \033[39;49;00mERROR: "]
+    end_token = "Working directory:"
+    re_block = re.compile("ERROR: (\S*) failed \([^)]+\).*?"
+                          "The complete build log is located at '([^']+)",
+                          re.DOTALL)
+    package = ""
+
+    def get_data(self, match):
+        self.result = self._get_text(match.group(2).rstrip())
+        self.package = match.group(1)
+
+    @property
+    def log(self):
+        return self.text_converter.transform(readFile(self.result))
+
+    def action(self, child):
+        raise EmergeError(_("Failed to emerge %s") % self.package)
+
+
+class RevdepPercentBlock(NotifierInformationBlock):
+    """
+    Блок определния статуса revdep-rebuild
+    """
+    token = "Collecting system binaries"
+    end_token = [re.compile("Assigning files to packages|"
+                            "All prepared. Starting rebuild")]
+    re_block = re.compile("\[\s(\d+)%\s\]")
+    action = None
+
+    def notify(self, observer, groups):
+        percent = int(groups[0])
+        observer(percent)
+
+    def get_block(self, child):
+        expect_result = [self.re_block]+self.end_token
+        try:
+            while True:
+                index = child.expect(expect_result)
+                if index == 0:
+                    for observer in self.observers:
+                        self.notify(observer, child.match.groups())
+                else:
+                    self.result = child.match
+                    break
+        except pexpect.EOF:
+            self.result = ""
+
+class EmergeParser(InfoBlockInterface):
+    """
+    Парсер вывода emerge
+    """
+
+    def __init__(self, command, run=False):
+        self.command = command
+        self.elements = {}
+
+        self.install_packages = InstallPackagesBlock(self)
+        self.uninstall_packages = UninstallPackagesBlock(self)
+        self.question_group = QuestionGroup(self)
+        self.change_config_question = QuestionChangeConfigBlock(
+            self.question_group)
+        self.question = QuestionBlock(self.question_group)
+        self.finish_block = FinishEmergeGroup(self)
+        self.need_root = NeedRootBlock(self)
+        self.prepare_error = PrepareErrorBlock(self.finish_block)
+        self.change_config_question.add_element(self.prepare_error)
+        self.download_size = DownloadSizeBlock(self)
+        self.skipped_packages = SkippedPackagesBlock(self)
+        self.emerging_error = EmergeingErrorBlock(self)
+
+        self.installing = InstallingPackage(self)
+        self.uninstalling = UnemergingPackage(self)
+        self.emerging = EmergingPackage(self)
+        self.fetching = FetchingTarball(self)
+
+        self.emerging.add_observer(self.mark_binary)
+        self.emerging.add_observer(self.skip_fetching)
+        if run:
+            self.run()
+
+    def mark_binary(self, package, binary=False, **kw):
+        if binary:
+            self.installing.mark_binary(package)
+
+    def skip_fetching(self, *argv, **kw):
+        self.fetching.action = lambda child: None
+
+    def add_element(self, element):
+        """
+        :type element: InfoBlockInterface
+        """
+        if element.token:
+            if type(element.token) == list:
+                for token in element.token:
+                    self.elements[token] = element
+            else:
+                self.elements[element.token] = element
+
+    def run(self):
+        """
+        Запустить команду
+        """
+        child = self.command.execute()
+
+        while True:
+            index = child.expect_exact(self.elements.keys())
+            element = list(self.elements.values())[index]
+            element.get_block(child)
+            if element.action:
+                if element.action(child) is False:
+                    break
+
+    def close(self):
+        self.command.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc_info):
+        self.close()
+
+
+class MtimeCheckvalue():
+    def __init__(self, *fname):
+        self.fname = fname
+
+    def value_func(self, fn):
+        return str(int(os.stat(fn).st_mtime))
+
+    def get_check_values(self, file_list):
+        for fn in file_list:
+            if path.exists(fn) and not path.isdir(fn):
+                yield fn, self.value_func(fn)
+            else:
+                for k, v in self.get_check_values(
+                        listDirectory(fn, fullPath=True)):
+                    yield k, v
+
+    def checkvalues(self):
+        return self.get_check_values(self.fname)
+
+
+class Md5Checkvalue(MtimeCheckvalue):
+    def value_func(self, fn):
+        return hashlib.md5(readFile(fn, binary=True)).hexdigest()
+
+
+class GitCheckvalue():
+    def __init__(self, git, rpath):
+        self.rpath = rpath
+        self.git = git
+
+    def checkvalues(self):
+        with ignore(GitError):
+            if self.git.is_git(self.rpath):
+                yield self.rpath, self.git.getCurrentCommit(self.rpath)
+
+
+class EmergeCache():
+    """
+    Кэш пакетов
+    """
+    cache_file = '/var/lib/calculate/calculate-update/world.cache'
+    # список файлов проверяемый по mtime на изменения
+    check_list = [MtimeCheckvalue('/etc/make.conf',
+                                  '/etc/portage',
+                                  '/etc/make.profile'),
+                  Md5Checkvalue('/var/lib/portage/world',
+                                '/var/lib/portage/world_sets')]
+    logger = log("emerge-cache",
+                 filename="/var/log/calculate/emerge-cache.log",
+                 formatter="%(asctime)s - %(levelname)s - %(message)s")
+
+    def __init__(self):
+        self.files_control_values = {}
+        self.pkg_list = PackageList([])
+
+    def set_cache(self, package_list):
+        """
+        Установить в кэш список пакетов
+        """
+        with writeFile(self.cache_file) as f:
+            for fn, val in self.get_control_values().items():
+                f.write("{fn}={val}\n".format(fn=fn, val=val))
+            f.write('\n')
+            for pkg in package_list:
+                f.write("%s\n" % str(pkg))
+        self.logger.info("Setting cache (%d packages)" % len(package_list))
+
+    def drop_cache(self, reason=None):
+        if path.exists(self.cache_file):
+            with ignore(OSError):
+                os.unlink(self.cache_file)
+            self.logger.info("Droping cache. Reason: %s" % reason)
+        else:
+            self.logger.info("Droping empty cache. Reason: %s" % reason)
+
+    def get_cached_package_list(self):
+        self.read_cache()
+        if not path.exists(self.cache_file):
+            self.logger.info("Requesting empty cache")
+        if self.check_actuality():
+            return self.pkg_list
+        return None
+
+    def check_actuality(self):
+        """
+        Кэш считается актуальным если ни один из файлов не менялся
+        """
+        if self.get_control_values() == self.files_control_values:
+            self.logger.info(
+                "Getting actuality cache (%d packages)" % len(self.pkg_list))
+            return True
+        else:
+            reason = "Unknown"
+            for k, v in self.get_control_values().items():
+                if k in self.files_control_values:
+                    if v != self.files_control_values[k]:
+                        reason = "%s was modified" % k
+                else:
+                    reason = "Checksum of file %s is not exist" % k
+            self.logger.info("Failed to get cache. Reason: %s" % reason)
+            return False
+
+    def read_cache(self):
+        self.files_control_values = {}
+        cache_file_lines = readLinesFile(self.cache_file)
+        for line in cache_file_lines:
+            if "=" not in line:
+                break
+            k, v = line.split('=')
+            self.files_control_values[k] = v.strip()
+        self.pkg_list = PackageList(cache_file_lines)
+
+    def get_control_values(self):
+        def generate():
+            for obj in self.check_list:
+                for check_value in obj.checkvalues():
+                    yield check_value
+
+        return dict(generate())

pym/update/profile.py

@@ -0,0 +1,281 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2014-2016 Mir Calculate. 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.
+
+import sys
+import os
+from os import path
+import shutil
+from calculate.lib.utils.files import (listDirectory, readFile, readLinesFile,
+                                       makeDirectory, removeDir)
+from calculate.lib.utils.git import Git
+from .update import UpdateError
+
+from calculate.lib.cl_lang import setLocalTranslate, _
+setLocalTranslate('cl_update3', sys.modules[__name__])
+
+DEFAULT_BRANCH = Git.Reference.Master
+
+class RepositoryStorageInterface():
+    def __iter__(self):
+        raise StopIteration
+
+    def get_profiles(self, url, branch=DEFAULT_BRANCH):
+        return []
+
+    def get_repository(self, url, branch=DEFAULT_BRANCH):
+        return None
+
+class RepositoryStorage(RepositoryStorageInterface):
+    directory = '/tmp'
+
+    def __init__(self, git, directory):
+        self.directory = directory
+        self.git = git
+        makeDirectory(directory)
+
+    def __iter__(self):
+        for dn in listDirectory(self.directory, onlyDir=True, fullPath=True):
+            if self.git.is_git(dn):
+                yield ProfileRepository(self.git, path.basename(dn), self)
+
+    def get_profiles(self, url, branch=DEFAULT_BRANCH):
+        return []
+
+    def get_repository(self, url, branch=DEFAULT_BRANCH):
+        return None
+
+
+class ProfileStorage(RepositoryStorage):
+    def get_profiles(self, url, branch=DEFAULT_BRANCH):
+        rep = self.get_repository(url, branch)
+        if rep:
+            return rep.get_profiles()
+        return None
+
+    def get_repository(self, url, branch=DEFAULT_BRANCH):
+        return None
+
+
+class LocalStorage(ProfileStorage):
+    """
+    Локальное хранилище репозиториев, при запросе по урлу смотрит, доступные
+    репозитории если находит подходящий - возвращает его профили
+    """
+    def get_repository(self, url, branch=DEFAULT_BRANCH):
+        for rep in self:
+            if rep.is_like(url, branch):
+                return rep
+
+class CacheStorage(ProfileStorage):
+    """
+    Хранилище репозиториев, при запросе по урлу смотрит, доступные
+    репозитории если находит подходящий - возвращает его профили,
+    если не находит - скачивает и возвращает профили
+    """
+    def get_repository(self, url, branch=DEFAULT_BRANCH):
+        for rep in self:
+            if rep.is_like(url, branch):
+                return rep
+        else:
+            return ProfileRepository.clone(self.git, url, self,
+                                           branch or DEFAULT_BRANCH)
+
+class RepositoryStorageSet(RepositoryStorageInterface):
+    """
+    Набор хранилищ репозиториев
+    """
+    def __init__(self, *storages):
+        self.storages = storages
+
+    def get_profiles(self, url, branch=DEFAULT_BRANCH):
+        """
+        Получить профили из указанного репозитория
+        """
+        for storage in self.storages:
+            profiles = storage.get_profiles(url, branch)
+            if profiles is not None:
+                return profiles
+        return None
+
+    def __iter__(self):
+        for storage in self.storages:
+            for rep in storage:
+                yield rep
+
+    def get_repository(self, url, branch=DEFAULT_BRANCH):
+        """
+        Получить репозиторий по параметрам
+        """
+        for rep in self:
+            if rep.is_like(url, branch):
+                return rep
+        for storage in self.storages:
+            rep = storage.get_repository(url, branch)
+            if rep:
+                return rep
+        return None
+
+    def is_local(self, url, branch=DEFAULT_BRANCH):
+        """
+        Проверить является ли репозиторий с указанными параметрами
+        локальным
+        """
+        rep = self.get_repository(url, branch)
+        if rep and isinstance(rep.storage, LocalStorage):
+            return True
+        return False
+
+    def __repr__(self):
+        return "Repository set"
+
+class Profile():
+    """
+    Профиль репозитория
+    """
+    available_arch = ["amd64", "x86"]
+
+    def __init__(self, repository, profile, arch):
+        self.repository = repository
+        self.profile = profile
+        self.arch = arch
+        self._path = None
+
+    @property
+    def path(self):
+        if self._path:
+            return self._path
+        return path.join(self.repository.directory,"profiles", self.profile)
+
+    @path.setter
+    def path(self, value):
+        self._path = value
+        return value
+
+    @classmethod
+    def from_string(cls, repository, s):
+        parts = [x for x in s.split() if x]
+        if len(parts) == 3 and parts[0] in cls.available_arch:
+            return Profile(repository, parts[1], parts[0])
+        return None
+
+    def __repr__(self):
+        return "<Profile (%s) %s:%s from %s>" % (self.arch,
+                                                 self.repository.repo_name,
+                                                 self.profile,
+                                                 self.repository.directory)
+
+
+class ProfileRepository():
+    """
+    Репозиторий либо скачивается, либо берется из кэша
+    """
+    def __init__(self, git, name, storage):
+        self._storage = storage
+        self.name = name
+        self.git = git
+
+    @property
+    def storage(self):
+        return self._storage
+
+    @storage.setter
+    def storage(self, storage):
+        if storage.directory != self._storage.directory:
+            newpath = path.join(storage.directory, self.name)
+            if self.directory == newpath:
+                return
+            try:
+                if path.exists(newpath):
+                    removeDir(newpath)
+                shutil.move(self.directory, newpath)
+                self._storage = storage
+            except OSError as e:
+                raise UpdateError(_("Failed to move the profile: %s") %
+                                  str(e))
+
+    @classmethod
+    def clone(cls, git, url, storage, branch=DEFAULT_BRANCH):
+        name = path.basename(url)
+        if name.endswith(".git"):
+            name = name[:-4]
+        rpath = path.join(storage.directory, name)
+        if path.exists(rpath):
+            removeDir(rpath)
+        if git.is_private_url(url):
+            try:
+                makeDirectory(rpath)
+                os.chmod(rpath, 0o700)
+            except OSError:
+                pass
+        git.cloneRepository(url, rpath, branch)
+        pr = cls(git, name, storage)
+        repo_name = pr.repo_name
+        if name != repo_name:
+            rpath_new = path.join(storage.directory, repo_name)
+            if path.exists(rpath_new):
+                removeDir(rpath_new)
+            shutil.move(rpath, rpath_new)
+            pr = cls(git, repo_name, storage)
+        return pr
+
+    @property
+    def repo_name(self):
+        return readFile(path.join(self.directory,
+                                  "profiles/repo_name")).strip()
+
+    def is_like(self, url, branch=DEFAULT_BRANCH):
+        if self.url == url and (branch is None or self.branch == branch):
+            return True
+        return False
+
+    @property
+    def directory(self):
+        """
+        Получить локальную директорию на данные репозитория
+        """
+        return path.join(self.storage.directory, self.name)
+
+    @property
+    def url(self):
+        return self.git.get_url(self.directory, "origin")
+
+    @property
+    def branch(self):
+        return self.git.getBranch(self.directory)
+
+    def sync(self):
+        """
+        Синхронизировать репозиторий
+        """
+        if not self.git.pullRepository(self.directory, quiet_error=True):
+            self.git.resetRepository(self.directory, to_origin=True)
+            self.git.pullRepository(self.directory, quiet_error=True)
+
+    def get_profiles(self):
+        """
+        Получить список профилей репозитория
+        """
+        profiles_desc = path.join(self.directory, "profiles/profiles.desc")
+        return list(filter(None, (Profile.from_string(self, line)
+                             for line in readLinesFile(profiles_desc))))
+    @staticmethod
+    def get_local_profiles(directory):
+        profiles_desc = path.join(directory, "profiles/profiles.desc")
+        return list(filter(None, (Profile.from_string(Profile, line)
+                                  for line in readLinesFile(profiles_desc))))
+
+    def __repr__(self):
+        return "<ProfileRepository %s url=%s>" % (self.directory, self.url)

pym/update/update_info.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2012-2016 Mir Calculate. 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.
+
+import os
+from os import path
+from calculate.core.datavars import DataVarsCore
+from calculate.core.server.gen_pid import search_worked_process
+from calculate.lib.cl_template import SystemIni
+from calculate.lib.utils.content import getCfgFiles
+from calculate.lib.utils.files import getRunCommands, readFile, writeFile
+
+
+class UpdateInfo():
+    """
+    Информационный объект о процессе обновления
+    """
+    update_file = "/var/lib/calculate/calculate-update/updates.available"
+
+    def __init__(self, dv=None):
+        if dv is None:
+            self.dv = DataVarsCore()
+            self.dv.importCore()
+        else:
+            self.dv = dv
+
+    def need_update(self):
+        return self.update_ready()
+
+    @classmethod
+    def update_ready(cls):
+        """
+        Проверить есть ли обновления по ini.env
+        """
+        return path.exists(cls.update_file)
+
+    @classmethod
+    def set_update_ready(cls, value):
+        """
+        Установить статус обновления
+        """
+        try:
+            if value:
+                writeFile(cls.update_file).close()
+            else:
+                os.unlink(cls.update_file)
+        except OSError:
+            pass
+
+    def check_for_dispatch(self):
+        """
+        Есть ли в системе не примененные файлы для dispatch-conf
+        """
+        return bool(getCfgFiles(self.dv.Get('cl_config_protect'),
+                                prefix=self.dv.Get('cl_chroot_path')))
+
+    def is_console_gui_run(self):
+        """
+        Проверить есть ли уже запущенная копия console-gui
+        """
+        return any([x for x in getRunCommands() if "cl-console-gui" in x])
+
+    def update_already_run(self):
+        """
+        В системе уже есть работающий процесс обновления
+        """
+        return search_worked_process("update", self.dv)
+
+    @property
+    def outdated_kernel(self):
+        flag_path = self.dv.Get('update.cl_update_outdated_kernel_path')
+        if path.exists(flag_path):
+            try:
+                flag_kernel = readFile(flag_path).strip()
+                current_kernel = self.dv.Get('update.cl_update_kernel_version')
+                if flag_kernel != current_kernel:
+                    return True
+            except ValueError:
+                pass
+        return False
+
+    @outdated_kernel.setter
+    def outdated_kernel(self, value):
+        flag_path = self.dv.Get('update.cl_update_outdated_kernel_path')
+        try:
+            if value:
+                with writeFile(flag_path) as f:
+                    f.write(self.dv.Get('update.cl_update_kernel_version'))
+            else:
+                if path.exists(flag_path):
+                    os.unlink(flag_path)
+        except IOError:
+            pass

pym/update/update_tasks.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2015-2016 Mir Calculate. 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.
+
+class EmergeMark:
+    Schedule = "schedule"
+    Premerge = "check updates"
+    PythonUpdater = "update python modules"
+    PerlCleaner = "update perl modules"
+    KernelModules = "update kernel modules"
+    Depclean = "depclean"
+    XorgModules = "update xorg modules"
+    PreservedLibs = "update preserved libs"
+    RevdepRebuild = "revdep rebuild"
+    Prelink = "prelink"
+    Automagic = "check for auto depends"
+    SaveTag = "save latest calculate update tag"

pym/update/utils/cl_setup_update.py

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2010-2016 Mir Calculate. 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.
+
+import sys
+from calculate.core.server.func import Action
+from calculate.lib.cl_lang import setLocalTranslate, getLazyLocalTranslate
+from calculate.lib.utils.files import FilesError
+from ..update import UpdateError
+from calculate.lib.utils.git import GitError
+
+_ = lambda x: x
+setLocalTranslate('cl_update3', sys.modules[__name__])
+__ = getLazyLocalTranslate(_)
+
+
+class ClSetupUpdateAction(Action):
+    """
+    Действие для настройки параметров автопроверки обновлений
+    """
+    # ошибки, которые отображаются без подробностей
+    native_error = (FilesError, UpdateError, GitError)
+
+    successMessage = __("Updates autocheck configured!")
+    failedMessage = __("Failed to configure the updates autocheck procedure!")
+    interruptMessage = __("Configuration manually interrupted")
+
+    # список задач для действия
+    tasks = [
+        {'name': 'set_variables',
+         'method': 'Update.setAutocheckParams(cl_update_autocheck_set,'
+                   'cl_update_autocheck_interval,'
+                   'cl_update_other_set,'
+                   'cl_update_cleanpkg_set)'}
+    ]

pym/update/utils/cl_update.py

@@ -0,0 +1,557 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2010-2016 Mir Calculate. 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.
+
+import sys
+from calculate.core.server.func import Action, Tasks, AllTasks
+from calculate.lib.cl_lang import setLocalTranslate, getLazyLocalTranslate
+from calculate.lib.cl_template import TemplatesError
+from calculate.lib.utils.binhosts import BinhostError
+from calculate.lib.utils.files import FilesError, readFile
+from ..update import UpdateError
+from ..emerge_parser import EmergeError
+from calculate.lib.utils.git import GitError
+from calculate.lib.utils.portage import (EmergeLog, isPkgInstalled,
+                                         EmergeLogNamedTask, PackageList)
+from ..update_tasks import EmergeMark
+
+_ = lambda x: x
+setLocalTranslate('cl_update3', sys.modules[__name__])
+__ = getLazyLocalTranslate(_)
+
+
+def get_synchronization_tasks(object_name):
+    Object = lambda s: "%s.%s"%(object_name, s)
+    return [
+        
+        {'name': 'reps_synchronization',
+         'group': __("Repositories synchronization"),
+         'tasks': [
+             # создать объект проверки PGP
+             {'name': 'prepare_gpg',
+              'method': Object("prepare_gpg()"),
+             },
+             # создать объект хранилище серверов обновлений
+             {'name': 'create_binhost_data',
+              'method': Object('create_binhost_data()')
+             },
+             {
+              'name': 'perform_migration_system_pre_check',
+              'method': Object('perform_migration_system_pre_check()'),
+              'condition': lambda Get, GetBool: (Get('cl_update_ignore_level')  == 'off')
+             },
+             # проверить валиден ли текущий хост
+             {'name': 'check_current_binhost',
+              'message': __("Checking current binhost"),
+              'essential': False,
+              'method': Object('check_current_binhost(update.cl_update_binhost)'),
+              'condition': lambda GetBool, Get: (
+                    not GetBool('update.cl_update_binhost_recheck_set') and
+                    not Get('update.cl_update_binhost_choice') and
+                    Get('update.cl_update_binhost_choice') != 'auto' and
+                    Get('update.cl_update_sync_rep') and
+                    Get('update.cl_update_binhost') and 
+                    Get('update.cl_update_use_migration_host') == 'off')
+             },
+             {'name': 'drop_packeges_cache',
+              'method': 'Update.drop_packages_cache()',
+              'depend': AllTasks.failed_all("check_current_binhost")
+              },
+             {'name': 'not_use_search:failed_base_binhost',
+              'error': __("Failed to use base binhost"),
+              'method': Object("delete_binhost()"),
+              'depend': AllTasks.failed_all("check_current_binhost")
+             },
+             {'name': 'check_chosen_binhost',
+              'message': _("Checking chosen binhost"),
+              'method': Object('check_chosen_binhost(update.cl_update_binhost_choice)'),
+              'essential': False,
+              'condition': lambda GetBool, Get: (
+                  not GetBool('update.cl_update_binhost_recheck_set') and
+                  Get('update.cl_update_binhost_choice') and
+                  Get('update.cl_update_binhost_choice') != 'auto'),
+              'depend': AllTasks.hasnot("check_current_binhost")},
+             {'name': 'failed_check_chosen_binhost',
+              'method': Object('check_if_migration()'),
+              'depend': AllTasks.failed_all("check_chosen_binhost")},
+             {'name': 'group_find_binhost',
+              'group': '',
+              'while': (~AllTasks.has_any("detect_best_binhost") &
+                         ((AllTasks.failed_all("update_packages_cache")
+                           & ~AllTasks.has_any("not_use_search")) |
+                          ~AllTasks.has_any("sync_reps"))) & Tasks.success(),
+              'condition': lambda GetBool, Get: (GetBool('update.cl_update_usetag_set') and
+                                                 Get('update.cl_update_sync_rep')),
+              'tasks': [
+                 # найти лучший сервер обновлений
+                 {'name': 'detect_best_binhost',
+                  'method': Object(f'detect_best_binhost({object_name.lower()}.cl_update_ignore_level)'),
+                  'essential': False,
+                  'depend': (Tasks.success() & ~AllTasks.has_any("not_use_search") &
+                             (AllTasks.failed_one_of("check_current_binhost") |
+                              AllTasks.failed_one_of("check_chosen_binhost") |
+                              (AllTasks.hasnot("check_current_binhost") &
+                               AllTasks.hasnot("check_chosen_binhost")) |
+                             AllTasks.success_all("sync_reps"))),
+                  'condition': lambda Get: Get('update.cl_update_use_migration_host') == 'off',
+                 },
+                 {'name': 'interrupt_on_no_leveled_binhost',
+                  'method': Object("interrupt_on_no_leveled_binhost()"),
+                  'essential': True,
+                  'depend': (Tasks.success() & ~AllTasks.has_any("not_use_search") &
+                             (~AllTasks.success_one_of("check_current_binhost")) &
+                             AllTasks.failed_all("detect_best_binhost")),
+                  'condition': lambda Get: Get('update.cl_update_use_migration_host') == 'off'
+                 },
+                 {'name': 'set_migration_binhost',
+                  'method': Object('set_migration_host()'),
+                  'depend': (Tasks.success() & ~AllTasks.has_any("not_use_search")|
+                             AllTasks.success_all("sync_reps")),
+                  'condition': lambda Get: Get('update.cl_update_use_migration_host') == 'on'
+                 },
+                 # запасная синхронизация, в ходе которой ветки обновляются до
+                 # master
+                #  {'name': 'sync_reps_fallback',
+                #   'foreach': 'update.cl_update_sync_rep',
+                #   'message':
+                #       __("Fallback syncing the {eachvar:capitalize} repository"),
+                #   'method': Object('syncRepositories(eachvar,True)'),
+                #   'depend': Tasks.success() & AllTasks.failed_one_of("detect_best_binhost"),
+                #  },
+                #  # обновление переменных информации из binhost
+                #  {'name': 'sync_reps_fallback:update_binhost_list',
+                #   'method': Object('update_binhost_list()'),
+                #   'depend': Tasks.success() & AllTasks.failed_one_of("detect_best_binhost"),
+                #  },
+                #  # найти лучший сервер обновлений 
+                #  {'name': 'sync_reps_fallback:detect_best_binhost',
+                #   'method': Object('detect_best_binhost()'),
+                #   'depend': Tasks.success() & AllTasks.failed_one_of("detect_best_binhost"),
+                #  },
+                 {'name': 'sync_reps',
+                  'foreach': 'update.cl_update_sync_rep',
+                  'message': __("Checking {eachvar:capitalize} updates"),
+                  'method': Object('syncRepositories(eachvar)'),
+                  'condition': lambda Get: Get('update.cl_update_sync_rep'),
+                  'depend': Tasks.success() & ~AllTasks.success_all("update_packages_cache")
+                 },
+                 {'name': 'sync_reps:update_local_info_binhost',
+                  'method': Object('update_local_info_binhost()'),
+                  'condition': lambda Get: Get("update.cl_update_binhost_choice") == 'auto'
+                                           or not Get("update.cl_update_binhost_choice")
+                                           or Get("update.cl_update_binhost_recheck_set"),
+                  'depend': AllTasks.hasnot('check_chosen_binhost')
+                 },
+                 {'name': 'sync_reps:update_binhost_list',
+                  'essential': False,
+                  'method': Object('update_binhost_list()'),
+                  'condition': lambda GetBool: GetBool('update.cl_update_outdate_set')
+                 },
+                 {'name': 'sync_reps:update_packages_cache',
+                  'message': __("Update packages index"),
+                  'method': Object('download_packages(update.cl_update_portage_binhost,'
+                            'update.cl_update_package_cache, update.cl_update_package_cache_sign,'
+                            'update.cl_update_gpg)'),
+                  'condition': lambda Get, GetBool: (
+                      Get('update.cl_update_package_cache') and (
+                          Get('update.cl_update_outdate_set') == 'on' or
+                          Get('update.cl_update_package_cache_set') == 'on'))
+                 },
+                ],
+             },
+             {'name': 'no_server',
+              'error': __("Failed to find the binary updates server"),
+              'method': Object("delete_binhost()"),
+              # method: который должен удалить текущую информацию о сервере обновлений
+              'depend': (~Tasks.has_any("failed_base_binhost") & (Tasks.failed() |
+                         Tasks.success() & AllTasks.failed_one_of("update_packages_cache"))),
+              'condition': lambda GetBool, Get: (GetBool('update.cl_update_usetag_set') and
+                                                 Get('update.cl_update_sync_rep')),
+             },
+             {'name': 'sync_reps',
+              'foreach': 'update.cl_update_sync_rep',
+              'message': __("Checking {eachvar:capitalize} updates"),
+              'method': Object('syncRepositories(eachvar)'),
+              'condition': lambda Get, GetBool: (Get('update.cl_update_sync_rep') and
+                                                 not GetBool('update.cl_update_usetag_set')),
+             },
+             {'name': 'update_rep_list',
+              'message': __("Repository cache update"),
+              'method': Object('update_rep_list()'),
+              'condition': lambda Get: (isPkgInstalled(
+                  "app-eselect/eselect-repository", prefix=Get('cl_chroot_path')) and
+                  Get('cl_chroot_path') != "/"),
+              'essential': False,
+             },
+             {'name': 'sync_other_reps',
+              'foreach': 'update.cl_update_other_rep_name',
+              'message': __("Syncing the {eachvar:capitalize} repository"),
+              'method': Object('syncOtherRepository(eachvar)'),
+              'condition': lambda GetBool: (GetBool('update.cl_update_other_set') or
+                                            not GetBool('update.cl_update_other_git_exists'))
+             },
+             {'name': 'trim_reps',
+              'foreach': 'update.cl_update_sync_rep',
+              'message': __("Cleaning the history of the "
+                            "{eachvar:capitalize} repository"),
+              'method': Object('trimRepositories(eachvar)'),
+              'condition': lambda Get: (Get('update.cl_update_sync_rep') and
+                                        Get('update.cl_update_onedepth_set') == 'on')
+              },
+             {'name': 'sync_reps:regen_cache',
+              'foreach': 'update.cl_update_sync_overlay_rep',
+              'essential': False,
+              'method': Object('regenCache(eachvar)'),
+              'condition': (
+                  lambda Get: (Get('update.cl_update_outdate_set') == 'on' and
+                               Get('update.cl_update_egencache_force') != 'skip' or
+                               Get('update.cl_update_egencache_force') == 'force'))
+             },
+             {'name': 'sync_other_reps:regen_other_cache',
+              'foreach': 'update.cl_update_other_rep_name',
+              'method': Object('regenCache(eachvar)'),
+              'essential': False,
+             },
+             {'name': 'eix_update',
+              'message': __("Updating the eix cache for "
+                            "{update.cl_update_eix_repositories}"),
+              'method': Object('eixUpdate(cl_repository_name)'),
+              'condition': (
+                  lambda Get: (Get('update.cl_update_outdate_set') == 'on' and
+                               Get('update.cl_update_eixupdate_force') != 'skip' or
+                               Get('update.cl_update_eixupdate_force') == 'force'))
+             },
+             {'name': 'update_setup_cache',
+              'message': __("Updating the cache of configurable packages"),
+              'method': Object('updateSetupCache()'),
+              'essential': False,
+              'condition': lambda Get: Get('update.cl_update_outdate_set') == 'on'
+             },
+             {'name': 'sync_reps:cleanpkg',
+              'message': __("Removing obsolete distfiles and binary packages"),
+              'method': Object('cleanpkg()'),
+              'condition': (
+                  lambda Get: Get('update.cl_update_cleanpkg_set') == 'on' and
+                              Get('update.cl_update_outdate_set') == 'on'),
+              'essential': False
+             },
+             # сообщение удачного завершения при обновлении репозиториев
+             {'name': 'success_syncrep',
+              'message': __("Synchronization finished"),
+              'depend': (Tasks.success() & Tasks.has_any("sync_reps",
+                                                         "sync_other_reps",
+                                                         "emerge_metadata",
+                                                         "eix_update")),
+              }
+         ]
+         },
+    ]
+
+class UpdateConditions():
+    @staticmethod
+    def was_installed(pkg, task_name):
+        def func():
+            task = EmergeLog(EmergeLogNamedTask(task_name))
+            return bool(PackageList(task.list)[pkg])
+        return func
+
+    @staticmethod
+    def need_depclean(pkg, task_name):
+        def func(Get):
+            task = EmergeLog(EmergeLogNamedTask(task_name))
+            return (bool(PackageList(task.list)[pkg])
+                    or Get('cl_update_force_depclean_set') == 'on'
+                    or Get('cl_update_outdated_kernel_set') == 'on'
+                    or Get('cl_update_world_hash_set') == 'on')
+        return func
+
+    @staticmethod
+    def force_preserved(Get):
+        pfile = "/var/lib/portage/preserved_libs_registry"
+        content = readFile(pfile).strip()
+        if not content or content[1:-1].strip() == '':
+            return False
+        else:
+            return True
+    
+    @staticmethod
+    def check_world_updated_after_tag_save():
+        def func():
+            task = EmergeLog(EmergeLogNamedTask(EmergeMark.SaveTag))
+            return task.did_update_world_happen()
+        return func
+
+class ClUpdateAction(Action):
+    """
+    Действие обновление конфигурационных файлов
+    """
+    # ошибки, которые отображаются без подробностей
+    native_error = (FilesError, UpdateError,
+                    TemplatesError, BinhostError,
+                    GitError, EmergeError)
+
+    successMessage = None
+    failedMessage = None
+    interruptMessage = __("Update manually interrupted")
+
+    emerge_tasks = [
+        {'name': 'save_bdeps_val',
+         'method': 'Update.save_with_bdeps()',
+         'essential': False
+         },
+        {'name': 'update_fastlogin_domain',
+         'method': "Update.update_fastlogin_domain_path()"
+        },
+        {'name': 'drop_portage_hash_on_sync',
+         'method': 'Update.drop_portage_state_hash()',
+         'condition': lambda Get: Get('cl_update_outdate_set') == 'on'
+         },
+        {'name': 'premerge_group',
+         'group': __("Checking for updates"),
+         'tasks': [
+            {'name': 'premerge',
+             'message': __("Calculating dependencies"),
+             'method': 'Update.premerge("-uDN","@world")',
+             'condition': lambda Get: (
+                 Get('cl_update_sync_only_set') == 'off' and
+                 Get('cl_update_pretend_set') == 'on') and \
+                   (Get('cl_update_world') != "update" or
+                    Get('cl_update_outdate_set') == 'on' or
+                    Get('cl_update_settings_changes_set') == 'on' or
+                    Get('cl_update_binhost_recheck_set') == 'on' or
+                    Get('cl_update_force_fix_set') == 'on' or
+                    Get('update.cl_update_package_cache_set') == 'on')
+            }],
+         },
+        {'name': 'update',
+         'condition': lambda Get:Get('cl_update_pretend_set') == 'off' and \
+                           (Get('cl_update_world') != "update" or
+                            Get('cl_update_outdate_set') == 'on' or
+                            Get('cl_update_settings_changes_set') == 'on' or
+                            Get('cl_update_binhost_recheck_set') == 'on' or
+                            Get('cl_update_force_fix_set') == 'on' or
+                            Get('cl_update_available_set') == 'on' or
+                            Get('update.cl_update_package_cache_set') == 'on')
+             },
+        {'name': 'update_other',
+         'condition': lambda Get: ( Get('cl_update_pretend_set') == 'off' and
+                                    Get('cl_update_sync_only_set') == 'off')
+         },
+        {'name': 'update:update_world',
+         'group': __("Updating packages"),
+         'tasks': [
+             {'name': 'update_world',
+              'message': __("Calculating dependencies"),
+              'method': 'Update.emerge_ask(cl_update_pretend_set,'
+                        '"-uDN","@world")',
+              }
+         ],
+         'condition': lambda Get: (Get('cl_update_sync_only_set') == 'off' and
+                                   (Get('update.cl_update_outdate_set') == 'on' or
+                                    Get('cl_update_settings_changes_set') == 'on'))
+         },
+        {'name': 'update_other:update_perl',
+         'group': __("Updating Perl modules"),
+         'tasks': [
+             {'name': 'update_other:perl_cleaner',
+              'message': __('Find & rebuild packages and Perl header files '
+                            'broken due to a perl upgrade'),
+              'method': 'Update.emergelike("perl-cleaner", "all")',
+              'condition': UpdateConditions.was_installed(
+                  'dev-lang/perl$', EmergeMark.PerlCleaner),
+              'decoration': 'Update.update_task("%s")' % EmergeMark.PerlCleaner
+             },
+         ]
+        },
+        {'name': 'update_other:depclean',
+         'group': __("Cleaning the system from needless packages"),
+         'tasks': [
+             {'name': 'update_other:update_depclean',
+              'message': __("Calculating dependencies"),
+              'method': 'Update.depclean()',
+              'condition': UpdateConditions.need_depclean(
+                  '.*', EmergeMark.Depclean),
+              'decoration': 'Update.update_task("%s")' % EmergeMark.Depclean
+             },
+         ]
+        },
+        {'name': 'update_other:update_modules',
+         'group': __("Rebuilding dependent modules"),
+         'tasks': [
+             {'name': 'update_other:module_rebuild',
+              'message': __('Updating Kernel modules'),
+              'method': 'Update.emerge("","@module-rebuild")',
+              'condition': UpdateConditions.was_installed(
+                  'sys-kernel/(calculate-sources|gentoo-kernel|vanilla-kernel)', EmergeMark.KernelModules),
+              'decoration': 'Update.update_task("%s")' %
+                            EmergeMark.KernelModules
+             },
+             {'name': 'update_other:x11_module_rebuild',
+              'message': __('Updating X.Org server modules'),
+              'method': 'Update.emerge("","@x11-module-rebuild")',
+              'condition': UpdateConditions.was_installed(
+                  'x11-base/xorg-server', EmergeMark.XorgModules),
+              'decoration': 'Update.update_task("%s")' %
+                            EmergeMark.XorgModules
+             },
+             {'name': 'update_other:preserved_rebuild',
+              'message': __('Updating preserved libraries'),
+              'method': 'Update.emerge("","@preserved-rebuild")',
+              'condition': lambda Get: (UpdateConditions.was_installed(
+                  '.*', EmergeMark.PreservedLibs)() or
+                                        UpdateConditions.force_preserved(Get)),
+              'decoration': 'Update.update_task("%s")' %
+                            EmergeMark.PreservedLibs
+              },
+             {'name': 'update_other:revdev_rebuild',
+              'message': __('Checking reverse dependencies'),
+              'method': 'Update.revdep_rebuild("revdep-rebuild")',
+              'condition': lambda Get: (Get(
+                  'cl_update_revdep_rebuild_set') == 'on' and
+                  UpdateConditions.was_installed(
+                      '.*', EmergeMark.RevdepRebuild)()),
+              'decoration': 'Update.update_task("%s")' %
+                            EmergeMark.RevdepRebuild
+             },
+             {'name': 'update_other:dispatch_conf_end',
+              'message': __("Updating configuration files"),
+              'method': 'Update.dispatchConf()',
+              'condition': lambda Get: (Get('cl_dispatch_conf') != 'skip' and
+                                        Get('cl_update_pretend_set') == 'off')
+             },
+         ]
+        },
+        {'name': 'set_upto_date_cache',
+         'method': 'Update.setUpToDateCache()',
+         'condition': lambda Get: Get('cl_update_sync_only_set') == 'off' and \
+                                  Get('cl_update_pretend_set') == 'off'
+        }
+    ]
+
+    # список задач для действия
+    tasks = [
+        {'name': 'check_schedule',
+         'method': 'Update.checkSchedule(cl_update_autocheck_interval,'
+                   'cl_update_autocheck_set)',
+         'condition': lambda Get: (
+             Get('cl_update_autocheck_schedule_set') == 'on'),
+        },
+        {'name': 'check_run',
+         'method': 'Update.checkRun(cl_update_wait_another_set)'
+        },
+        {'name': 'check_if_world_was_updated',
+         'method': 'Update.update_set_current_saved_tag()',
+         'essential': False,
+         'condition': lambda Get: (Get('cl_update_sync_only_set') == 'off' and \
+                Get('cl_update_pretend_set') == 'off' and \
+                UpdateConditions.check_world_updated_after_tag_save()())
+        },
+        ] + get_synchronization_tasks("Update") + [
+        {'name': 'system_configuration',
+         'group': __("System configuration"),
+         'tasks': [
+            {'name': 'binhost_changed',
+             'method': 'Update.message_binhost_changed()'
+             },
+            {'name': 'revision',
+             'message': __("Fixing the settings"),
+             'method': 'Update.applyTemplates(install.cl_source,'
+                       'cl_template_clt_set,True,None,False)',
+             'condition': lambda Get, GetBool: (Get('cl_templates_locate') and
+                                       (Get('cl_update_world') != "update" or
+                                        GetBool('cl_update_outdate_set') or
+                                        GetBool('cl_update_binhost_recheck_set') or
+                                        GetBool('cl_update_force_fix_set') or
+                                        GetBool('update.cl_update_package_cache_set')))
+             },
+            {'name': 'dispatch_conf',
+             'message': __("Updating configuration files"),
+             'method': 'Update.dispatchConf()',
+             'condition': lambda Get, GetBool: (Get('cl_dispatch_conf') != 'skip' and
+                                       Get('cl_update_pretend_set') == 'off' and
+                                       (GetBool('cl_update_outdate_set') or
+                                        GetBool('cl_update_binhost_recheck_set') or
+                                        GetBool('cl_update_force_fix_set') or
+                                        GetBool('update.cl_update_package_cache_set')))
+             },
+         ]
+         }
+    ] + emerge_tasks + [
+        {'name': 'failed',
+         'error': __("Update failed"),
+         'depend': (Tasks.failed() & Tasks.hasnot("interrupt") &
+                    (Tasks.hasnot("check_schedule") |
+                     Tasks.success_all("check_schedule")))},
+        {'name': 'failed',
+         'depend': Tasks.failed_all("check_schedule")
+         },
+        # сообщение удачного завершения при обновлении ревизии
+
+        {'name': 'drop_portage_hash',
+         'method': 'Update.drop_portage_state_hash()',
+         'depend': Tasks.failed()
+         },
+        {'name': 'drop_world_hash',
+         'method': 'Update.drop_world_state_hash()',
+         'depend': Tasks.failed()},
+         {'name': 'update:set_current_level',
+         'method': 'Update.update_increment_current_level()',
+         'depend': (Tasks.success() & Tasks.hasnot("interrupt") &
+             Tasks.success_all("update") & Tasks.hasnot("check_schedule")), 
+         'condition': lambda Get: Get('cl_update_sync_only_set') == 'off' and
+                Get('cl_update_pretend_set') == 'off' and
+                Get('update.cl_update_use_migration_host') == 'on'
+         },
+         {'name': 'update_world:set_latest_tag',
+         'method': 'Update.update_set_current_saved_tag()',
+         'depend': (Tasks.success() & Tasks.hasnot("interrupt") &
+             Tasks.success_all("update") & Tasks.hasnot("check_schedule")), 
+         'condition': lambda Get: Get('cl_update_sync_only_set') == 'off' and
+                Get('cl_update_pretend_set') == 'off',
+         'decoration': 'Update.update_task("%s")' % EmergeMark.SaveTag
+         },
+        {'name': 'update:save_portage_hash',
+         'method': 'Update.save_portage_state_hash()',
+         'condition': lambda Get: Get('cl_update_sync_only_set') == 'off'
+         },
+        {'name': 'update:save_world_hash',
+         'method': 'Update.save_world_state_hash()',
+         'condition': lambda Get: Get('cl_update_sync_only_set') == 'off'
+         },
+        {'name': 'clear_migration_host',
+         'method': 'Update.delete_binhost()',
+         'depend': (Tasks.hasnot("check_schedule")), 
+         'condition': lambda Get: Get('update.cl_update_use_migration_host') == 'on'
+         },
+        # сообщение удачного завершения при обновлении ревизии
+        {'name': 'success_rev',
+         'message': __("System update finished!"),
+         'condition': lambda Get: (Get('cl_update_rev_set') == 'on' and
+                                    Get('cl_update_pretend_set') == 'off' and
+                                    Get('cl_update_sync_only_set') == 'off')
+         },
+        # сообщение удачного завершения при обновлении ревизии
+        {'name': 'success_sync_only',
+         'message': __("System sync finished!"),
+         'condition': lambda Get: (Get('cl_update_rev_set') == 'on' and
+                                    Get('cl_update_pretend_set') == 'off' and
+                                    Get('cl_update_sync_only_set') == 'on')
+         },
+        # сообщение удачного завершения при пересоздании world
+        {'name': 'success_world',
+         'message': __("World rebuild finished!"),
+         'condition': lambda Get: Get('cl_rebuild_world_set') == 'on'
+         },
+    ]

pym/update/utils/cl_update_profile.py

@@ -0,0 +1,108 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2010-2016 Mir Calculate. 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.
+
+import sys
+from calculate.core.server.func import Action, Tasks
+from calculate.lib.cl_lang import setLocalTranslate, getLazyLocalTranslate
+from calculate.lib.cl_template import TemplatesError
+from calculate.lib.utils.binhosts import BinhostError
+from calculate.lib.utils.files import FilesError
+from ..update import UpdateError
+from calculate.lib.utils.git import GitError
+
+_ = lambda x: x
+setLocalTranslate('cl_update3', sys.modules[__name__])
+__ = getLazyLocalTranslate(_)
+
+
+class ClUpdateProfileAction(Action):
+    """
+    Действие обновление конфигурационных файлов
+    """
+    # ошибки, которые отображаются без подробностей
+    native_error = (FilesError,
+                    TemplatesError, BinhostError,
+                    UpdateError, GitError)
+
+    successMessage = __("The profile was successfully updated")
+    failedMessage = __("Failed to update the profile")
+    interruptMessage = __("Profile update manually interrupted")
+
+    # список задач для действия
+    tasks = [
+        {'name': 'migrate_repository',
+         'method': 'Update.migrateCacheRepository('
+                   'cl_update_profile_url,cl_update_profile_branch,'
+                   'cl_update_profile_storage)',
+         'condition': lambda Get: Get('cl_update_profile_url')},
+        {'name': 'profile_from_url',
+         'group': __('setting up from url'),
+         'tasks': [
+            {'message': __("Repository transfer"),
+             'condition': lambda Get: not (
+                 Get('cl_update_profile_storage').is_local(
+                     Get('cl_update_profile_url'),
+                     Get('cl_update_profile_branch'))) and Get('cl_update_profile_check_sync_allowed'),
+             },
+            {'name': 'reconfigure_vars1',
+             'method': 'Update.invalidateVariables("cl_update_profile_storage")',
+             },
+            {'name': 'check_datavars',
+             'error': _("Profile not found in master"),
+             'condition': lambda Get: not Get('update.cl_update_profile_datavars'),
+             },
+            {'name': 'drop_binhosts',
+             'method': 'Update.drop_binhosts(update.cl_update_profile_datavars)',
+             },
+            {'name': 'reconfigure_vars',
+             'method': 'Update.reconfigureProfileVars(cl_update_profile_datavars,'
+                              'cl_chroot_path)',
+             },
+         ],
+         'depend': Tasks.has('migrate_repository')
+         },
+        {'name': 'reps_synchronization',
+         'group': __("Setting up the profile"),
+         'tasks': [
+             {'name': 'set_profile',
+              'message': __("Switching to profile {cl_update_profile_system}"),
+              'method': 'Update.setProfile(cl_update_profile_system)'
+              },
+             {'name': 'rename_custom',
+              'method': 'Update.rename_custom_files()',
+             },
+             {'name': 'revision',
+              'message': __("Fixing the settings"),
+              'method': 'Update.applyProfileTemplates(cl_template_clt_set,'
+                        'True,False,"update_profile")',
+              'condition': lambda Get: Get('cl_templates_locate')
+              },
+             {'name': 'reconfigure',
+              'message': __("The system is being configured"),
+              'method': 'Update.applyProfileTemplates(cl_template_clt_set,'
+                        'True,False,"merge")',
+              'condition': lambda Get: (
+                  Get('cl_update_templates_locate') and
+                  Get('cl_update_skip_setup_set') == 'off')
+              },
+             {'name': 'dispatch_conf',
+              'message': __("Updating configuration files"),
+              'method': 'Update.dispatchConf()',
+              'condition': lambda Get: Get('cl_dispatch_conf') != 'skip'
+              },
+         ]
+         }
+        ]

pym/update/variables/__init__.py

@@ -1,6 +1,6 @@
 #-*- coding: utf-8 -*-
 
-# Copyright 2008-2013 Calculate Ltd. http://www.calculate-linux.org
+# Copyright 2008-2016 Mir Calculate. 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.
@@ -14,7 +14,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-import action
-import update
+from . import action
+from . import update
 
 section = "update"

pym/update/variables/action.py

@@ -1,6 +1,6 @@
-#-*- coding: utf-8 -*-
+# -*- coding: utf-8 -*-
 
-# Copyright 2008-2013 Calculate Ltd. http://www.calculate-linux.org
+# Copyright 2013-2016 Mir Calculate. 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.
@@ -14,10 +14,8 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-import os
 import sys
-from os import path
-from calculate.lib.datavars import Variable,VariableError,ReadonlyVariable
+from calculate.lib.datavars import ReadonlyVariable
 
 from calculate.lib.cl_lang import setLocalTranslate
 setLocalTranslate('cl_update3',sys.modules[__name__])
@@ -29,6 +27,7 @@ class VariableAcUpdateSync(ReadonlyVariable):
     """
     def get(self):
         action = self.Get("cl_action")
-        if action in ("sync",):
+        if action in ("sync", 'update_profile') and \
+            not self.Get('cl_merge_pkg'):
             return "on"
         return "off"

pym/update/wsdl_update.py

@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2010-2016 Mir Calculate. 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.
+
+import sys
+
+from calculate.lib.datavars import VariableError,DataVarsError
+
+from calculate.core.server.func import WsdlBase
+from calculate.install.install import InstallError
+from .update import Update, UpdateError
+from calculate.lib.utils.git import GitError
+from .utils.cl_update import ClUpdateAction
+from .utils.cl_update_profile import ClUpdateProfileAction
+from .utils.cl_setup_update import ClSetupUpdateAction
+from calculate.lib.cl_lang import setLocalTranslate, getLazyLocalTranslate, _
+
+setLocalTranslate('cl_update3', sys.modules[__name__])
+__ = getLazyLocalTranslate(_)
+
+
+
+class Wsdl(WsdlBase):
+    methods = [
+        #
+        # Обновить текущую конфигурацию системы (world,ревизия)
+        #
+        {
+            # идентификатор метода
+            'method_name': "update",
+            # категория метода
+            'category': __('Update '),
+            # заголовок метода
+            'title': __("Update the System"),
+            # иконка для графической консоли
+            'image': 'calculate-update',
+            # метод присутствует в графической консоли
+            'gui': True,
+            # консольная команда
+            'command': 'cl-update',
+            # права для запуска метода
+            'rights': ['update'],
+            # объект содержащий модули для действия
+            'logic': {'Update': Update},
+            # описание действия
+            'action': ClUpdateAction,
+            # объект переменных
+            'datavars': "update",
+            'native_error': (VariableError, DataVarsError,
+                             InstallError, UpdateError, GitError),
+            # значения по умолчанию для переменных этого метода
+            'setvars': {'cl_action!': 'sync'},
+            # описание груп (список лямбда функций)
+            'groups': [
+                lambda group: group(_("Update the system"),
+                                    normal=(
+                                        'cl_update_binhost_stable_opt_set',
+                                        'cl_update_binhost_recheck_set',
+                                        'cl_update_with_bdeps_opt_set',
+                                        'cl_update_binhost_choice',
+                                        'cl_update_rep_hosting_choice',
+                                    ),
+                                    expert=(
+                                        'cl_update_other_set',
+                                        'cl_update_sync_only_set',
+                                        'cl_update_pretend_set',
+                                        'cl_update_sync_rep',
+                                        'cl_update_emergelist_set',
+                                        'cl_update_check_rep_set',
+                                        'cl_update_force_fix_set',
+                                        'cl_update_ignore_level',
+                                        'cl_update_force_level',
+                                        'cl_update_world',
+                                        'cl_update_gpg_force',
+                                        'cl_update_egencache_force',
+                                        'cl_update_eixupdate_force',
+                                        'cl_update_revdep_rebuild_set',
+                                        'cl_update_wait_another_set',
+                                        'cl_update_autocheck_schedule_set',
+                                        'cl_update_onedepth_set',
+                                        'cl_update_cleanpkg_set',
+                                        'cl_update_branch_data',
+                                        'cl_templates_locate',
+                                        'cl_verbose_set', 'cl_dispatch_conf'),
+                                    next_label=_("Run"))]},
+        #
+        # Сменить профиль
+        #
+        {
+            # идентификатор метода
+            'method_name': "update_profile",
+            # категория метода
+            'category': __('Update '),
+            # заголовок метода
+            'title': __("Change the Profile"),
+            # иконка для графической консоли
+            'image': 'calculate-update-profile,'
+                     'notification-display-brightness-full,gtk-dialog-info,'
+                     'help-hint',
+            # метод присутствует в графической консоли
+            'gui': True,
+            # консольная команда
+            'command': 'cl-update-profile',
+            # права для запуска метода
+            'rights': ['change_profile'],
+            # объект содержащий модули для действия
+            'logic': {'Update': Update},
+            # описание действия
+            'action': ClUpdateProfileAction,
+            # объект переменных
+            'datavars': "update",
+            'native_error': (VariableError, DataVarsError,
+                             InstallError, UpdateError, GitError),
+            # значения по умолчанию для переменных этого метода
+            'setvars': {'cl_action!': 'update_profile', 'cl_update_world_default': "rebuild"},
+            # описание груп (список лямбда функций)
+            'groups': [
+                lambda group: group(_("Repository"),
+                                    brief=('cl_update_profile_repo_name',),
+                                    hide=('cl_update_profile_url',
+                                          'cl_update_profile_sync_set'),
+                                    normal=('cl_update_profile_url',),
+                                    expert=('cl_update_profile_sync_set',)),
+                lambda group: group(_("Profile"),
+                                    normal=('cl_update_profile_system',
+                                            'cl_update_world'),
+                                    expert=('cl_update_skip_setup_set',
+                                            'cl_update_templates_locate',
+                                            'cl_verbose_set',
+                                            'cl_dispatch_conf'),
+                                    hide=('cl_update_templates_locate',
+                                            'cl_verbose_set',
+                                            'cl_dispatch_conf'),
+                                    brief=('cl_update_profile_system',
+                                           'cl_update_profile_linux_fullname',
+                                           'cl_update_profile_depend_data')
+                                    )],
+            'brief': {'next': __("Run"),
+                      'name': __("Set the profile")}},
+        #
+        # Настроить автопроверку обновлений
+        #
+        {
+            # идентификатор метода
+            'method_name': "setup_update",
+            # категория метода
+            'category': __('Configuration'),
+            # заголовок метода
+            'title': __("Update Check"),
+            # иконка для графической консоли
+            'image': 'calculate-setup-update,software-properties,preferences-desktop',
+            # метод присутствует в графической консоли
+            'gui': True,
+            # консольная команда
+            'command': 'cl-setup-update',
+            # права для запуска метода
+            'rights': ['setup_update'],
+            # объект содержащий модули для действия
+            'logic': {'Update': Update},
+            # описание действия
+            'action': ClSetupUpdateAction,
+            # объект переменных
+            'datavars': "update",
+            'native_error': (VariableError, DataVarsError,
+                             InstallError, UpdateError, GitError),
+            # значения по умолчанию для переменных этого метода
+            'setvars': {'cl_action!': 'merge'},
+            # описание груп (список лямбда функций)
+            'groups': [
+                lambda group: group(_("Updates autocheck settings"),
+                                    normal=('cl_update_autocheck_set',
+                                            'cl_update_autocheck_interval',
+                                            'cl_update_cleanpkg_set',
+                                            'cl_update_other_set'),
+                                    next_label=_("Save"))]},
+    ]

setup.py

@@ -3,7 +3,7 @@
 
 # setup.py --- Setup script for calculate-update
 
-# Copyright 2012 Calculate Ltd. http://www.calculate-linux.org
+# Copyright 2012-2016 Mir Calculate. 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.
@@ -18,17 +18,72 @@
 #  limitations under the License.
 
 __app__ = "calculate-update"
-__version__ = "3.1.7"
+__version__ = "3.7.3" #TODO bump version
 
+import os
+from glob import glob
 from distutils.core import setup
+from distutils.command import install_data as module_install_data
+from distutils.util import change_root, convert_path
+
+class install_data(module_install_data.install_data):
+    def run (self):
+        self.mkpath(self.install_dir)
+        for f in self.data_files:
+            if isinstance(f, str):
+                # it's a simple file, so copy it
+                f = convert_path(f)
+                if self.warn_dir:
+                    self.warn("setup script did not provide a directory for "
+                              "'%s' -- installing right in '%s'" %
+                              (f, self.install_dir))
+                (out, _) = self.copy_file(f, self.install_dir)
+                self.outfiles.append(out)
+            else:
+                # it's a tuple with path to install to and a list of files
+                dir = convert_path(f[0])
+                if not os.path.isabs(dir):
+                    dir = os.path.join(self.install_dir, dir)
+                elif self.root:
+                    dir = change_root(self.root, dir)
+                self.mkpath(dir)
+
+                if f[1] == []:
+                    # If there are no files listed, the user must be
+                    # trying to create an empty directory, so add the
+                    # directory to the list of output files.
+                    self.outfiles.append(dir)
+                else:
+                    # Copy files, adding them to the list of output files.
+                    for data in f[1]:
+                        # is's a simple filename without chmod
+                        if isinstance(data,str):
+                            chmod = None
+                        else:
+                            data, chmod = data
+                        data = convert_path(data)
+                        (out, _) = self.copy_file(data, dir)
+                        if chmod and os.stat(out).st_mode != chmod:
+                            os.chmod(out,chmod)
+                        self.outfiles.append(out)
+
+data_files = [('/usr/libexec/calculate', [('data/cl-git-wrapper', 0o755)])]
+
+packages = [
+    "calculate."+str('.'.join(root.split(os.sep)[1:]))
+    for root, dirs, files in os.walk('pym/update')
+    if '__init__.py' in files
+]
 
 setup(
-    name = __app__,
-    version = __version__,
-    description = "Update system utilities",
-    author = "Calculate Ltd.",
-    author_email = "support@calculate.ru",
-    url = "http://calculate-linux.org",
-    license = "http://www.apache.org/licenses/LICENSE-2.0",
-    package_dir = {'calculate.update': "update"},
-    packages = ['calculate.update','calculate.update.utils','calculate.update.variables'])
+    name=__app__,
+    version=__version__,
+    description="Update system utilities",
+    author="Calculate Ltd.",
+    author_email="support@calculate.ru",
+    url="http://calculate-linux.org",
+    license="http://www.apache.org/licenses/LICENSE-2.0",
+    package_dir = {'calculate.update': "pym/update"},
+    packages = packages,
+    data_files=data_files,
+    cmdclass={'install_data': install_data})

update/utils/cl_update.py

@@ -1,53 +0,0 @@
-#-*- coding: utf-8 -*-
-
-# Copyright 2010-2013 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.
-
-import sys
-from calculate.core.server.func import Action
-from calculate.lib.cl_lang import setLocalTranslate,getLazyLocalTranslate
-from calculate.lib.utils.files import FilesError
-from calculate.install.install import (MigrationError, TemplatesError,
-                                  InstallError)
-
-setLocalTranslate('cl_update3',sys.modules[__name__])
-__ = getLazyLocalTranslate(_)
-
-class ClUpdateAction(Action):
-    """
-    Действие обновление конфигурационных файлов
-    """
-    # ошибки, которые отображаются без подробностей
-    native_error = (FilesError,)
-
-    successMessage = None
-    failedMessage = __("Revision update failed")
-    interruptMessage = __("Update manually interrupted")
-
-    # список задач для дейсвия
-    tasks = [
-         {'name':'dispatch',
-          'method':'Install.applyTemplates(install.cl_source,cl_template_clt_set,'\
-                   'True,None)',
-         },
-         # сообщение удачного завершения при обновлении ревизии
-         {'name':'success_rev',
-          'message' : __("Revision update finished!"),
-          'condition':lambda Get:Get('cl_update_rev_set') == 'on'
-         },
-         # сообщение удачного завершения при пересоздании world
-         {'name':'success_world',
-          'message' : __("World rebuild finished!"),
-          'condition':lambda Get:Get('cl_rebuild_world_set') == 'on'
-         }]

update/variables/update.py

@@ -1,72 +0,0 @@
-#-*- coding: utf-8 -*-
-
-# Copyright 2008-2013 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.
-
-import os
-import sys
-from os import path
-from calculate.lib.datavars import Variable,VariableError,ReadonlyVariable
-
-from calculate.lib.cl_lang import setLocalTranslate
-setLocalTranslate('cl_update3',sys.modules[__name__])
-
-class VariableAcUpdateSync(ReadonlyVariable):
-    """
-    Action variable which has value "up" for package install and
-    install this package
-    """
-    def get(self):
-        action = self.Get("cl_action")
-        if action in ("sync",):
-            if self.Get('cl_update_world'):
-                return self.Get('cl_update_world')
-        return ""
-
-class VariableClUpdateWorld(Variable):
-    def get(self):
-        if self.Get('cl_rebuild_world_set') == "on":
-            return "rebuild"
-        else:
-            return ""
-
-class VariableClRebuildWorldSet(Variable):
-    """
-    List of action update world, rebuild world, 
-    """
-    type = "bool"
-    opt = ["--rebuild-world"]
-    untrusted = True
-    value = "off"
-
-    def init(self):
-        self.help = _("Rebuild world")
-        self.label = _("Rebuild world")
-
-class VariableClUpdateRevSet(Variable):
-    """
-    List of action update world, rebuild world, 
-    """
-    type = "bool"
-    opt = ["--update-rev"]
-    untrusted = True
-    value = "off"
-
-    def init(self):
-        self.help = _("revision update")
-        self.label = _("Revision update")
-
-    def check(self,value):
-        if value != "on" and self.Get('cl_rebuild_world_set') != 'on':
-            raise VariableError(_("Select at least one update action"))

update/wsdl_update.py

@@ -1,66 +0,0 @@
-#-*- coding: utf-8 -*-
-
-# Copyright 2010-2013 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.
-
-import  sys, time, os
-
-from calculate.lib.datavars import VariableError,DataVarsError,DataVars
-
-from calculate.core.server.func import WsdlBase
-from calculate.install.install import InstallError,Install
-from utils.cl_update import ClUpdateAction
-from calculate.lib.cl_lang import setLocalTranslate,getLazyLocalTranslate
-setLocalTranslate('cl_update3',sys.modules[__name__])
-__ = getLazyLocalTranslate(_)
-
-
-class Wsdl(WsdlBase):
-    methods = [
-        #
-        # Обновить текущую конфигурацию системы (world,ревизия)
-        #
-        {
-        # идентификатор метода
-        'method_name':"update",
-        # категория метода
-        'category':__('Update'),
-        # заголовок метода 
-        'title':__("Update configuration"),
-        # иконка для графической консоли
-        'image':'software-properties,preferences-desktop',
-        # метод присутствует в графической консоли
-        'gui':True,
-        # консольная команда
-        'command':'cl-update',
-        # права для запуска метода 
-        'rights':['update'],
-        # объект содержащий модули для действия
-        'logic':{'Install':Install},
-        # описание действия
-        'action':ClUpdateAction,
-        # объект переменных
-        'datavars':"update",
-        'native_error':(VariableError,DataVarsError,
-                        InstallError),
-        # значения по умолчанию для переменных этого метода
-        'setvars':{'cl_action!':'sync'},
-        # описание груп (список лямбда функций)
-        'groups':[
-            lambda group:group(_("Update configuration"),
-                normal=('cl_rebuild_world_set','cl_update_rev_set'),
-                expert=('cl_templates_locate',
-                        'cl_verbose_set','cl_dispatch_conf'),
-                next_label=_("Update"))]},
-        ]