calculate-utils-3-client/pym/client/client.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 stat
import re
import sys

import subprocess
import ldap
import time

import getpass
from os import path

from calculate.lib.cl_ini_parser import iniParser
from calculate.lib.cl_print import color_print
from calculate.lib.utils.ip import Pinger, IPError
from calculate.lib.utils.files import (getModeFile, removeDir,
                                       pathJoin, tarLinks, readFile, writeFile,
                                       listDirectory, process, find, STDOUT,
                                       checkUtils)
from calculate.lib.utils.samba import Samba, SambaError
from calculate.lib.utils.mount import isMount
from calculate.lib.utils.common import cmpVersion
from calculate.desktop._cl_keys import getKey, clearKey
from calculate.lib.convertenv import convertEnv
from calculate.lib.encrypt import encrypt
from client_cache import userCache
from shutil import copy2
from socket import gethostbyname
import tarfile
from calculate.desktop.desktop import Desktop
from calculate.client.rsync import ProfileSyncer, ProfileSyncerError
from calculate.lib.utils.common import get_fastlogin_domain_path

from calculate.lib.cl_lang import setLocalTranslate, getLazyLocalTranslate

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


class ClientError(Exception):
    pass


class RsyncProgressBar:
    """
    Rsync with using setProgress
    """
    # get number of send file from info rsync stream
    senderre = re.compile("\[sender\] i=(\d+) ", re.S)
    # get number of receivce file from info rsync rtream
    receiverre = re.compile("recv_generator\(.+,([0-9]+)\)", re.S)
    pipe = None
    maximum = 1
    copyStarting = False

    def __init__(self, title, secondtitle, rsyncstr, parent, maximum=1,
                 rsyncver="3.0.9"):
        self.title = title
        self.secondtitle = secondtitle
        self.maximum = maximum
        self.rsyncstr = rsyncstr
        self.parent = parent
        self.value = 0
        self.errors = []
        if cmpVersion(rsyncver, "3.1.0") >= 0:
            self.extraopts = " --msgs2stderr"
            self.use_stderr = True
        else:
            self.extraopts = ""
            self.use_stderr = False

    def getFilesNum(self):
        """
        Get files count created by generator
        """
        if self.pipe:
            return self.value

    def getExitCode(self):
        """
        Get rsync exitcode
        """
        if self.pipe:
            return self.pipe.wait()
        return 255

    def getErrMessage(self):
        """
        Rsync error message 
        """
        if self.pipe:
            if self.use_stderr:
                return "".join(self.errors)
            else:
                return self.pipe.stderr.read()
        return _("RsyncProgressBar: Wrong pipe")

    def runsilent(self):
        """
        Run rsync without progressbar
        """
        self.pipe = subprocess.Popen(self.rsyncstr + self.extraopts,
                                     stdin=subprocess.PIPE,
                                     stdout=subprocess.PIPE,
                                     stderr=subprocess.PIPE,
                                     close_fds=True, shell=True)
        while True:
            if self.use_stderr:
                s = self.pipe.stderr.readline()
            else:
                s = self.pipe.stdout.readline()
            if len(s) == 0:
                break
            q = self.receiverre.search(s)
            if q:
                self.value = int(q.groups()[0])

    def run(self):
        """
        Run rsync with progressbar
        """
        self.parent.startTask(self.title, progress=True)
        self.pipe = subprocess.Popen(self.rsyncstr + self.extraopts,
                                     stdin=subprocess.PIPE,
                                     stdout=subprocess.PIPE,
                                     stderr=subprocess.PIPE,
                                     close_fds=True, shell=True)
        oldpercent = 0
        while True:
            if self.use_stderr:
                s = self.pipe.stderr.readline()
            else:
                s = self.pipe.stdout.readline()
            if len(s) == 0:
                break
            if s.startswith("rsync:"):
                self.errors.append(s)
            q = self.receiverre.search(s)
            if q:
                if not self.copyStarting:
                    self.parent.endTask()
                    self.parent.startTask(self.secondtitle, progress=True)
                    # self.parent.setProgress(0)
                    self.copyStarting = True
                self.value = int(q.groups()[0])
                if self.maximum:
                    newvalue = int(100 * self.value / self.maximum)
                    newvalue = min(newvalue, 99)
                    if newvalue > oldpercent:
                        self.parent.setProgress(newvalue)
                        oldpercent = newvalue
        self.parent.setProgress(100)

    def close(self):
        self.parent.endTask()


class commandServer(color_print):
    """Server command object"""

    def setServerCommand(self, command, varsCommand, fileConfig,
                         uid=None, gid=None):
        """Set server command"""
        pathConfig = os.path.split(fileConfig)[0]
        # create user config directory
        if not os.path.exists(pathConfig):
            os.makedirs(pathConfig)
            if not uid is None and not gid is None:
                os.chown(pathConfig, uid, gid)
        objConfig = iniParser(fileConfig)
        varsRun = {"run": "on"}
        varsRun.update(varsCommand)
        if not objConfig.setVar(["command"] + command, varsRun):
            raise ClientError(_("Failed to write variables in file %s") \
                              % fileConfig)
        if not uid is None and not gid is None:
            os.chown(fileConfig, uid, gid)
        return True

    def checkUserPwdLDAP(self, server, userDN, password):
        """Проверка пароля Unix пользователя на сервере"""
        ldapInit = ldap.initialize("ldap://%s" % server)
        errMessage = ""
        try:
            ldapInit.bind_s(userDN, password)
        except ldap.INVALID_CREDENTIALS:
            errMessage = _("Wrong password")
            return False, errMessage
        except ldap.LDAPError, e:
            errMessage = e[0]['desc']
            return False, errMessage
        return True, errMessage

    def getUserPwd(self, options, optDialog, optStdIn, pwDialog=False):
        """Получить пароль у пользователя

        options   - полученные опции командной строки
        optDialog - опция командной строки для вывода диалога для получения
                    пароля
        optStdIn  - опция командной строки для получения пароля из
                    стандартного ввода (stdin)
        pwDialog  - структура для вывода приглашения в режиме диалога
        """
        if optStdIn and options.has_key(optStdIn):
            pwdA = sys.stdin.readline().rstrip()
            pwdB = sys.stdin.readline().rstrip()
        elif optDialog and options.has_key(optDialog):
            if not pwDialog:
                pwDialog = [_("New password"),
                            _("Retype the new password")]
            pwdA = getpass.getpass(pwDialog[0] + _(":"))
            pwdB = getpass.getpass(pwDialog[1] + _(":"))
        else:
            return ""
        if not pwdA or not (pwdA == pwdB):
            self.printERROR(_("ERROR") + _(": ") + \
                            _("passwords do not match"))
            return False
        userPwd = pwdA
        return userPwd


class Client(commandServer, encrypt, Desktop):
    """
    Клиентский модуль работы с доменом
    """

    # user calculate config directory
    pathConfig = ".calculate"
    # client soft config file
    configFileSoft = os.path.join(pathConfig, "ini.env")
    # client config file
    configFileDesktop = os.path.join(pathConfig, "desktop.env")
    # client config for server
    configFileServer = os.path.join(pathConfig, "server.env")
    # file list of user profile
    listTemplFile = os.path.join(pathConfig, "files.txt")

    # files which not cleaning from user home directory
    skipHomeFile = ["Laptop", "Home", "Disks", "Share", "FTP",
                    configFileDesktop]

    # option dict of services from /var/calculate/remote/server.env
    optionsInfo = {}

    # convertation object from old remote env
    convObj = None
    # private user files
    privateFiles = [configFileServer]
    # private user directories
    privateDirs = []

    def init(self):
        self.domainnames = {}

    def removeVars(self):
        """
        Remove domain variables. Useing on remove package
        and undomain action
        """
        self.clVars.Delete("cl_remote_host", "local")
        self.clVars.Delete("cl_remote_pw", "local")
        self.clVars.Delete("os_remote_auth")
        self.clVars.Set("cl_remote_host", "", True)
        self.clVars.Set("cl_remote_pw", "", True)
        self.clVars.Set("os_remote_auth", "", True)
        return True

    def mountSambaRes(self, host, userName, userPwd, res, rpath, uid=None,
                      gid=None):
        """
        Подключить samba ресурс
        """
        mountCmd = checkUtils('/bin/mount')
        addon = ""
        if cmpVersion(self.clVars.Get('cl_cifs_ver'), "2.05") >= 0:
            addon = ",nomapposix"
        cache_method = self.clVars.Get('cl_cifs_cache')
        domain = self.get_server_domainname(host)
        cifs_mount_vers = self.clVars.Get('cl_cifs_mount_vers')
        if not uid is None:
            # mount by uid
            p = process(mountCmd, "-t", "cifs", "-o",
                "cache=%s,domain=%s,user=%s,uid=%d,gid=%d,noperm%s" % (
                    cache_method, domain,
                    userName, uid, gid, addon),
                "//%s/%s" % (host, res), rpath,
                envdict={"PASSWD": userPwd}, stderr=STDOUT)
            return p.success()
        else:
            if cmpVersion(self.clVars.Get('cl_cifsutils_ver'), "6.9_rc73") >= 0:
                addon += ",forcemandatorylock"
            if rpath in ("unix", "remote_profile"):
                versopt = ",vers=%s" % cl_cifs_mount_vers
            else:
                versopt = ""
            p = process(mountCmd, "-t", "cifs", "-o",
                "cache=%s,domain=%s%s,user=%s%s" % (cache_method,
                    domain, versopt, userName, addon),
                "//%s/%s" % (host, res), rpath,
                envdict={"PASSWD": userPwd}, stderr=STDOUT)
            return p.success()

    def get_server_domainname(self, host):
        vardomain = self.clVars.Get('cl_remote_domain')
        if vardomain:
            return vardomain
        if host not in self.domainnames:
            try:
                self.domainnames[host] = Samba().get_server_domainname(host)
            except SambaError as e:
                raise ClientError(str(e))
        return self.domainnames[host]

    def mountSleepRes(self, host, userName, userPwd, res, rpath, uid=None,
                      gid=None):
        """
        Подключить пользовательский ресурс
        """
        for waittime in [0.5, 2, 5]:
            if not self.mountSambaRes(host, userName, userPwd, res, rpath,
                                      uid, gid):
                # check on mount path
                if isMount(rpath):
                    if not self.umountSleepPath(rpath):
                        return False
                # wait
                time.sleep(waittime)
            else:
                return True
        return False

    def syncUser(self, uid, gid, userHome, sync, remoteProfile,
                 host="default", skipList=()):
        """
        Синхронизация профиля пользователя
        """
        execStr = ""
        skipPaths = self.clVars.Get("cl_sync_skip_path")
        if not skipPaths:
            self.printERROR(
                _("Variable 'cl_sync_skip_path' empty") % userHome)
            return False
        deletePaths = self.clVars.Get("cl_sync_del_path")
        if not deletePaths:
            deletePaths = []
        excludePaths = " ".join(map(
            lambda x: '--exclude="/%s"' % x.replace('"', "").replace(
                "'", ""),
            skipPaths + deletePaths + list(skipList)))
        if sync == "login":
            if os.path.exists(userHome) and \
                    os.path.exists(remoteProfile):
                filterPath = " ".join(map(
                    lambda x: '--filter="P /%s"' % x.replace(
                        '"', "").replace("'", ""),
                    skipPaths))
                execStr = ('/usr/bin/rsync --delete-excluded --delete %s %s '
                           '-rlptgo -x -v -v -v  %s/ %s/'
                           % (excludePaths, filterPath,
                              remoteProfile, userHome))
        elif sync == "logout":
            if os.path.exists(userHome) and os.listdir(userHome) and \
                    os.path.exists(remoteProfile):
                execStr = ('/usr/bin/rsync --delete-excluded --delete %s '
                           '-rlpt -x -v -v -v %s/ %s/' % (
                               excludePaths, userHome, remoteProfile))
        else:
            raise ClientError(
                _("Method syncUser: wrong option sync=%s") % str(sync))
        if execStr:
            host = "<i>" + host + "</i>"
            if sync == "login":
                rsync = RsyncProgressBar(
                    _("Fetching the file list from %s") % host,
                    _("Fetching the user profile from %s") % host,
                    execStr, self, rsyncver=self.clVars.Get('cl_rsync_ver'))
            else:
                rsync = RsyncProgressBar(
                    _("Sending the file list to %s") % host,
                    _("Uploading the user profile to %s") % host,
                    execStr, self, rsyncver=self.clVars.Get('cl_rsync_ver'))
            pathConfig = os.path.join(remoteProfile,
                                      self.pathConfig)
            # remove old ini file
            prevIniFile = os.path.join(remoteProfile, ".calculate.ini")
            if os.path.exists(prevIniFile):
                os.remove(prevIniFile)
            # create home directory
            if not os.path.exists(pathConfig):
                self.createUserDirectory(pathConfig, uid, gid)
            numfiles = 0
            configFileName = os.path.join(remoteProfile, self.configFileDesktop)
            if sync == "login":
                # get rsync files
                try:
                    numfiles = iniParser(
                        configFileName).getVar('rsync', 'files')
                    if numfiles is False:
                        if os.path.exists(configFileName):
                            os.remove(configFileName)
                        numfiles = 0
                    else:
                        numfiles = int(numfiles)
                except Exception:
                    numfiles = 0
            rsync.maximum = numfiles
            if sync == "login":
                rsync.run()
            if sync == "logout":
                rsync.run()
                try:
                    if iniParser(configFileName).setVar(
                            'rsync', {'files': rsync.getFilesNum()}):
                        os.chmod(configFileName, 0600)
                        os.chown(configFileName, uid, gid)
                except Exception:
                    pass
            rsync.close()
            try:
                if iniParser(configFileName).setVar(
                        'rsync', {'exitcode': rsync.getExitCode()}):
                    os.chmod(configFileName, 0600)
                    os.chown(configFileName, uid, gid)
            except Exception:
                pass
            if rsync.getExitCode() != 0:
                self.printERROR(rsync.getErrMessage())
                self.printERROR(_("Failed to execute rsync") + " " + \
                                str(sync))
                return False
        # change permissions
        changeDirs = [userHome, remoteProfile]
        for changeDir in filter(path.exists, changeDirs):
            # get directory permissions
            mode = getModeFile(changeDir, mode="mode")
            # if permission wrong( not 0700) then change it
            if mode != 0700:
                os.chmod(changeDir, 0700)
        return True

    def clearHomeDir(self, homeDir):
        """
        Очистить домашнюю директорию
        """
        skipHomeFile = list(set(self.skipHomeFile) |
                            set(self.clVars.Get('cl_moved_skip_path')))
        rmFiles = list(set(os.listdir(homeDir)) - set(skipHomeFile))
        for rmFile in rmFiles:
            delFile = os.path.join(homeDir, rmFile)
            if os.path.islink(delFile):
                os.unlink(delFile)
            elif os.path.isfile(delFile):
                os.remove(delFile)
            elif os.path.isdir(delFile):
                if not removeDir(delFile):
                    return False
            elif stat.S_ISSOCK(os.stat(delFile)[stat.ST_MODE]):
                os.remove(delFile)
        self.printSUCCESS(_("Cleaning the local user profile"))
        return True

    def syncLoginProfile(self, host, uid, gid, homeDir, resourceName,
                         profileName, clearHomeDir=True):
        """
        Получить профиль пользователя из домена
        """
        homeProfile = path.join(
            self.clVars.Select('cl_client_user_mount_path',
                               where='cl_client_user_mount_name',
                               eq=resourceName, limit=1),
            profileName)
        # if currect server has any files then sync it
        if any(x not in ('.calculate',) for x in listDirectory(homeProfile)):
            if not self.syncUser(uid, gid, homeDir, "login",
                                 homeProfile, host=host):
                return False
        # remove home directory on workstation
        else:
            if clearHomeDir:
                # clean home directory
                if not self.clearHomeDir(homeDir):
                    return False
        return True

    def syncLogoutProfile(self, host, uid, gid, homeDir, resourceName,
                          profileName, skipList):
        """
        Закачать профиль пользователя в домен
        """
        homeProfile = path.join(
            self.clVars.Select('cl_client_user_mount_path',
                               where='cl_client_user_mount_name',
                               eq=resourceName, limit=1),
            profileName)
        # if currect server has any files then sync it
        if listDirectory(homeDir):
            if not path.exists(homeProfile):
                self.createUserDirectory(homeProfile, uid, gid)
            if not self.syncUser(uid, gid, homeDir, "logout",
                                 homeProfile, host=host, skipList=skipList):
                return False
        return True

    def strftime(self, timeobj, dateformat="%Y-%m-%d %H:%M:%S"):
        return time.strftime(dateformat, timeobj)

    def packRemote(self, resourceName, localTime, currentTime, profileName,
                   uid, gid):
        """
        Запаковать удаленный профиль
        """
        remoteProfilePath = path.join(
            self.clVars.Select('cl_client_user_mount_path',
                               where='cl_client_user_mount_name',
                               eq=resourceName,
                               limit=1), profileName)
        fileServer = path.join(remoteProfilePath,
                               Client.configFileServer)
        if not localTime:
            return False
        varsConfig = {"arch_date": self.strftime(localTime),
                      "curr_time": currentTime}

        self.setServerCommand(["pack"], varsConfig, fileServer)
        fileDesktop = path.join(remoteProfilePath,
                                Client.configFileDesktop)
        self.setVarToConfig(uid, gid, "main", {"status_sync": "success"},
                            fileDesktop)
        return self.umountRemoteUserRes(False, resourceName)

    def waitingArchFile(self, packTime, profileName, resourceName):
        """
        Ожидание архива профиля от домена
        """
        arch_fn_success, arch_fn_process = self._getArchNames(
            packTime, profileName, resourceName)

        def arch_exists():
            return any(os.path.exists(x) for x in (arch_fn_process,
                                                   arch_fn_success))

        for sleeptime in [0.1, 0.2, 0.5]:
            # archive in packing process found
            if arch_exists():
                break
            time.sleep(sleeptime)
        else:
            return False

        # wait finish packing
        if arch_exists():
            while arch_exists():
                for waittime in [0.5, 1, 2]:
                    if path.exists(arch_fn_success):
                        return True
                    try:
                        startSize = os.stat(arch_fn_process).st_size
                        time.sleep(waittime)
                        if startSize != os.stat(arch_fn_process).st_size:
                            break
                    except OSError:
                        if path.exists(arch_fn_success):
                            return True
                else:
                    return False
        return False

    def unpackArch(self, homeDir, packTime, profileName, resourceName):
        """
        Распаковать архив с профилем
        """

        def fileReader(fileName, stdin, maxSize):
            """
            Прочитать файл по блокам
            """
            self.addProgress()
            fd = os.open(fileName, os.O_RDONLY)
            currSize = 0
            # default buffer size
            buffSize = 131072
            dataBlock = os.read(fd, buffSize)
            while dataBlock:
                currSize += len(dataBlock)
                self.setProgress(currSize * 100 / maxSize)
                stdin.write(dataBlock)
                dataBlock = os.read(fd, buffSize)
            stdin.close()
            os.close(fd)

        archFile, drop = self._getArchNames(packTime, profileName, resourceName)
        archiveSize = os.stat(archFile).st_size
        # os.system('tar tf %s'%archFile)
        execStr = "tar -C '%s' -xzf -" % homeDir
        # запустить процесс распаковки
        pipe = subprocess.Popen(execStr,
                                stdin=subprocess.PIPE,
                                stdout=subprocess.PIPE,
                                stderr=subprocess.PIPE,
                                close_fds=True,
                                env=os.environ, shell=True)
        try:
            # прочитать в конвеер
            fileReader(archFile, pipe.stdin, archiveSize)
            self.endTask()
        finally:
            ret = pipe.wait()
            pipe.stdout.close()
            pipe.stderr.close()
        if ret:
            return False
        removedFileList = path.join(
            self.clVars.Select('cl_client_user_mount_path',
                               where='cl_client_user_mount_name',
                               eq=resourceName, limit=1), profileName,
            self.listTemplFile)
        return self.removeFilesInProfile(homeDir, removedFileList)

    def cleanArchs(self, packTime, profileName, resourceName):
        """
        Удалить архивы использованные для синхронизации пользовательского
        профиля
        """
        for rmFile in filter(lambda x: x and path.exists(x),
                             self._getArchNames(packTime, profileName,
                                                resourceName)):
            os.remove(rmFile)
        return True

    def _getArchNames(self, packTime, profileName, resourceName):
        """
        Получить имена файлов архивов по времени, профилю и ресурсу
        """
        remoteProfile = self.clVars.Select('cl_client_user_mount_path',
                                           where='cl_client_user_mount_name',
                                           eq=resourceName, limit=1)
        extSuccess = "gz"
        extProcess = "process"
        packTime = packTime.replace(".", "_")
        archPathTmp = os.path.join(remoteProfile, "profile.%s.%s.tar"
                                   % (profileName, packTime))
        # result archive file name
        archPathSuccess = "%s.%s" % (archPathTmp, extSuccess)
        # archive in pack process
        archPathProcess = "%s.%s" % (archPathTmp, extProcess)
        return archPathSuccess, archPathProcess

    def setVarToConfig(self, uid, gid, nameSection, varsDict, configFileName):
        """Записывает переменную в файл конфигурации"""
        # Создаем директорию для конфигурационных файлов
        pathConfig = os.path.split(configFileName)[0]
        if not os.path.exists(pathConfig):
            self.createUserDirectory(pathConfig, uid, gid)
        try:
            if iniParser(configFileName).setVar(nameSection, varsDict):
                os.chmod(configFileName, 0600)
                os.chown(configFileName, uid, gid)
        except Exception:
            return False
        return True

    def createUserDirectory(self, userdir, uid, gid):
        """
        Создать директорию с правами пользователя
        """
        if not os.path.exists(userdir):
            try:
                pdir = os.path.dirname(userdir)
                if not os.path.exists(pdir):
                    self.createUserDirectory(pdir, uid, gid)
                os.mkdir(userdir)
                os.chown(userdir, uid, gid)
                os.chmod(userdir, 0700)
            except OSError:
                raise ClientError(_("Failed to create the directory") + ". " +
                                  _("Permission denied: '%s'") % userdir)
        return True

    def mountUserDomainRes(self, userName, userPwd, uid, gid, *resources):
        """
        Mount all local samba resource
        """
        for rpath, res, host in \
                self.clVars.Select(['cl_client_user_mount_path',
                                    'cl_client_user_mount_resource',
                                    'cl_client_user_mount_host'],
                                   where='cl_client_user_mount_name',
                                   _in=resources):
            if not rpath:
                continue
            self.createUserDirectory(rpath, uid, gid)
            if isMount(rpath):
                continue
            else:
                if not self.mountSleepRes(host, userName, userPwd,
                                          res, rpath, uid, gid):
                    raise ClientError(
                        _("Failed to mount the Samba volume [%s]") % res)
        else:
            return True

    def setSyncStatus(self, userDir, uid, gid, status):
        """
        Установить статус синхронизации
        """
        # сохранение текущего статуса перед изменением
        self.clVars.Get('cl_client_sync_status')
        fileDesktop = path.join(userDir, Client.configFileDesktop)
        return self.setVarToConfig(uid, gid, "main",
                                   {"status_sync": status}, fileDesktop)

    def tarSymLinks(self, uid, gid, userHome, delPath, skipPath):
        """
        Создать tar архив с симлинками
        """
        linkArch = pathJoin(userHome, ".calculate/links.tar.bz2")
        try:
            tarLinks(userHome, linkArch, skip=delPath + skipPath)
            if path.exists(linkArch):
                os.chown(linkArch, uid, gid)
        except Exception:
            return False
        return True

    def unpackLinks(self, userHome):
        """
        Распаковать архив с симлинками
        """
        linksArch = path.join(userHome, ".calculate/links.tar.bz2")
        try:
            if os.path.exists(linksArch):
                tf = tarfile.open(linksArch)
                tf.extractall(userHome)
                tf.close()
        except Exception:
            return False
        return True

    def moveHomeDir(self, userHome, movedDir, resourceName, skipPaths):
        """
        Переместить непрофильные файлы из корня домашней директории
        в Home/Moved
        """
        desktopDir = "Desktop"
        resourcePath = self.clVars.Select('cl_client_user_mount_path',
                                          where='cl_client_user_mount_name',
                                          eq=resourceName,
                                          limit=1)
        if not isMount(resourcePath):
            raise ClientError(_("Unable to mount %s") % resourcePath)
        movedPath = path.join(resourcePath, movedDir)
        movedLink = path.join(userHome, movedDir)
        if not skipPaths:
            skipPaths = ['Laptop', 'Disks', 'Share', 'Home',
                         'Moved', 'FTP', 'Desktop']
        filesAndDir = filter(lambda x: not (
            path.islink(x) or
            x[len(userHome) + 1:].startswith('.') or
            x[len(userHome) + 1:] in skipPaths),
                             listDirectory(userHome, fullPath=True))
        filesDir = []
        for fd in filesAndDir:
            if os.path.islink(fd):
                os.unlink(fd)
            else:
                filesDir.append(fd)
        # find files in Desktop
        pathDesktop = path.join(userHome, desktopDir)
        filesDirDesk = filter(lambda x: (not path.islink(x) and
                                         not path.split(x)[1].startswith(
                                             '.') and
                                         not x.rpartition('.')[2] == 'desktop'),
                              listDirectory(pathDesktop, fullPath=True))
        filesDir += filesDirDesk
        if not filesDir or not path.exists(resourcePath):
            # remove empty Moved folder
            if path.exists(movedPath) and not listDirectory(movedPath):
                os.rmdir(movedPath)
            # remove link to Moved in home directory
            if path.islink(movedLink) and not path.exists(movedPath):
                os.unlink(movedLink)
            return True
        if not path.exists(movedPath):
            os.mkdir(movedPath)
        directFile = path.join(movedPath, ".directory")
        if not path.exists(directFile):
            with open(directFile, 'w') as f:
                f.write("[Desktop Entry]\nIcon=folder-development")
        if not path.exists(movedLink):
            os.symlink(movedPath[len(userHome) + 1:], movedLink)
        cpCmd, rmCmd = checkUtils('/bin/cp', '/bin/rm')
        for fd in filesDir:
            if process(cpCmd, '-xr', fd, movedPath).failed():
                self.printERROR(_("Failed to copy {ffrom} to {fto}")
                                .format(ffrom=fd, fto=movedPath))
                return False
            if process(rmCmd, '-rf', '--one-file-system', fd).failed():
                self.printERROR(_("Failed to remove " % fd))
                return False
        return True

    def removeNoiseFiles(self, userHome):
        """
        Remove files which hinder dm
        """
        noiseFiles = []
        for nsFile in noiseFiles:
            rmFile = path.join(userHome, nsFile)
            if os.path.exists(rmFile):
                os.remove(rmFile)
        return True

    def getPrivateFiles(self, userHome):
        """
        Get all private files relative user home directory
        """
        privateFiles = []
        for privateHomeDir in self.privateDirs:
            privateDir = os.path.join(userHome, privateHomeDir)
            if os.path.isdir(privateDir):
                # .ssh files relative user home directory
                privateFiles += map(lambda x: os.path.join(privateHomeDir, x),
                                    filter(lambda x: \
                                               os.path.isfile(
                                                   os.path.join(privateDir, x)),
                                           os.listdir(privateDir)))
        return self.privateFiles + privateFiles

    def removePrivateFiles(self, userHome):
        """
        Remove private files
        """
        privateFiles = self.getPrivateFiles(userHome)
        for prFile in privateFiles:
            rmFile = os.path.join(userHome, prFile)
            if os.path.exists(rmFile):
                os.remove(rmFile)
        return True

    def copyPrivateFiles(self, serverProfileDir, userHomeDir):
        """
        Copy privates files from server to home directory
        """
        privateFiles = self.getPrivateFiles(serverProfileDir)
        for prFile in privateFiles:
            src = os.path.join(serverProfileDir, prFile)
            dst = os.path.join(userHomeDir, prFile)
            if os.path.exists(src):
                dstPath = os.path.dirname(dst)
                if not os.path.exists(dstPath):
                    listElPath = []
                    for el in filter(lambda x: x,
                                     dstPath.partition(userHomeDir)[2].split(
                                         "/")):
                        listElPath.append(el)
                        joinPath = "/".join(listElPath)
                        dPath = os.path.join(userHomeDir, joinPath)
                        if not os.path.exists(dPath):
                            sPath = os.path.join(serverProfileDir, joinPath)
                            sMode, sUid, sGid = getModeFile(sPath)
                            os.mkdir(dPath, sMode)
                            os.chown(dPath, sUid, sGid)
                copy2(src, dst)
                sUid, sGid = getModeFile(src, mode="owner")
                os.chown(dst, sUid, sGid)
        return True

    def getListFilesProfile(self, homeDir):
        """
        Generation file list in user home directory, exclude mount dirs
        """
        lHomeDir = len(homeDir) + 1
        return map(lambda x: x[lHomeDir:],
                   find(homeDir, onefilesystem=True))

    def removeFilesInProfile(self, homeDir, pathListFile):
        """
        Удалить файлы которые отсутствуют в пользовательском профиле
        """
        # read file list from config
        try:
            filesProfileTxt = readFile(pathListFile)
        except IOError:
            return False
        listFilesProfile = filter(lambda x: x.strip(),
                                  filesProfileTxt.split("\n"))
        filesProfile = set(listFilesProfile)
        # get files in home directory
        listFilesHome = self.getListFilesProfile(homeDir)
        if listFilesHome is False:
            return False
        filesHome = set(listFilesHome)
        filesRemove = list(filesHome - filesProfile)
        try:
            for rmFile in sorted(filesRemove, reverse=True):
                rmPath = os.path.join(homeDir, rmFile)
                if path.ismount(rmPath):
                    continue
                if os.path.islink(rmPath):
                    os.unlink(rmPath)
                elif os.path.isfile(rmPath):
                    os.remove(rmPath)
                elif os.path.isdir(rmPath):
                    os.rmdir(rmPath)
                else:
                    os.remove(rmPath)
        except Exception:
            return False
        return True

    def getRunCommandsWithEnv(self):
        """List run program"""

        def getCmd(procNum):
            cmdLineFile = '/proc/%s/cmdline' % procNum
            environFile = '/proc/%s/environ' % procNum
            try:
                if os.path.exists(cmdLineFile) and \
                        os.path.exists(environFile):
                    return (readFile(cmdLineFile).strip(),
                            readFile(environFile).strip())
            except (OSError, IOError):
                pass
            return "", ""

        if not os.access('/proc', os.R_OK):
            return []
        return map(getCmd,
                   filter(lambda x: x.isdigit(),
                          os.listdir('/proc')))

    def clearUserKey(self, userName):
        """
        Clear user key from kernel
        """
        # find user key in kernel and check on relogout
        if getKey(userName) and not \
                filter(lambda x: "xdm/xdm\x00--login" in x[0] and
                                ("USER=%s" % userName) in x[1],
                       self.getRunCommandsWithEnv()):
            # clean
            ret = clearKey(userName)
            if ret == 0:
                return True
            else:
                self.printERROR(_("Failed to clear the kernel key for user %s") \
                                % userName)
                return False
        return True

    def setLogoutDate(self, homeDir, uid, gid):
        """
        Установить дату выхода из сеанса
        """
        configFileName = path.join(homeDir, self.configFileDesktop)
        currentDateStr = self.strftime(time.localtime())
        return self.setVarToConfig(uid, gid, "main",
                                   {"date_logout": currentDateStr},
                                   configFileName)

    def umountRemoteUserRes(self, removeEmpty, *resourceNames):
        """
        Отключить пользовательский ресурс
        """
        retRes = True
        for resourceName in resourceNames:
            resourcePath = self.clVars.Select('cl_client_user_mount_path',
                                              where='cl_client_user_mount_name',
                                              eq=resourceName,
                                              limit=1)
            if resourcePath:
                result = self.umountSleepPath(resourcePath)
                retRes &= result
                if (result and removeEmpty and path.exists(resourcePath) and
                        not listDirectory(resourcePath)):
                    os.rmdir(resourcePath)
                    resourcePath = os.path.dirname(resourcePath)
                    if (resourceName in ("unix", "remote_profile") and 
                        path.exists(resourcePath) and
                        not listDirectory(resourcePath)):
                        os.rmdir(resourcePath)
        return retRes

    def umountUserRes(self, umountPaths):
        """
        Отключить пользовательские ресурсы
        """
        for umountPath in umountPaths:
            if not self.umountSleepPath(umountPath):
                return False
        self.umountRemoteUserRes(True,
                                 *self.clVars.Get('cl_client_user_mount_name'))
        return True
    
    def getDefaultRunlevelDaemons(self):
        """
        Получить все службы из default уровня загрузки
        """
        rcUpdateCmd = checkUtils("/sbin/rc-update")
        p = process(rcUpdateCmd, "show")
        if p.success():
            # получить список названии служб default уровня
            return map(lambda x: x[0].strip(),
                       # [\s*<название_службы>\s*,\s*default\s*]
                       filter(lambda x: len(x) > 1 and "default" in x[1],
                              # [\s*<название_службы>\s*,\s*уровень запуска\s*]
                              map(lambda x: x.split('|'),
                                  # \s*<название_службы>\s*|
                                  # \s*<уроверь запуска>?\s*
                                  p.readlines())))
        else:
            raise ClientError(_("ERROR") + _(": ") + p.read())

    def delDaemonAutostart(self, daemon):
        """
        Удалить службу из автозапуска
        """
        rcUpdateCmd = checkUtils('/sbin/rc-update')
        defaultDaemons = self.getDefaultRunlevelDaemons()
        if daemon in defaultDaemons:
            p = process(rcUpdateCmd, 'del', daemon, 'default')
            if p.success():
                return True
            else:
                self.printERROR(_("ERROR") + _(": ") + p.read())
                self.printERROR(_("Failed to delete from the default runlevel"))
                return False
        return True

    def addDaemonAutostart(self, daemon):
        """
        Добавить службу в автозагрузку
        """
        rcUpdateCmd = checkUtils('/sbin/rc-update')
        if daemon in self.getDefaultRunlevelDaemons():
            return True
        p = process(rcUpdateCmd, 'add', daemon, 'default')
        if p.success():
            return True
        else:
            self.printERROR(_("ERROR") + _(": ") + p.read())
            self.printERROR(_("Failed to add to the default runlevel"))
            return False

    def getInfoService(self, service, option, envFile=False):
        """
        Получить параметр севирса из удаленного env
        """
        if not envFile:
            if self.convObj is None:
                # file /var/calculate/remote/server.env
                envFile = self.clVars.Get("cl_env_server_path")
                if os.access(envFile, os.R_OK):
                    self.convObj = False
                elif os.access("/var/calculate/remote/calculate.env", os.R_OK):
                    self.convObj = convertEnv()
            if self.convObj:
                return self.convObj.getVar(service, option)
        if not self.optionsInfo:
            if not envFile:
                # file /var/calculate/remote/server.env
                envFile = self.clVars.Get("cl_env_server_path")
            optInfo = self.clVars.getRemoteInfo(envFile)
            if optInfo is False:
                return False
            if optInfo:
                self.optionsInfo = optInfo
        value = ''
        if service in self.optionsInfo and option in self.optionsInfo[service]:
            value = self.optionsInfo[service][option]
        return value

    def checkDomainServer(self, domainName, netDomain):
        """
        Проверить указанный адрес на то, что он может быть доменом
        """
        # get domain name
        if "." in domainName:
            domain = domainName
        else:
            import socket

            domain = "%s.%s" % (domainName, netDomain)
            try:
                gethostbyname(domain)
            except socket.gaierror as e:
                domain = domainName
        # check domain by ping
        for i in range(0, 1):
            try:
                Pinger().ping(domain, 1000, 16)
                break
            except IPError as e:
                pass
        else:
            self.printERROR(_("Server %s does not respond") % domain)
            return False
        smbClientCmd = checkUtils('/usr/bin/smbclient')
        p = process(smbClientCmd, "-N", "//{}/remote".format(domain),
                    stderr=STDOUT)
        if "NT_STATUS_ACCESS_DENIED" in p.read():
            self.get_server_domainname(domain)
            return True
        else:
            self.printERROR(_("Samba server not found in %s") % domain)
            return False

    def getDomainPassword(self, host):
        """
        Получить пароль для ввода в домен
        """

        def passwdQueue():
            remotePw = self.clVars.Get('cl_remote_pw')
            if remotePw:
                yield remotePw
            if remotePw:
                self.printERROR(_("Wrong password"))
            yield self.askPassword(
                _("Domain password for the desktop"), False)
            self.printERROR(_("Wrong password"))

        samba = Samba()
        for pwdRemote in passwdQueue():
            pwdRemote = pwdRemote or ""
            domain = self.get_server_domainname(host)
            if samba.password_check("client", pwdRemote, host, "remote",
                                    domain):
                self.clVars.Set('cl_remote_pw', pwdRemote)
                return True
        return False

    def writeClientVars(self, domain, currentVersion, pwdRemote):
        """
        Записать переменные переменные клиента
        """
        # write domain to config
        self.clVars.Write("os_remote_auth", domain, True)
        # write current program version
        self.clVars.Write("cl_remote_host", domain, True, "local")
        self.clVars.Write("cl_remote_pw", pwdRemote, True, "local")
        return True

    def checkDomainInfo(self, domain):
        """
        Проверить наличие настроек на сервере для конфигурации LDAP
        """
        servDn = self.getInfoService("ldap", "services_dn")
        unixDn = self.getInfoService("unix", "dn")
        bindDn = self.getInfoService("unix", "bind_dn")
        bindPw = self.getInfoService("unix", "bind_pw")
        sambaHost = self.getInfoService("samba", "host")
        # check info from server
        if not (servDn and unixDn and bindDn and bindPw):
            raise ClientError(_("Info not found on the server") + _(": ") +
                              _(
                                  "services DN or unix DN or bind DN or bind password"))
        self.clVars.Set("os_remote_auth", domain)
        try:
            self.getDomainPassword(sambaHost)
        except ClientError:
            self.printWARNING(
                _("Failed to authorize on %s") % sambaHost)
            self.printWARNING(
                _("Wrong value of variable sr_samba_host in %s") %
                "/var/calculate/remote/calculate.env")
        return True

    def applyClientTemplates(self, hostAuth=""):
        """
        Применить шаблоны клиента

        Установка события домен/не домен по удаленному хосту
        Установка переменной os_remote_auth, необходимой для корректного
        выполнения шаблонов
        Выполнение шаблонов
        Установка необходимых переменных в calculate.env
        """
        if hostAuth:
            # add to domain
            self.clVars.Set("cl_action", "domain", True)
        else:
            # del from domain
            self.clVars.Set("cl_action", "undomain", True)
        self.clVars.Set("os_remote_auth", hostAuth)
        # apply system templates
        self.applyTemplates(None, False)
        if hostAuth:
            self.printSUCCESS(_("The workstation was configured for work "
                                "in the domain"))
            self.clVars.Write("os_remote_auth", hostAuth, True)
        else:
            self.printSUCCESS(_("The workstation was configured for work "
                                "outside the domain"))
            self.clVars.Delete("os_remote_auth")
        return True

    def cDelLdapSysUsersAndSyncCache(self):
        """
        Удалить LDAP пользователей из системы (/etc/passwd и т.д.) и
        синхронизировать кэш
        """
        cacheObj = userCache(self)
        if not cacheObj.deleteCacheUsersFromSystem():
            return False
        if not cacheObj.syncCacheToLdap():
            return False
        return True

    def cAddCacheUsersFromSystem(self):
        """
        Добавить кэш пользователей из системы
        """
        cacheObj = userCache(self)
        if not cacheObj.addCacheUsersFromSystem():
            return False
        return True

    def cAddUserToCache(self, userName, userPwd):
        """
        Добавить пользователя в кэш
        """
        cacheObj = userCache(self)
        pwdHash = self.getHashPasswd(userPwd, "shadow_ssha256")
        if not cacheObj.addUserToCache(userName, pwdHash):
            return False
        return True

    def cDelLdapSysUsersAndClearCache(self):
        """
        Удалить LDAP пользователей из системы и очистить кэш
        """
        cacheObj = userCache(self)
        if not cacheObj.deleteCacheUsersFromSystem():
            return False
        if not cacheObj.clearCache():
            return False
        return True

    def mountRemoteRes(self, pwdRemote, pathRemote, *domains):
        """
        Подключить удаленный ресурс remote
        """
        # первый домен из списка
        domain = reduce(lambda x, y: x if x else y, domains, "")
        foundMountRemote = isMount(pathRemote)
        if foundMountRemote:
            self.printWARNING(_("Samba volume [%s] mounted") % "remote")
            return True
        else:
            if not (domain and pwdRemote):
                self.printERROR(_("Variable not found") +
                                _(": ") + "cl_remote_pw")
                return False
            if not os.path.exists(pathRemote):
                os.makedirs(pathRemote)
            if not self.mountSambaRes(domain, "client", pwdRemote,
                                      "remote", pathRemote):
                self.printERROR(
                    _("Failed to mount the Samba volume [%s]") % "remote")
                return False
            self.printSUCCESS(_("Samba volume [%s] mounted") % "remote")
            return True

    def clientPasswd(self, userLogin, uid, gid, homeDir, password, curPassword):
        """
        Изменить пароль пользователя. Пароль пользователя меняется на сервере
        после выхода из сеанса
        """
        varsConfig = {"unix_hash": self.getHashPasswd(password, "ssha"),
                      "samba_lm_hash": self.getHashPasswd(password, "lm"),
                      "samba_nt_hash": self.getHashPasswd(password, "nt"),
                      "samba_nt_hash_old": self.getHashPasswd(curPassword,
                                                              "nt")}
        if filter(lambda x: not x, varsConfig.values()):
            return False
        # ~/.calculate/server.env
        fileConfig = os.path.join(homeDir, self.configFileServer)
        try:
            res = self.setServerCommand(["passwd_samba"], varsConfig,
                                        fileConfig,
                                        uid, gid)
        except OSError as e:
            if e.errno == 13:
                self.printERROR(_("Permission denied"))
                return False
            return False
        return res

    def get_syncer(self, remotehost, user, pwd):
        return ProfileSyncer(remotehost, 2009, user, pwd)

    def checkSync(self, remotehost):
        status = self.get_syncer(remotehost, None, None).check()
        self.clVars.Set('cl_client_rsync_profile_set',
            "on" if status else "off",
            force=True)
        return status

    def syncLoginProfileNew(self, host, username, pwd,
                            uid, gid, homeDir,
                            profileName, replHost=False,
                            clearHomeDir=True):
        """
        Получить профиль пользователя из домена
        """
        ps = self.get_syncer(host, username, pwd)
        # if currect server has any files then sync it
        remoteProfile = "::profile/{}".format(profileName)
        if replHost:
            remoteOpts = ("-c", "--zc=zstd")
        else:
            remoteOpts = ()
        if not self.syncUserNew(ps, uid, gid, homeDir, "login",
                                remoteProfile, host=host,
                                rsyncopts=remoteOpts):
            error_output = ps.output
            if remoteOpts and re.search(r"(on remote machine.*unknown option|"
                          "unknown compress name:)",
                    error_output):
                if self.syncUserNew(ps, uid, gid, homeDir, "login",
                                    remoteProfile, host=host):
                    return True
            if re.search(r'change_dir "\?{resPath}" \(in {resName}\) '
                'failed: No such file or directory'.format(
                    resPath=profileName,
                    resName="profile"), error_output) or \
                    not ps.exists(remoteProfile):
                if clearHomeDir:
                    # clean home directory
                    if not self.clearHomeDir(homeDir):
                        return False
                return True
            else:
                self.printERROR(error_output)
                self.printERROR(_("Failed to execute rsync"))
                return False
        return True

    def syncLogoutProfileNew(self, host, username, pwd,
                             uid, gid, homeDir,
                             profileName, skipList):
        """
        Закачать профиль пользователя в домен
        """
        skipList = [os.path.relpath(x, homeDir) for x in skipList]
        ps = self.get_syncer(host, username, pwd)
        # if currect server has any files then sync it
        remoteProfile = "::profile/{}".format(profileName)
        if listDirectory(homeDir):
            with writeFile(os.path.join(homeDir,".logout")) as f:
                f.write("SUCCESS")
            if not self.syncUserNew(ps, uid, gid, homeDir, "logout",
                                    remoteProfile, host=host, skipList=skipList):
                self.printERROR(ps.output)
                self.printERROR(_("Failed to execute rsync"))
                return False
        return True

    def syncUserNew(self, ps, uid, gid, userHome, sync,
                 remoteProfile,
                 host="default", skipList=(), rsyncopts=()):
        """
        Синхронизация профиля пользователя
        """
        execStr = ""
        rsyncopts = list(rsyncopts)
        skipPaths = self.clVars.Get("cl_sync_skip_path")
        if not skipPaths:
            self.printERROR(
                _("Variable 'cl_sync_skip_path' empty") % userHome)
            return False
        deletePaths = self.clVars.Get("cl_sync_del_path")
        if not deletePaths:
            deletePaths = []
        excludePaths = ['--exclude=/%s'% x
            for x in skipPaths + deletePaths + list(skipList)
            if x not in {".logout"} ]
        rsyncParams = []
        if sync == "login":
            if os.path.exists(userHome):
                filterPath = ['--filter=P /%s'% x for x in skipPaths
                    if x not in {".logout"}
                ]
                rsyncParams = ['--delete-excluded',
                    '--delete'] + excludePaths + filterPath + [
                        '-rlptgo', '-x'
                    ]
                source, target = remoteProfile, userHome
        elif sync == "logout":
            if os.path.exists(userHome) and os.listdir(userHome):
                rsyncParams = ['--delete-excluded',
                    '--delete'] + excludePaths + [
                        '-rlpt', '-x'
                    ]
                source, target = userHome, remoteProfile
        else:
            raise ClientError(
                _("Method syncUser: wrong option sync=%s") % str(sync))
        if rsyncParams:
            host = "<i>" + host + "</i>"
            if sync == "login":
                title = _("Fetching the user profile from %s") % host
            elif sync == "logout":
                title = _("Uploading the user profile to %s") % host
            self.startTask(title)
            self.addProgress()
            rsyncParams.extend(rsyncopts)

            for i in ps.sync("%s/"%source, "%s/"%target, *rsyncParams):
                self.setProgress(i)

            pathConfig = os.path.join(userHome,
                                      self.pathConfig)
            try:
                if iniParser(configFileName).setVar(
                        'rsync', {'exitcode': rsync.getExitCode()}):
                    os.chmod(configFileName, 0600)
                    os.chown(configFileName, uid, gid)
            except Exception:
                pass
            if ps.exitstatus != 0:
                return False
        # change permissions
        changeDirs = [userHome]
        for changeDir in filter(path.exists, changeDirs):
            # get directory permissions
            mode = getModeFile(changeDir, mode="mode")
            # if permission wrong( not 0700) then change it
            if mode != 0700:
                os.chmod(changeDir, 0700)
        self.endTask()
        return True

    def update_fastlogin_domain_path(self):
        fn = '/var/lib/calculate/calculate-desktop/fastlogin-domain'
        try:
            with writeFile(fn) as f:
                f.write("{}\n".format(
                    "\n".join(get_fastlogin_domain_path(self.clVars))))
        except Exception:
            if os.path.exists(fn):
                try:
                    os.unlink(fn)
                except Exception:
                    pass
        return True