calculate-utils-3-lib/pym/calculate/lib/variables/env.py

#-*- 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 itertools import *
from calculate.lib.datavars import (TableVariable,Variable,ReadonlyVariable,
                                   VariableError)
import calculate.lib.cl_template as cl_template
from calculate.lib.utils.files import listDirectory,process,PIPE,pathJoin

from calculate.lib.cl_lang import setLocalTranslate
setLocalTranslate('cl_lib3',sys.modules[__name__])

_envData = [('system', '/etc/calculate/calculate.env'),
            ('local', '/var/calculate/calculate.env'),
            ('remote', '/var/calculate/remote/calculate.env')]

class VariableClEnvData(TableVariable):
    """
    Aliases and path to ini files
    """
    source = ["cl_env_location","cl_env_path"]

class VariableClEnvLocation(ReadonlyVariable):
    """
    Aliases to ini files (from cl_env_data)
    """
    type = 'list'
    value = list(zip(*_envData)[0])

class VariableClEnvPath(Variable):
    """
    Path to ini files (from cl_env_data)
    """
    type = 'list'
    value = list(zip(*_envData)[1])

class VariableClTemplateData(TableVariable):
    """
    Aliases to templates path
    """
    source = ["cl_template_location","cl_template_path"]

class VariableClTemplateLocation(Variable):
    """
    Name to templates
    """
    type = 'list'
    value = ["overlay","local","remote"]


class VariableClTemplatePath(Variable):
    """
    Path to information file on server
    """
    type = 'list'
    value = ["/var/lib/layman/calculate/profiles/templates",
             "/var/calculate/templates",
             "/var/calculate/remote/templates"]

class VariableClEnvServerPath(ReadonlyVariable):
    """
    Path to server environment
    """
    value = '/var/calculate/remote/server.env'

class VariableClTemplateCltPath(ReadonlyVariable):
    """
    Paths to clt-template files
    """
    type = 'list'

    def get(self):
        """
        Clt templates path is /etc and CONFIG_PROTECT
        """
        chroot = self.Get('cl_chroot_path')
        if "CONFIG_PROTECT" in os.environ:
            protectPaths = ["/etc"] + filter(lambda x: x.strip(),
                                      os.environ["CONFIG_PROTECT"].split(" "))
        else:
            protectPaths = ["/etc", "/usr/share/X11/xkb", "var/lib/hsqldb",
                            "/usr/share/config"]
        return filter(path.exists, 
               map(lambda x:pathJoin(chroot,x),
               protectPaths))

class VariableClRootPath(Variable):
    """
    Path to directory relative which perform joining templates to system files
    (sandbox)
    """
    value = '/'

class VariableClRootPathNext(Variable):
    """
    Path to directory relative which perform joining templates to system files
    (sandbox). This set for configure packages specified throug merge=
    """
    def get(self):
        return self.Get('cl_root_path')

class VariableClChrootPath(ReadonlyVariable):
    """
    Path to directory which contain other system
    """
    value = '/'

class VariableClPassStep(Variable):
    """
    Pass for templates join 1,2,3,4,5 and etc
    """

class VariableClPassFile(Variable):
    """
    Template file performed at now
    """

class VariableClMergeSet(ReadonlyVariable):
    """
    Force by package template appling
    """
    type = "bool"
    value = "off"

class VariableClMergePkg(ReadonlyVariable):
    """
    This variable work with template function belong(package_name)
    if the variable is defined then will use only template, which 
    has package_name in belong equal value of this variable or
    hasn't belong function
    (package_name == value of cl_belong_pkg)
    """
    type = "list"
    def get(self):
        return self.Get('cl_belong_pkg')

class VariableClMergePkgNew(ReadonlyVariable):
    """
    New variable value for cl_merge_pkg
    """
    type = "list"

class VariableClMergePkgPass(ReadonlyVariable):
    """
    Performed packages
    """
    type = "list"

class VariableClBelongPkg(ReadonlyVariable):
    """
    Depricated by cl_merge_pkg
    """
    type = "list"

class VariableClAction(ReadonlyVariable):
    """
    Program action
    Example: install, uninstall, merge, domain, undomain, system, desktop
    """

class VariableClPassState(ReadonlyVariable):
    """
    Program state
    specifies addition to cl_pass_action for needing
    """

class VariableClMerges(Variable):
    """
    Programs have templates setup
    """
    type = 'list'

    def get(self):
        return []

    def set(self,value):
        return []

class VariableClAutoupdateSet(Variable):
    """
    (on or off) autoupdate config from install program
    """
    type = 'bool'

    def get(self):
        if self.Get('cl_dispatch_conf') == 'usenew':
            return "on"
        else:
            return "off"

class VariableClHumanEditSet(Variable):
    """
    Параметр для отметки "ручной правки"
    """
    type = "bool"
    opt = ["--human-edit"]
    value = "off"

    def init(self):
        self.help = _("mark as human modification")
        self.label = _("Mark as human modification")

class VariableClProtectUseSet(ReadonlyVariable):
    """
    Использовать portage интеграцию с конфигурационными файлами
    """
    type = "bool"

    def get(self):
        return "on" if self.Get('cl_human_edit_set') == 'off' else "off"

class VariableClDispatchConf(Variable):
    """

    """
    type = "choice"
    opt = ["--conf"]
    value = "dispatch"
    syntax = "--{choice}-conf"
    metavalue = "METHOD"

    def init(self):
        self.help = "'usenew' - " +_("use the new config files") +\
                    ",\n'skip' - " + _("skip the update of config files") +\
                    ",\n'dispatch' - " + _("manually update config files")
        self.label = _("Method for updating config files")

    def choice(self):
        return [("usenew",_("Use the new config files")),
                ("skip",_("Skip the update of config files")),
                ("dispatch",_("Manually update config files"))]

class VariableClWsdl(Variable):
    """
    Packages with wsdl
    """
    type = "list-choice"

    def choice(self):
        return self.Get('cl_wsdl_available')

class VariableClWsdlAvailable(ReadonlyVariable):
    """
    Packages which has wsdl interfaces
    """
    type = "list"
    
    def get(self):
        sitePackages = map(lambda x:path.join(x,"calculate"),
                       filter(lambda x:x.endswith('site-packages') and \
                                       x.startswith('/usr/lib'),sys.path))
        retList = []
        for module,modDir in chain(*map(lambda x:map(lambda y:(path.basename(y),y),
                             listDirectory(x,True,True)),sitePackages)):
            if path.exists(path.join(modDir,"wsdl_%s.py"%module)):
                if not "calculate-%s"%module in retList:
                    retList.append("calculate-%s"%module)
        return retList

class VariableClConfigProtectMask(ReadonlyVariable):
    """
    Value of CONFIG_PROTECT after source /etc/profile, and /etc append
    """
    type = "list"

    def get(self):
        displayEnv = process('/bin/bash',"-c","source /etc/profile;env",
                             stdout=PIPE)
        for line in displayEnv:
            if line.startswith("CONFIG_PROTECT_MASK="):
                configProtectMask=line.rstrip().partition('=')[2].split()
                break
        else:
            configProtectMask = []
        return configProtectMask

class VariableClConfigProtect(ReadonlyVariable):
    """
    Value of CONFIG_PROTECT after source /etc/profile, and /etc append
    """
    type = "list"

    def get(self):
        displayEnv = process('/bin/bash',"-c","source /etc/profile;env",
                             stdout=PIPE)
        for line in displayEnv:
            if line.startswith("CONFIG_PROTECT="):
                configProtect=line.rstrip().partition('=')[2].split()
                break
        else:
            configProtect = []
        configProtect.append('/etc')
        return configProtect


class VariableClVerboseSet(Variable):
    """
    Verbose output variable
    """
    type = "bool"
    opt = ["-v", "--verbose"]
    value = "off"

    def init(self):
        self.help = _("verbose output")
        self.label = _("Verbose output")

class VariableClEbuildPhase(ReadonlyVariable):
    """
    Current ebuild phase
    """
    def get(self):
        return os.environ.get("EBUILD_PHASE","")

class VariableClEmergeInfo(ReadonlyVariable):
    """
    Emerge --info cache
    """
    type = "list"

    def get(self):
        return filter(lambda x:x.startswith('PORTDIR_OVERLAY=') or \
                               x.startswith('EMERGE') or \
                               x.startswith('PORTDIR='),
               process("/usr/bin/emerge","--ask=n","--info",
                       envdict=os.environ).read().split('\n'))

class VariableClPortdirOverlay(ReadonlyVariable):
    """
    Overlays path
    """
    type = "list"

    def get(self):
        emergeInfo = self.Get('cl_emerge_info')
        for line in filter(lambda x:x.startswith("PORTDIR_OVERLAY="),
                    emergeInfo):
            return filter(None,
                   line.partition("=")[2].strip('\n"\'').split(' '))
        return []

class VariableClEmergeDefaultOpts(ReadonlyVariable):
    """
    EMERGE_DEFAULT_OPTS
    """
    type = "list"

    def get(self):
        emergeInfo = self.Get('cl_emerge_info')
        for line in filter(lambda x:x.startswith("EMERGE_DEFAULT_OPTS="),
                           emergeInfo):
            return filter(None,
                          line.partition("=")[2].strip('\n"\'').split(' '))
        return []

class VariableClTemplatesLocate(Variable):
    """
    Выбранные типы хранилищ шаблонов
    """
    type = "choice-list"
    #value = ['overlay','local','remote','clt']
    element = "selecttable"
    opt = ["-T","--templates"]
    metavalue = "TEMPLATES"
    untrusted = True

    descriptionMap = {'overlay': _('Overlay templates'),
                      'local': _('Local templates'),
                      'distro': _('Distribution templates'),
                      'remote': _('Remote templates'),
                      'clt': _('clt templates')}

    def init(self):
        self.label = _("Templates location")
        self.help = _("select location for templates %s") \
                      %",".join(self.get())

    def get(self):
        vals = \
            self.Get('cl_template_location')[:len(self.Get('cl_template_path'))]
        if self.Get('cl_action') == 'desktop':
            return vals
        else:
            return vals + ['clt']

    def choice(self):
        return map(lambda x:(x,self.descriptionMap.get(x,x)),
               self.get())

class VariableClTemplatePathUse(ReadonlyVariable):
    """
    Пути до шаблонов, используемых в настройке системы или профиля пользователя
    """
    type = 'list'

    def get(self):
        return self.Select('cl_template_path',where='cl_template_location',
                          _in=self.Get('cl_templates_locate'))

class VariableClTemplateCltSet(ReadonlyVariable):
    """
    Использовать clt шаблоны для настройки системы
    """
    def get(self):
        return "on" if "clt" in self.Get('cl_templates_locate') else "off"

class VariableClEnvDebugSet(Variable):
    """
    Переменная для включения отладки
    """
    type = "bool"
    value = "on"

class VariableClMakeProfile(Variable):
    """
    Путь до актуального make.profile
    """
    systemRoot = "/"

    def get_work_link(self, *links):
        for link in links:
            if path.exists(link):
                return link

    def get(self):
        files = ["etc/portage/make.profile", "etc/make.profile"]
        val = self.get_work_link(
            *[path.join(self.systemRoot, x) for x in files])
        if not val:
            raise VariableError(
                _("Failed to detect the system profile.") + " " +
                _("Select the profile with command {cmd}").format(
                    cmd="cl-update-profile"))
        return val