fixed some encoding bugs
This commit is contained in:
parent
17a38b0cfb
commit
15f84dd3aa
6 changed files with 329 additions and 610 deletions
|
|
@ -35,6 +35,7 @@ import string
|
|||
import cl_utils
|
||||
# from .cl_xml import firstChild
|
||||
from cl_xml import firstChild
|
||||
import importlib
|
||||
##############################################################################
|
||||
|
||||
_expand_lang = gettext._expand_lang
|
||||
|
|
@ -449,7 +450,7 @@ class iniParser(cl_profile._error):
|
|||
xmlBody = objIni.docObj.getNodeBody()
|
||||
flagFound, xmlBody = self.getLastNode(objIni, xmlBody, strHeader,
|
||||
formatPlasma)
|
||||
if flagFound and xmlBody:
|
||||
if flagFound and xmlBody is not None:
|
||||
if formatPlasma:
|
||||
strHeader = strHeader[-1]
|
||||
# находим в области переменную
|
||||
|
|
@ -504,7 +505,7 @@ class iniParser(cl_profile._error):
|
|||
xmlBody = objIni.docObj.getNodeBody()
|
||||
flagFound, xmlBody = self.getLastNode(objIni, xmlBody, strHeader,
|
||||
formatPlasma)
|
||||
if flagFound and xmlBody:
|
||||
if flagFound and xmlBody is not None:
|
||||
if formatPlasma:
|
||||
strHeader = strHeader[-1]
|
||||
# если находим область то выдаем словарем все переменные иначе False
|
||||
|
|
@ -656,10 +657,10 @@ class DataVars():
|
|||
# Импортируемые модули - (раздел: модуль переменных, модуль заполнения
|
||||
#переменных)
|
||||
__modlist={
|
||||
# 'Global':('cl_vars','cl_fill'),
|
||||
'Global':('cl_vars','cl_fill'),
|
||||
'Server':('cl_vars_server','cl_fill_server'),
|
||||
# 'Builder':('cl_vars_builder','cl_fill_builder'),
|
||||
# 'Client':('cl_vars_client','cl_fill_client'),
|
||||
'Builder':('cl_vars_builder','cl_fill_builder'),
|
||||
'Client':('cl_vars_client','cl_fill_client'),
|
||||
}
|
||||
def __init__(self):
|
||||
#self.t1 = fillVars()
|
||||
|
|
@ -685,14 +686,16 @@ class DataVars():
|
|||
modFill = self.__modlist[section][1]
|
||||
# Импортируем класс описания переменных и класс заполнения
|
||||
try:
|
||||
eval("import %s" % (modVar))
|
||||
# eval("import %s" % (modVar))
|
||||
modVar_imported = importlib.import_module(modVar)
|
||||
except ImportError as e:
|
||||
err1 = _("Error in import module %s")%modVar
|
||||
err2 = _("error") + ": " +str(e)
|
||||
raise self.DataVarsError("%s\n%s"%(err1,err2))
|
||||
flagFindFillModule = True
|
||||
try:
|
||||
eval("import %s" % (modFill))
|
||||
# eval("import %s" % (modFill))
|
||||
modFill_imported = importlib.import_module(modFill)
|
||||
except ImportError as e:
|
||||
if "No module named" in str(e):
|
||||
flagFindFillModule = False
|
||||
|
|
@ -702,14 +705,16 @@ class DataVars():
|
|||
raise self.DataVarsError("%s\n%s"%(err1,err2))
|
||||
if flagFindFillModule:
|
||||
# Создаем объект с методами заполнения переменных
|
||||
fillObj = eval("%s.fillVars()" % modFill)
|
||||
fillObj = modFill_imported.fillVars()
|
||||
importlib.import_module(modFill)
|
||||
# Подключаем методы получения и записи переменных
|
||||
fillObj.Get = self.Get
|
||||
fillObj.Set = self.Set
|
||||
else:
|
||||
fillObj = False
|
||||
# Заполняем self._importList
|
||||
eval("self._importList.insert(0,(section,%s,fillObj))"%(modVar))
|
||||
self._importList.insert(0,(section, modVar_imported, fillObj))
|
||||
|
||||
|
||||
def __findVarData(self, nameVar):
|
||||
"""Находит данные для создания объекта переменная в модулях и
|
||||
|
|
@ -718,20 +723,21 @@ class DataVars():
|
|||
"""
|
||||
# Ищем переменную в модуле
|
||||
dataVar = False
|
||||
e = False
|
||||
err = False
|
||||
for section, moduleVar, fillobj in self._importList:
|
||||
try:
|
||||
eval("dataVar=moduleVar.Data.%s"%nameVar)
|
||||
# dataVar = moduleVar.Data.nameVar
|
||||
dataVar = getattr(moduleVar.Data, nameVar)
|
||||
except AttributeError as e:
|
||||
pass
|
||||
err = e
|
||||
if dataVar:
|
||||
break
|
||||
if dataVar == False:
|
||||
err1 = _("Not found variable %s")%nameVar
|
||||
err2 = ""
|
||||
if e:
|
||||
err2 = _("error") + ": " +str(e)
|
||||
raise self.DataVarsError("%s\n%s"%(err1,err2))
|
||||
if err:
|
||||
err2 = _("error") + ": " +str(err)
|
||||
raise self.DataVarsError("%s\n%s"%(err1, err2))
|
||||
dataVar['service'] = section
|
||||
# Ищем метод в объекте методов заполнения
|
||||
nameMethod = "get_" + nameVar
|
||||
|
|
|
|||
575
pym/cl_fill.py
575
pym/cl_fill.py
|
|
@ -1,311 +1,304 @@
|
|||
# #-*- coding: utf-8 -*-
|
||||
#-*- coding: utf-8 -*-
|
||||
|
||||
# # Copyright 2008-2010 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.
|
||||
# Copyright 2008-2010 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 re
|
||||
# import os
|
||||
# import types
|
||||
# import cl_utils
|
||||
# import cl_base
|
||||
import re
|
||||
import os
|
||||
import types
|
||||
import cl_utils
|
||||
import cl_base
|
||||
|
||||
# class fillVars_(cl_base.glob_attr):
|
||||
class fillVars(cl_base.glob_attr):
|
||||
|
||||
# def get_os_net_domain(self):
|
||||
# ''' Определим домен'''
|
||||
# domain=self._runos("hostname -d 2>&1")
|
||||
# if not domain:
|
||||
# print _("Error:") + " " +_("Not found domain name")
|
||||
# print _("Command 'hostname -d' returns an empty value")
|
||||
# cl_base.exit(1)
|
||||
# elif re.search("^hostname: ",domain):
|
||||
# return "local"
|
||||
# else:
|
||||
# return domain
|
||||
def get_os_net_domain(self):
|
||||
''' Определим домен'''
|
||||
domain=self._runos("hostname -d 2>&1")
|
||||
if not domain:
|
||||
print(_("Error:") + " " +_("Not found domain name"))
|
||||
print(_("Command 'hostname -d' returns an empty value"))
|
||||
cl_base.exit(1)
|
||||
elif re.search("^hostname: ",domain):
|
||||
return "local"
|
||||
else:
|
||||
return domain
|
||||
|
||||
# def get_os_linux_shortname(self):
|
||||
# '''Получить переменную короткого названия системы'''
|
||||
# path = '/etc/calculate/calculate.ini'
|
||||
# if os.path.exists(path):
|
||||
# FD = open(path)
|
||||
# data = FD.readlines()
|
||||
# FD.close()
|
||||
# shortNameList = filter(lambda y:y,
|
||||
# map(lambda x:\
|
||||
# len(x.split("="))==2 and\
|
||||
# x.split("=")[0]=="calculate" and\
|
||||
# x.split("=")[1].strip(), data))
|
||||
# if shortNameList:
|
||||
# return shortNameList[0]
|
||||
# gentooFile = "/etc/gentoo-release"
|
||||
# shortName = "Linux"
|
||||
# if os.path.exists(gentooFile):
|
||||
# shortName = "Gentoo"
|
||||
# return shortName
|
||||
def get_os_linux_shortname(self):
|
||||
'''Получить переменную короткого названия системы'''
|
||||
path = '/etc/calculate/calculate.ini'
|
||||
if os.path.exists(path):
|
||||
FD = open(path)
|
||||
data = FD.readlines()
|
||||
FD.close()
|
||||
shortNameList = [x for x in (len(y.split("=")) == 2 and\
|
||||
y.split("=")[0]=="calculate" and\
|
||||
y.split("=")[1].strip() for y in data) if x]
|
||||
if shortNameList:
|
||||
return shortNameList[0]
|
||||
gentooFile = "/etc/gentoo-release"
|
||||
shortName = "Linux"
|
||||
if os.path.exists(gentooFile):
|
||||
shortName = "Gentoo"
|
||||
return shortName
|
||||
|
||||
# def get_os_linux_name(self):
|
||||
# """полное название системы"""
|
||||
# linuxShortName = self.Get("os_linux_shortname")
|
||||
# if linuxShortName:
|
||||
# dictLinuxName = {"CLD":"Calculate Linux Desktop",
|
||||
# "CLDX":"Calculate Linux Desktop",
|
||||
# "CLDG":"Calculate Linux Desktop",
|
||||
# "CDS":"Calculate Directory Server",
|
||||
# "Gentoo":"Gentoo"}
|
||||
# if linuxShortName in dictLinuxName.keys():
|
||||
# return dictLinuxName[linuxShortName]
|
||||
# else:
|
||||
# return "Linux"
|
||||
# else:
|
||||
# return "Linux"
|
||||
def get_os_linux_name(self):
|
||||
"""полное название системы"""
|
||||
linuxShortName = self.Get("os_linux_shortname")
|
||||
if linuxShortName:
|
||||
dictLinuxName = {"CLD":"Calculate Linux Desktop",
|
||||
"CLDX":"Calculate Linux Desktop",
|
||||
"CLDG":"Calculate Linux Desktop",
|
||||
"CDS":"Calculate Directory Server",
|
||||
"Gentoo":"Gentoo"}
|
||||
if linuxShortName in dictLinuxName.keys():
|
||||
return dictLinuxName[linuxShortName]
|
||||
else:
|
||||
return "Linux"
|
||||
else:
|
||||
return "Linux"
|
||||
|
||||
# def get_os_linux_subname(self):
|
||||
# """постфикс к названию системы"""
|
||||
# linuxShortName = self.Get("os_linux_shortname")
|
||||
# if linuxShortName:
|
||||
# dictLinuxSubName = {"CLD":"KDE", "CLDX":"XFCE", "CLDG":"GNOME"}
|
||||
# if linuxShortName in dictLinuxSubName.keys():
|
||||
# return dictLinuxSubName[linuxShortName]
|
||||
# else:
|
||||
# return ""
|
||||
# else:
|
||||
# return ""
|
||||
def get_os_linux_subname(self):
|
||||
"""постфикс к названию системы"""
|
||||
linuxShortName = self.Get("os_linux_shortname")
|
||||
if linuxShortName:
|
||||
dictLinuxSubName = {"CLD":"KDE", "CLDX":"XFCE", "CLDG":"GNOME"}
|
||||
if linuxShortName in dictLinuxSubName.keys():
|
||||
return dictLinuxSubName[linuxShortName]
|
||||
else:
|
||||
return ""
|
||||
else:
|
||||
return ""
|
||||
|
||||
# def get_os_linux_ver(self):
|
||||
# '''Получить версию системы'''
|
||||
# path = '/etc/calculate/calculate.ini'
|
||||
# if os.path.exists(path):
|
||||
# FD = open(path)
|
||||
# data = FD.readlines()
|
||||
# FD.close()
|
||||
# shortNameList = filter(lambda y:y,
|
||||
# map(lambda x:\
|
||||
# len(x.split("="))==2 and\
|
||||
# x.split("=")[0]=="linuxver" and\
|
||||
# x.split("=")[1].strip(), data))
|
||||
# if shortNameList:
|
||||
# return shortNameList[0]
|
||||
# gentooFile = "/etc/gentoo-release"
|
||||
# systemVersion = ""
|
||||
# flagGentoo = False
|
||||
# if os.path.exists(gentooFile):
|
||||
# gentooLink = "/etc/make.profile"
|
||||
# if os.path.islink(gentooLink):
|
||||
# systemVersion = os.readlink(gentooLink).rpartition("/")[2]
|
||||
# flagGentoo = True
|
||||
# if not flagGentoo:
|
||||
# kernelVersion=self._runos("uname -r")
|
||||
# if kernelVersion:
|
||||
# systemVersion = kernelVersion.partition("-")[0]
|
||||
# return systemVersion
|
||||
def get_os_linux_ver(self):
|
||||
'''Получить версию системы'''
|
||||
path = '/etc/calculate/calculate.ini'
|
||||
if os.path.exists(path):
|
||||
FD = open(path)
|
||||
data = FD.readlines()
|
||||
FD.close()
|
||||
shortNameList = [x for x in ( len(y.split("="))==2 and\
|
||||
y.split("=")[0]=="linuxver" and\
|
||||
y.split("=")[1].strip() for y in data) if x]
|
||||
if shortNameList:
|
||||
return shortNameList[0]
|
||||
gentooFile = "/etc/gentoo-release"
|
||||
systemVersion = ""
|
||||
flagGentoo = False
|
||||
if os.path.exists(gentooFile):
|
||||
gentooLink = "/etc/make.profile"
|
||||
if os.path.islink(gentooLink):
|
||||
systemVersion = os.readlink(gentooLink).rpartition("/")[2]
|
||||
flagGentoo = True
|
||||
if not flagGentoo:
|
||||
kernelVersion=self._runos("uname -r")
|
||||
if kernelVersion:
|
||||
systemVersion = kernelVersion.partition("-")[0]
|
||||
return systemVersion
|
||||
|
||||
# def get_os_net_hostname(self):
|
||||
# '''Считать имя компьютера net_host'''
|
||||
# hostname=self._runos("hostname -s 2>&1")
|
||||
# if not hostname:
|
||||
# return ""
|
||||
# if re.search("^hostname: ",hostname):
|
||||
# hostname=self._runos("hostname 2>&1")
|
||||
# if not hostname:
|
||||
# return ""
|
||||
# if re.search("^hostname: ",hostname):
|
||||
# return self.Get('os_linux_shortname')
|
||||
# else:
|
||||
# if hostname=='livecd':
|
||||
# return self.Get('os_linux_shortname')
|
||||
# return hostname
|
||||
def get_os_net_hostname(self):
|
||||
'''Считать имя компьютера net_host'''
|
||||
hostname=self._runos("hostname -s 2>&1")
|
||||
if not hostname:
|
||||
return ""
|
||||
if re.search("^hostname: ",hostname):
|
||||
hostname=self._runos("hostname 2>&1")
|
||||
if not hostname:
|
||||
return ""
|
||||
if re.search("^hostname: ",hostname):
|
||||
return self.Get('os_linux_shortname')
|
||||
else:
|
||||
if hostname=='livecd':
|
||||
return self.Get('os_linux_shortname')
|
||||
return hostname
|
||||
|
||||
# # все ip
|
||||
# def get_os_net_ip(self):
|
||||
# """все ip компьютера, разделитель запятая"""
|
||||
# return ",".join(map(cl_utils.getIp,
|
||||
# cl_utils.getInterfaces()))
|
||||
# все ip
|
||||
def get_os_net_ip(self):
|
||||
"""все ip компьютера, разделитель запятая"""
|
||||
return ",".join(cl_utils.getIp(x) for x in cl_utils.getInterfaces())
|
||||
|
||||
# # Разрешенные сети (в данном случае все сети)
|
||||
# def get_os_net_allow(self):
|
||||
# """Разрешенные сети разделитель запятая"""
|
||||
# networks=[]
|
||||
# netInterfaces=cl_utils.getInterfaces()
|
||||
# for i in netInterfaces:
|
||||
# ipaddr, mask = cl_utils.getIp(i), \
|
||||
# cl_utils.cidrToMask(cl_utils.getMask(i))
|
||||
# if ipaddr and mask:
|
||||
# networks.append(cl_utils.getIpNet(ipaddr, mask))
|
||||
# else:
|
||||
# networks.append("")
|
||||
# return ",".join(filter(lambda x:x,networks))
|
||||
# Разрешенные сети (в данном случае все сети)
|
||||
def get_os_net_allow(self):
|
||||
"""Разрешенные сети разделитель запятая"""
|
||||
networks=[]
|
||||
netInterfaces=cl_utils.getInterfaces()
|
||||
for i in netInterfaces:
|
||||
ipaddr, mask = cl_utils.getIp(i), \
|
||||
cl_utils.cidrToMask(cl_utils.getMask(i))
|
||||
if ipaddr and mask:
|
||||
networks.append(cl_utils.getIpNet(ipaddr, mask))
|
||||
else:
|
||||
networks.append("")
|
||||
return ",".join(x for x in networks if x)
|
||||
|
||||
# def get_os_locale_locale(self):
|
||||
# """локаль (прим: ru_RU.UTF-8)"""
|
||||
# if os.environ.has_key("LANG"):
|
||||
# return os.environ["LANG"]
|
||||
# else:
|
||||
# return "en_US.UTF-8"
|
||||
def get_os_locale_locale(self):
|
||||
"""локаль (прим: ru_RU.UTF-8)"""
|
||||
if "LANG" in os.environ:
|
||||
return os.environ["LANG"]
|
||||
else:
|
||||
return "en_US.UTF-8"
|
||||
|
||||
# def get_os_locale_lang(self):
|
||||
# """язык (прим: ru_RU)"""
|
||||
# locale = self.Get("os_locale_locale")
|
||||
# if locale:
|
||||
# return locale.split(".")[0]
|
||||
# return ""
|
||||
def get_os_locale_lang(self):
|
||||
"""язык (прим: ru_RU)"""
|
||||
locale = self.Get("os_locale_locale")
|
||||
if locale:
|
||||
return locale.split(".")[0]
|
||||
return ""
|
||||
|
||||
# def get_os_locale_language(self):
|
||||
# """язык (прим: ru)"""
|
||||
# lang = self.Get("os_locale_lang")
|
||||
# if lang:
|
||||
# return lang.split("_")[0]
|
||||
# return ""
|
||||
def get_os_locale_language(self):
|
||||
"""язык (прим: ru)"""
|
||||
lang = self.Get("os_locale_lang")
|
||||
if lang:
|
||||
return lang.split("_")[0]
|
||||
return ""
|
||||
|
||||
# def get_os_locale_xkb(self):
|
||||
# """раскладка клавиатуры для X"""
|
||||
# path = '/etc/conf.d/keymaps'
|
||||
# mapDict={"by":"us,by",
|
||||
# "be-latin1":"be,us",
|
||||
# "br-abnt2":"br,us",
|
||||
# "cf":"ca,us",
|
||||
# "dk-latin1":"dk,us",
|
||||
# "fr-latin9":"fr,us",
|
||||
# "de-latin1":"de,us",
|
||||
# "is-latin1":"is,us",
|
||||
# "it":"it,us",
|
||||
# "no-latin1":"no,us",
|
||||
# "pl":"pl,us",
|
||||
# "-u ru4":"us,ru(winkeys)",
|
||||
# "es euro2":"es,us",
|
||||
# "sv-latin1":"se,us",
|
||||
# "ua-utf":"us,ua(winkeys)",
|
||||
# "uk":"gb,us",
|
||||
# "us":"us"}
|
||||
# if os.path.exists(path):
|
||||
# FD = open(path)
|
||||
# data = FD.readlines()
|
||||
# FD.close()
|
||||
# shortNameList = filter(lambda y:y,
|
||||
# map(lambda x:\
|
||||
# len(x.split("="))==2 and\
|
||||
# x.split("=")[0]=="KEYMAP" and\
|
||||
# x.split("=")[1].replace('"',"").strip(),\
|
||||
# data))
|
||||
# if shortNameList:
|
||||
# if shortNameList[0] in mapDict.keys():
|
||||
# return mapDict[shortNameList[0]]
|
||||
# lang = self.Get("os_locale_lang")
|
||||
# # Языки:
|
||||
# # Португальский - pt_BR
|
||||
# # Французский - fr_FR
|
||||
# # Немецкий - de_DE
|
||||
# # Итальянский - it_IT
|
||||
# # Польский - pl_PL
|
||||
# # Русский - ru_RU
|
||||
# # Испанский - es_ES
|
||||
# # Украинский - uk_UA
|
||||
# # Английский - en_US
|
||||
# xkbDict = {'pt_BR':'br,us',
|
||||
# 'fr_FR':'fr,us',
|
||||
# 'de_DE':'de,us',
|
||||
# 'it_IT':'it,us',
|
||||
# 'pl_PL':'pl,us',
|
||||
# 'ru_RU':'us,ru(winkeys)',
|
||||
# 'es_ES':'es,us',
|
||||
# 'uk_UA':'us,ua(winkeys)',
|
||||
# 'en_US':'us'}
|
||||
# if lang:
|
||||
# if xkbDict.has_key(lang):
|
||||
# return xkbDict[lang]
|
||||
# return ""
|
||||
def get_os_locale_xkb(self):
|
||||
"""раскладка клавиатуры для X"""
|
||||
path = '/etc/conf.d/keymaps'
|
||||
mapDict={"by":"us,by",
|
||||
"be-latin1":"be,us",
|
||||
"br-abnt2":"br,us",
|
||||
"cf":"ca,us",
|
||||
"dk-latin1":"dk,us",
|
||||
"fr-latin9":"fr,us",
|
||||
"de-latin1":"de,us",
|
||||
"is-latin1":"is,us",
|
||||
"it":"it,us",
|
||||
"no-latin1":"no,us",
|
||||
"pl":"pl,us",
|
||||
"-u ru4":"us,ru(winkeys)",
|
||||
"es euro2":"es,us",
|
||||
"sv-latin1":"se,us",
|
||||
"ua-utf":"us,ua(winkeys)",
|
||||
"uk":"gb,us",
|
||||
"us":"us"}
|
||||
if os.path.exists(path):
|
||||
FD = open(path)
|
||||
data = FD.readlines()
|
||||
FD.close()
|
||||
shortNameList = [x for x in (len(y.split("="))==2 and\
|
||||
y.split("=")[0]=="KEYMAP" and\
|
||||
y.split("=")[1].replace('"',"").strip()
|
||||
for y in data) if x]
|
||||
if shortNameList:
|
||||
if shortNameList[0] in mapDict.keys():
|
||||
return mapDict[shortNameList[0]]
|
||||
lang = self.Get("os_locale_lang")
|
||||
# Языки:
|
||||
# Португальский - pt_BR
|
||||
# Французский - fr_FR
|
||||
# Немецкий - de_DE
|
||||
# Итальянский - it_IT
|
||||
# Польский - pl_PL
|
||||
# Русский - ru_RU
|
||||
# Испанский - es_ES
|
||||
# Украинский - uk_UA
|
||||
# Английский - en_US
|
||||
xkbDict = {'pt_BR':'br,us',
|
||||
'fr_FR':'fr,us',
|
||||
'de_DE':'de,us',
|
||||
'it_IT':'it,us',
|
||||
'pl_PL':'pl,us',
|
||||
'ru_RU':'us,ru(winkeys)',
|
||||
'es_ES':'es,us',
|
||||
'uk_UA':'us,ua(winkeys)',
|
||||
'en_US':'us'}
|
||||
if lang:
|
||||
if lang in xkbDict:
|
||||
return xkbDict[lang]
|
||||
return ""
|
||||
|
||||
# def get_os_locale_xkbname(self):
|
||||
# """названия используемых раскладок клавиатуры для X"""
|
||||
# localeXkb = self.Get("os_locale_xkb")
|
||||
# if localeXkb:
|
||||
# return localeXkb.split("(")[0]
|
||||
# return ""
|
||||
def get_os_locale_xkbname(self):
|
||||
"""названия используемых раскладок клавиатуры для X"""
|
||||
localeXkb = self.Get("os_locale_xkb")
|
||||
if localeXkb:
|
||||
return localeXkb.split("(")[0]
|
||||
return ""
|
||||
|
||||
# def get_os_arch_machine(self):
|
||||
# """архитектура процессора"""
|
||||
# march = self._runos("uname -m")
|
||||
# if not march:
|
||||
# return ""
|
||||
# return march
|
||||
def get_os_arch_machine(self):
|
||||
"""архитектура процессора"""
|
||||
march = self._runos("uname -m")
|
||||
if not march:
|
||||
return ""
|
||||
return march
|
||||
|
||||
# def get_os_root_dev(self):
|
||||
# """корневой раздел файловой системы"""
|
||||
# for record in open('/proc/cmdline','rb').readlines():
|
||||
# re_res=re.search('^root=(\/dev\/[a-z]+[0-9]).*',record.strip())
|
||||
# if re_res:
|
||||
# return re_res.group(1)
|
||||
# else:
|
||||
# mountLunes = self._runos("mount")
|
||||
# if not mountLunes:
|
||||
# return ""
|
||||
# if type(mountLunes) == types.ListType:
|
||||
# root_dev = mountLunes[0].split("on / type")[0].strip()
|
||||
# if root_dev:
|
||||
# return root_dev
|
||||
# return ""
|
||||
def get_os_root_dev(self):
|
||||
"""корневой раздел файловой системы"""
|
||||
for record in open('/proc/cmdline','rb').readlines():
|
||||
re_res=re.search('^root=(\/dev\/[a-z]+[0-9]).*',record.strip())
|
||||
if re_res:
|
||||
return re_res.group(1)
|
||||
else:
|
||||
mountLunes = self._runos("mount")
|
||||
if not mountLunes:
|
||||
return ""
|
||||
if type(mountLunes) == list:
|
||||
root_dev = mountLunes[0].split("on / type")[0].strip()
|
||||
if root_dev:
|
||||
return root_dev
|
||||
return ""
|
||||
|
||||
# def get_os_root_type(self):
|
||||
# """тип носителя (ram, hdd, livecd)"""
|
||||
# mountLunes = self._runos("mount")
|
||||
# if not mountLunes:
|
||||
# return ""
|
||||
# rootType = "hdd"
|
||||
# if type(mountLunes) == types.ListType:
|
||||
# flagCD = False
|
||||
# for line in mountLunes:
|
||||
# if "/dev/loop0 on / type" in line:
|
||||
# rootType = "ram"
|
||||
# break
|
||||
# elif "/dev/loop0 on /newroot/mnt/livecd type" in line:
|
||||
# rootType = "ram"
|
||||
# flagCD = True
|
||||
# break
|
||||
# if rootType == "ram":
|
||||
# if os.path.exists("/mnt/livecd") or flagCD:
|
||||
# rootType = "livecd"
|
||||
# return rootType
|
||||
# rootDev = self.Get("os_root_dev")
|
||||
# if rootType != "ram" and rootDev:
|
||||
# slpRootDev = rootDev.split("/dev/")
|
||||
# if len(slpRootDev) == 2:
|
||||
# rDev = slpRootDev[1]
|
||||
# devLines = self._runos("ls -la /dev/disk/by-id/", None,
|
||||
# {"LANG":"C"})
|
||||
# if not devLines:
|
||||
# return ""
|
||||
# if type(devLines) == types.ListType:
|
||||
# for line in devLines:
|
||||
# if rDev in line and "usb-" in line:
|
||||
# rootType = "usb-hdd"
|
||||
# break
|
||||
# if rootType == "ram":
|
||||
# rootType = "hdd"
|
||||
# return rootType
|
||||
# else:
|
||||
# return ""
|
||||
def get_os_root_type(self):
|
||||
"""тип носителя (ram, hdd, livecd)"""
|
||||
mountLunes = self._runos("mount")
|
||||
if not mountLunes:
|
||||
return ""
|
||||
rootType = "hdd"
|
||||
if type(mountLunes) == list:
|
||||
flagCD = False
|
||||
for line in mountLunes:
|
||||
if "/dev/loop0 on / type" in line:
|
||||
rootType = "ram"
|
||||
break
|
||||
elif "/dev/loop0 on /newroot/mnt/livecd type" in line:
|
||||
rootType = "ram"
|
||||
flagCD = True
|
||||
break
|
||||
if rootType == "ram":
|
||||
if os.path.exists("/mnt/livecd") or flagCD:
|
||||
rootType = "livecd"
|
||||
return rootType
|
||||
rootDev = self.Get("os_root_dev")
|
||||
if rootType != "ram" and rootDev:
|
||||
slpRootDev = rootDev.split("/dev/")
|
||||
if len(slpRootDev) == 2:
|
||||
rDev = slpRootDev[1]
|
||||
devLines = self._runos("ls -la /dev/disk/by-id/", None,
|
||||
{"LANG":"C"})
|
||||
if not devLines:
|
||||
return ""
|
||||
if type(devLines) == list:
|
||||
for line in devLines:
|
||||
if rDev in line and "usb-" in line:
|
||||
rootType = "usb-hdd"
|
||||
break
|
||||
if rootType == "ram":
|
||||
rootType = "hdd"
|
||||
return rootType
|
||||
else:
|
||||
return ""
|
||||
|
||||
# def get_hr_virtual(self):
|
||||
# """Название виртуальной машины (virtualbox, vmware, qemu)"""
|
||||
# pciLines = self._runos("/usr/sbin/lspci")
|
||||
# if not pciLines:
|
||||
# return False
|
||||
# virtSysDict = {'VirtualBox':'virtualbox',
|
||||
# 'VMware':'vmware',
|
||||
# 'Qumranet':'qemu'}
|
||||
# virtName = ''
|
||||
# for vName in virtSysDict.keys():
|
||||
# if filter(lambda x: vName in x, pciLines):
|
||||
# virtName = virtSysDict[vName]
|
||||
# break
|
||||
# return virtName
|
||||
def get_hr_virtual(self):
|
||||
"""Название виртуальной машины (virtualbox, vmware, qemu)"""
|
||||
pciLines = self._runos("/usr/sbin/lspci")
|
||||
if not pciLines:
|
||||
return False
|
||||
virtSysDict = {'VirtualBox':'virtualbox',
|
||||
'VMware':'vmware',
|
||||
'Qumranet':'qemu'}
|
||||
virtName = ''
|
||||
for vName in virtSysDict.keys():
|
||||
if [x for x in pciLines if vName in x]:
|
||||
virtName = virtSysDict[vName]
|
||||
break
|
||||
return virtName
|
||||
|
|
|
|||
|
|
@ -609,283 +609,4 @@ class fillVars(cl_base.glob_attr):
|
|||
return getNetAllow(netAllow)
|
||||
return "listen-on { 127.0.0.1; };"
|
||||
|
||||
def get_os_net_domain(self):
|
||||
''' Определим домен'''
|
||||
domain=self._runos("hostname -d 2>&1")
|
||||
if not domain:
|
||||
print(_("Error:") + " " +_("Not found domain name"))
|
||||
print(_("Command 'hostname -d' returns an empty value"))
|
||||
cl_base.exit(1)
|
||||
elif re.search("^hostname: ",domain):
|
||||
return "local"
|
||||
else:
|
||||
return domain
|
||||
|
||||
def get_os_linux_shortname(self):
|
||||
'''Получить переменную короткого названия системы'''
|
||||
path = '/etc/calculate/calculate.ini'
|
||||
if os.path.exists(path):
|
||||
FD = open(path)
|
||||
data = FD.readlines()
|
||||
FD.close()
|
||||
shortNameList = [x for x in (len(y.split("=")) == 2 and\
|
||||
y.split("=")[0]=="calculate" and\
|
||||
y.split("=")[1].strip() for y in data) if x]
|
||||
if shortNameList:
|
||||
return shortNameList[0]
|
||||
gentooFile = "/etc/gentoo-release"
|
||||
shortName = "Linux"
|
||||
if os.path.exists(gentooFile):
|
||||
shortName = "Gentoo"
|
||||
return shortName
|
||||
|
||||
def get_os_linux_name(self):
|
||||
"""полное название системы"""
|
||||
linuxShortName = self.Get("os_linux_shortname")
|
||||
if linuxShortName:
|
||||
dictLinuxName = {"CLD":"Calculate Linux Desktop",
|
||||
"CLDX":"Calculate Linux Desktop",
|
||||
"CLDG":"Calculate Linux Desktop",
|
||||
"CDS":"Calculate Directory Server",
|
||||
"Gentoo":"Gentoo"}
|
||||
if linuxShortName in dictLinuxName.keys():
|
||||
return dictLinuxName[linuxShortName]
|
||||
else:
|
||||
return "Linux"
|
||||
else:
|
||||
return "Linux"
|
||||
|
||||
def get_os_linux_subname(self):
|
||||
"""постфикс к названию системы"""
|
||||
linuxShortName = self.Get("os_linux_shortname")
|
||||
if linuxShortName:
|
||||
dictLinuxSubName = {"CLD":"KDE", "CLDX":"XFCE", "CLDG":"GNOME"}
|
||||
if linuxShortName in dictLinuxSubName.keys():
|
||||
return dictLinuxSubName[linuxShortName]
|
||||
else:
|
||||
return ""
|
||||
else:
|
||||
return ""
|
||||
|
||||
def get_os_linux_ver(self):
|
||||
'''Получить версию системы'''
|
||||
path = '/etc/calculate/calculate.ini'
|
||||
if os.path.exists(path):
|
||||
FD = open(path)
|
||||
data = FD.readlines()
|
||||
FD.close()
|
||||
shortNameList = [x for x in ( len(y.split("="))==2 and\
|
||||
y.split("=")[0]=="linuxver" and\
|
||||
y.split("=")[1].strip() for y in data) if x]
|
||||
if shortNameList:
|
||||
return shortNameList[0]
|
||||
gentooFile = "/etc/gentoo-release"
|
||||
systemVersion = ""
|
||||
flagGentoo = False
|
||||
if os.path.exists(gentooFile):
|
||||
gentooLink = "/etc/make.profile"
|
||||
if os.path.islink(gentooLink):
|
||||
systemVersion = os.readlink(gentooLink).rpartition("/")[2]
|
||||
flagGentoo = True
|
||||
if not flagGentoo:
|
||||
kernelVersion=self._runos("uname -r")
|
||||
if kernelVersion:
|
||||
systemVersion = kernelVersion.partition("-")[0]
|
||||
return systemVersion
|
||||
|
||||
def get_os_net_hostname(self):
|
||||
'''Считать имя компьютера net_host'''
|
||||
hostname=self._runos("hostname -s 2>&1")
|
||||
if not hostname:
|
||||
return ""
|
||||
if re.search("^hostname: ",hostname):
|
||||
hostname=self._runos("hostname 2>&1")
|
||||
if not hostname:
|
||||
return ""
|
||||
if re.search("^hostname: ",hostname):
|
||||
return self.Get('os_linux_shortname')
|
||||
else:
|
||||
if hostname=='livecd':
|
||||
return self.Get('os_linux_shortname')
|
||||
return hostname
|
||||
|
||||
# все ip
|
||||
def get_os_net_ip(self):
|
||||
"""все ip компьютера, разделитель запятая"""
|
||||
return ",".join(cl_utils.getIp(x) for x in cl_utils.getInterfaces())
|
||||
|
||||
# Разрешенные сети (в данном случае все сети)
|
||||
def get_os_net_allow(self):
|
||||
"""Разрешенные сети разделитель запятая"""
|
||||
networks=[]
|
||||
netInterfaces=cl_utils.getInterfaces()
|
||||
for i in netInterfaces:
|
||||
ipaddr, mask = cl_utils.getIp(i), \
|
||||
cl_utils.cidrToMask(cl_utils.getMask(i))
|
||||
if ipaddr and mask:
|
||||
networks.append(cl_utils.getIpNet(ipaddr, mask))
|
||||
else:
|
||||
networks.append("")
|
||||
return ",".join(x for x in networks if x)
|
||||
|
||||
def get_os_locale_locale(self):
|
||||
"""локаль (прим: ru_RU.UTF-8)"""
|
||||
if "LANG" in os.environ:
|
||||
return os.environ["LANG"]
|
||||
else:
|
||||
return "en_US.UTF-8"
|
||||
|
||||
def get_os_locale_lang(self):
|
||||
"""язык (прим: ru_RU)"""
|
||||
locale = self.Get("os_locale_locale")
|
||||
if locale:
|
||||
return locale.split(".")[0]
|
||||
return ""
|
||||
|
||||
def get_os_locale_language(self):
|
||||
"""язык (прим: ru)"""
|
||||
lang = self.Get("os_locale_lang")
|
||||
if lang:
|
||||
return lang.split("_")[0]
|
||||
return ""
|
||||
|
||||
def get_os_locale_xkb(self):
|
||||
"""раскладка клавиатуры для X"""
|
||||
path = '/etc/conf.d/keymaps'
|
||||
mapDict={"by":"us,by",
|
||||
"be-latin1":"be,us",
|
||||
"br-abnt2":"br,us",
|
||||
"cf":"ca,us",
|
||||
"dk-latin1":"dk,us",
|
||||
"fr-latin9":"fr,us",
|
||||
"de-latin1":"de,us",
|
||||
"is-latin1":"is,us",
|
||||
"it":"it,us",
|
||||
"no-latin1":"no,us",
|
||||
"pl":"pl,us",
|
||||
"-u ru4":"us,ru(winkeys)",
|
||||
"es euro2":"es,us",
|
||||
"sv-latin1":"se,us",
|
||||
"ua-utf":"us,ua(winkeys)",
|
||||
"uk":"gb,us",
|
||||
"us":"us"}
|
||||
if os.path.exists(path):
|
||||
FD = open(path)
|
||||
data = FD.readlines()
|
||||
FD.close()
|
||||
shortNameList = [x for x in (len(y.split("="))==2 and\
|
||||
y.split("=")[0]=="KEYMAP" and\
|
||||
y.split("=")[1].replace('"',"").strip()
|
||||
for y in data) if x]
|
||||
if shortNameList:
|
||||
if shortNameList[0] in mapDict.keys():
|
||||
return mapDict[shortNameList[0]]
|
||||
lang = self.Get("os_locale_lang")
|
||||
# Языки:
|
||||
# Португальский - pt_BR
|
||||
# Французский - fr_FR
|
||||
# Немецкий - de_DE
|
||||
# Итальянский - it_IT
|
||||
# Польский - pl_PL
|
||||
# Русский - ru_RU
|
||||
# Испанский - es_ES
|
||||
# Украинский - uk_UA
|
||||
# Английский - en_US
|
||||
xkbDict = {'pt_BR':'br,us',
|
||||
'fr_FR':'fr,us',
|
||||
'de_DE':'de,us',
|
||||
'it_IT':'it,us',
|
||||
'pl_PL':'pl,us',
|
||||
'ru_RU':'us,ru(winkeys)',
|
||||
'es_ES':'es,us',
|
||||
'uk_UA':'us,ua(winkeys)',
|
||||
'en_US':'us'}
|
||||
if lang:
|
||||
if lang in xkbDict:
|
||||
return xkbDict[lang]
|
||||
return ""
|
||||
|
||||
def get_os_locale_xkbname(self):
|
||||
"""названия используемых раскладок клавиатуры для X"""
|
||||
localeXkb = self.Get("os_locale_xkb")
|
||||
if localeXkb:
|
||||
return localeXkb.split("(")[0]
|
||||
return ""
|
||||
|
||||
def get_os_arch_machine(self):
|
||||
"""архитектура процессора"""
|
||||
march = self._runos("uname -m")
|
||||
if not march:
|
||||
return ""
|
||||
return march
|
||||
|
||||
def get_os_root_dev(self):
|
||||
"""корневой раздел файловой системы"""
|
||||
for record in open('/proc/cmdline','rb').readlines():
|
||||
re_res=re.search('^root=(\/dev\/[a-z]+[0-9]).*',record.strip())
|
||||
if re_res:
|
||||
return re_res.group(1)
|
||||
else:
|
||||
mountLunes = self._runos("mount")
|
||||
if not mountLunes:
|
||||
return ""
|
||||
if type(mountLunes) == list:
|
||||
root_dev = mountLunes[0].split("on / type")[0].strip()
|
||||
if root_dev:
|
||||
return root_dev
|
||||
return ""
|
||||
|
||||
def get_os_root_type(self):
|
||||
"""тип носителя (ram, hdd, livecd)"""
|
||||
mountLunes = self._runos("mount")
|
||||
if not mountLunes:
|
||||
return ""
|
||||
rootType = "hdd"
|
||||
if type(mountLunes) == list:
|
||||
flagCD = False
|
||||
for line in mountLunes:
|
||||
if "/dev/loop0 on / type" in line:
|
||||
rootType = "ram"
|
||||
break
|
||||
elif "/dev/loop0 on /newroot/mnt/livecd type" in line:
|
||||
rootType = "ram"
|
||||
flagCD = True
|
||||
break
|
||||
if rootType == "ram":
|
||||
if os.path.exists("/mnt/livecd") or flagCD:
|
||||
rootType = "livecd"
|
||||
return rootType
|
||||
rootDev = self.Get("os_root_dev")
|
||||
if rootType != "ram" and rootDev:
|
||||
slpRootDev = rootDev.split("/dev/")
|
||||
if len(slpRootDev) == 2:
|
||||
rDev = slpRootDev[1]
|
||||
devLines = self._runos("ls -la /dev/disk/by-id/", None,
|
||||
{"LANG":"C"})
|
||||
if not devLines:
|
||||
return ""
|
||||
if type(devLines) == list:
|
||||
for line in devLines:
|
||||
if rDev in line and "usb-" in line:
|
||||
rootType = "usb-hdd"
|
||||
break
|
||||
if rootType == "ram":
|
||||
rootType = "hdd"
|
||||
return rootType
|
||||
else:
|
||||
return ""
|
||||
|
||||
def get_hr_virtual(self):
|
||||
"""Название виртуальной машины (virtualbox, vmware, qemu)"""
|
||||
pciLines = self._runos("/usr/sbin/lspci")
|
||||
if not pciLines:
|
||||
return False
|
||||
virtSysDict = {'VirtualBox':'virtualbox',
|
||||
'VMware':'vmware',
|
||||
'Qumranet':'qemu'}
|
||||
virtName = ''
|
||||
for vName in virtSysDict.keys():
|
||||
if [x for x in pciLines if vName in x]:
|
||||
virtName = virtSysDict[vName]
|
||||
break
|
||||
return virtName
|
||||
|
||||
|
|
@ -149,7 +149,7 @@ class report:
|
|||
|
||||
сначала строки будет вставлено char[1:] в конце строки char[:-1]
|
||||
"""
|
||||
# lineUnicode = cl_utils._toUNICODE(line)
|
||||
lineUnicode = cl_utils._toUNICODE(line)
|
||||
prevPos = 0
|
||||
convLine = char[1:]
|
||||
lenLenCols = len(lenCols)
|
||||
|
|
@ -14867,7 +14867,6 @@ with another option."))
|
|||
# Если сервис не установлен то ошибка
|
||||
if not servObj.isServiceSetup(service):
|
||||
return False
|
||||
#TODO debug this:
|
||||
if relAttr not in servObj.__dict__:
|
||||
self.printERROR("getQueryLDAP service=%s"%service)
|
||||
self.printERROR(_("ERROR: getQueryLDAP incorrect branch=%s")%branch)
|
||||
|
|
@ -15040,7 +15039,7 @@ with another option."))
|
|||
if service == "mail":
|
||||
for i in searchRes:
|
||||
i[0][1]['homeDirectory'] = [os.path.join(\
|
||||
clVars.Get("sr_mail_path"), i[0][1]['uid'][0])]
|
||||
clVars.Get("sr_mail_path"), i[0][1]['uid'][0].decode("UTF-8"))]
|
||||
data.append((_("Home directory"),"homeDirectory"))
|
||||
# Добавляем директории пользователя для сервиса samba
|
||||
# а так же первичную и дополнительные группы
|
||||
|
|
@ -15062,7 +15061,7 @@ with another option."))
|
|||
data.append((_("Primary group"),"gidNumber"))
|
||||
homePath = os.path.join(\
|
||||
clVars.Get("sr_samba_home_path"),
|
||||
i[0][1]['uid'][0])
|
||||
i[0][1]['uid'][0].decode("UTF-8"))
|
||||
if os.path.exists(homePath):
|
||||
i[0][1]['homePath'] = [homePath]
|
||||
data.append((_("Home directory"),"homePath"))
|
||||
|
|
@ -15072,19 +15071,19 @@ with another option."))
|
|||
data.append((_("Share directory"),"sharePath"))
|
||||
linProfPath = os.path.join(\
|
||||
clVars.Get("sr_samba_linprof_path"),
|
||||
i[0][1]['uid'][0])
|
||||
i[0][1]['uid'][0].decode("UTF-8"))
|
||||
if os.path.exists(linProfPath):
|
||||
i[0][1]['linProfPath'] = [linProfPath]
|
||||
data.append((_("Linux profile"),"linProfPath"))
|
||||
winProfPath = os.path.join(\
|
||||
clVars.Get("sr_samba_winprof_path"),
|
||||
i[0][1]['uid'][0])
|
||||
i[0][1]['uid'][0].decode("UTF-8"))
|
||||
if os.path.exists(winProfPath):
|
||||
i[0][1]['winProfPath'] = [winProfPath]
|
||||
data.append((_("Windows profile"),"winProfPath"))
|
||||
winLogonPath = os.path.join(\
|
||||
clVars.Get("sr_samba_winlogon_path"),
|
||||
i[0][1]['uid'][0])
|
||||
i[0][1]['uid'][0].decode("UTF-8"))
|
||||
if os.path.exists(winLogonPath):
|
||||
i[0][1]['winLogonPath'] = [winLogonPath]
|
||||
data.append((_("Windows logon"),"winLogonPath"))
|
||||
|
|
@ -15450,15 +15449,15 @@ with another option."))
|
|||
def modUserAttr(self, attr, value, service):
|
||||
"""Модифицирует аттрибуты пользователя для вывода на печать"""
|
||||
# Конвертируем время в текстовый формат
|
||||
retValue = value
|
||||
retValue = value.decode("UTF-8") if isinstance(value, bytes) else value
|
||||
if attr == "shadowLastChange" or\
|
||||
attr == "sambaPwdLastSet":
|
||||
retValue = self._convDatatoStr(value)
|
||||
# Находим имя группы
|
||||
elif attr == "gidNumber" and service in ("unix", "ftp"):
|
||||
retValue = self._getUserGroupName(value, "unix")
|
||||
retValue = self._getUserGroupName(retValue, "unix")
|
||||
elif attr == "gidNumber" and service in ("samba",):
|
||||
retValue = self._getUserGroupName(value, service)
|
||||
retValue = self._getUserGroupName(retValue, service)
|
||||
# Ставим Y в случае выставленного флага
|
||||
elif attr == "initials":
|
||||
if value == "No":
|
||||
|
|
@ -15476,7 +15475,7 @@ with another option."))
|
|||
else:
|
||||
retValue = _("No")
|
||||
elif attr == "sambaAcctFlags":
|
||||
if "D" in value:
|
||||
if "D" in retValue:
|
||||
retValue = _("Yes")
|
||||
else:
|
||||
retValue = _("No")
|
||||
|
|
@ -15492,7 +15491,7 @@ with another option."))
|
|||
retValue = _("No")
|
||||
elif attr == "sambaNTPassword":
|
||||
retValue = _("Yes")
|
||||
return retValue
|
||||
return retValue.decode("UTF-8") if isinstance(retValue, bytes) else retValue
|
||||
|
||||
def _convDatatoStr(self, dataDays):
|
||||
"""Конвертирует количество дней или секунд с 1970, в строку даты"""
|
||||
|
|
@ -15517,7 +15516,7 @@ with another option."))
|
|||
if service == "unix":
|
||||
retCondUnix, userGidNamesLdap, errMessUnix =\
|
||||
servObj.searchGroupsUnix([userGid], False)
|
||||
userGidNamesLdap = userGidNamesLdap.keys()
|
||||
userGidNamesLdap = list(userGidNamesLdap.keys())
|
||||
userGidNamesPasswd = servObj.searchGroupsGroups([userGid], False)
|
||||
if userGidNamesPasswd:
|
||||
#Имя группы пользователя
|
||||
|
|
@ -15531,7 +15530,7 @@ with another option."))
|
|||
if service == "samba":
|
||||
retCondSamba, userGidNamesLdap, errMessUnix =\
|
||||
servObj.searchGroupsSamba([userGid], False)
|
||||
userGidNamesLdap = userGidNamesLdap.keys()
|
||||
userGidNamesLdap = list(userGidNamesLdap.keys())
|
||||
if userGidNamesLdap:
|
||||
#Имя группы пользователя
|
||||
groupName = userGidNamesLdap[0]
|
||||
|
|
|
|||
|
|
@ -142,7 +142,7 @@ def prettyColumnStr(*cols):
|
|||
q += 2
|
||||
# колонки отображены
|
||||
retstr += "\n"
|
||||
return retstr.encode('utf8')
|
||||
return retstr
|
||||
|
||||
def columnStr(*cols):
|
||||
'''Вывод данных по колонкам, причем, если данные не вмещаются в указнаную
|
||||
|
|
@ -162,7 +162,7 @@ def columnStr(*cols):
|
|||
cols = list(cols)
|
||||
# перевести текст в юникод, заодно перевести числа в строку
|
||||
for i in range(0,len(cols),2):
|
||||
cols[i] = (str(cols[i])).decode('utf8')
|
||||
cols[i] = (str(cols[i]))
|
||||
|
||||
# флаг "есть еще текст для вывода"
|
||||
repeat = True
|
||||
|
|
@ -179,7 +179,7 @@ def columnStr(*cols):
|
|||
cols[q] = ''
|
||||
else:
|
||||
# вывести часть строки не больше указанной ширины колонки
|
||||
retstr+=(cols[q][:cols[q+1]].ljust(cols[q+1])).encode('utf8') \
|
||||
retstr+=(cols[q][:cols[q+1]].ljust(cols[q+1])) \
|
||||
+ " "
|
||||
# остальную часть строки оставить на следующую итерацию
|
||||
cols[q] = cols[q][cols[q+1]:]
|
||||
|
|
@ -207,7 +207,7 @@ def columnWrite(*cols):
|
|||
cols = list(cols)
|
||||
# перевести текст в юникод, заодно перевести числа в строку
|
||||
for i in range(0,len(cols),2):
|
||||
cols[i] = (str(cols[i])).decode('utf8')
|
||||
cols[i] = (str(cols[i]))
|
||||
|
||||
# флаг "есть еще текст для вывода"
|
||||
repeat = True
|
||||
|
|
@ -220,11 +220,11 @@ def columnWrite(*cols):
|
|||
# если это последний параметр, и для него не указана ширина
|
||||
if q == len(cols)-1:
|
||||
# выводим его полностью не смотря на ширину окна
|
||||
print(cols[q].encode('utf8'), end=' ')
|
||||
print(cols[q], end=' ')
|
||||
cols[q] = ''
|
||||
else:
|
||||
# вывести часть строки не больше указанной ширины колонки
|
||||
print((cols[q][:cols[q+1]].ljust(cols[q+1])).encode('utf8'), end=' ')
|
||||
print((cols[q][:cols[q+1]].ljust(cols[q+1])), end=' ')
|
||||
# остальную часть строки оставить на следующую итерацию
|
||||
cols[q] = cols[q][cols[q+1]:]
|
||||
# если от строки что то осаталось
|
||||
|
|
@ -252,7 +252,7 @@ def justify(s,width):
|
|||
pos = 0
|
||||
# переводим в юникод для правильного вычисления длины
|
||||
try:
|
||||
s = s.decode( 'utf-8' )
|
||||
s = s
|
||||
# пропуск если это не utf-8
|
||||
except UnicodeEncodeError:
|
||||
pass
|
||||
|
|
@ -268,7 +268,7 @@ def justify(s,width):
|
|||
# оставить удвоенный пробел
|
||||
pos += 3
|
||||
# вернуть строку в utf8 если она пришла в utf8
|
||||
return s.encode('utf-8')
|
||||
return s
|
||||
|
||||
def runOsCommand(cmd, inStr=None, ret_first=None, env_dict=None):
|
||||
"""Выполняет внешнюю программу
|
||||
|
|
@ -514,7 +514,7 @@ def _toUNICODE(val):
|
|||
if type(val) == str:
|
||||
return val
|
||||
else:
|
||||
return str(val).decode('UTF-8')
|
||||
return str(val)
|
||||
|
||||
SYSFS_NET_PATH = "/sys/class/net"
|
||||
|
||||
|
|
|
|||
|
|
@ -814,7 +814,7 @@ class xmlDoc():
|
|||
def getNameArea(self, xmlArea):
|
||||
"""Выдает имя области"""
|
||||
xmlNameAreas = xpath.Evaluate('child::caption/name', xmlArea)
|
||||
if xmlNameAreas and firstChild(xmlNameAreas[0]):
|
||||
if xmlNameAreas and firstChild(xmlNameAreas[0]) is not None:
|
||||
return firstChild(xmlNameAreas[0]).text
|
||||
else:
|
||||
return False
|
||||
|
|
|
|||
Loading…
Reference in a new issue