calculate
/
calculate-utils-3-lib
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Update libs

Browse Source
master3.3
Mike Hiretsky 12 years ago
parent 2c8055ca72
commit 3b920bf63e
17 changed files with 273 additions and 1439 deletions
Show Stats Download Patch File Download Diff File

12
calculate/lib/cl_api.py
Unescape View File

@ -58,7 +58,7 @@ class _services(color_print, libVars):
'serviceAPI')
except (ImportError, AttributeError), e:
self.printERROR(str(e).strip())
self.printERROR(_("Can not import module %s")% apiFile)
self.printERROR(_("Failed to import module %s")% apiFile)
cl_overriding.exit(1)
return className
@ -77,7 +77,7 @@ class _services(color_print, libVars):
apiObject = className()
except Exception, e:
self.printERROR(str(e).strip())
self.printERROR(_("Can not create API object"))
self.printERROR(_("Failed create an API object"))
self.printERROR(_("Module %s")% apiFile)
cl_overriding.exit(1)
self.apiObjs[pkgName] = apiObject
@ -98,7 +98,7 @@ class _services(color_print, libVars):
try:
apiObjects.append(className())
except:
self.printERROR(_("Can not create API object"))
self.printERROR(_("Failed create an API object"))
self.printERROR(_("Module %s")% apiFile)
cl_overriding.exit(1)
return apiObjects
@ -110,8 +110,8 @@ class _services(color_print, libVars):
return ""
if not hasattr(pkgObj, methodName) or\
not callable(getattr(pkgObj, methodName)):
self.printERROR(_("Can not found method %(method)s in \
API object service %(service)s") %{'method':methodName,
self.printERROR(_("Method %(method)s not found in object API of"
" service %(service)s") %{'method':methodName,
'service':pkgObj.getServiceName()})
cl_overriding.exit(1)
if argv:
@ -198,7 +198,7 @@ class _pkgAPI(object):
try:
value = object.__getattribute__(self, attr)()
except:
raise APIError(_("Can not found method %s")%attr)
raise APIError(_("Method %s not found")%attr)
return value
class _allPkg(object):

17
calculate/lib/cl_opt.py
Unescape View File

@ -275,23 +275,23 @@ class opt(optparse.OptionParser):
[{'longOption':"set",
'optVal':"VAR=VALUE",
'action':'append',
'help':_("set value for variable")
'help':_("set the variable value")
}]
variable_view = \
[{'shortOption':"v",
'longOption':"show-variables",
'action':'count',
'help':_("print variables, if the two options is verbose "
"(added print hidden variables)")
'help':_("print variables, in verbose mode if the two options "
"applied (includes printing hidden variables)")
},
{'longOption':"filter",
'optVal':"FILTER",
'help':_("filtered variables by regular expression, \
is used in conjunction with the options '-v --show-variables'")
'help':_("filter variables (as regexp, use *), to be used in"
" conjunction with options '-v --show-variables'")
},
{'longOption':"xml",
'help':_("output variables in the format of XML, \
is used in conjunction with the option '-v --show-variables'")
'help':_("output variables in XML format, to be used in"
" conjunction with options '-v --show-variables'")
}]
variable_control = variable_set + variable_view
@ -370,7 +370,8 @@ is used in conjunction with the option '-v --show-variables'")
should either exit or raise an exception.
"""
self.print_usage(sys.stderr)
self.exit(2, "%s: %s: %s\n%s\n" % (self.get_prog_name(), _("error"), msg,
self.exit(2, "%s: %s: %s\n%s\n" % (self.get_prog_name(),
_("error"), msg,
_("Try `%s' for more information")%
("%s --help"%self.get_prog_name())))

285
calculate/lib/cl_template.py
Unescape View File

@ -335,7 +335,7 @@ class _terms(_error, _shareTermsFunction):
self.setError("'%s'"%rpl(term)+" "+\
_("incorrect"))
self.setError(\
_("Value function is not version"))
_("Function value is not version"))
return False
verFile, verVar = self._convertVers(vals[1],valVars)
res = dictRuleFunc[sepF](verVar,verFile)
@ -570,7 +570,7 @@ class fileHeader(_terms):
foundTerm = True
errorMsg = _("Incorrect template") +\
": "+ templateName +"\n"+\
_("header template not valid")+\
_("template header not valid")+\
": "+ i
if function:
rezTerm = self._equalTerm(i,
@ -717,7 +717,7 @@ class dirHeader(_terms):
foundTerm = True
errorMsg = _("Incorrect template") +\
": "+ templateName +"\n"+\
_("header template not valid")+ ": "+ i
_("template header not valid")+ ": "+ i
if function:
rezTerm = self._equalTerm(i, errorMsg,
function)
@ -2106,7 +2106,8 @@ class _file(_error):
try:
self.F_CONF.write(self.textConfig)
except:
self.setError(_("not open file:" ) + self.nameFileConfig)
self.setError(_("unable to open the file:")
+ self.nameFileConfig)
return False
self.F_CONF.flush()
return True
@ -2117,7 +2118,8 @@ class _file(_error):
try:
F_TEMPL = open(nameFileTemplate, "r")
except:
self.setError(_("not open file:" ) + nameFileTemplate)
self.setError(_("unable to open the file:")
+ nameFileConfig)
return False
return F_TEMPL
@ -2143,7 +2145,8 @@ class _file(_error):
try:
F_CONF = open(nameFileConfig, "w+")
except:
self.setError(_("not open file:" ) + nameFileConfig)
self.setError(_("unable to open the file:")
+ nameFileConfig)
return False
return F_CONF
@ -2401,13 +2404,13 @@ class _shareTemplate:
gid = pwdObj.pw_gid
homeDir = pwdObj.pw_dir
except:
raise TemplatesError(_("Can not found user %s")%str(userName))
raise TemplatesError(_("User %s not found")%str(userName))
if groupsInfo:
import grp
try:
groupName = grp.getgrgid(gid).gr_name
except:
raise TemplatesError(_("Can not found group id %s")%str(gid))
raise TemplatesError(_("Group id %s not found")%str(gid))
groupsNames = map(lambda x: x.gr_name,\
filter(lambda x: userName in x.gr_mem, grp.getgrall()))
groupsNames = [groupName] + groupsNames
@ -2633,7 +2636,7 @@ class templateFunction(_error, _shareTemplate, _shareTermsFunction):
flagNotRootFS = False
else:
self.raiseErrTemplate(
_("Second argument function is not 'root'"))
_("The second argument function is not 'root'"))
if fileName[0] == "~":
# Получаем директорию пользователя
fileName = os.path.join(self.homeDir,
@ -2672,12 +2675,12 @@ class templateFunction(_error, _shareTemplate, _shareTermsFunction):
flagNotRootFS = False
else:
self.raiseErrTemplate(
_("Third argument function is not 'root'"))
_("The third argument of the function is not 'root'"))
if lenTerms >= 2:
if not terms[0] in ["ver","num","char","key","empty"]:
self.raiseErrTemplate(
_("first argument function is not 'ver' or 'num' or 'char'"
" or 'empty'"))
_("the first argument of the function is not 'ver'"
" or 'num' or 'char' or 'empty'"))
if lenTerms == 1:
fileName = terms[0].strip()
else:
@ -2806,7 +2809,7 @@ class templateFunction(_error, _shareTemplate, _shareTermsFunction):
lenStr = int(terms[1])
except:
self.raiseErrTemplate(
_("two argument function is not number"))
_("the second argument of the function is not a number"))
choiceStr = fArgvNames[terms[0]]
replace = ''.join([random.choice(choiceStr) for i in xrange(lenStr)])
textTemplateTmp = textTemplateTmp[:resS.start()] + replace +\
@ -2829,8 +2832,9 @@ class templateFunction(_error, _shareTemplate, _shareTermsFunction):
self.raiseErrTemplate()
fArgvNames = ['upper','lower','capitalize']
if not terms[0] in fArgvNames:
self.raiseErrTemplate(_("first argument function is not 'upper' \
or 'lower' or 'capitalize'"))
self.raiseErrTemplate(_("the first argument of the function"
" is not 'upper' or 'lower' or"
" 'capitalize'"))
try:
strValue = str(self.objVar.Get(terms[1]))
except:
@ -3009,8 +3013,9 @@ or 'lower' or 'capitalize'"))
self.currDictIni[nameLocVar] = valueLocVar
elif len(terms) == 3:
if not terms[2] in ['url','purl','unicode']:
self.raiseErrTemplate(_("third argument function is not "
"'url' or 'purl' or 'unicode'"))
self.raiseErrTemplate(
_("the third argument of the function is not "
"'url' or 'purl' or 'unicode'"))
if terms[1]:
self.raiseErrTemplate()
if self.timeIni != curTime:
@ -3230,7 +3235,7 @@ or 'lower' or 'capitalize'"))
%str(nameLocVar))
if not type(value) in (list,tuple):
# Значение переменной не список или кортеж
self.raiseErrTemplate(_("value of %s is not a list or tuple")\
self.raiseErrTemplate(_("value of %s is not a list or a tuple")\
%str(nameLocVar))
try:
if len(value) > intIndex:
@ -3238,7 +3243,7 @@ or 'lower' or 'capitalize'"))
else:
replace = ""
except:
self.raiseErrTemplate(_("%s wrong")%strIndex)
self.raiseErrTemplate(_("wrong %s")%strIndex)
textTemplateTmp = textTemplateTmp[:resS.start()] + replace +\
textTemplateTmp[resS.end():]
return textTemplateTmp
@ -3261,7 +3266,7 @@ or 'lower' or 'capitalize'"))
mountPoint = terms[0]
lastElementVar = terms[1]
if not mountPoint or mountPoint[:1] !="/":
self.raiseErrTemplate(_("%s wrong")%lastElementVar)
self.raiseErrTemplate(_("wrong %s")%lastElementVar)
nameVar = "os_install_disk_mount"
try:
valueVar = self.objVar.Get(nameVar)
@ -3278,16 +3283,16 @@ or 'lower' or 'capitalize'"))
try:
valueElementVar = self.objVar.Get(nameElementVar)
except:
self.raiseErrTemplate(_("%s wrong")%lastElementVar+"\n"+
self.raiseErrTemplate(_("wrong %s")%lastElementVar+"\n"+
_("error: variable %s is not exists")\
%nameElementVar)
if not type(valueVar) in (list,tuple):
# Значение переменной не список или кортеж
self.raiseErrTemplate(_("value of %s is not a list or tuple")\
self.raiseErrTemplate(_("value of %s is not a list or a tuple")\
%nameVar)
if not type(valueElementVar) in (list,tuple):
# Значение переменной не список или кортеж
self.raiseErrTemplate(_("value of %s is not a list or tuple")\
self.raiseErrTemplate(_("value of %s is not a list or a tuple")\
%nameElementVar)
if len(valueVar) != len(valueElementVar):
self.raiseErrTemplate(
@ -3304,8 +3309,9 @@ or 'lower' or 'capitalize'"))
index = num
break
if index is None:
self.raiseErrTemplate(_("in the value of the variable \
os_disk_install not found mount point '\' and '\%s'")%mountPoint)
self.raiseErrTemplate(_("mount point '/' or '/%s' not found "
" in the value of the variable os_disk_install")
%mountPoint)
replace = valueElementVar[index]
textTemplateTmp = textTemplateTmp[:resS.start()] + replace +\
textTemplateTmp[resS.end():]
@ -3353,7 +3359,7 @@ os_disk_install not found mount point '\' and '\%s'")%mountPoint)
message = ""
raise TemplatesError(
_("error in template %s")%self.nameTemplate + "\n" + \
_("error template term '%s'")%str(self.functText) + \
_("error, template term '%s'")%str(self.functText) + \
message)
def applyFuncTemplate(self, textTemplate, nameTemplate):
@ -3383,7 +3389,7 @@ os_disk_install not found mount point '\' and '\%s'")%mountPoint)
flagIniFunc = True
else:
self.raiseErrTemplate(
_("can not found template function '%s'")\
_("function of templates '%s' not found")\
%str(self.functText))
if flagIniFunc:
# Очистка файла в случае его ошибочного чтения
@ -3563,7 +3569,7 @@ re.M|re.S)
try:
res = string.atoi(strOct, 8)
except ValueError:
self.setError(_("Not valid oct value: ") + str(strOct))
self.setError(_("Invalid oct value: ") + str(strOct))
return False
return res
else:
@ -3602,7 +3608,7 @@ re.M|re.S)
try:
dUid,dGid = getModeFile(prevDir,"owner")
except OSError:
self.setError(_("Not access dir: " ) + prevDir)
self.setError(_("No access to the directory: ") + prevDir)
return False
if not mode is False:
dMode = mode
@ -3620,7 +3626,8 @@ re.M|re.S)
os.mkdir(nameDir)
os.chown(nameDir, dUid, dGid)
except:
self.setError(_("Can not create dir: " ) + nameDir)
self.setError(_("Failed to create the directory: ")
+ nameDir)
return False
try:
if dMode:
@ -3631,7 +3638,8 @@ re.M|re.S)
os.chown(dirName, dUid, dGid)
createDirs.append(dirName)
except:
self.setError(_("Can not create dir: " ) + dirName)
self.setError(_("Failed to create the directory: ")
+ dirName)
return False
return createDirs
@ -3672,7 +3680,7 @@ re.M|re.S)
parent = ""
term = resS.group("rTerm") + parent +\
resS.group("lTerm")
if self._equalTerm(term, _("content template not valid: ")+\
if self._equalTerm(term, _("invalid template content: ")+\
nameTemplate, function):
textTemplateTmp = textTemplateTmp.replace(mark, body+end)
else:
@ -3689,7 +3697,7 @@ re.M|re.S)
if len(spFile)>1:
flagTrue = False
for term in spFile[1:]:
if self._equalTerm(term, _("name template not valid: ")+\
if self._equalTerm(term, _("invalid template name: ")+\
fileTemplate):
flagTrue = True
break
@ -3700,7 +3708,7 @@ re.M|re.S)
else:
return True
else:
self.setError(_("name template not valid: ")+ str(fileTemplate))
self.setError(_("invalid template name: ")+ str(fileTemplate))
return False
def getTitle(self, comment, commentList, configPath=""):
@ -3845,24 +3853,25 @@ re.M|re.S)
setWARNING = lambda x: self.setWarning(x) and\
self.printWarning and\
printObj.printWARNING(x)
setWARNING(_("No conditions of checking a value of the \
variable 'cl_name'"))
setWARNING(_("No conditions of checking the value of variable"
" 'cl_name'"))
skipDirTemplates = []
for skipDir in skipDirs:
skipTempl = os.path.join(skipDir,self.templDirNameFile)
if os.path.isfile(skipTempl):
skipDirTemplates.append(skipTempl)
if skipTemplates or skipDirTemplates:
setWARNING(_("Skip templates:"))
setWARNING(_("Skipped templates:"))
for skipTemplate in skipTemplates + skipDirTemplates:
setWARNING(" "*6 + skipTemplate)
if skipDirs:
setWARNING(_("Skip directories:"))
setWARNING(_("Skipped directories:"))
for skipDir in skipDirs:
setWARNING(" "*6 + skipDir)
setWARNING("")
setWARNING(_("Headers directory and template files first level "\
"should include of the 'cl_name' variable."))
setWARNING(_("Headers of directory templates and headers of files"
" on the first level should include 'cl_name'"
" variable."))
setWARNING(_("Example:"))
setWARNING("# Calculate cl_name==calculate-install")
return skipDirs + skipTemplates
@ -3889,7 +3898,7 @@ variable 'cl_name'"))
return dictTemplates
if not self.objVar.defined("cl_template_path"):
self.setError(_("not defined Var: ") + "cl_template_path")
self.setError(_("undefined variable: ") + "cl_template_path")
return False
dirsTemplates = self.objVar.Get("cl_template_path")
# Созданные директории
@ -4174,7 +4183,7 @@ variable 'cl_name'"))
textTemplate = FD.read()
FD.close()
except:
self.setError(_("Error open template") + ": " +\
self.setError(_("Error in opening template") + ": " +\
templateDirFile)
return ("", False, [])
@ -4205,7 +4214,7 @@ variable 'cl_name'"))
path = os.path.join(self.homeDir,
path.partition("/")[2],"")[:-1]
elif not path or path and path[0] != "/":
self.setError(_("False value 'path' in template") + ": " +\
self.setError(_("Wrong value 'path' in the template") + ": " +\
templateDirFile)
return ("", False, [])
else:
@ -4215,7 +4224,7 @@ variable 'cl_name'"))
if "name" in objHead.params:
nameDir = objHead.params['name']
if "/" in nameDir or nameDir == ".." or nameDir == ".":
self.setError(_("False value 'name' in template") + ": " +\
self.setError(_("Wrong value 'name' in the template") + ": " +\
templateDirFile)
return ("", False, [])
# Новый путь к директории
@ -4234,7 +4243,7 @@ variable 'cl_name'"))
try:
removeDir(applyDir)
except:
self.setError(_("Can not delete dir: " ) +\
self.setError(_("Failed to delete the directory: ") +\
applyDir)
return ("", False, [])
@ -4248,13 +4257,15 @@ variable 'cl_name'"))
try:
removeDir(removePath)
except:
self.setError(_("Can not delete dir: " ) +\
self.setError(
_("Failed to delete the directory: ") +\
removePath)
else:
try:
os.unlink(removePath)
except:
self.setError(_("Can not delete: " ) + removePath)
self.setError(
_("Failed to delete: ") + removePath)
return ("", False, [])
# Созданные директории
@ -4272,7 +4283,7 @@ variable 'cl_name'"))
else:
os.chmod(applyDir, mode)
else:
self.setError(_("False value 'chmod' in template") + ": " +\
self.setError(_("Wrong value 'chmod' in the template") + ": " +\
templateDirFile)
return ("", False, [])
# chown - изменяем владельца и группу
@ -4286,8 +4297,9 @@ variable 'cl_name'"))
try:
uid = pwd.getpwnam(strUid).pw_uid
except:
self.setError(_("Not user in this system: ") + strUid)
self.setError(_("False value 'chown' in template")+\
self.setError(_("No such user on the system: ")
+ strUid)
self.setError(_("Wrong value 'chown' in the template")+\
": " + templateDirFile)
return ("", False, [])
gid = self.getGidFromGroup(strGid)
@ -4295,8 +4307,10 @@ variable 'cl_name'"))
import grp
gid = grp.getgrnam(strGid).gr_gid
except:
self.setError(_("Not group in this system: ")+strGid)
self.setError(_("False value 'chown' in template") +\
self.setError(_("Group not found on the system: ")
+strGid)
self.setError(
_("Wrong value 'chown' in the template") +\
": "+ templateDirFile)
return ("", False, [])
@ -4311,12 +4325,12 @@ variable 'cl_name'"))
templateDirFile):
return ("", False, [])
else:
self.setError(_("False value 'chown' in template") + ": " +\
templateDirFile)
self.setError(_("Wrong value 'chown' in the template")
+ ": " + templateDirFile)
return ("", False, [])
else:
self.setError(_("False value 'chown' in template") + ": " +\
templateDirFile)
self.setError(_("Wrong value 'chown' in the template") +
": " + templateDirFile)
return ("", False, [])
else:
# Устанавливаем владельцем директории, пользователя по умолчанию
@ -4438,7 +4452,7 @@ variable 'cl_name'"))
self.nameFileTemplate = os.path.abspath(nameFileTemplate)
self.F_TEMPL = self.openTemplFile(self.nameFileTemplate)
if not self.F_TEMPL:
self.setError(_("Error open template") + ": " +\
self.setError(_("Error in opening template") + ": " +\
templateDirFile)
return False
self.textTemplate = self.F_TEMPL.read()
@ -4458,7 +4472,7 @@ variable 'cl_name'"))
mergePkgs = objHeadNew.params['merge'].split(',')
reRight = re.compile(r'^(\w+-\w+/)?[\w-]+$')
for wrongPkg in (x for x in mergePkgs if not reRight.match(x)):
self.setError(_("Wrong value '%s' for 'merge' in template")%
self.setError(_("Wrong value '%s' for 'merge' in the template")%
wrongPkg + ": " + nameFileTemplate)
return ([], False)
for pkg in mergePkgs:
@ -4475,7 +4489,7 @@ variable 'cl_name'"))
# Получаем путь с заменой ~ на директорию пользователя
path = os.path.join(self.homeDir,path.partition("/")[2],"")[:-1]
elif not path or path and path[0] != "/":
self.setError(_("False value 'path' in template") + ": " +\
self.setError(_("Wrong value 'path' in the template") + ": " +\
nameFileTemplate)
return ([], False)
else:
@ -4486,7 +4500,7 @@ variable 'cl_name'"))
if objHeadNew.params.has_key("name"):
nameFile = objHeadNew.params['name']
if "/" in nameFile or nameFile == ".." or nameFile == ".":
self.setError(_("False value 'name' in template") + ": " +\
self.setError(_("Wrong value 'name' in the template") + ": " +\
nameFileTemplate)
return ([], False)
# Новый путь к оригинальному файлу
@ -4504,12 +4518,13 @@ variable 'cl_name'"))
if "exec" in objHeadNew.params:
execPath = objHeadNew.params['exec']
if not os.access(execPath,os.X_OK):
self.setError(_("False value 'exec' in template") + ": " +\
self.setError(_("Wrong value 'exec' in the template") + ": " +\
nameFileTemplate)
self.setError(_("Can not execute %s") %execPath)
self.setError(_("Failed to execute %s") %execPath)
return ([], False)
if typeAppendTemplate == "join":
self.setError(_("False value 'append=join' in template") + ": " +\
self.setError(_("Wrong value 'append=join' in the template") +
": " +\
nameFileTemplate)
return ([], False)
@ -4518,9 +4533,9 @@ variable 'cl_name'"))
try:
open(pathOldFile, "w").truncate(0)
except:
self.setError(_("Error in template") + ": " +\
self.setError(_("Template error") + ": " +\
nameFileTemplate)
self.setError(_("Can not clear file") + ": " +\
self.setError(_("Failed to clear the file") + ": " +\
pathOldFile)
return (applyFiles, False)
# Удаляем оригинальный файл
@ -4530,9 +4545,9 @@ variable 'cl_name'"))
try:
os.unlink(pathOldFile)
except:
self.setError(_("Error in template") + ": " +\
self.setError(_("Template error") + ": " +\
nameFileTemplate)
self.setError(_("Can not delete link") + ": " +\
self.setError(_("Failed to delete the link") + ": " +\
pathOldFile)
return ([], False)
if os.path.isfile(pathOldFile):
@ -4540,9 +4555,9 @@ variable 'cl_name'"))
try:
os.remove(pathOldFile)
except:
self.setError(_("Error in template") + ": " +\
self.setError(_("Template error") + ": " +\
nameFileTemplate)
self.setError(_("Can not delete file") + ": " +\
self.setError(_("Failed to delete the file") + ": " +\
pathOldFile)
return ([], False)
return (applyFiles, False)
@ -4561,9 +4576,9 @@ variable 'cl_name'"))
try:
os.unlink(pathOldFile)
except:
self.setError(_("Error in template") + ": " +\
self.setError(_("Template error") + ": " +\
nameFileTemplate)
self.setError(_("Can not delete link") + ": " +\
self.setError(_("Failed to delete the link") + ": " +\
pathOldFile)
return ([], False)
if os.path.isfile(pathOldFile):
@ -4571,9 +4586,9 @@ variable 'cl_name'"))
try:
os.remove(pathOldFile)
except:
self.setError(_("Error in template") + ": " +\
self.setError(_("Template error") + ": " +\
nameFileTemplate)
self.setError(_("Can not delete file") + ": " +\
self.setError(_("Failed to delete the file") + ": " +\
pathOldFile)
return ([], False)
@ -4589,9 +4604,9 @@ variable 'cl_name'"))
try:
os.remove(pathOldFile)
except:
self.setError(_("Error in template") + ": " +\
self.setError(_("Template error") + ": " +\
nameFileTemplate)
self.setError(_("Can not delete file") + ": " +\
self.setError(_("Failed to delete the file") + ": " +\
pathOldFile)
return ([], False)
elif not os.path.exists(pathOldFile):
@ -4609,18 +4624,18 @@ variable 'cl_name'"))
F_CONF.close()
fMode, fUid, fGid = getModeFile(templateFile)
except:
self.setError(_("Error in template") + ": " +\
self.setError(_("Template error") + ": " +\
nameFileTemplate)
self.setError(_("Can not open file") + ": " +\
self.setError(_("Failed to open the file") + ": " +\
templateFile)
return ([], False)
if os.path.exists(pathOldFile):
try:
os.remove(pathOldFile)
except:
self.setError(_("Error in template") + ": " +\
self.setError(_("Template error") + ": " +\
nameFileTemplate)
self.setError(_("Can not delete file") + ": " +\
self.setError(_("Failed to delete the file") + ": " +\
pathOldFile)
return ([], False)
if foundTemplateFile:
@ -4629,9 +4644,9 @@ variable 'cl_name'"))
FD.write(buff)
FD.close()
except:
self.setError(_("Error in template") + ": " +\
self.setError(_("Template error") + ": " +\
nameFileTemplate)
self.setError(_("Can not create file") + " '%s'"\
self.setError(_("Failed to create the file") + " '%s'"\
%pathOldFile)
return ([], False)
oMode = getModeFile(pathOldFile, mode="mode")
@ -4656,9 +4671,10 @@ variable 'cl_name'"))
try:
os.chdir(pathLink)
except:
self.setError(_("Error in template") + ": " +\
self.setError(_("Template error") + ": " +\
nameFileTemplate)
self.setError(_("Can not change the current directory to")+\
self.setError(
_("Failed to change the current directory to")+\
" " + pathLink)
return ([], False)
@ -4670,7 +4686,7 @@ variable 'cl_name'"))
preReturn(pathProg)
return ([], False)
else:
self.setError(_("False value 'chmod' in template") + ": " +\
self.setError(_("Wrong value 'chmod' in the template") + ": " +\
nameFileTemplate)
preReturn(pathProg)
return ([], False)
@ -4689,9 +4705,10 @@ variable 'cl_name'"))
if uid is None:
uid = pwd.getpwnam(strUid).pw_uid
except:
self.setError(_("Not user in this system: ") +
self.setError(_("No such user on the system: ") +
strUid)
self.setError(_("False value 'chown' in template") +
self.setError(
_("Wrong value 'chown' in the template") +
": "+ nameFileTemplate)
preReturn(pathProg)
return ([], False)
@ -4704,9 +4721,10 @@ variable 'cl_name'"))
import grp
gid = grp.getgrnam(strGid).gr_gid
except:
self.setError(_("Not group in this system: ") +
self.setError(_("Group not found on the system: ") +
strGid)
self.setError(_("False value 'chown' in template") +
self.setError(
_("Wrong value 'chown' in the template") +
": "+ nameFileTemplate)
preReturn(pathProg)
return ([], False)
@ -4715,13 +4733,13 @@ variable 'cl_name'"))
preReturn(pathProg)
return ([], False)
else:
self.setError(_("False value 'chown' in template") + ": " +\
nameFileTemplate)
self.setError(_("Wrong value 'chown' in the template") +
": " + nameFileTemplate)
preReturn(pathProg)
return ([], False)
else:
self.setError(_("False value 'chown' in template") + ": " +\
nameFileTemplate)
self.setError(_("Wrong value 'chown' in the template")
+ ": " + nameFileTemplate)
preReturn(pathProg)
return ([], False)
if not flagSymlink:
@ -4749,9 +4767,9 @@ variable 'cl_name'"))
# иначе удаляем файл
os.remove(prevOldFile)
except:
self.setError(_("Error in template") + ": " +\
self.setError(_("Template error") + ": " +\
nameFileTemplate)
self.setError(_("Can not delete file") + ": " +\
self.setError(_("Failed to delete the file") + ": " +\
prevOldFile)
preReturn(pathProg)
return ([], False)
@ -4762,9 +4780,9 @@ variable 'cl_name'"))
try:
os.symlink(pathOldFile, prevOldFile)
except:
self.setError(_("Error in template") + ": " +\
self.setError(_("Template error") + ": " +\
nameFileTemplate)
self.setError(_("Can not create symbolic link") + " :" +\
self.setError(_("Failed to create a symbolic link") + " :" +\
"%s -> %s"%(prevOldFile, pathOldFile))
preReturn(pathProg)
return ([], False)
@ -4911,14 +4929,15 @@ variable 'cl_name'"))
if formatTemplate == "patch":
if typeAppendTemplate != "patch":
self.setError(\
_("False option append=%(type)s in template %(file)s")\
_("Wrong option append=%(type)s in template %(file)s")\
%{"type":typeAppendTemplate,"file":nameFileTemplate})
return False
# создаем объект формата шаблона
objTempl = self.getFormatObj(formatTemplate, self.textTemplate)
if not objTempl:
self.setError(\
_("Incorrect header parameter format=%s in template")\
_("Incorrect header parameter format=%s "
"in the template")\
%formatTemplate + " " + nameFileTemplate)
return False
if objHeadOld and objHeadOld.body:
@ -4926,7 +4945,7 @@ variable 'cl_name'"))
# обработка конфигурационного файла
self.textTemplate = objTempl.processingFile(self.textConfig)
if objTempl.getError():
self.setError(_("False template") + ": " +\
self.setError(_("Wrong template") + ": " +\
nameFileTemplate)
return False
if execStr:
@ -4937,9 +4956,9 @@ variable 'cl_name'"))
if 'exec' in objHeadNew.params:
if not self.executeTemplate(self.nameFileConfig,
objHeadNew.params['exec']):
self.setError(_("False template") + ": " +\
self.setError(_("Wrong template") + ": " +\
nameFileTemplate)
self.setError(_("Can not execute") + ": " +\
self.setError(_("Failed to execute") + ": " +\
self.nameFileConfig)
return False
return False
@ -4959,12 +4978,13 @@ variable 'cl_name'"))
self.textTemplate)
if not objTemplNew:
self.setError(\
_("Incorrect header parameter format=%s in template")\
_("Incorrect header parameter format=%s "
"in the template")\
%formatTemplate + " " + nameFileTemplate)
return False
if "xml_" in formatTemplate:
if objTemplNew.getError():
self.setError(_("False template") + ": " +\
self.setError(_("Wrong template") + ": " +\
nameFileTemplate)
return False
# Имя файла внутри xml xfce конфигурационных файлов
@ -5009,9 +5029,9 @@ variable 'cl_name'"))
if 'exec' in objHeadNew.params:
if not self.executeTemplate(self.nameFileConfig,
objHeadNew.params['exec']):
self.setError(_("False template") + ": " +\
self.setError(_("Wrong template") + ": " +\
nameFileTemplate)
self.setError(_("Can not execute") + ": " +\
self.setError(_("Failed to execute") + ": " +\
self.nameFileConfig)
return False
return False
@ -5020,7 +5040,7 @@ variable 'cl_name'"))
elif typeAppendTemplate == "before":
if "xml_" in formatTemplate:
self.setError(\
_("False option append=before in template %s")\
_("Wrong option append=before in template %s")\
%nameFileTemplate)
return False
if objHeadOld and objHeadOld.body:
@ -5038,9 +5058,9 @@ variable 'cl_name'"))
if 'exec' in objHeadNew.params:
if not self.executeTemplate(self.nameFileConfig,
objHeadNew.params['exec']):
self.setError(_("False template") + ": " +\
self.setError(_("Wrong template") + ": " +\
nameFileTemplate)
self.setError(_("Can not execute") + ": " +\
self.setError(_("Failed to execute") + ": " +\
self.nameFileConfig)
return False
return False
@ -5049,7 +5069,7 @@ variable 'cl_name'"))
elif typeAppendTemplate == "after":
if "xml_" in formatTemplate:
self.setError(\
_("False option append=after in template %s")\
_("Wrong option append=after in template %s")\
%nameFileTemplate)
return False
if objHeadOld and objHeadOld.body:
@ -5066,9 +5086,9 @@ variable 'cl_name'"))
if 'exec' in objHeadNew.params:
if not self.executeTemplate(self.nameFileConfig,
objHeadNew.params['exec']):
self.setError(_("False template") + ": " +\
self.setError(_("Wrong template") + ": " +\
nameFileTemplate)
self.setError(_("Can not execute") + ": " +\
self.setError(_("Failed to execute") + ": " +\
self.nameFileConfig)
return False
return False
@ -5080,7 +5100,8 @@ variable 'cl_name'"))
self.textTemplate = objTxtCoder.encode(self.textTemplate)
if formatTemplate =="raw":
self.setError(\
_("Incorrect header parameter append=%s in template")\
_("Incorrect header parameter append=%s "
"in the template")\
%typeAppendTemplate + " " + nameFileTemplate)
return False
# создаем объект формата шаблона
@ -5088,12 +5109,13 @@ variable 'cl_name'"))
self.textTemplate)
if not objTemplNew:
self.setError(\
_("Incorrect header parameter format=%s in template")\
_("Incorrect header parameter format=%s in "
"the template")\
%formatTemplate + " " + nameFileTemplate)
return False
if "xml_" in formatTemplate:
if objTemplNew.getError():
self.setError(_("False template") + ": " +\
self.setError(_("Wrong template") + ": " +\
nameFileTemplate)
return False
nameRootNode=nameFileConfig.rpartition("/")[2].split(".")[0]
@ -5128,7 +5150,7 @@ variable 'cl_name'"))
return False
if "xml_" in formatTemplate:
if objTemplOld.getError():
self.setError(_("False template") + ": " +\
self.setError(_("Wrong template") + ": " +\
nameFileConfig)
return False
nameRootNode=nameFileConfig.rpartition("/")[2].split(".")[0]
@ -5137,7 +5159,7 @@ variable 'cl_name'"))
objTemplOld.join(objTemplNew)
if "xml_" in formatTemplate:
if objTemplOld.getError():
self.setError(_("False template") + ": " +\
self.setError(_("Wrong template") + ": " +\
nameFileTemplate)
return False
data = objTemplOld.getConfig().encode("UTF-8").split("\n")
@ -5158,19 +5180,19 @@ variable 'cl_name'"))
if 'exec' in objHeadNew.params:
if not self.executeTemplate(self.nameFileConfig,
objHeadNew.params['exec']):
self.setError(_("False template") + ": " +\
self.setError(_("Wrong template") + ": " +\
nameFileTemplate)
self.setError(_("Can not execute") + ": " +\
self.setError(_("Failed to execute") + ": " +\
self.nameFileConfig)
return False
return False
return filesApply
else:
self.setError(_("False (type append) template") + ": " +\
self.setError(_("Wrong (type append) template") + ": " +\
typeAppendTemplate)
return False
else:
self.setError(_("Type template not found: ") + nameFileTemplate)
self.setError(_("Template type not found: ") + nameFileTemplate)
return False
return filesApply
@ -5306,7 +5328,7 @@ class templateClt(scanDirectoryClt, Template):
if not self.flagApplyTemplates:
return ([],[])
if not self.objVar.defined("cl_template_clt_path"):
self.setError(_("not defined Var: ") + "cl_template_clt_path")
self.setError(_("undefined variable: ") + "cl_template_clt_path")
return False
dirsTemplates = self.objVar.Get("cl_template_clt_path")
dirsTemplates.sort()
@ -5379,7 +5401,7 @@ class iniParser(_error, templateFormat):
def writeIniFile(self, txtConfig):
if self.readOnly:
self.setError(_("Unable to write into file") + ": " + self.iniFile)
self.setError(_("Failed to write to file") + ": " + self.iniFile)
return False
if not os.path.exists(self.iniFile):
try:
@ -5388,10 +5410,11 @@ class iniParser(_error, templateFormat):
fcntl.flock(self.FD.fileno(), fcntl.LOCK_EX)
os.chmod(self.iniFile, self.mode)
except:
self.setError(_("Failed to create the file") + ": " + self.iniFile)
self.setError(_("Failed to create the file") +
": " + self.iniFile)
return False
if not self.FD:
self.setError(_("Unable to write into file") + ": " + self.iniFile)
self.setError(_("Failed to write to file") + ": " + self.iniFile)
return False
self.FD.truncate(0)
self.FD.seek(0)
@ -5416,8 +5439,8 @@ class iniParser(_error, templateFormat):
classObj = self.getClassObj("plasma")
else:
if nameFomat == "plasma":
self.setError(_("In the file %s (format - 'plasma'), "\
"write the variable in the format 'samba'")\
self.setError(_("Trying to write a variable of 'samba' "
"format to file %s (format - 'plasma')")\
%self.iniFile)
return False
# формат samba
@ -5468,7 +5491,7 @@ class iniParser(_error, templateFormat):
try:
objIni = self.getClassObj("plasma")(textIni)
except:
self.setError(_("Incorrect format file") + ": " + \
self.setError(_("Incorrect file format") + ": " + \
self.iniFile)
self.checkIni = False
return self.checkIni
@ -5521,8 +5544,8 @@ class iniParser(_error, templateFormat):
formatPlasma = True
else:
if nameFomat == "plasma":
self.setError(_("In the file %s (format - 'plasma'), "\
"get the variable in the format 'samba'")\
self.setError(_("Trying to fetch a variable of 'samba' "
"format from file %s (format - 'plasma')")\
%self.iniFile)
return False
# формат samba
@ -5588,8 +5611,8 @@ class iniParser(_error, templateFormat):
formatPlasma = True
else:
if nameFomat == "plasma":
self.setError(_("In the file %s (format - 'plasma'), "\
"get all variables in the format 'samba'")\
self.setError(_("Trying to fetch a variable of 'samba' "
"format from file %s (format - 'plasma')")\
%self.iniFile)
return False
# формат samba

2
calculate/lib/datavars.py
Unescape View File

@ -1061,7 +1061,7 @@ class DataVars:
return True
else:
raise DataVarsError(_("Unable to find alias '%s' of the path"
"for storage of template variables")%location)
" for storage of template variables")%location)
return False
def Select(self,selField,where="os_disk_dev",eq=None,ne=None,

158
calculate/lib/encrypt.py
Unescape View File

@ -30,7 +30,7 @@ except ImportError:
from cl_print import color_print
# для создания сертификата
import pwd
from server.utils import execProg
#from server.utils import execProg
import cl_overriding
from utils.common import genpassword
from utils.files import removeDir
@ -61,7 +61,7 @@ class encrypt(color_print):
"""
if not password:
self.printERROR(_("ERROR") + " getHashPasswd: " +
_("password empty"))
_("empty password"))
return False
hashPwd = ""
@ -111,11 +111,11 @@ class encrypt(color_print):
else:
if SecHashAlg in ("lm","nt"):
self.printERROR(_("ERROR") + " getHashPasswd: " +
(_("Can not support '%s' crypto algorithm")
(_("Failed to support '%s' crypto algorithm")
%SecHashAlg) + " " + _("without py-smbpasswd"))
else:
self.printERROR(_("ERROR") + " getHashPasswd: " +
_("Can not support '%s' crypto algorithm")
_("Failed to support '%s' crypto algorithm")
%SecHashAlg)
return False
return hashPwd
@ -255,7 +255,7 @@ nsCertType = %(nsCertType)s
def createCnfFile(self, textCnf):
'''Generate openssl.cnf file'''
if not os.path.exists(self.sslFile):
self.printERROR(_("Can not found %s")%self.sslFile)
self.printERROR(_("%s not found")%self.sslFile)
return False
strData = time.strftime("%Y%m%d%H%M%S",time.localtime(time.time()))
cnfFileName = "%s.%s.cnf" %(strData,genpassword())
@ -307,7 +307,7 @@ nsCertType = %(nsCertType)s
try:
pwdObj = pwd.getpwnam(userName)
except:
self.printERROR(_("Not found user %s")%userName)
self.printERROR(_("User %s not found")%userName)
return False
uid = pwdObj.pw_uid
gid = pwdObj.pw_gid
@ -353,7 +353,7 @@ nsCertType = %(nsCertType)s
'certKeyFile':CAKeyFile,
'sslBits':sslBits}
if execProg(execStr) is False:
self.printERROR(_("Can not execute '%s'")%execStr)
self.printERROR(_("Failed to execute '%s'")%execStr)
return False
if os.path.exists(CAKeyFile):
os.chown(CAKeyFile, uid,gid)
@ -365,7 +365,7 @@ nsCertType = %(nsCertType)s
'certKeyFile':CAKeyFile,
'certFile':CACertFile}
if execProg(execStr) is False:
self.printERROR(_("Can not execute '%s'")%execStr)
self.printERROR(_("Failed to execute '%s'")%execStr)
return False
if os.path.exists(CACertFile):
os.chown(CACertFile, uid,gid)
@ -409,7 +409,7 @@ nsCertType = %(nsCertType)s
try:
pwdObj = pwd.getpwnam(userName)
except:
self.printERROR(_("Not found user %s")%userName)
self.printERROR(_("User %s not found")%userName)
return False
uid = pwdObj.pw_uid
gid = pwdObj.pw_gid
@ -448,7 +448,7 @@ nsCertType = %(nsCertType)s
'certKeyFile':keyFile,
'sslBits':sslBits}
if execProg(execStr) is False:
self.printERROR(_("Can not execute '%s'")%execStr)
self.printERROR(_("Failed to execute '%s'")%execStr)
return False
if os.path.exists(keyFile):
os.chown(keyFile, uid,gid)
@ -460,7 +460,7 @@ nsCertType = %(nsCertType)s
'certKeyFile':keyFile,
'certCsrFile':csrFile}
if execProg(execStr) is False:
self.printERROR(_("Can not execute '%s'")%execStr)
self.printERROR(_("Failed to execute '%s'")%execStr)
return False
if os.path.exists(csrFile):
os.chown(csrFile, uid,gid)
@ -485,73 +485,73 @@ nsCertType = %(nsCertType)s
# check certificate
return self.checkCertificate(certFile)
def createCertificate(self,
sslCountry=sslCountry,
sslState=sslCountry,
sslLocality=sslLocality,
sslOrganization=sslOrganization,
sslUnit=sslUnit,
sslCommonName=sslCommonName,
sslEmail=sslEmail,
nsCertType=nsCertType,
sslDays=sslDays,
sslBits=sslBits,
userName=userName,
certFile=certFile,
fileMode=fileMode,
keyFile=keyFile):
"""Создает сертификат"""
certAndKeyFiles = [certFile, keyFile]
foundCertFiles = filter(lambda x: os.path.exists(x), certAndKeyFiles)
if len(foundCertFiles)==2:
return True
# Удаляем файл сертификата
map(lambda x: os.remove(x), foundCertFiles)
# получаем id и gid пользователя
try:
pwdObj = pwd.getpwnam(userName)
except:
self.printERROR(_("Not found user %s")%userName)
return False
uid = pwdObj.pw_uid
gid = pwdObj.pw_gid
textCnf=self.templCnfData%{'sslBits':sslBits,
'sslCountry':sslCountry,
'sslState':sslState,
'sslLocality':sslLocality,
'sslOrganization':sslOrganization,
'sslUnit':sslUnit,
'sslCommonName':sslCommonName,
'sslEmail':sslEmail,
'nsCertType':nsCertType}
cnfFile = self.createCnfFile(textCnf)
if cnfFile is False:
return False
# Cоздание директорий
for fileName in certAndKeyFiles:
dirName = os.path.split(fileName)[0]
if not os.path.exists(dirName):
self._createDir(dirName, uid=uid, gid=gid)
# Создание сертификата
textLine = execProg("%s req -new -x509 -nodes -config '%s'"
"-days %s -out '%s'-keyout '%s'"
%(self.sslFile, cnfFile, sslDays, certFile,
keyFile))
if textLine is False:
self.printERROR(_("Can not create certificate %s")%certFile)
return False
# Удаление конфигурационного файла
if os.path.exists(cnfFile):
os.remove(cnfFile)
# Меняем права
if os.path.exists(certFile):
os.chown(certFile, uid,gid)
os.chmod(certFile, fileMode)
if os.path.exists(keyFile):
os.chown(keyFile, uid,gid)
os.chmod(keyFile, fileMode)
return self.checkCertificate(certFile)
# def createCertificate(self,
# sslCountry=sslCountry,
# sslState=sslCountry,
# sslLocality=sslLocality,
# sslOrganization=sslOrganization,
# sslUnit=sslUnit,
# sslCommonName=sslCommonName,
# sslEmail=sslEmail,
# nsCertType=nsCertType,
# sslDays=sslDays,
# sslBits=sslBits,
# userName=userName,
# certFile=certFile,
# fileMode=fileMode,
# keyFile=keyFile):
# """Создает сертификат"""
# certAndKeyFiles = [certFile, keyFile]
# foundCertFiles = filter(lambda x: os.path.exists(x), certAndKeyFiles)
# if len(foundCertFiles)==2:
# return True
# # Удаляем файл сертификата
# map(lambda x: os.remove(x), foundCertFiles)
# # получаем id и gid пользователя
# try:
# pwdObj = pwd.getpwnam(userName)
# except:
# self.printERROR(_("Not found user %s")%userName)
# return False
# uid = pwdObj.pw_uid
# gid = pwdObj.pw_gid
# textCnf=self.templCnfData%{'sslBits':sslBits,
# 'sslCountry':sslCountry,
# 'sslState':sslState,
# 'sslLocality':sslLocality,
# 'sslOrganization':sslOrganization,
# 'sslUnit':sslUnit,
# 'sslCommonName':sslCommonName,
# 'sslEmail':sslEmail,
# 'nsCertType':nsCertType}
# cnfFile = self.createCnfFile(textCnf)
# if cnfFile is False:
# return False
# # Cоздание директорий
# for fileName in certAndKeyFiles:
# dirName = os.path.split(fileName)[0]
# if not os.path.exists(dirName):
# self._createDir(dirName, uid=uid, gid=gid)
# # Создание сертификата
# textLine = execProg("%s req -new -x509 -nodes -config '%s'"
# "-days %s -out '%s'-keyout '%s'"
# %(self.sslFile, cnfFile, sslDays, certFile,
# keyFile))
# if textLine is False:
# self.printERROR(_("Can not create certificate %s")%certFile)
# return False
# # Удаление конфигурационного файла
# if os.path.exists(cnfFile):
# os.remove(cnfFile)
# # Меняем права
# if os.path.exists(certFile):
# os.chown(certFile, uid,gid)
# os.chmod(certFile, fileMode)
# if os.path.exists(keyFile):
# os.chown(keyFile, uid,gid)
# os.chmod(keyFile, fileMode)
#
# return self.checkCertificate(certFile)
def _createDir(self, dirName, uid=0, gid=0, mode=0700):
"""Создание пользовательской директории"""
@ -572,7 +572,7 @@ nsCertType = %(nsCertType)s
"""
dirName = os.path.split(fileName)[0]
if not os.path.exists(dirName):
self.printERROR(_("Path %s not exists") %dirName)
self.printERROR(_("Path %s does not exist") %dirName)
return False
fd = os.open(fileName, os.O_CREAT)
os.close(fd)

14
calculate/lib/format/patch.py
Unescape View File

@ -54,7 +54,7 @@ class patch(_error):
def processingFile(self, textConfigFile):
"""Обработка конфигурационного файла"""
if not self.doc:
self.setError(_("Can not convert text template in XML"))
self.setError(_("Cannot convert the text template in XML"))
return False
retTextConfigFile = textConfigFile
tags = ["reg", "text"]
@ -63,7 +63,7 @@ class patch(_error):
for node in self.rootNode.childNodes:
if node.nodeType==node.ELEMENT_NODE:
if not node.tagName == tags[tagsIndex]:
self.setError(_("Incorrect text template"))
self.setError(_("Incorrect template text"))
return False
if tagsIndex == 1:
tagsIndex = 0
@ -76,23 +76,23 @@ class patch(_error):
if reText is None:
textNode = node.toxml().encode("UTF8")
self.setError(\
_("Incorrect text template")+ ": \n" +\
_("Incorrect template text")+ ": \n" +\
"%s" %textNode)
return False
else:
self.setError(\
_("Incorrect text template '<reg></reg>'"))
_("Incorrect text of template '<reg></reg>'"))
return False
if not reText.strip():
self.setError(\
_("Incorrect text template '<reg>%s</reg>'")\
_("Incorrect text of template '<reg>%s</reg>'")\
%reText)
return False
try:
regex = re.compile(reText)
except:
self.setError(\
_("Incorrect text template '<reg>%s</reg>'")\
_("Incorrect text of template '<reg>%s</reg>'")\
%reText)
return False
elif node.tagName == "text" and regex:
@ -101,7 +101,7 @@ class patch(_error):
if text is None:
textNode = node.toxml().encode("UTF8")
self.setError(\
_("Incorrect text template")+ ": \n" +\
_("Incorrect template text")+ ": \n" +\
"%s" %textNode)
return False
else:

9
calculate/lib/format/xml_gconf.py
Unescape View File

@ -119,7 +119,8 @@ class xml_gconf(xml_xfce):
(found '<gconf><%(tag)s>..</%(tag)s></gconf>'")%{'tag':tagName})
return False
if not n.hasAttribute("name"):
self.setError(_('Not found attribute "name" in tag entry'))
self.setError(
_("Arrtibute \"name\" not found in the tag entry"))
return False
flagType = n.hasAttribute("type")
flagValue = False
@ -127,7 +128,8 @@ class xml_gconf(xml_xfce):
if flagSchema:
nSchema = n.getAttribute("schema")
if not flagType and not flagSchema:
self.setError(_('Not found attribute "type" in tag entry'))
self.setError(
_("Arrtibute \"type\" not found in the tag entry"))
return False
nName = n.getAttribute("name")
attrName = u"attribute::name='%s'"%nName
@ -179,8 +181,7 @@ Valid values attribute 'action': \
flagJoin = False
flagDrop = True
if flagRootNode:
textError = \
_('Incorrect action="drop" in the root node')
textError = _('Incorrect action="drop" in root node')
self.setError(textError)
return False
if oldNodes:

3
calculate/lib/format/xml_gconf_tree.py
Unescape View File

@ -91,8 +91,7 @@ Valid values attribute 'action': \
flagDrop = True
flagJoin = False
if flagRootNode:
textError = \
_('Incorrect action="drop" in the root node')
textError = _('Incorrect action="drop" in root node')
self.setError(textError)
return False
if oldNodes:

3
calculate/lib/format/xml_xfce.py
Unescape View File

@ -182,8 +182,7 @@ Valid values attribute 'action': \
flagJoin = False
flagDrop = True
if flagRootNode:
textError = \
_('Incorrect action="drop" in the root node')
textError = _('Incorrect action="drop" in root node')
self.setError(textError)
return False
if oldNodes:

3
calculate/lib/format/xml_xfcepanel.py
Unescape View File

@ -105,8 +105,7 @@ Valid values attribute 'action': \
flagJoin = False
flagDrop = True
if flagRootNode:
textError = \
_('Incorrect action="drop" in the root node')
textError = _('Incorrect action="drop" in root node')
self.setError(textError)
return False
if path == "panel":

0
calculate/lib/server/__init__.py
Unescape View File

435
calculate/lib/server/ldap.py
Unescape View File

@ -1,435 +0,0 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2012 Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
from mod import mod_ldap
import sys
sys.modules['mod_ldap'] = mod_ldap
from mod_ldap import LDAPError, MOD_REPLACE, MOD_ADD, SCOPE_SUBTREE,\
SCOPE_ONELEVEL
from ldif import LDIFParser, LDIFWriter
import cStringIO, StringIO
from calculate.lib.cl_utils import _error
from calculate.lib.cl_print import color_print
from calculate.lib.cl_template import template, iniParser
from calculate.lib.cl_ldap import ldapFun
from share import shareVars
from utils import genSleep, stringIsJpeg
# Перевод модуля
from calculate.lib.cl_lang import setLocalTranslate
setLocalTranslate("cl_lib3",sys.modules[__name__])
def adminConnectLdap(fun):
"""Cоединение с LDAP администратором сервиса (декоратор)
соединение с LDAP и проверка установки необходимых переменных
"""
def ret (self, *arg, **argv):
flagError = False
if not self.clVars:
self.createClVars()
if not self.ldapObj:
if not self.getLdapObjInFile():
flagError = True
if not self.baseDN:
if self.clVars.defined("ld_base_dn"):
self.baseDN = self.clVars.Get("ld_base_dn")
if not self.baseDN:
self.printERROR (_('Not found LDAP base DN'))
if flagError:
return False
else:
return fun(self, *arg , **argv)
return ret
class addLdif(LDIFParser):
"""Класс необходимый для добавления записей в LDAP"""
def __init__(self, strInput,ldapCon):
FD = cStringIO.StringIO(strInput)
LDIFParser.__init__(self, FD)
self.ldapCon = ldapCon
def handle(self, dn, entry):
self.ldapCon.add_s(dn, entry.items())
class ldapFunction(ldapFun):
'''Объект для работы с LDAP сервером'''
def __init__(self, dnUser, password):
ldapFun.__init__(self, dnUser, password)
def ldapAdd(self, strLdif):
"""Добавляем строку содержащую ldif в LDAP
Если данные существуют - ошибка
"""
if self.conLdap:
try:
# Записываем параметры из ldif файла в LDAP сервер
parser = addLdif(strLdif,self.conLdap)
parser.parse()
except LDAPError, e:
self.setError(e[0]['desc'])
return False
except:
self.setError("Error in ldif file")
return False
return True
else:
self.setError(_("No connect to LDAP server"))
return False
class iniLdapParser(iniParser):
"""Класс для работы c ini-файлом ldap"""
def __init__(self):
# название ini файла
self.nameIniFile = "/etc/calculate/calculate.ldap"
iniParser.__init__(self, self.nameIniFile)
# права создаваемого ini-файла
self.setMode(0600)
pathIniFile = os.path.split(self.nameIniFile)[0]
if not os.path.exists(pathIniFile):
os.makedirs(pathIniFile)
class shareldap(_error, color_print, shareVars):
"""Общие методы для работы с LDAP для серверных программ"""
# DN сервисов относительно базового
ServicesDN = "ou=Services"
# Переменная объект Vars
clVars = False
# Переменная объект ldapFunction
ldapObj = False
# Переменная соединение с LDAP сервером
conLdap = False
# Базовый DN LDAP сервера
baseDN = False
def addDN(self, *arg):
"""Складывает текстовые элементы DN"""
DNs = []
for dn in arg:
if dn:
DNs.append(dn)
return ','.join(DNs)
@adminConnectLdap
def searchLdapDN(self, name, relDN, attr, retAttr=None):
"""Находит DN в LDAP"""
DN = self.addDN(relDN,self.baseDN)
#searchScope = SCOPE_SUBTREE
searchScope = SCOPE_ONELEVEL
searchFilter = "%s=%s" %(attr,name)
retrieveAttributes = retAttr
resSearch = self.ldapObj.ldapSearch(DN, searchScope,
searchFilter, retrieveAttributes)
return resSearch
@adminConnectLdap
def addEntry(self, DN, entry, errorMessage):
"""Добавление узла в LDAP"""
try:
self.conLdap.add_s(DN, entry)
except LDAPError, e:
self.printERROR(_("LDAP Error") + ": " + e[0]['desc'].strip())
self.printERROR(errorMessage)
return False
return True
def getLdapObjInFile(self, part="admin"):
"""Получаем объект ldapFunction из ini файла
В выходном объекте есть соединение с LDAP сервером: self.conLdap
"""
# Если раннее была ошибка то выходим
if self.getError():
self.printERROR (_("ERROR") + ": " +\
self.getError().strip())
return False
ldapParser = iniLdapParser()
adminDn = ldapParser.getVar(part,"DN")
adminPw = ldapParser.getVar(part,"PASS")
if not (adminDn or adminPw):
if part == "admin":
service = "LDAP"
else:
service = part
self.printERROR(\
_("Admin password for the service %s could not be found")%service)
return False
ldapObj = ldapFunction(adminDn, adminPw)
# Генератор задержек
wait = genSleep()
while ldapObj.getError():
try:
# Задержка
wait.next()
except StopIteration:
break
# Очистка ошибки
_error.error = []
ldapObj = ldapFunction(adminDn, adminPw)
if ldapObj.getError():
# Удаляем одинаковые ошибки
listError = []
for e in ldapObj.error:
if not e in listError:
listError.append(e)
_error.error = listError
self.printERROR (_("LDAP connect error") + ": " +\
ldapObj.getError().strip())
return False
# Устанавливаем у объекта соединение и объект LDAP функций
self.ldapObj = ldapObj
self.conLdap = ldapObj.conLdap
return True
def connectToLDAP(self, adminDn, adminPw):
"""Подключаемся к LDAP - для внешних программ запускающихся не от root
"""
ldapObj = ldapFunction(adminDn, adminPw)
# Генератор задержек
wait = genSleep()
while ldapObj.getError():
try:
# Задержка
wait.next()
except StopIteration:
break
# Очистка ошибки
_error.error = []
ldapObj = ldapFunction(adminDn, adminPw)
if ldapObj.getError():
# Удаляем одинаковые ошибки
listError = []
for e in ldapObj.error:
if not e in listError:
listError.append(e)
_error.error = listError
self.printERROR (_("LDAP connect error") + ": " +\
ldapObj.getError().strip())
return False
# Устанавливаем у объекта соединение и объект LDAP функций
self.ldapObj = ldapObj
self.conLdap = ldapObj.conLdap
return True
@adminConnectLdap
def modAttrsDN(self, relDN, modAttrs):
"""Модифицирует аттрибуты DN"""
DN = self.addDN(relDN,self.baseDN)
if modAttrs:
try:
self.conLdap.modify_s(DN, modAttrs)
except LDAPError, e:
self.printERROR(e[0]['desc'])
return False
return True
@adminConnectLdap
def modifyElemDN(self, relDN, newFirstDn):
"""Изменяет основной элемент DN (uid, cn и др.)"""
DN = self.addDN(relDN,self.baseDN)
try:
self.conLdap.modrdn_s(DN, newFirstDn)
except LDAPError, e:
self.printERROR(e[0]['desc'])
return False
return True
def getMaxAttrDN(self, relDN, name, attr, numMin, numMax, attrSearch):
"""Находит максимальный добавленный аттрибут в LDAP DN"""
resSearch = self.searchLdapDN(name, relDN, attr, [attrSearch])
lst = []
lst.append(0)
if resSearch:
for scope in resSearch:
if scope[0][1].has_key(attrSearch):
uid = int(scope[0][1][attrSearch][0])
if uid<=numMax and uid>=numMin:
lst.append(uid)
return max(lst)
return False
def createLdif(self, ldifFile):
"""Cоздает ldif из ldif - шаблона"""
if not os.access(ldifFile, os.F_OK):
self.setError(_("File not found") + ":\n " + ldifFile)
return False
FD = open (ldifFile)
ldifTemplate = FD.read()
FD.close()
clTempl = template(self.clVars)
# Применяем условия к шаблону
ldifTemplate = clTempl.applyTermsTemplate(ldifTemplate, ldifFile)
# Заменяем переменные в шаблоне
ldifTemplate = clTempl.applyVarsTemplate(ldifTemplate, ldifFile)
return ldifTemplate
@adminConnectLdap
def delDN(self, relDN):
"""Удаляет одиночный DN"""
DN = self.addDN(relDN,self.baseDN)
try:
self.conLdap.delete_s(DN)
except LDAPError, e:
self.printERROR(e[0]['desc'])
return False
return True
@adminConnectLdap
def deleteDN(self, relDelDN):
"""Удаляет DN и все внутренние элементы"""
delDN = self.addDN(relDelDN, self.baseDN)
delListDN=[]
try:
dnList = self.conLdap.search_s(delDN,
SCOPE_SUBTREE,
'(objectclass=*)',
[''])
except LDAPError, e:
self.printERROR("deleteDN: "+e[0]['desc'])
return False
for dn, f in dnList:
delListDN.append(dn)
delListDN.sort(lambda x, y: cmp(len(y), len(x)))
for dn in delListDN:
try:
self.conLdap.delete_s(dn)
except LDAPError, e:
self.printERROR("deleteDN: "+e[0]['desc'])
return False
return True
@adminConnectLdap
def fullElementDNtoText(self, relDN="", ldapFilter='(objectclass=*)'):
"""Выводит все внутренние элементы DN виде текста"""
DN = self.addDN(relDN, self.baseDN)
listDN=[]
try:
dnList = self.conLdap.search_s(DN,
SCOPE_SUBTREE,
ldapFilter,None)
except LDAPError, e:
self.printERROR("fullElementDN: "+e[0]['desc'])
return False
FDOUT = StringIO.StringIO("")
writer = LDIFWriter(FDOUT)
for dn, f in dnList:
writer.unparse(dn, f)
FDOUT.seek(0)
return FDOUT.read()
@adminConnectLdap
def fullElementSambaDNtoText(self, relDN=""):
"""Выводит все внутренние элементы ветки Samba в виде текста"""
return self.fullElementDNtoText(relDN,'(|(|(|(|(ou:dn:=Samba)\
(ou:dn:=Unix))(ou:dn:=LDAP))(!(ou:dn:=Services)))(ou=Services))')
@adminConnectLdap
def fullElementUnixDNtoText(self, relDN=""):
"""Выводит все внутренние элементы ветки Unix в виде текста"""
return self.fullElementDNtoText(relDN,'(|(|(|(ou:dn:=Unix)\
(ou:dn:=LDAP))(!(ou:dn:=Services)))(ou=Services))')
@adminConnectLdap
def fullElementMailDNtoText(self, relDN=""):
"""Выводит все внутренние элементы ветки Mail в виде текста"""
baseDN = self.clVars.Get("ld_base_dn")
baseDNName, baseLogin = baseDN.split(",")[0].split("=")
proxyDN = self.clVars.Get("ld_bind_dn")
proxyDNName, proxyLogin = proxyDN.split(",")[0].split("=")
#return self.fullElementDNtoText(relDN,'(&(|(|(&(ou:dn:=Replication)\
#(ou:dn:=Mail))(!(ou:dn:=Services)))(ou=Services))(!(&(%s:dn:=%s)\
#(%s:dn:=%s))))'%(proxyDNName, proxyLogin, baseDNName, baseLogin))
return self.fullElementDNtoText(relDN,'(&(&(|(|(|(ou:dn:=LDAP)\
(ou=Mail))(!(ou:dn:=Services)))(ou=Services))(!(&(%s:dn:=%s)(%s:dn:=%s))))\
(!(ou:dn:=Worked)))'%(proxyDNName, proxyLogin, baseDNName, baseLogin))
@adminConnectLdap
def fullElementMailSambaDNtoText(self, relDN=""):
"""Выводит все внутренние элементы ветки Samba и Mail в виде текста"""
return self.fullElementDNtoText(relDN,'(&(|(|(|(|(|(ou:dn:=Samba)\
(ou:dn:=Unix))(ou:dn:=LDAP))(ou:dn:=Mail))(!(ou:dn:=Services)))(ou=Services))\
(!(|(&(&(ou:dn:=Users)(ou:dn:=Mail))(uid=*))(&(&(ou:dn:=Groups)(ou:dn:=Mail))\
(cn=*)))))')
@adminConnectLdap
def fullElementMailUnixDNtoText(self, relDN=""):
"""Выводит все внутренние элементы ветки Unix и Mail в виде текста"""
return self.fullElementDNtoText(relDN,'(&(|(|(|(|(ou:dn:=Unix)\
(ou:dn:=LDAP))(ou:dn:=Mail))(!(ou:dn:=Services)))(ou=Services))\
(!(|(&(&(ou:dn:=Users)(ou:dn:=Mail))(uid=*))(&(&(ou:dn:=Groups)(ou:dn:=Mail))\
(cn=*)))))')
def setJpegPhotoUser(self, userName, photoPath, attr="uid"):
"""Добавляем jpeg фотографию пользователя в LDAP"""
import subprocess
try:
FD = open(photoPath)
photoData = FD.read()
FD.close()
except:
self.printERROR(_("Not open file") + ": " + str(photoPath))
return False
searchUser = self.searchLdapDN(userName, self.relUsersDN, attr)
if not searchUser:
self.printERROR(_("User") + " " + str(userName) + " "+\
_("not found"))
return False
modAttrs = []
if not stringIsJpeg(photoData):
flagError = False
pipe = subprocess.Popen("convert '%s' jpg:-" %photoPath,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE, close_fds=True,
shell=True)
fOut, fIn, fErr = (pipe.stdout, pipe.stdin, pipe.stderr)
fIn.close()
# Код возврата
retcode = pipe.wait()
if retcode != 0:
self.printERROR(_("Can not convert file '%s' in jpeg format")\
%photoPath)
flagError = True
fErr.close()
if not flagError:
photoData = fOut.read()
if not stringIsJpeg(photoData):
self.printERROR(\
_("Can not convert file '%s' in jpeg format") %photoPath)
flagError = True
fOut.close()
if flagError:
return False
if searchUser[0][0][1].has_key('jpegPhoto'):
modAttrs.append((MOD_REPLACE, 'jpegPhoto', photoData))
else:
modAttrs.append((MOD_ADD, 'jpegPhoto', photoData))
userDN = self.addDN("%s=%s"%(attr,userName),self.relUsersDN)
if not self.modAttrsDN(userDN, modAttrs):
return False
return True
def searchService(self):
"""Поиск DN сервиса"""
name, value = self.relServDN.split('=')
resSearch = self.searchLdapDN(value, self.ServicesDN, name)
return resSearch

137
calculate/lib/server/share.py
Unescape View File

@ -1,137 +0,0 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2012 Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import sys
from calculate.lib.cl_datavars import DataVars
from calculate.lib.cl_print import color_print
from calculate.lib.cl_lang import setLocalTranslate
setLocalTranslate('cl_lib3',sys.modules[__name__])
class shareVars:
"""Общие методы для классов модулей серверных программ"""
# Переменная объект Vars
clVars = False
def createClVars(self, clVars=False, returnImportVar=False):
"""Создает объект Vars"""
# Словарь импортируемых переменных из ini Файлов
dictImportVars = {}
if not clVars:
clVars = DataVars()
clVars.flServer()
dictImportVars = clVars.flIniFile()
# Устанавливаем у объекта объект Vars
self.clVars = clVars
if returnImportVar:
return dictImportVars
return True
def deleteServiceVarsInFile(self, service):
"""Удаляет переменные сервиса из ini файлов
После запуска этого метода объект self.clVars должен быть пересоздан
"""
importVarsDict = self.createClVars(False,True)
serviceNameVars = "_%s_" %service
for location in importVarsDict.keys():
for nameVar in importVarsDict[location]:
# Если имя сервиса присутствует в переменной -
# Удаляем переменную
if serviceNameVars in nameVar:
if not self.clVars.Delete(nameVar, location, "server"):
return False
self.clVars = False
return True
def saveVarsClient(self, listVarName):
"""Записывает переменные для клиента calcualte-client"""
#считаем переменные для клиента
dictVar = {}
flagError = False
for varName in listVarName:
value = self.clVars.Get(varName)
if not value and value != "":
self.printERROR(_("Variables %s is empty")%varName)
flagError = True
break
dictVar[varName] = value
if flagError:
return False
#Запишем переменные в клиентскую секцию
for name,value in dictVar.items():
value = str(value)
if not value.strip():
self.clVars.Delete(name)
if not self.clVars.Write(name,value,True,"remote","client"):
self.printERROR(_("Error writing variable %s")%name)
flagError = True
break
if flagError:
return False
return True
def reloadDefaultVar(self, nameVar):
"""При получениии значения переменной снова
вызывается метод заполнения переменной"""
self.clVars.Set(nameVar,"",True)
self.clVars.__getattribute__(nameVar).countFill = 0
self.clVars.__getattribute__(nameVar).fillStart = True
return True
class servicesAPI(color_print):
"""Методы сервисов используемые другими сервисами"""
# Путь к модулю сервера
__pathServer__ = "/usr/lib/calculate/calculate-server/pym"
# Названия импортированных классов
__imports_names__ = []
# Импортированные классы
__imports_classes__ = {}
def __getServiceObj__(self, serviceName):
"""Получаем объект сервиса"""
if not serviceName in __imports_names__:
try:
classImport = getattr(__import__("cl_ldap", globals(),\
locals(),[]), serviceName)
except (ImportError, AttributeError):
self.printERROR(_("Can not found service class '%s'")\
%serviceName)
return False
__imports_classes__[serviceName] = classImport
__imports_names__.append(serviceName)
retObj = classImport()
else:
retObj = __imports_classes__[serviceName]()
return retObj
def searchUnixUser(self, userName, servUnixObj=None):
"""Поиск пользователя в LDAP ветке Unix сервиса"""
if not servUnixObj:
servUnixObj = self.__getServiceObj__("unix")
if not servUnixObj:
exit(1)
return servUnixObj.searchUnixUser(userName)
def searchPasswdUser(self, userName, servUnixObj=None):
"""Поиск пользователя в /etc/passwd"""
if not servUnixObj:
servUnixObj = self.__getServiceObj__("unix")
if not servUnixObj:
exit(1)
return servUnixObj.searchPasswdUser(userName)

326
calculate/lib/server/users.py
Unescape View File

@ -1,326 +0,0 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2012 Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import sys
# Ввод pwd
import getpass
import types
from calculate.lib.utils.files import removeDir
from calculate.lib.cl_print import color_print
from share import servicesAPI
from utils import rawInput, isCorrectStringNet, addInfoUser, addInfoGroup, dialogYesNo
from calculate.lib.cl_lang import setLocalTranslate
setLocalTranslate('cl_lib3',sys.modules[__name__])
class users(color_print):
"""Общие методы для серверных программ,
(работа с пользователями и группами)"""
# Объект с методами доступа к другим сервисам
servicesAPIObj = servicesAPI()
# Статические группы
staticGroups = {\
'client':addInfoGroup('client',
'900',
'Client group',
'2801',
'2'),
'Domain Admins':addInfoGroup('Domain Admins',
'512',
'Domain Administrators',
'512',
'2'),
'Domain Users':addInfoGroup('Domain Users',
'513',
'Domain Users',
'513',
'2'),
'Domain Guests':addInfoGroup('Domain Guests',
'514',
'Domain Guests Users',
'514',
'2'),
'Domain Computers':addInfoGroup('Domain Computers',
'515',
'Domain Computers accounts',
'515',
'2'),
'Administrators':addInfoGroup('Administrators',
'544',
'Domain Members can fully \
administer the computer/sambaDomainName',
'544',
'5',
"S-1-5-32-544"),
'Account Operators':addInfoGroup('Account Operators',
'548',
'Domain Users to manipulate \
users accounts',
'548',
'5',
"S-1-5-32-548"),
'System Operators':addInfoGroup('System Operators',
'549',
'Domain System Operators',
'549',
'5',
"S-1-5-32-549"),
'Print Operators':addInfoGroup('Print Operators',
'550',
'Domain Print Operators',
'550',
'5',
"S-1-5-32-550"),
'Backup Operators':addInfoGroup('Backup Operators',
'551',
'Domain Members can bypass \
file security to back up files',
'551',
'5',
"S-1-5-32-551"),
'Replicators':addInfoGroup('Replicators',
'552',
'Domain Supports file replication \
in a sambaDomainName',
'552',
'5',
"S-1-5-32-552"),
}
# Статические пользователи
staticUsers = {\
'client':addInfoUser('client',
'900',
'900',
'Client samba user'),
'admin':addInfoUser('admin',
'901',
'544',
'Admin samba user')}
def getUserUidAndGid(self, userName, groupName=""):
"""Находит в системе uid и gid пользователя
userName - имя пользователя и имя группы пользователя
"""
if not groupName:
groupName = userName
import pwd
try:
uid = pwd.getpwnam(userName)[2]
except:
self.printERROR(_("Can not found user %s in this system")%userName)
return ()
try:
import grp
gid = grp.getgrnam(groupName)[2]
except:
self.printERROR(_("Can not found group %s in this system")\
%groupName)
return ()
return (uid, gid)
def __restoreDelUser(self,userName,service,srcDir,message,unixObj=False):
"""Возвращаем данные удаленного пользователя"""
# Ищем Unix пользователя
searchUnixUser = self.servicesAPIObj.searchUnixUser(userName, unixObj)
# id пользователя
strUid = ""
if searchUnixUser:
strUid = searchUnixUser[0][0][1]['uidNumber'][0]
else:
resPasswd = self.servicesAPIObj.searchPasswdUser(userName, unixObj)
if resPasswd:
strUid = resPasswd.split(":")[2]
if strUid:
delBackDir =\
os.path.join(self.clVars.Get("sr_deleted_path"),
"%s-%s"%(userName,strUid),
service)
if strUid and os.path.exists(delBackDir) and os.listdir(delBackDir):
if message == None or type(message) == types.BooleanType:
dialogRes = message
else:
dialogRes = dialogYesNo(message)
if dialogRes and dialogRes == True:
try:
copyDir(srcDir, delBackDir)
except:
self.printERROR(_("Not restore user data in dir %s")\
%srcDir)
return False
self.printSUCCESS(_("Restore user data in dir %s")\
%srcDir)
return "Yes", delBackDir
elif dialogRes == False:
return "No", delBackDir
elif dialogRes == None:
return "Cancel", delBackDir
return True
def restorePathDelUser(self,userName,destDir,relDir,message,unixObj=False):
"""Восстанавливает директорию удаленного пользователя"""
removedDir = False
flagError = False
resRestore = self.__restoreDelUser(userName, relDir,
destDir, message, unixObj)
# Если ошибка то выходим
if not resRestore:
flagError = True
# Флаг создания директории профиля пользователя
createDir = destDir
term = ""
if resRestore == True:
term = message
if not flagError and type(resRestore) == types.TupleType:
# Если cansel
if resRestore[0] == "Cancel":
# Удаляем пользователя
flagError = True
term = None
# Если No
elif resRestore[0] == "No":
try:
removeDir(resRestore[1])
except:
flagError = True
if not flagError:
removedDir = resRestore[1]
term = False
elif resRestore[0] == "Yes":
createDir = False
removedDir = resRestore[1]
term = True
if flagError or term == "":
return False
else:
return (term, createDir, removedDir)
def backupDelUser(self, userName, service, srcDir, unixObj=False):
"""Сохраняем данные удаляемого пользователя"""
# Ищем Unix пользователя
searchUnixUser = self.servicesAPIObj.searchUnixUser(userName, unixObj)
# id пользователя
strUid = ""
if searchUnixUser:
strUid = searchUnixUser[0][0][1]['uidNumber'][0]
if strUid:
delBackDir =\
os.path.join(self.clVars.Get("sr_deleted_path"),
"%s-%s"%(userName,strUid),
service)
if os.path.exists(delBackDir) and os.listdir(delBackDir):
self.printERROR(_("Found deleted user’s data in directory %s")\
%delBackDir)
self.printERROR(_("Not created deleted user data dir %s")\
%delBackDir)
return False
else:
delBackDir =\
os.path.join(self.clVars.Get("sr_deleted_path"),
"%s"%(userName),
service)
i = 0
while os.path.exists(delBackDir):
i += 1
delBackDir =\
os.path.join(self.clVars.Get("sr_deleted_path"),
"%s_%s"%(userName,i),
service)
# Cоздаем директорию хранения удаленных пользователей
if not os.path.exists(self.clVars.Get("sr_deleted_path")):
os.makedirs(self.clVars.Get("sr_deleted_path"))
#Делаем сохранение директории
try:
copyDir(delBackDir,srcDir)
except:
self.printERROR(_("Can not copy deleted user data in dir %s")\
%delBackDir)
return False
self.printSUCCESS(_("Created deleted user data dir %s")\
%delBackDir)
return True
def removeEmptyDir(self, rmDir):
"""Удаление пустых директорий"""
if not os.path.exists(rmDir):
self.printERROR(_("Not found remove dir %s") %rmDir)
return False
rDir = rmDir
while os.listdir(rDir) == []:
os.rmdir(rDir)
rDir = os.path.split(rDir)[0]
if rDir == "/":
break
return True
def createUserDir(self, uid, gid, userDir, mode=0700):
"""Создание пользовательской директории"""
if not os.path.exists(userDir):
os.makedirs(userDir)
if mode:
os.chmod(userDir,mode)
os.chown(userDir,uid,gid)
return True
else:
self.printERROR(_("Path %s exists") %userDir)
return False
def createUserFile(self, fileName, fileTxt, uid, gid, mode=0644):
"""Создает пользовательский файл с содержимым
Если директория файла не существует то ошибка
"""
userDir = os.path.split(fileName)[0]
if not os.path.exists(userDir):
self.printERROR(_("Path %s not exists") %userDir)
return False
fd = os.open(fileName, os.O_CREAT)
os.close(fd)
os.chmod(fileName, mode)
os.chown(fileName,uid,gid)
if fileTxt:
FD = open(fileName, "r+")
FD.write(fileTxt)
FD.close()
return True
def getUserAllowNetwork(self, strPrompt, strNetAllow):
"""Получаем от пользователя доверительные сети
вывод - список доверительных сетей
"""
def printW():
cl_overriding.printSUCCESS(_("Incorrect string allow networks"))
cl_overriding.printSUCCESS(\
_("Example: available networks: 10.0.0.0/24 10.0.10.0/24"))
cl_overriding.printSUCCESS(_("Try again\n"))
strNet = rawInput(strPrompt, strNetAllow)
i = 0
while i<3 and not isCorrectStringNet(strNet):
printW()
strNet = rawInput(strPrompt, strNet)
i +=1
if i == 3 and not isCorrectStringNet(strNet):
printW()
self.printERROR(_("You used four attempts, \
if you want to continue to run the program again"))
return False
return isCorrectStringNet(strNet)

288
calculate/lib/server/utils.py
Unescape View File

@ -1,288 +0,0 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2012 Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import sys
import re
import cStringIO
import termios
# for symbol input
import tty
import time
from calculate.lib.utils.common import getpathenv
from calculate.lib.utils.files import runOsCommand
"""общие функции серверных программ"""
def unicList(listEl):
"""Уникальный список с сохранением порядка"""
retList = []
[not x in retList and retList.append(x) for x in listEl]
return retList
def dialogYn(message):
"""Вывод сообщения, ожидание нажатия Y или n
если Y - True если n - False"""
def getChar():
fd = sys.stdin.fileno()
oldSet = termios.tcgetattr(fd)
tty.setraw(fd)
char = sys.stdin.read(1)
termios.tcsetattr(fd, termios.TCSADRAIN, oldSet)
return char
def term(char):
if ord(char) == 3:
return None
if char == "Y":
return True
elif char == "n":
return False
else:
char = getChar()
return term(char)
sys.stdout.write(message + ":")
char = getChar()
res = term(char)
sys.stdout.write("\n")
return res
def dialogYesNo(message, reYes=re.compile("^ye?s?$",re.I),
reNo=re.compile("^no?$",re.I)):
"""Вывод сообщения, ожидание набора Yes или No (в любом регистре)
если Yes - True, если No - False"""
sys.stdout.write(message + ": ")
sys.stdout.flush()
#strIn=sys.stdin.readline().lower().strip()
strIn = raw_input("")
sys.stdout.write("\n")
if reYes.match(strIn):
return True
elif reNo.match(strIn):
return False
else:
return dialogYesNo(message, reYes, reNo)
def rawInput(promptText="", inputText=""):
"""Создает поле ввода
promptText - текст перед полем ввода
inputText - текст в поле ввода
"""
# Вывод в строку ввода
import readline
if inputText:
# Записываем текст для последующего вывода в строке ввода
readline.set_pre_input_hook(lambda:\
readline.insert_text(inputText) or\
readline.redisplay())
strInput = ""
if promptText:
# Получаем текст введенный пользователем
strInput = raw_input(promptText)
else:
strInput = raw_input()
if inputText:
# Сбрасываем строку ввода
readline.set_pre_input_hook(None)
return strInput
def execProg(cmdStrProg, inStr=False, envProg={}):
"""Выполняет внешнюю программу
Параметры:
cmdStrProg внешняя программа
inStr данные передаваемые программе на страндартный вход.
Возвращаемые параметры:
строки которые выведет внешняя программа или False в случае ошибки
"""
env_path = {"PATH":getpathenv()}
env = {}
env.update(os.environ.items() + env_path.items() + envProg.items())
retCode,programOut = runOsCommand(cmdStrProg,in_str=inStr,env_dict=env)
if not retCode:
return programOut
return False
def genSleep(timeSleep=(0.2, 0.4, 0.8)):
"""Генератор задержек"""
for t in timeSleep:
time.sleep(t)
yield(t)
def stringIsJpeg(string):
"""Определяет является ли строка - jpeg изображением"""
if len(string)<8:
return False
FD = cStringIO.StringIO(string)
isJpeg = False
FD.seek(0, 0)
(firstByte, secondByte) = FD.read(2)
if (ord(firstByte) == 0xff and ord(secondByte) == 0xd8):
(firstByte, secondByte) = FD.read(2)
if (ord(firstByte) == 0xff and ord(secondByte) == 0xe0):
isJpeg = True
return isJpeg
def isCorrectStringNet(strNetworks, checkNet=True):
"""Проверяет на корректность строку доверительных сетей
Выводит cписок сетей
"""
splNet = strNetworks.replace(","," ").split(" ")
if checkNet:
checkIP = False
res=re.compile("^\d\d?\d?\.\d\d?\d?\.\d\d?\d?\.\d\d?\d?\/\d\d?$")
else:
checkIP = True
res=re.compile("^\d\d?\d?\.\d\d?\d?\.\d\d?\d?\.\d\d?\d?$")
flagError = False
networks = []
for i in splNet:
r = i.strip()
if not r:
continue
find =res.search(r)
if not find:
flagError = True
break
else:
splIP = map(lambda x: 255>=int(x.split("/")[0]) and\
x.split("/")[0], find.group().split("."))
if not splIP[0] or splIP[0] and int(splIP[0]) == 0:
flagError = True
break
if not splIP[3] or splIP[3] and int(splIP[3]) == 255:
flagError = True
break
if checkNet:
netList = r.split("/")
if len(netList)==2:
try:
netMaskInt = int(netList[1])
except:
flagError = True
break
if netMaskInt>31 or netMaskInt<4:
flagError = True
break
else:
flagError = True
break
if checkIP and splIP[3] and int(splIP[3]) == 0:
flagError = True
break
for t in splIP:
if t == False:
flagError = True
break
if flagError:
break
networks.append(r)
if flagError:
return False
else:
return list(set(networks))
def searchLineInFile(name, fileName, numEl=0):
"""Ищет строку в которой есть название разделенное ':'
в файле похожем на /etc/passwd"""
if os.path.exists(fileName):
FD = open(fileName)
lines = FD.readlines()
FD.close()
lineFound = ""
for line in lines:
if name == line.split(":")[numEl]:
lineFound = line
break
if lineFound:
return lineFound
else:
return False
def getMaxInFile(fileName, numMin, numMax, numEl=2):
"""Получаем максимальный номер из файла похожего на /etc/group"""
lst = []
lst.append(0)
if os.path.exists(fileName):
FD = open(fileName)
lines = FD.readlines()
FD.close()
for line in lines:
if not ':' in line:
continue
num = int(line.split(":")[numEl])
if num<=numMax and num>=numMin:
lst.append(num)
return max(lst)
return False
def chortToFullName(listNames, domain):
"""Из списка коротких имен получаем cписок полных имен
К коротким именам добавляем домен, длинные выдаем как есть
"""
listFillNames = []
for name in listNames:
if "." in name:
listFillNames.append(name)
else:
listFillNames.append("%s.%s" %(name,domain))
return listFillNames
def addInfoUser(name, uid, gid, comment):
"""Добавляем информацию о пользователе"""
class user():
"""Информация о пользователе"""
name = ""
uid = ""
gid = ""
comment = ""
us = user()
us.name = name
us.uid = uid
us.gid = gid
us.comment = comment
return us
def addInfoGroup(name, gid, comment, rid="", type="", sid=""):
"""Добавляем информацию о группе"""
class group():
"""Информация о группе"""
name = ""
gid = ""
comment = ""
rid = ""
type = ""
sid = ""
gr = group()
gr.name = name
gr.gid = gid
gr.comment = comment
gr.rid = rid
gr.type = type
gr.sid = sid
return gr

19
calculate/lib/update_config/cl_update_config.py
Unescape View File

@ -216,7 +216,7 @@ class updateUserConfigs(shareUpdateConfigs):
filter(lambda y: y, x.split(" "))),
resWho))))))
else:
self.printERROR(_("Can not execute 'who'"))
self.printERROR(_("Failed to execute 'who'"))
return False
return xUsers
@ -244,7 +244,7 @@ class updateUserConfigs(shareUpdateConfigs):
set(self.getConfiguredPasswdUsers()))))
if not xUsers:
self.logger.info(_("Package %s") %nameProgram)
self.logger.warn(_("X session users not found"))
self.logger.warn(_("X sessions users not found"))
return True
self.logger.info(_("Package %s") %nameProgram)
self.logger.info(_("Update desktop configuration files"))
@ -272,7 +272,7 @@ class updateUserConfigs(shareUpdateConfigs):
dirsFiles = clTempl.applyTemplates()
if dirsFiles is False:
self.printERROR(\
_("Error using templates for the user %s")\
_("Error in using templates for the user %s")\
%userName)
for errMess in clTempl.getError().splitlines():
self.printERROR(errMess)
@ -288,14 +288,14 @@ class updateUserConfigs(shareUpdateConfigs):
if dictPakkages:
for calcPkg in listIndex:
self.printWARNING(
_("Package %s has modified the following files")\
_("Package %s has changed the following files")\
%calcPkg+":")
for userName, configFiles in dictPakkages[calcPkg]:
self.printWARNING(" "*2 + _("User %s")%userName + ":")
for nameConfigFile in configFiles:
self.printWARNING(" "*5 + nameConfigFile)
if not dictPakkages:
self.logger.warn(_("Not found templates"))
self.logger.warn(_("Templates not found"))
return True
class updateSystemConfigs(shareUpdateConfigs):
@ -367,7 +367,7 @@ class updateSystemConfigs(shareUpdateConfigs):
"""Копирование конфигурационных файлов"""
configDstFiles = self.scanProtectDirs(configPath)
if configDstFiles:
self.logger.warn(_("Replace files:"))
self.logger.warn(_("Replaced files:"))
for dst in configDstFiles:
src = pathJoin(configPath, dst)
if src != dst:
@ -435,7 +435,7 @@ class updateSystemConfigs(shareUpdateConfigs):
dirsFiles = clTempl.applyTemplates()
nameAndVerPkg = nameProg + "-"+clVars.Get("cl_ver")
if dirsFiles is False:
self.printERROR(_("Error template in a package %s")\
self.printERROR(_("Template error in package %s")\
%nameAndVerPkg)
for errMess in clTempl.getError().splitlines():
self.printERROR(errMess)
@ -454,8 +454,7 @@ class updateSystemConfigs(shareUpdateConfigs):
if dictPakkages:
for calcPkg in listIndex:
self.printWARNING(
_("Package %s has modified the following files")%
calcPkg+":")
_("Package %s has changed the following files")%calcPkg+":")
for nameF in dictPakkages[calcPkg]:
nameFile = nameF.partition(configPath)[2]
if nameFile:
@ -465,7 +464,7 @@ class updateSystemConfigs(shareUpdateConfigs):
nameFile = nameF
self.printWARNING(" "*5 + nameFile)
else:
self.logger.warn(_("Not found templates"))
self.logger.warn(_("Templates not found"))
if flagUpdate:
self.copyConfigFiles(configPath)
if clTempl and clTempl.getWarning():

1
setup.py
Unescape View File

@ -42,7 +42,6 @@ setup(
module_name + '.format',
module_name + '.variables',
module_name + '.mod',
module_name + '.server',
module_name + '.update_config',
module_name + '.utils'],
data_files = [("/etc/calculate", []),

Write Preview
Loading…
Cancel
Save