calculate-utils-3-desktop/pym/desktop/variables/desktop.py

# -*- 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 os
import sys
import re
from os import path
import pwd
from calculate.lib.datavars import (Variable, VariableError, ReadonlyVariable,
                                    ReadonlyTableVariable, FieldValue,
                                    VariableInterface)
from calculate.lib.utils.common import getValueFromConfig
from calculate.lib.variables import user
import calculate.lib.utils.device as device
from calculate.lib.utils.files import (readLinesFile, process,
                                       listDirectory, readFile)
from calculate.desktop._cl_keys import getKey
from itertools import *
import glob
from calculate.lib.cl_template import templateFunction
from calculate.lib.cl_ini_parser import iniParser
from calculate.lib.utils.portage import isPkgInstalled
import hashlib

from calculate.lib.cl_lang import setLocalTranslate

_ = lambda x: x
setLocalTranslate('cl_desktop3', sys.modules[__name__])


class VariableUrJidHost(ReadonlyVariable):
    """
    Jabber host for user
    """

    def get(self):
        userJid = self.Get("ur_jid")
        if userJid:
            return userJid.partition('@')[2]
        return ""


class DomainInfoHelper(VariableInterface):
    """
    Вспомогательный класс для определения доменный ли пользователь 
    """

    def getUserDataInFile(self, login, filePasswd):
        return list(filter(lambda x: x[0] == login,
                      map(lambda x: x.strip().split(':'),
                          readLinesFile(filePasswd))))

    def isDomainUser(self, userName):
        if userName:
            try:
                passwdUserData = self.getUserDataInFile(userName, "/etc/passwd")
            except Exception:
                return False
            if passwdUserData:
                passwdUserData = passwdUserData[0]
                try:
                    cacheUserData = self.getUserDataInFile(
                        userName,
                        "/var/lib/calculate/calculate-client/cache/passwd")
                except Exception:
                    return False
                if cacheUserData:
                    cacheUserData = cacheUserData[0]
                    if cacheUserData == passwdUserData:
                        return True
            else:
                return True
        return False


class VariableUrDomainSet(ReadonlyVariable, DomainInfoHelper):
    """
    Flag for determining domain user or local
    """
    type = "bool"

    def getUserDataInFile(self, login, file_passwd):
        return list(filter(lambda x: x[0] == login,
                      map(lambda x: x.strip().split(':'),
                          readLinesFile(file_passwd))))

    def get(self):
        return "on" if self.isDomainUser(self.Get('ur_login')) else "off"


class VariableClDesktopXsession(ReadonlyVariable):
    """
    User current X session
    """
    session_list = ("kde", "gnome", "mate", "xfce", "plasma")

    def get(self):
        envXsessionFile = "/etc/env.d/90xsession"
        xsession = os.environ.get("XSESSION", None)
        desktopSession = os.environ.get("DESKTOP_SESSION", None)
        if self.Get('ur_login') == 'root' or not xsession:
            xsession = getValueFromConfig(envXsessionFile, "XSESSION")
        if xsession:
            if (desktopSession and any(x in desktopSession.lower()
                                       for x in self.session_list)):
                xsession = desktopSession
            xsession = xsession.lower()
            for session in self.session_list:
                if session in xsession:
                    return session
            else:
                return xsession
        return ""


class VariableClDesktopGstData(ReadonlyVariable):
    """
    GStreamer data
    """

    def get(self):
        # try import gst
        copyargv = sys.argv
        sys.argv = []
        olderr = os.dup(sys.stderr.fileno())
        try:
            os.close(sys.stderr.fileno())
            import gst
            import gst.interfaces
        except ImportError:
            gst = None
        finally:
            sys.argv = copyargv
            os.dup2(olderr, sys.stderr.fileno())
        if gst is None:
            return {}

        outdata = {}
        try:
            pipeline = "alsamixer"
            alsamixer = gst.element_factory_make(pipeline)
            res = alsamixer.set_state(gst.STATE_PAUSED)
            if res == gst.STATE_CHANGE_SUCCESS:
                outdata['device_name'] = alsamixer.get_property("device-name")
                outdata['long_name'] = alsamixer.get_factory().get_longname()
                outdata['internal_name'] = list(filter(str.isalnum,
                                                  "%s (%s)" % (
                                                      outdata['device_name'],
                                                      outdata['long_name'])))
                outdata['channels'] = []
                for t in alsamixer.list_tracks():
                    if t.flags & gst.interfaces.MIXER_TRACK_OUTPUT:
                        if t.flags & gst.interfaces.MIXER_TRACK_MASTER or \
                                any(x in t.label
                                    for x in ("Wave", "Front", "LFE", "Center",
                                              "Head", "Side", "Speaker",
                                              "Surround", "PCM")):
                            outdata['channels'].append(t.label)
                            if t.flags & gst.interfaces.MIXER_TRACK_MASTER:
                                outdata['master_channel'] = t.label
        except Exception:
            pass
        return outdata


class VariableClDesktopGstCard(ReadonlyVariable):
    """
    Internal card name for xfce mixer
    """

    def get(self):
        return self.Get('cl_desktop_gst_data').get('internal_name', '')


class VariableClDesktopGstMasterchannel(ReadonlyVariable):
    """
    Master track name
    """

    def get(self):
        return self.Get('cl_desktop_gst_data').get('master_channel', '')


class VariableClDesktopXfceMixer(ReadonlyVariable):
    """
    List of channel for xfce-perchannel mixer
    """

    def get(self):
        return "\n".join(
            map(lambda x: '      <value type="string" value="%s" />' % x,
                self.Get('cl_desktop_gst_data').get('channels', [])))


class VariableClDesktopXfcePointers(ReadonlyVariable):
    """
    Список устройств-указателей для xfce
    """
    type = "list"

    def get(self):
        def generate():
            for input_device_name in sorted(
                    device.sysfs.glob(device.sysfs.Path.Input,
                                      "mouse*/device/name")):
                data = device.sysfs.read(input_device_name)
                if data:
                    yield data.strip().replace(" ", "_").replace("/","")

        return list(generate())


class VariableClDesktopOnlineData(ReadonlyTableVariable, DomainInfoHelper):
    """
    Information about online users
    """
    source = ['cl_desktop_online_user',
              'cl_desktop_online_display',
              'cl_desktop_online_uid',
              'cl_desktop_online_domain_set',
              'cl_desktop_online_count']

    reDisplay = re.compile(r"^\(?:(\d+\.?\d*)")

    def _getDisplay(self, *args):
        """
        Get DISPLAY from args
        """
        for arg in map(self.reDisplay.search, args):
            if arg:
                return arg.group(1)
        return ""

    def get_user_uid(self, username):
        try:
            return str(pwd.getpwnam(username).pw_uid)
        except Exception:
            return ""

    def get(self, hr=False):
        # TODO: need to KISS rewrite
        resWho = process("who")
        xData = [[]]
        if resWho.success():
            listProcessing = lambda x: (x[0], x[1], x[-1]) \
                if len(x) >= 5 else []
            xData = groupby(
                sorted(
                    filter(lambda x: x[0] != "root",
                           map(lambda x: (x[0], self._getDisplay(x[1], x[2])),
                               filter(lambda x: x and \
                                                (x[2].startswith("(:") or
                                                 x[1].startswith(":")),
                                      map(lambda x: listProcessing(
                                          list(filter(lambda y: y, x.split()))),
                                          resWho)))),
                    key=lambda x: x[0]),
                lambda x: x[0])
            xData = list(map(lambda x: (x[0][0], x[0][1],
                                   self.get_user_uid(x[0][0]),
                                   "on" if self.isDomainUser(
                                       x[0][0]) else "off",
                                   len(x)),
                        map(lambda x: list(x[1]),
                            xData)))
        return xData

    setValue = Variable.setValue


class VariableClDesktopOnlineUser(FieldValue, ReadonlyVariable):
    """
    Логин пользователя
    """
    type = "list"
    source_variable = "cl_desktop_online_data"
    column = 0


class VariableClDesktopOnlineDisplay(FieldValue, ReadonlyVariable):
    """
    Display пользователя
    """
    type = "list"
    source_variable = "cl_desktop_online_data"
    column = 1


class VariableClDesktopOnlineUid(FieldValue, ReadonlyVariable):
    """
    UID пользователя
    """
    type = "list"
    source_variable = "cl_desktop_online_data"
    column = 2


class VariableClDesktopOnlineDomainSet(FieldValue, ReadonlyVariable):
    """
    Является ли пользователь доменным
    """
    type = "list"
    source_variable = "cl_desktop_online_data"
    column = 3


class VariableClDesktopOnlineCount(FieldValue, ReadonlyVariable):
    """
    Количество сеансов пользователя
    """
    type = "list"
    source_variable = "cl_desktop_online_data"
    column = 4


class VariableClDesktopLogin(user.VariableUrLogin):
    """
    User Login
    """
    opt = ["cl_desktop_login"]

    def choice(self):
        if self.Get('cl_action') == 'logout':
            return self.Get('cl_desktop_online_user')
        else:
            return user.VariableUrLogin.choice(self)

    def check(self, value):
        """Does user exist"""
        if value not in self.choice() and self.Get('cl_action') == 'logout':
            raise VariableError(_("No X session user found"))
        if value == "":
            raise VariableError(_("Please specify the user name"))
        try:
            pwd.getpwnam(value).pw_gid
        except Exception:
            raise VariableError(_("User %s does not exist") % value)

    def get(self):
        return ""


class VariableUrMountDirs(ReadonlyVariable):
    """
    Примонтированные директории в профиле пользователя
    """
    type = "list"

    def get(self):
        homeDir = self.Get("ur_home_path")
        if not homeDir:
            return []
        dirStart, dirEnd = path.split(homeDir)
        mountProfileDir = path.join(dirStart, ".%s" % dirEnd)
        mountRemoteProfileDir = path.join(dirStart, ".%s.remote" % dirEnd)

        directories = filter(lambda x: x != homeDir,
                             filter(lambda x: (x.startswith(homeDir) or
                                               x.startswith(mountProfileDir) or
                                               x.startswith(
                                                   mountRemoteProfileDir)),
                                    map(lambda x: x.split(" ")[1],
                                        readLinesFile('/proc/mounts'))))
        # if isMount(homeDir):
        #    directories.append(homeDir)
        return sorted(directories, reverse=True)


class VariableUrPassword(ReadonlyVariable):
    """
    Пароль пользователя, получаемый из ключей ядра
    """

    def get(self):
        return getKey(self.Get('ur_login')) or ""


class VariableClDesktopUpdateProfileSet(Variable):
    """
    Нужно ли выполнять обновление профиля пользователя на основании
    обновлении пакетов
    """
    type = "bool"

    def is_fastlogin(self):
        urLogin = self.Get('ur_login')
        fastlogin = self.Get('cl_desktop_fastlogin_path')
        fastlogin_user = path.join(fastlogin, urLogin)
        if path.exists(fastlogin_user):
            return True
        return False
            

    def get(self):
        lastTimestamp = templateFunction.getLastElog()
        iniEnv = path.join(self.Get('ur_home_path'), '.calculate/ini.env')
        userIni = iniParser(iniEnv)
        userTimestamp = userIni.getVar('main', 'elog')
        if userTimestamp:
            userTimestamp = userTimestamp.encode('utf-8')
        profileSetup = userIni.getVar('main', 'profile_setup')
        login_setup = profileSetup == 'on'

        if (self.Get('ur_domain_set') == 'on' or
                not self.is_fastlogin() or login_setup or
                not path.exists(iniEnv) or userTimestamp != lastTimestamp):
            return 'on'
        else:
            return 'off'


class VariableClDesktopForceSetupSet(Variable):
    """
    Принудительно выполнить обновление пользовательского профиля
    """
    type = "bool"
    opt = ["--force-setup"]
    metavalue = "ON/OFF"
    value = "off"

    def init(self):
        self.label = _("Force configuration")
        self.help = _("force configuration")


class VariableClDesktopFacePath(Variable):
    """Путь к стандартным иконкам пользователей"""
    value = "/usr/share/pixmaps/faces"


class VariableClDesktopFaceList(Variable):
    """Список доступных иконок по умолчанию для пользователей"""
    type = "list"

    def get(self):
        return sorted(
            filter(lambda x: x.endswith('.png'),
                   listDirectory(self.Get('cl_desktop_face_path'))))


class VariableClDesktopHashFace(Variable):
    """Номер иконки пользователя

    Номер вычисляется по контрольной сумму md5 логина пользователя
    """

    def get(self):
        login = self.Get('ur_login')
        icon_list = self.Get('cl_desktop_face_list')
        if icon_list:
            # return path.join(self.Get('cl_desktop_face_path'),
            #                  icon_list[sum(map(lambda x: ord(x), hashlib.md5(login).digest())) % len(icon_list)])
            return path.join(self.Get('cl_desktop_face_path'),
                             icon_list[sum([x for x in hashlib.md5(login.encode("UTF-8")).digest()]) % len(icon_list)])
        else:
            return ""


class VariableClDesktopFastloginPath(ReadonlyVariable):
    """
    Путь до каталога в котором указаны пользователи быстрого входа в сеанс
    """
    value = "/var/lib/calculate/calculate-desktop/fastlogin"


class VariableClDesktopElogindSet(ReadonlyVariable):
    """
    В системе используется elogind
    """
    type = Variable.Types.Boolean
    elogind = "sys-auth/elogind"
    consolekit = "sys-auth/consolekit"

    def get(self):
        if isPkgInstalled(self.elogind) and \
            not isPkgInstalled(self.consolekit):
            return Variable.On
        return Variable.Off