# -*- coding: utf-8 -*-

# 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.
#  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
import re
from calculate.lib.datavars import (Variable, VariableError, ReadonlyVariable,
                                    ReadonlyTableVariable, FieldValue,
                                    HumanReadable)
from calculate.lib.cl_ini_parser import iniParser
from calculate.lib.configparser import ConfigParser
import calculate.lib.utils.device as device
from calculate.lib.utils.files import (readFile, find,
                                       FindFileType)
from calculate.lib.utils.mount import isMount
from calculate.lib.utils.common import getValueFromCmdLine, CmdlineParams
from calculate.lib.utils.portage import isPkgInstalled
from calculate.lib.variables import user
from calculate.lib.convertenv import convertEnv
from calculate.lib.utils.ip import isOpenPort
import time
import ldap
from socket import gethostbyname
from calculate.lib.cl_ldap import ldapUser
from calculate.lib.variables.user import LdapHelper
import pwd
from ..client import Client
from ..rsync import ProfileSyncer, ProfileSyncerError

from calculate.lib.cl_lang import setLocalTranslate, getLazyLocalTranslate

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


class VariableClRemoteHost(Variable):
    """
    IP or domain name of CDS
    """
    value = ""

class VariableClRemoteDomain(Variable):
    """
    Имя домена 
    """
    value = ""

class VariableClRemoteHostNew(Variable):
    """
    IP or domain name of CDS
    """
    opt = ["cl_remote_host_new"]
    metavalue = "DOMAIN"
    type = "choiceedit"
    value = ""
    untrusted = True

    def init(self):
        self.label = _("Domain IP")
        self.help = _("domain")

    def check(self, value):
        if self.Get('cl_client_mount_set') == 'off':
            if self.Get('cl_localhost_set') == 'off':
                if self.Get('cl_remote_host') == '':
                    if not value:
                        raise VariableError(_("Please specify the domain"))
                    elif not isOpenPort(value, 445):
                        raise VariableError(
                            _("The specified address is not available"))


class VariableClRemoteHostLive(ReadonlyVariable):
    """
    Remote host from /proc/cmdline param domain
    """

    def get(self):
        return getValueFromCmdLine(CmdlineParams.Calculate,
                                   CmdlineParams.Domain) or ""


class VariableOsRemoteAuth(Variable):
    """
    Client work mode (local or hostname)
    """


class VariableOsRemoteClient(Variable):
    """
    Version which apply templates
    """
    pass


class VariableClRemotePw(Variable):
    """
    Client password
    """
    type = "onepassword"
    opt = ["--domain-password"]

    def init(self):
        self.label = __("Domain password")
        self.help = _("specify the domain password")

    def get(self):
        return getValueFromCmdLine(CmdlineParams.Calculate,
                                   CmdlineParams.DomainPassword) or ""


class VariableClMovedSkipPath(Variable):
    """
    Skip "Moved" path
    """
    type = "list"
    value = ['Disks', 'Home', 'Moved', 'FTP', 'Desktop', 'Share']


class VariableClSyncSkipPath(Variable):
    """
    Skip sync path
    """
    type = "list"
    value = [".googleearth", "Home", "Disks", "FTP",
             'Share', ".local/share/akonadi/db_data", ".VirtualBox",
             ".mozilla/firefox/calculate.default/urlclassifier3.sqlite",
             ".local/share/mime/mime.cache", ".gvfs",
             ".kde4/share/apps/nepomuk/repository/main/data", ".logout",
             ".Xauthority", ".thumbnails", ".mozilla/firefox/*/Cache",
             ".kde4/socket-*", ".cache/", ".local/share/Trash"]


class VariableClSyncDelPath(Variable):
    """
    Removed path on sync
    """
    type = "list"
    value = [".kde4/share/config/phonondevicesrc",
             ".kde4/cache-*", ".kde4/tmp-*"]


class VariableClProfileAllSet(Variable):
    type = "bool"
    value = "off"


class VariableClClientSync(Variable):
    type = "bool"
    value = "on"
    metavalue = "ON/OFF"

    opt = ["--sync"]

    def init(self):
        self.label = _("Synchronize the user profile")
        self.help = _("synchronize user preferences")


class VariableClLocalhostSet(Variable):
    """
    Using autopartition
    """
    type = "bool"
    element = "radio"
    value = "off"
    opt = ["-r"]
    metavalue = "ON/OFF"
    untrusted = True

    def init(self):
        self.label = _("Workstation role")
        self.help = _("remove the domain connection settings")

    def choice(self):
        return [("off", _("Domain workstation")),
                ("on", _("Local workstation"))]

    def check(self, value):
        if self.Get('cl_client_mount_set') == 'off':
            if self.Get('cl_remote_host') == '' and value == "on":
                raise VariableError(_("The workstation is not in the domain"))
            if self.Get('cl_remote_host') != '' and value == "off":
                raise VariableError(
                    _("The workstation is already in the domain %s")
                    % self.Get('cl_remote_host') + "\n" +
                    _("Before joining the domain, "
                      "you need to remove it from the previous domain"))

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


class VariableClClientMountSet(Variable):
    """
    Mount remote by configured domain information
    """
    type = "bool"
    value = "off"
    metavalue = "ON/OFF"
    opt = ["--mount"]

    def init(self):
        self.label = _("Only mount the domain resource")
        self.help = _("only mount the [remote] domain resource")


class VariableUrUserPw(Variable, LdapHelper):
    """
    Current user password
    """
    type = "need-onepassword"
    opt = ["--old-password"]
    metavalue = "OLDPASSWORD"
    value = ""
    untrusted = True

    def init(self):
        self.label = _("Current password")
        self.help = _("current user password")

    def checkUserPwdLDAP(self, server, userDN, password):
        """Check unix user password on server"""
        ldapInit = ldap.initialize("ldap://%s" % server)
        try:
            ldapInit.bind_s(userDN, password)
        except ldap.INVALID_CREDENTIALS:
            raise VariableError(_("Wrong password"))
        except ldap.LDAPError as e:
            raise VariableError(f"{e.args[0]['desc']}; {e.args[0]['info']}")
        return True

    def check(self, value):
        if not value:
            raise VariableError(_("Empty password"))
        # читаем os_remote_auth, так как при смене пароля
        # чтение должно выполняться от пользователя,
        # cl_remote_host не может быть прочитан пользователем
        server = self.Get('os_remote_auth')
        ldapObj = self.getLdapUserObject()
        if ldapObj:
            usersDN = ldapObj.getUsersDN()
            userDN = ldapObj.addDN("uid=%s" % self.Get('ur_login'),
                                   usersDN)
            self.checkUserPwdLDAP(server, userDN, value)


class VariableUrUserNewPw(Variable):
    """
    New user password
    """
    type = "need-password"
    opt = ["--new-password"]
    metavalue = "NEWPASSWORD"
    value = ""
    untrusted = True

    def init(self):
        self.label = _("New password")
        self.help = _("new user password")

    def check(self, value):
        if not value:
            raise VariableError(_("Empty password"))


class VariableClClientLogin(user.VariableUrLogin):
    """
    User Login
    """
    opt = ["cl_client_login"]
    alias = "ur_login"

    def choice(self):
        loginChoice = user.VariableUrLogin.choice(self)
        if self.Get('cl_action') == 'passwd':
            return [x for x in loginChoice if x != "root"]
        else:
            return loginChoice

    def check(self, value):
        """Does user exist"""
        if not value in self.choice() and self.Get('cl_action') == 'logout':
            raise VariableError(_("X session users not found"))
        if value == "":
            raise VariableError(_("Please specify the user"))
        if value == "root" and self.Get('cl_action') == 'passwd':
            raise VariableError(
                _("This action can be executed by a non-root user only"))
        try:
            pwd.getpwnam(value).pw_gid
        except (TypeError, KeyError):
            raise VariableError(_("User %s does not exist") % value)

    def get(self):
        if (self.Get('cl_action') == 'passwd' and
                    self.Get('ur_login') != 'root'):
            return self.Get('ur_login')
        return ""


class VariableClClientRelevanceSet(ReadonlyVariable):
    """
    Актуальны ли сейчас выполненные шаблоны
    """
    type = "bool"

    def get(self):
        # если происходят действия ввода или вывода из домена
        if (self.Get('cl_action') in ("domain", "undomain") and
                    self.Get('cl_client_mount_set') == 'off'):
            return "off"
        # если изменился домен
        if self.Get('cl_remote_host') != self.Get("os_remote_auth"):
            return "off"
        if (self.Get('cl_remote_host') and
                not isMount(self.Get('cl_client_remote_path'))):
            return "off"
        return "on"


class VariableClClientRemotePath(Variable):
    """
    Путь для монитрования //domain/remote
    """
    value = "/var/calculate/remote"


class VariableClClientProfileName(Variable):
    """
    Название удаленного профиля (CLD,CLDX,all)
    """

    def get(self):
        return ("all" if self.Get('cl_profile_all_set') == 'on'
                else self.Get('os_linux_shortname'))


class VariableClLdapData(ldapUser, ReadonlyVariable):
    """
    Внутренняя переменная, содержащая объект для доступа к данным LDAP
    """
    type = "object"

    def get(self):
        return self

    def getReplDN(self):
        """
        Получить из LDAP домен на котором находится актуальный профиль
        Get from LDAP last domain server

        Branch has ((username,systemname,host))
        """
        usersDN = self.getUsersDN()
        if usersDN:
            partDN = "ou=Worked,ou=Replication,ou=LDAP"
            servicesDN = "ou=Services"
            baseDN = usersDN.rpartition(servicesDN + ",")[2]
            replDN = self.addDN(partDN, servicesDN, baseDN)
            return replDN
        return False

    def searchPrevHost(self, userName, osLinuxShort):
        """Find server which user use"""
        connectData = self.getBindConnectData()
        if connectData:
            bindDn, bindPw, host = connectData
            replDN = self.getReplDN()
            # find string for service replication branch
            userAndOsName = "%s@%s" % (userName, osLinuxShort)
            findAttr = "uid=%s" % userAndOsName
            # connect to LDAP
            if not self.ldapConnect(bindDn, bindPw, host):
                return False
            resSearch = self.ldapObj.ldapSearch(replDN, ldap.SCOPE_ONELEVEL,
                                                findAttr, ["host"])
            return resSearch
        return False

    def _gethostbyname(self, hostname):
        try:
            return gethostbyname(hostname)
        except Exception:
            return None

    def getNameRemoteServer(self, userName, osLinuxShort, curHost):
        """
        Get remote domain hostname or empty if profile is keeped on 
        current server
        """
        searchPrevHost = self.searchPrevHost(userName, osLinuxShort)
        if searchPrevHost and 'host' in searchPrevHost[0][0][1]:
            prevHost = searchPrevHost[0][0][1]['host'][0]
        else:
            prevHost = None
        # get ip address of previous server and current server
        prevIp = self._gethostbyname(prevHost)
        curIp = self._gethostbyname(curHost)
        # if actual profile not found or on local
        if not prevHost or curIp and prevIp == curIp:
            return ""
        else:
            return prevHost

    def isRepl(self):
        """
        Is on or off replication on server
        """
        connectData = self.getBindConnectData()
        if connectData:
            bindDn, bindPw, host = connectData
            usersDN = self.getUsersDN()
            partDN = "ou=Replication,ou=LDAP"
            servicesDN = "ou=Services"
            baseDN = usersDN.rpartition(servicesDN + ",")[2]
            replDN = self.addDN(partDN, servicesDN, baseDN)
            findAttr = "ou=Worked"
            # connect to LDAP
            if not self.ldapConnect(bindDn, bindPw, host):
                return False
            resSearch = self.ldapObj.ldapSearch(replDN, ldap.SCOPE_ONELEVEL,
                                                findAttr,
                                                [findAttr.partition("=")[0]])
            if resSearch:
                return True
        return False


class VariableClReplicationHost(ReadonlyVariable):
    """
    Удаленный сервер при репликации, который содержит актуальный профиль
    """

    def get(self):
        return self.Get('cl_ldap_data').getNameRemoteServer(
            self.Get('ur_login'), self.Get('cl_client_profile_name'),
            self.Get('cl_remote_host'))


class VariableClClientUserMountData(ReadonlyTableVariable):
    """
    Таблица монтирования ресурсов
    """
    source = ['cl_client_user_mount_name',
              'cl_client_user_mount_resource',
              'cl_client_user_mount_path',
              'cl_client_user_mount_host']

    def get(self, hr=HumanReadable.No):
        home = path.split(self.Get('ur_home_path'))[0]
        envFile = self.Get('cl_env_server_path')
        samba_host = self.Get('sr_samba_host')
        ftp_host = convertEnv().getVar("ftp", "host")

        def generate():
            yield (
                "share", "share", path.join(self.Get('ur_home_path'), "Share"),
                samba_host)
            yield (
                "unix", "unix", path.join(home, ".%s" % self.Get('ur_login'),
                                          "profile"),
                samba_host)
            yield (
                "homes", "homes", path.join(self.Get('ur_home_path'), "Home"),
                samba_host)
            if ftp_host:
                yield ("ftp", "ftp", path.join(self.Get('ur_home_path'), "FTP"),
                       ftp_host)
            else:
                yield ("ftp", '', '', '')
            if self.Get('cl_replication_host'):
                yield ("remote_profile", "unix",
                       path.join(home, ".%s" % self.Get('ur_login'),
                                 "remote_profile"),
                       self.Get('cl_replication_host'))
            else:
                yield ("remote_profile", 'unix', '', '')

        return list(generate())


class VariableClClientUserMountUnixPath(ReadonlyVariable):
    """
    Путь до подключенного unix ресурса данного пользователя
    """
    def get(self):
        return self.select('cl_client_user_mount_path',
                            cl_client_user_mount_name='unix', limit=1) or ""


class VariableClClientUserMountName(FieldValue, ReadonlyVariable):
    """
    Название удаленного ресурса
    """
    type = "list"
    source_variable = "cl_client_user_mount_data"
    column = 0


class VariableClClientUserMountResource(FieldValue, ReadonlyVariable):
    """
    Название удаленного ресурса
    """
    type = "list"
    source_variable = "cl_client_user_mount_data"
    column = 1


class VariableClClientUserMountPath(FieldValue, ReadonlyVariable):
    """
    Путь подключения удаленного ресурса
    """
    type = "list"
    source_variable = "cl_client_user_mount_data"
    column = 2


class VariableClClientUserMountHost(FieldValue, ReadonlyVariable):
    """
    Удаленный сервер
    """
    type = "list"
    source_variable = "cl_client_user_mount_data"
    column = 3


class SyncHelper():
    """
    Вспомогательный объект для определения статуса синхронизации и времени
    по конфигурационным файлам
    """

    def getSyncStatus(self, rpath):
        """
        Получить  status_sync из desktop файла
        """
        fileConfig = path.join(rpath, Client.configFileDesktop)
        # get data from desktop config on success run get by archive
        if os.path.exists(fileConfig):
            objConfig = iniParser(fileConfig)
            data = self.getDataInConfig("main", ["status_sync"],
                                        objConfig)
            if data:
                return data.get("status_sync", "")
        return ""

    def getDataInConfig(self, section, listVars, objConfig):
        """
        Прочитать список переменных из области конфигурационного файла
        """
        varsConfig = {}
        for varName in listVars:
            varsConfig[varName] = objConfig.getVar(section, varName)
        if objConfig.getError():
            return False
        return varsConfig

    def convertDate(self, strdate, dateformat="%Y-%m-%d %H:%M:%S"):
        """
        Convert date from string format (dateformat) to stuct or None
        """
        if strdate:
            try:
                return time.strptime(strdate, dateformat)
            except ValueError:
                pass
        return ""

    def getDateObjClientConf(self, rpath):
        """
        Получить время синхронизации из .calculate/desktop.env
        """
        fileConfig = path.join(rpath, Client.configFileDesktop)
        if os.path.exists(fileConfig):
            objConfig = iniParser(fileConfig)
            data = self.getDataInConfig("main", ["date", "date_logout"],
                                        objConfig)
            timeLogout = data["date_logout"]
            timeConfig = data["date"]
            dates = [x for x in [self.convertDate(timeLogout),
                            self.convertDate(timeConfig)] if x]
            if dates:
                return dates[0]
        return ""

    def checkNeedSync(self, homeDir, rpath, curTimeObj, curStatusSync,
                      osLinuxShort):
        """
        Проверить необходимость синхронизации текущего профиля с удаленным
        """
        # profile directory
        # fileConfig = os.path.join(homeDir, Client.configFileServer)
        pathProfile = os.path.join(rpath, osLinuxShort)
        # if readFile(fileConfig).strip():
        #    return True
        fileSoftConfigThis = os.path.join(pathProfile,
                                          Client.configFileSoft)
        fileSoftConfigCur = os.path.join(homeDir,
                                         Client.configFileSoft)
        xSessionCur = iniParser(fileSoftConfigCur).getVar('main', 'xsession')
        xSessionThis = iniParser(fileSoftConfigThis).getVar('main', 'xsession')
        # check profile date on current server
        # fileConfigThis = os.path.join(pathProfile, Client.configFileDesktop)
        # if iniParser(fileConfigThis).getVar('main','status_sync') == "success":
        #    self.setVarToConfig("main", {"status_sync":"success_mount"},
        #                        fileConfigThis)
        thisTimeObj = self.getDateObjClientConf(pathProfile)
        if curStatusSync == "success_logout" and \
                        xSessionCur == xSessionThis and \
                thisTimeObj and curTimeObj and \
                        curTimeObj >= thisTimeObj:
            return False
        return True

    def getSyncDate(self, osLinuxShort, ps):
        """
        Получить время синхронизации из ::profile/.calculate/desktop.env
        """
        desktopEnvRemoteData = ps.readfile("::profile/{}/{}".format(
            osLinuxShort, Client.configFileDesktop))
        if desktopEnvRemoteData:
            cpRemote = ConfigParser(strict=False)
            cpRemote.read_string(desktopEnvRemoteData)
            timeLogout = cpRemote.get("main", "date_logout", fallback=None)
            timeConfig = cpRemote.get("main", "date", fallback=None)
            dates = [x for x in [self.convertDate(timeLogout),
                    self.convertDate(timeConfig)] if x]
            if dates:
                return dates[0]
        return ""


    def checkNeedSyncNew(self, homeDir, rpath, curTimeObj, curStatusSync,
                      osLinuxShort, ps):
        """
        Проверить необходимость синхронизации текущего профиля с удаленным
        """
        iniEnvRemoteData = ps.readfile("::profile/{}/{}".format(
            osLinuxShort, Client.configFileSoft))
        fileConfigCur = os.path.join(homeDir, Client.configFileSoft)
        iniEnvCurrentData = readFile(fileConfigCur)
        cpCur = ConfigParser(strict=False)
        cpCur.read_string(iniEnvCurrentData)
        cpRemote = ConfigParser(strict=False)
        cpRemote.read_string(iniEnvRemoteData)

        xSessionCur = cpCur.get('main', 'xsession', fallback=None)
        xSessionThis = cpThis.get('main', 'xsession', fallback=None)
        if curStatusSync == "success_logout" and \
                        xSessionCur == xSessionThis:
            thisTimeObj = self.getSyncDate(osLinuxShort, ps)
            if thisTimeObj and curTimeObj and \
                        curTimeObj >= thisTimeObj:
                return False
        return True


class VariableClClientSyncTime(SyncHelper, ReadonlyVariable):
    """
    Текущее время синхронизации профиля
    """

    def get(self):
        return self.getDateObjClientConf(self.Get('ur_home_path'))


class VariableClClientPackTime(SyncHelper, ReadonlyVariable):
    """
    Время комады упаковки профиля
    """

    def get(self):
        return str(float(time.time()))


class VariableClClientSyncStatus(SyncHelper, ReadonlyVariable):
    """
    Текущий статус синхронизации профиля
    """

    def get(self):
        return self.getSyncStatus(self.Get('ur_home_path'))


class VariableClClientLocalSyncTime(SyncHelper, ReadonlyVariable):
    """
    Текущий статус синхронизации профиля
    """

    def get(self):
        return self.getDateObjClientConf(
            path.join(
                self.Select('cl_client_user_mount_path',
                            where='cl_client_user_mount_name', eq='unix',
                            limit=1), self.Get('cl_client_profile_name')))


class VariableClClientRsyncProfileSet(ReadonlyVariable):
    """
    Используется rsync через ssh для синхронизации пользовательского профиля
    """
    type = "bool"
    value = "off"

#TODO ProfileSyncer likely doesn't work in py3
class VariableClClientSyncReplicationSet(SyncHelper, ReadonlyVariable):
    """
    Нужно ли синхронизировать текущий профиль с удаленным доменом
    """
    type = "bool"

    host_varname = "cl_replication_host"
    profile_type = "remote_profile"

    def old_synchronize(self):
        profilePath = self.Select('cl_client_user_mount_path',
                                  where='cl_client_user_mount_name',
                                  eq=self.profile_type, limit=1)
        if self.Get('cl_action') == 'login' and not isMount(profilePath):
            raise VariableError(_("Remote profile not mounted"))
        return "on" if self.checkNeedSync(self.Get('ur_home_path'), profilePath,
                                          self.Get('cl_client_sync_time'),
                                          self.Get('cl_client_sync_status'),
                                          self.Get(
                                              'cl_client_profile_name')) else "off"

    def new_synchronize(self):
        user = self.Get('ur_login')
        pwd = self.Get('desktop.ur_password')
        remotehost = self.Get(self.host_varname)
        ps =  ProfileSyncer(remotehost, 2009, user, pwd)

        if ps.check():
            return "on" if self.checkNeedSyncNew(
                self.Get('ur_home_path'), profilePath,
                self.Get('cl_client_sync_time'),
                self.Get('cl_client_sync_status'),
                self.Get('cl_client_profile_name'),
                ps) else "off"
        return "off"

    def get(self):
        if not self.Get(self.host_varname):
            return "off"

        if self.GetBool('cl_client_rsync_profile_set'):
            return self.new_synchronize()
        else:
            return self.old_synchronize()


class VariableClClientSyncLocalSet(VariableClClientSyncReplicationSet):
    """
    Нужно ли синхронизировать текущий профиль с локальным доменом
    """
    type = "bool"

    host_varname = "cl_remote_host"
    profile_type = "unix"


class VariableClClientSymlinks(ReadonlyVariable):
    """
    Список симлинков в пользовательском профиле
    """

    def get(self):
        skipFiles = (self.Get('cl_sync_del_path') +
                     self.Get('cl_sync_skip_path'))
        reSkip = re.compile("|".join((x.replace("*", ".*") for x in skipFiles))).search
        return [x for x in find(self.Get('ur_home_path'), onefilesystem=True,
                           filetype=FindFileType.SymbolicLink) 
                           if not reSkip(x)]


class VariableClClientNscdCache(Variable):
    """
    Частота обновления кэша nscd при работе в домене в часах
    """


class VariableClCifsVer(ReadonlyVariable):
    """
    Версия модуля CIFS
    """

    def get(self):
        return device.sysfs.read(device.sysfs.Path.Module, "cifs/version")


class VariableClCifsCache(Variable):
    """
    Параметр cache= при монтировании cifs
    """
    value = "loose"

class VariableClCifsMountVers(Variable):
    """
    Параметр vers= для cifs
    """
    value = "1.0"


class VariableClRsyncVer(ReadonlyVariable):
    """
    Версия rsync
    """

    def get(self):
        data = isPkgInstalled('net-misc/rsync')
        if data:
            return data[0]['PVR']
        return ""

class VariableClCifsutilsVer(ReadonlyVariable):
    """
    Версия cifs-utils
    """
    def get(self):
        data = isPkgInstalled('net-fs/cifs-utils')
        if data:
            return data[0]['PV']
        return ""

class VariableClClientIgnoreErrorsSet(Variable):
    """
    Параметр, для отключения отмонтирования пользовательских ресурсов,
    при ошбиках, возникших во вермя cl-client-sync-login
    """
    type = "bool"
    value = "on"
    metavalue = "ON/OFF"

    opt = ["--unmount-on-error"]

    def init(self):
        self.label = _("Unmount user resources on error")
        self.help = _("unmount user resources on error")

class VariableClSyncMovedSet(Variable):
    """
    Использовать или нет перенос файлов из домашней директории в Home/Moved при
    синхронизации
    """
    type = "bool"
    value = "on"

class VariableSrSambaHost(Variable):
    """
    Хост на котором находятся samba ресурсы
    """
    def get(self):
        return self.Get('cl_remote_host') or ''