22 changed files with 1223 additions and 106 deletions
@ -0,0 +1,65 @@ |
|||
# This is a sample Python script. |
|||
import os |
|||
import traceback |
|||
import sys |
|||
import yaml |
|||
import basic.program |
|||
import basic.constants as B |
|||
import basic.message |
|||
import tools.path_const as P |
|||
import tools.config_tool as config_tool |
|||
import tools.file_tool as file_tool |
|||
import model.component |
|||
|
|||
PROGRAM_NAME = "check_configuration" |
|||
|
|||
def startPyJob(job): |
|||
try: |
|||
job.m.logDebug("--- start " + PROGRAM_NAME + " ------>>>>") |
|||
components = job.par.component.split(",") |
|||
for c in components: |
|||
print("component "+c) |
|||
checkComponent(job, c) |
|||
job.m.setMsg("Job " + PROGRAM_NAME + " fertig") |
|||
job.m.logDebug("<<<<<<<<----- " + PROGRAM_NAME + " ------") |
|||
except Exception as e: |
|||
job.m.logDebug("+++++++++++++++++++++++++++++++++++++++++++++") |
|||
job.m.setFatal(str(e)) |
|||
job.m.logDebug("+++++++++++++++++++++++++++++++++++++++++++++") |
|||
job.m.logDebug("execpt "+traceback.format_exc()) |
|||
job.m.logDebug("+++++++++++++++++++++++++++++++++++++++++++++") |
|||
|
|||
def checkComponent(job, componentName): |
|||
""" |
|||
checks the configurations of the component |
|||
:param job: |
|||
:param componentName: |
|||
:return: |
|||
""" |
|||
configPath = config_tool.getExistingPath(job, [os.path.join(job.conf[B.SUBJECT_PATH][B.ATTR_PATH_COMPS], componentName, "CONFIG")]) |
|||
configTree = file_tool.read_file_dict(job, configPath, job.m) |
|||
for x in model.component.LIST_CP_SUBJECTS: |
|||
if "conf" not in configTree: |
|||
job.m.setError(componentName + ": root conf is not set: ") |
|||
break |
|||
if x not in configTree["conf"]: |
|||
job.m.setError(componentName + ": subject is not set: " + x) |
|||
else: |
|||
for c in configTree["conf"][x]: |
|||
if c == "none": |
|||
if len(configTree["conf"][x]) != 1: |
|||
job.m.setWarn("none is not the only subject in "+x) |
|||
continue |
|||
|
|||
|
|||
|
|||
if __name__ == '__main__': |
|||
job = basic.program.Job(PROGRAM_NAME) |
|||
print ("job "+str(job.__dict__)) |
|||
job.startJob() |
|||
if job.m.isRc("fatal"): |
|||
job.stopJob() |
|||
# now in theory the program is runnable |
|||
startPyJob(job) |
|||
job.stopJob() |
|||
# See PyCharm help at https://www.jetbrains.com/help/pycharm/ |
|||
@ -0,0 +1,50 @@ |
|||
# This is a sample Python script. |
|||
import sys# |
|||
# import jsonpickle # pip install jsonpickle |
|||
import yaml # pip install pyyaml |
|||
import basic.program |
|||
import basic.componentHandling |
|||
import basic.message |
|||
#import utils.tdata_tool |
|||
import traceback |
|||
|
|||
PROGRAM_NAME = "check_specification" |
|||
|
|||
def startPyJob(job): |
|||
try: |
|||
job.m.logDebug("--- start " + PROGRAM_NAME + " ------>>>>") |
|||
job.m.setMsg("Job " + PROGRAM_NAME + " fertig") |
|||
job.m.logDebug("<<<<<<<<----- " + PROGRAM_NAME + " ------") |
|||
except Exception as e: |
|||
job.m.logDebug("+++++++++++++++++++++++++++++++++++++++++++++") |
|||
job.m.setFatal(str(e)) |
|||
job.m.logDebug("+++++++++++++++++++++++++++++++++++++++++++++") |
|||
job.m.logDebug("execpt "+traceback.format_exc()) |
|||
job.m.logDebug("+++++++++++++++++++++++++++++++++++++++++++++") |
|||
|
|||
def checkHead(job): |
|||
pass |
|||
if __name__ == '__main__': |
|||
x = basic.program.Job(PROGRAM_NAME) |
|||
print ("x "+str(x)) |
|||
x.startJob() |
|||
x.m.logDebug(str(vars(x.par)) + "\n" + str(vars(x.conf))) |
|||
if x.m.isRc("fatal"): |
|||
x.stopJob() |
|||
exit(x.m.rc * (-1) + 3) |
|||
# now in theory the program is runnable |
|||
x.m.setMsg("# job initialized") |
|||
cm = basic.componentHandling.ComponentManager.getInstance(x) |
|||
print("cm "+str(cm)) |
|||
cm.initComponents() |
|||
comps = cm.getComponents(x, PROGRAM_NAME) |
|||
x.m.setMsg("# Components initialized with these relevant components " + str(comps)) |
|||
for c in comps: |
|||
comp = cm.getComponent(c) |
|||
print(str(comp)) |
|||
comp.check_Instance() |
|||
x.m.merge(comp.m) |
|||
comp.confs["function"][PROGRAM_NAME] = comp.m.topmessage |
|||
|
|||
x.stopJob() |
|||
# See PyCharm help at https://www.jetbrains.com/help/pycharm/ |
|||
@ -0,0 +1,115 @@ |
|||
#!/usr/bin/python |
|||
# -*- coding: utf-8 -*- |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
# Author : Ulrich Carmesin |
|||
# Source : gitea.ucarmesin.de |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
""" |
|||
program to clean the workspace : |
|||
* remove old debug-files |
|||
""" |
|||
import os |
|||
import re |
|||
import shutil |
|||
import sys |
|||
import traceback |
|||
import basic.program |
|||
import basic.constants as B |
|||
import tools.date_tool as date_tool |
|||
import tools.path_tool as path_tool |
|||
import tools.job_tool as job_tool |
|||
|
|||
LIMIT_DEBUG_FILES = -7 |
|||
PROGRAM_NAME = "clean_workspace" |
|||
|
|||
def startPyJob(job): |
|||
try: |
|||
job.m.logDebug("--- start " + PROGRAM_NAME + " ------>>>>") |
|||
# remove debug-files |
|||
removeDebugFiles(job) |
|||
# clean and archive log-files |
|||
cleanLogFiles(job) |
|||
job.m.setMsg("Job " + PROGRAM_NAME + " fertig") |
|||
job.m.logDebug("<<<<<<<<----- " + PROGRAM_NAME + " ------") |
|||
except Exception as e: |
|||
job.m.logDebug("+++++++++++++++++++++++++++++++++++++++++++++") |
|||
job.m.setFatal(str(e)) |
|||
job.m.logDebug("+++++++++++++++++++++++++++++++++++++++++++++") |
|||
job.m.logDebug("execpt "+traceback.format_exc()) |
|||
job.m.logDebug("+++++++++++++++++++++++++++++++++++++++++++++") |
|||
|
|||
def removeDebugFiles(job): |
|||
""" |
|||
to remove debug-files in any relevant folder |
|||
:param job: |
|||
:return: |
|||
""" |
|||
job.m.logInfo("# # remove log-files # # #") |
|||
limit = date_tool.getActdate(date_tool.F_LOG, LIMIT_DEBUG_FILES)[0:8] |
|||
path = job.conf[B.SUBJECT_PATH][B.ATTR_PATH_DEBUG] |
|||
cleanFolder(job, path, limit) |
|||
path = os.path.join(B.HOME_PATH, "temp") |
|||
cleanFolder(job, path, limit) |
|||
|
|||
def cleanFolder(job, path, limit): |
|||
""" |
|||
remove all files in the folder with a log-date older than limit |
|||
:param job: |
|||
:param path: |
|||
:param limit: |
|||
:return: |
|||
""" |
|||
date_regex = r"(.*)_(\d{8})_\d{6}" |
|||
cntRm = 0 |
|||
cntMv = 0 |
|||
cntAll = 0 |
|||
for f in os.listdir(path): |
|||
cntAll += 1 |
|||
if re.match(date_regex, f): |
|||
res = re.search(date_regex, f) |
|||
fileType = str(res.group(1)) |
|||
fileDate = str(res.group(2)) |
|||
if fileType in ["debug", "log", "start_dialog"]: |
|||
if fileDate >= limit: |
|||
continue |
|||
job.m.logInfo("remove " + os.path.join(path, f)) |
|||
os.remove(os.path.join(path, f)) |
|||
cntRm += 1 |
|||
else: |
|||
fileYear = fileDate[0:4] |
|||
actYear = date_tool.getActdate(date_tool.F_LOG)[0:4] |
|||
archivPath = os.path.join(path, fileYear) |
|||
if fileYear < actYear: |
|||
if not os.path.exists(archivPath): |
|||
os.mkdir(archivPath) |
|||
if not os.path.isdir(archivPath): |
|||
raise Exception("archiv-folder is not a directory: " + archivPath) |
|||
shutil.move(os.path.join(path, f), os.path.join(archivPath, f)) |
|||
cntMv += 1 |
|||
job.m.setMsg(str(cntRm) + " / " + str(cntAll) + " files removed in " + path) |
|||
job.m.setMsg(str(cntMv) + " / " + str(cntAll) + " files moved from " + path) |
|||
|
|||
def cleanLogFiles(job): |
|||
""" |
|||
searches all log-folder in test-documents and remove the oldest log-files except the newest |
|||
:param job: |
|||
:return: |
|||
""" |
|||
job.m.logInfo("# # clean log-files # # #") |
|||
limit = date_tool.getActdate(date_tool.F_LOG, LIMIT_DEBUG_FILES)[0:8] |
|||
path = path_tool.compose_path(job, "{job.par.wsdir}/{log}", None) |
|||
cleanFolder(job, path, limit) |
|||
environments = job_tool.select_environment(job, "", "ALL") |
|||
for env in environments: |
|||
jobEnv = "" |
|||
if hasattr(job.par, "environment"): |
|||
jobEnv = getattr(job.par, "environment") |
|||
setattr(job.par, "environment", env) |
|||
path = path_tool.compose_path(job, "{envlog}", None) |
|||
cleanFolder(job, path, limit) |
|||
setattr(job.par, "environment", jobEnv) |
|||
pass |
|||
|
|||
if __name__ == '__main__': |
|||
job = basic.program.Job(PROGRAM_NAME) |
|||
startPyJob(job) |
|||
@ -0,0 +1,267 @@ |
|||
#!/usr/bin/python |
|||
# -*- coding: utf-8 -*- |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
# Author : Ulrich Carmesin |
|||
# Source : gitea.ucarmesin.de |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
import json |
|||
import os |
|||
import datetime |
|||
import subprocess |
|||
|
|||
import yaml |
|||
|
|||
INSTALLED = False |
|||
try: |
|||
import basic.program |
|||
INSTALLED = True |
|||
except: |
|||
INSTALLED = False |
|||
|
|||
PROGRAM_NAME = "install_workspace" |
|||
CONFIG_FORMAT = "yml" |
|||
BASIS_FORMAT = "json" |
|||
|
|||
job = None |
|||
# ----------------------------------------------------------------------------------------- |
|||
# Miniimplementierung des Programmeahmens |
|||
class Logger: |
|||
""" |
|||
Kurzversion des Messages mit Standardfunktionen |
|||
* opel_logs() |
|||
* close_logs() |
|||
* log_info() |
|||
* log_error() |
|||
""" |
|||
def __init__(self, job, level, logTime, comp): |
|||
self.openLog(job, logTime) |
|||
|
|||
def openLog(self, job, logTime): |
|||
# job, level, logTime, componente |
|||
home = getHome() |
|||
path = os.path.join(home, "log") |
|||
if not os.path.exists(path): |
|||
os.mkdir(path) |
|||
logpath = os.path.join(home, "log", job.program+"_"+logTime+".txt") |
|||
print("logpath "+logpath) |
|||
self.logfile = open(logpath, "w") |
|||
|
|||
def logInfo(self, text): |
|||
self.logfile.write(text + "\n") |
|||
def logError(self, text): |
|||
self.logfile.write("ERROR:" + text + "\n") |
|||
print("ERROR:" + text) |
|||
|
|||
def closeLog(self): |
|||
self.logfile.close() |
|||
|
|||
class ActJob: |
|||
""" |
|||
Kurzversion des Jobs mit Standardfunktionen |
|||
* start_job() startet Job mit Messaging |
|||
* set_parameter() setzt Parameter aus args oder aus Aufruf |
|||
* stop_job() startet Job mit Messaging |
|||
""" |
|||
def __init__(self, program): |
|||
self.program = program |
|||
self.start = datetime.datetime.now().strftime("%Y%m%d_%H%M%S") |
|||
self.jobid = 100000 |
|||
|
|||
def startJob(self): |
|||
self.m = Logger(self, "info", self.start, None) # job, level, logTime, componente |
|||
text = "# # # Start Job " + self.start + " # # # " |
|||
self.m.logInfo(text) |
|||
print(text) |
|||
|
|||
def stopJob(self): |
|||
self.ende = datetime.datetime.now().strftime("%Y%m%d_%H%M%S") |
|||
text = "# # # Stop Job " + self.start + " - " + self.ende + " # # # " |
|||
self.m.logInfo(text) |
|||
self.m.closeLog() |
|||
print(text) |
|||
|
|||
def setParameter(self, args): |
|||
for k in args: |
|||
setattr(self, k, args[k]) |
|||
|
|||
# ----------------------------------------------------------------------------------------- |
|||
# Standardsteuerung Hauptverarbeitung |
|||
def startPyJob(job): |
|||
""" |
|||
Steuerung der Hauptverarbeitung, aufrufbar vom Programm selbst oder aus job_tool |
|||
:param job: |
|||
:return: |
|||
""" |
|||
job.m.logInfo("startPyJob gestertet ") |
|||
try: |
|||
setParameter(job) |
|||
readConfig(job) |
|||
createFolders(job) |
|||
createGit(job) |
|||
createBasisConfig(job) |
|||
except Exception as e: |
|||
job.m.logError(str(e)) |
|||
|
|||
# ----------------------------------------------------------------------------------------- |
|||
# konkrete Verarbeitungsroutinen |
|||
def setParameter(job): |
|||
job.m.logInfo("--- setze Parameter ") |
|||
|
|||
def readConfig(job): |
|||
job.m.logInfo("--- suche config-Datei ") |
|||
args = {} |
|||
args["home"] = getHome() |
|||
configPath = "" |
|||
for p in os.listdir(args["home"]): |
|||
print(p) |
|||
path = os.path.join(args["home"], p) |
|||
if os.path.isfile(path) and "workspace" in p: |
|||
configPath = path |
|||
break |
|||
if len(configPath) < 1: |
|||
raise Exception("Keine Konfiguration gefunden in "+args["home"]) |
|||
with open(configPath, 'r') as file: |
|||
doc = yaml.full_load(file) |
|||
file.close() |
|||
for k in doc: |
|||
args[k] = doc[k] |
|||
job.setParameter(args) |
|||
|
|||
def createFolders(job): |
|||
job.m.logInfo("--- erstelle Verzeichnisse ") |
|||
for p in job.paths: |
|||
path = os.path.join(job.home, job.paths[p]) |
|||
createFolder(job, path) |
|||
|
|||
def createFolder(job, path): |
|||
if not os.path.exists(path): |
|||
os.mkdir(path) |
|||
job.m.logInfo("Verzeichnis angelegt: "+ path) |
|||
elif not os.path.isdir(path): |
|||
job.m.logError("Verzeichnisname existiert und ist kein Verzeichnis "+ path) |
|||
else: |
|||
job.m.logInfo("Verzeichnis existiert: " + path) |
|||
|
|||
def createGit(job): |
|||
job.m.logInfo("--- erstelle und aktualisiere git-Repos ") |
|||
repos = {} |
|||
local = {} |
|||
attr = { |
|||
"_name": "", |
|||
"_branch": "" |
|||
} |
|||
# erstelle Repoliste mit den Attributen: name, branch, url |
|||
for r in job.repos: |
|||
if r in attr: |
|||
attr[r] = job.repos[r] |
|||
else: |
|||
repo = {} |
|||
for a in job.repos[r]: |
|||
repo[a] = job.repos[r][a] |
|||
repos[r] = repo |
|||
for k in attr: |
|||
a = k[1:] |
|||
for r in repos: |
|||
if a not in repos[r]: |
|||
repos[r][a] = attr[k] |
|||
for r in repos: |
|||
repo = repos[r] |
|||
path = os.path.join(job.home, job.paths[r]) |
|||
if os.path.exists(path): |
|||
local["url"] = os.path.join(job.home, job.paths[r]) |
|||
local["branch"] = repo["branch"] |
|||
rpath = os.path.join(local["url"], ".git") |
|||
if os.path.exists(rpath): |
|||
job.m.logInfo("Repo existiert bereits "+r) |
|||
else: |
|||
job.m.logInfo("Repo erzeugen "+r) |
|||
initGit(job, local, repo) |
|||
updateLocal(job, local, repo) |
|||
else: |
|||
job.m.logError("Verzeichnis existiert nicht: " + path) |
|||
|
|||
def initGit(job, local, repo, bare=False): |
|||
job.m.logInfo("--- initialisiere git-Repo "+str(repo)+","+str(local)) |
|||
os.chdir(local["url"]) |
|||
cmd = "git init " |
|||
if bare: |
|||
cmd += " --bare" |
|||
execCmd(job, cmd) |
|||
cmd = "git checkout " + local["branch"] |
|||
execCmd(job, cmd) |
|||
cmd = "git remote add " + repo["name"] + " " + repo["url"] |
|||
execCmd(job, cmd) |
|||
os.chdir(job.home) |
|||
|
|||
def execCmd(job, cmd): |
|||
job.m.logInfo(cmd) |
|||
process = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True) |
|||
btext = process.communicate()[0] |
|||
text = btext.decode('utf-8') |
|||
job.m.logInfo(text) |
|||
return text |
|||
|
|||
def switchLocal(job, local): |
|||
os.chdir(local["url"]) |
|||
cmd = "git checkout " + local["branch"] |
|||
execCmd(job, cmd) |
|||
|
|||
def updateLocal(job, local, repo): |
|||
job.m.logInfo("--- aktualisiere git-Repo "+str(repo)+","+str(local)) |
|||
switchLocal(job, local) |
|||
cmd = "git pull " + repo["name"] + " " + repo["branch"] |
|||
execCmd(job, cmd) |
|||
os.chdir(job.home) |
|||
|
|||
def updateRemote(job, local, repo): |
|||
job.m.logInfo("--- aktualisiere git-Repo "+str(repo)+","+str(local)) |
|||
switchLocal(job, local) |
|||
cmd = "git push " + repo["name"] + " " + repo["branch"] |
|||
execCmd(job, cmd) |
|||
os.chdir(job.home) |
|||
|
|||
def createBasisConfig(job): |
|||
job.m.logInfo("--- erstelle Basis-Koniguration ") |
|||
config = {} |
|||
config["basic"] = {} |
|||
config["basic"]["paths"] = {} |
|||
config["basic"]["paths"]["home"] = job.home |
|||
for p in job.paths: |
|||
path = os.path.join(job.home, job.paths[p]) |
|||
config["basic"]["paths"][p] = path |
|||
for p in ["temp", "config"]: |
|||
path = os.path.join(job.home, p) |
|||
createFolder(job, path) |
|||
config["basic"]["paths"][p] = path |
|||
if BASIS_FORMAT == "yml": |
|||
path = os.path.join(job.home, "config", "basis.json") |
|||
with open(path, 'w', encoding="utf-8") as file: |
|||
doc = yaml.dump(config, file) |
|||
file.write(doc) |
|||
file.close() |
|||
elif BASIS_FORMAT == "json": |
|||
path = os.path.join(job.home, "config", "basis.json") |
|||
with open(path, 'w', encoding="utf-8") as file: |
|||
doc = json.dumps(config, indent=4) |
|||
file.write(doc) |
|||
file.close() |
|||
|
|||
|
|||
def getHome(): |
|||
home = os.getcwd() |
|||
if home[-7:] == "program": |
|||
home = home[0:-8] |
|||
return home |
|||
|
|||
# ----------------------------------------------------------------------------------------- |
|||
# Pythonstandard Programmaufruf |
|||
# Job-Objekt erzeugen und beenden |
|||
if __name__ == '__main__': |
|||
if INSTALLED: |
|||
#job = basic.program.Job(PROGRAM_NAME) |
|||
job = ActJob(PROGRAM_NAME) |
|||
else: |
|||
job = ActJob(PROGRAM_NAME) |
|||
job.startJob() |
|||
startPyJob(job) |
|||
job.stopJob() |
|||
@ -0,0 +1,280 @@ |
|||
#!/usr/bin/python |
|||
# program to execute programs for a testcases or for a testsuite |
|||
# PARAM from INPUT: --granularity --application --environment --testcase/testsuite |
|||
# main functions |
|||
# + input_param() : cache-actjob --> user-input --> local-param |
|||
# + start_job() : local-param --> cache-actjob --> start-param |
|||
# --------------------------------------------------- |
|||
|
|||
""" |
|||
|
|||
""" |
|||
import os.path |
|||
import json |
|||
import re |
|||
|
|||
import basic.program |
|||
import basic.constants as B |
|||
import tools.job_tool |
|||
import tools.file_tool |
|||
import tools.data_const as D |
|||
import tools.date_tool |
|||
import tools.path_tool |
|||
import tools.path_const as P |
|||
|
|||
tempJob = {} |
|||
|
|||
PROGRAM_NAME = "service" |
|||
|
|||
DLG_TESTCASE = "Testfall" |
|||
DLG_TESTSUITE = "Testsuite" |
|||
DLG_COMPLETE = "Komplettausfuehrung" |
|||
LIST_DLG_GRAN = [DLG_TESTCASE, DLG_TESTSUITE] |
|||
DLG_START_QUESTION = "was soll getestet werden" |
|||
# DLG_TESTPLAN = "Testplan" |
|||
DLG_ENVIRONMENT = "Umgebung" |
|||
DLG_APPLICATION = "Anwendung" |
|||
DLG_REDO = "wiederholen" |
|||
DLG_CONTINUE = "fortsetzen" |
|||
DLG_DUMMY_STEP = "Dummy-Schritt" |
|||
DLG_NEWJOB = "neuer Job" |
|||
|
|||
JOB_NR = { |
|||
DLG_TESTSUITE : { |
|||
"start": "init_testsuite", |
|||
"init_testsuite": { |
|||
"jobnr": "0" }, |
|||
"execute_testsuite": { |
|||
"jobnr": "1"}, |
|||
"collect_testsuite": { |
|||
"jobnr": "2"}, |
|||
"compare_testsuite": { |
|||
"jobnr": "3"}, |
|||
"finish_testsuite": { |
|||
"jobnr": "4"} |
|||
}, |
|||
DLG_TESTCASE: { |
|||
"start": "init_testcase", |
|||
"init_testcase": { |
|||
"jobnr": "5" }, |
|||
"execute_testcase": { |
|||
"jobnr": "6" }, |
|||
"collect_testcase": { |
|||
"jobnr": "7" }, |
|||
"copy_appdummy": { |
|||
"jobnr": "8" }, |
|||
"compare_testcase": { |
|||
"jobnr": "9" }, |
|||
}, |
|||
"check_environment": { |
|||
"jobnr": "10" }, |
|||
"test_executer": { |
|||
"jobnr": "11"}, |
|||
} |
|||
|
|||
JOB_LIST = [ |
|||
"init_testsuite", # 0 |
|||
"execute_testsuite", # 1 |
|||
"collect_testsuite", # 2 |
|||
"compare_testsuite", # 3 |
|||
"finish_testsuite", # 4 |
|||
"init_testcase", # 5 |
|||
"execute_testcase", # 6 |
|||
"collect_testcase", # 7 |
|||
"copy_appdummy", # 8 |
|||
"compare_testcase", # 9 |
|||
"check_environment", # 10 |
|||
"test_executer" # 11 |
|||
] |
|||
|
|||
appList = [] |
|||
envList = [] |
|||
entities = {} |
|||
entities[DLG_TESTCASE] = {} |
|||
entities[DLG_TESTSUITE] = {} |
|||
|
|||
def readContext(job): |
|||
for k in job.conf[B.SUBJECT_APPS]: |
|||
appList.append(k) |
|||
path = job.conf[B.SUBJECT_PATH][B.ATTR_PATH_ENV] |
|||
if os.path.exists(path): |
|||
for d in os.listdir(path): |
|||
print ("-- "+d) |
|||
if not os.path.isdir(os.path.join(path, d)): |
|||
continue |
|||
if d[0:1] == "_": |
|||
continue |
|||
envList.append(d) |
|||
path = job.conf[B.SUBJECT_PATH][B.ATTR_PATH_TDATA] |
|||
if os.path.exists(path): |
|||
for d in os.listdir(path): |
|||
print("tdata path "+d) |
|||
if not os.path.isdir(os.path.join(path, d)): |
|||
print("continue a") |
|||
continue |
|||
if d[0:1] == "_": |
|||
print("continue b") |
|||
continue |
|||
specpath = os.path.join(path, d, D.DFILE_TESTCASE_NAME + ".csv") |
|||
readSpec(job, d, DLG_TESTCASE, specpath) |
|||
specpath = os.path.join(path, d, D.DFILE_TESTSUITE_NAME + ".csv") |
|||
readSpec(job, d, DLG_TESTSUITE, specpath) |
|||
|
|||
def readSpec(job, testentity, testgran, specpath): |
|||
print("spec "+specpath) |
|||
if not os.path.isfile(specpath): |
|||
print("continue c") |
|||
return |
|||
text = tools.file_tool.read_file_text(job, specpath, job.m) |
|||
print("-----------\n"+text+"\n------------------") |
|||
if re.match(r".*?depricated;[jJyY]", text): |
|||
return |
|||
if re.match(r".*\nhead:application;", text): |
|||
print("## app gematcht") |
|||
res = re.search(r".*head:application;(.+)\n", text) |
|||
apps = res.group(1).replace(";", ",").split(",") |
|||
print("# "+str(apps)) |
|||
for a in apps: |
|||
if len(a) < 1: |
|||
break |
|||
if a not in entities[testgran]: |
|||
entities[testgran][a] = [] |
|||
print(a+" in "+testentity+" "+testgran+" -- "+str(entities)) |
|||
entities[testgran][a].append(testentity) |
|||
|
|||
def printProc(job, process): |
|||
print("--------------------------------------------------") |
|||
for k in process: |
|||
print("| {0:15s} : {1}".format(k, process[k])) |
|||
print("--------------------------------------------------") |
|||
|
|||
|
|||
def restartActualProcess(job): |
|||
""" |
|||
check if an actual process is open |
|||
:return: |
|||
""" |
|||
path = tools.path_tool.getActualJsonPath(job) |
|||
if os.path.exists(path): |
|||
actProc = tools.file_tool.read_file_dict(job, path, job.m) |
|||
print("restartActJob "+str(actProc)) |
|||
printProc(job, actProc) |
|||
step = int(actProc["step"]) |
|||
if actProc["program"] == "test_executer": |
|||
if step > 5: |
|||
dialogProcess(job) |
|||
else: |
|||
actProc["step"] = str(step+1) |
|||
tools.job_tool.start_child_process(job, actProc) |
|||
restartActualProcess(job) |
|||
selection = [DLG_NEWJOB, DLG_REDO] |
|||
|
|||
nr = int(JOB_NR[actProc["gran"]][actProc["program"]]["jobnr"]) |
|||
if (actProc["gran"] == DLG_TESTSUITE and nr < 4) or (actProc["gran"] == DLG_TESTCASE and nr < 9): |
|||
selection.append(DLG_CONTINUE) |
|||
if nr == 7: |
|||
selection.append(DLG_DUMMY_STEP) |
|||
choice = getChoice(job, selection, DLG_ENVIRONMENT) |
|||
print(choice) |
|||
if choice == DLG_REDO: |
|||
tools.job_tool.start_child_process(job, actProc) |
|||
restartActualProcess(job) |
|||
elif choice == DLG_DUMMY_STEP: |
|||
actProc["program"] = JOB_LIST[nr+1] |
|||
tools.job_tool.start_child_process(job, actProc) |
|||
restartActualProcess(job) |
|||
elif choice == DLG_CONTINUE: |
|||
if nr == 7: |
|||
nr = 9 |
|||
else: |
|||
nr += 1 |
|||
print (" act nr "+str(nr)) |
|||
actProc["step"] = str(step + 1) |
|||
actProc["program"] = JOB_LIST[nr] |
|||
tools.job_tool.start_child_process(job, actProc) |
|||
elif choice == DLG_NEWJOB: |
|||
dialogProcess(job) |
|||
else: |
|||
dialogProcess(job) |
|||
|
|||
|
|||
def dialogProcess(job): |
|||
""" |
|||
dialog for selection and starting a process |
|||
:param job: |
|||
:return: |
|||
""" |
|||
process = {} |
|||
index = 0 |
|||
print("create new process") |
|||
selection = [] |
|||
selection = LIST_DLG_GRAN |
|||
if DLG_TESTCASE + " - " + DLG_COMPLETE not in selection: |
|||
selection.append(DLG_TESTCASE + " - " + DLG_COMPLETE) |
|||
if DLG_TESTSUITE + " - " + DLG_COMPLETE not in selection: |
|||
selection.append(DLG_TESTSUITE + " - " + DLG_COMPLETE) |
|||
choice = getChoice(job, LIST_DLG_GRAN, DLG_START_QUESTION) |
|||
if DLG_COMPLETE in choice: |
|||
process["gran"] = choice[0:-3-len(DLG_COMPLETE)] |
|||
process["program"] = "test_executer" |
|||
process["step"] = 1 |
|||
else: |
|||
process["gran"] = choice |
|||
process["program"] = JOB_NR[process["gran"]]["start"] |
|||
process["step"] = 1 |
|||
if len(appList) == 1: |
|||
process["app"] = appList[0] |
|||
else: |
|||
process["app"] = getChoice(job, appList, DLG_ENVIRONMENT) |
|||
# |
|||
if len(envList) == 1: |
|||
process["env"] = envList[0] |
|||
else: |
|||
process["env"] = getChoice(job, envList, DLG_ENVIRONMENT) |
|||
# |
|||
if len(entities[process["gran"]][process["app"]]) == 1: |
|||
process["entity"] = entities[process["gran"]][process["app"]][0] |
|||
else: |
|||
process["entity"] = getChoice(job, entities[process["gran"]][process["app"]], process["gran"]) |
|||
print(str(process)) |
|||
setattr(job.par, B.PAR_ENV, process["env"]) |
|||
setattr(job.par, B.PAR_APP, process["app"]) |
|||
if process["gran"] == DLG_TESTCASE: |
|||
setattr(job.par, B.PAR_TESTCASE, process["entity"]) |
|||
setattr(job.par, B.PAR_TCTIME, tools.date_tool.getActdate(tools.date_tool.F_DIR)) |
|||
path = tools.path_tool.composePattern(job, "{"+P.P_TCBASE+"}", None) |
|||
process[B.PAR_TCDIR] = path |
|||
elif process["gran"] == DLG_TESTSUITE: |
|||
setattr(job.par, B.PAR_TESTSUITE, process["entity"]) |
|||
setattr(job.par, B.PAR_TSTIME, tools.date_tool.getActdate(tools.date_tool.F_DIR)) |
|||
path = tools.path_tool.composePattern(job, "{"+P.P_TSBASE+"}", None) |
|||
process[B.PAR_TSDIR] = path |
|||
tools.job_tool.start_child_process(job, process) |
|||
restartActualProcess(job) |
|||
|
|||
def getChoice(job, choiselist, description): |
|||
index = 0 |
|||
print("+------------- "+description+" ----------") |
|||
print('| | {:2d} : {:60s}'.format(0, "exit")) |
|||
for k in choiselist: |
|||
index += 1 |
|||
print('| | {:2d} : {:60s}'.format(index, k)) |
|||
print("+-----------------------------------------------") |
|||
choice = input("Auswahl 1-" + str(index) + ": ") |
|||
if not choice.isnumeric(): |
|||
print("FEHLER Fehleingabe "+choice) |
|||
getChoice(job, choiselist, description) |
|||
elif int(choice) < 1: |
|||
exit(0) |
|||
elif int(choice) > index: |
|||
print("FEHLER Fehleingabe "+choice) |
|||
getChoice(job, choiselist, description) |
|||
else: |
|||
return choiselist[int(choice) - 1] |
|||
|
|||
|
|||
|
|||
if __name__ == '__main__': |
|||
job = basic.program.Job(PROGRAM_NAME, "", {}) |
|||
readContext(job) |
|||
restartActualProcess(job) |
|||
@ -0,0 +1,143 @@ |
|||
import getpass |
|||
import os |
|||
import re |
|||
import basic.toolHandling |
|||
import tools.data_const as D |
|||
import basic.constants as B |
|||
import tools.date_tool |
|||
import tools.file_tool |
|||
|
|||
class Entity: |
|||
def __int__(self, job): |
|||
self.job = job |
|||
self.table = "" |
|||
self.testserver = None |
|||
|
|||
def get_schema(self): |
|||
""" |
|||
gets schema/ddl-informations in order to create the database |
|||
""" |
|||
raise Exception(B.EXCEPT_NOT_IMPLEMENT) |
|||
|
|||
def read_entity(self, job, name): |
|||
""" |
|||
reads the entity from the file-system |
|||
:param job: |
|||
:param name: |
|||
:return: |
|||
""" |
|||
raise Exception(B.EXCEPT_NOT_IMPLEMENT) |
|||
|
|||
def select_entity(self, job, name): |
|||
""" |
|||
reads the entity from the database |
|||
it should get the same result like read_entity |
|||
:param job: |
|||
:param name: |
|||
:return: |
|||
""" |
|||
raise Exception(B.EXCEPT_NOT_IMPLEMENT) |
|||
|
|||
def write_entity(self, job, name): |
|||
""" |
|||
writes the entity into the database |
|||
it similar to update_entity |
|||
:param job: |
|||
:param name: |
|||
:return: |
|||
""" |
|||
raise Exception(B.EXCEPT_NOT_IMPLEMENT) |
|||
|
|||
def update_entity(self, job, name): |
|||
""" |
|||
writes the entity into the database |
|||
it similar to update_entity |
|||
:param job: |
|||
:param name: |
|||
:return: |
|||
""" |
|||
raise Exception(B.EXCEPT_NOT_IMPLEMENT) |
|||
|
|||
def getDbAttr(self, job): |
|||
out = {} |
|||
for attr in [B.ATTR_DB_HOST, B.ATTR_DB_USER, B.ATTR_DB_DATABASE, B.ATTR_DB_PASSWD]: |
|||
out[attr] = job.conf[B.TOPIC_NODE_DB][attr] |
|||
return out |
|||
|
|||
def getDdl(self, job, ddl): |
|||
out = {} |
|||
for t in ddl: |
|||
out[t] = {} |
|||
for f in ddl[t]: |
|||
out[t][f] = {} |
|||
for a in ddl[t][f]: |
|||
print("entity-23 "+f+", "+a+" "+str(ddl)) |
|||
out[t][f][a] = ddl[t][f][a] |
|||
out[t][f][D.DDL_FNAME] = f |
|||
out[t][B.DATA_NODE_HEADER] = list(ddl[t].keys()) |
|||
return out |
|||
|
|||
def createSchema(self, testserver): |
|||
if B.TOPIC_NODE_DB in self.job.conf: |
|||
dbi = basic.toolHandling.getDbTool(self.job, testserver, self.job.conf[B.TOPIC_NODE_DB][B.ATTR_TYPE]) |
|||
else: |
|||
return "No DB in job-config" |
|||
sql = self.get_schema() |
|||
print(sql) |
|||
for s in sql.split(";\n"): |
|||
if len(s) < 3: continue |
|||
try: |
|||
dbi.execStatement(s+";", self.job.conf[B.TOPIC_NODE_DB]) |
|||
print("SQL executed: "+s) |
|||
except Exception as e: |
|||
raise Exception("Fehler bei createSchema "+s) |
|||
|
|||
|
|||
|
|||
|
|||
def getHistoryFields(self): |
|||
dbtype = self.job.conf[B.TOPIC_NODE_DB][B.ATTR_TYPE] |
|||
dbi = basic.toolHandling.getDbTool(self.job, None, dbtype) |
|||
sql = dbi.getSchemaAttribut("inscommit", D.TYPE_STR)+"," |
|||
sql += dbi.getSchemaAttribut("insauthor", D.TYPE_STR)+"," |
|||
sql += dbi.getSchemaAttribut("instime", D.TYPE_TIME)+"," |
|||
sql += dbi.getSchemaAttribut("updcommit", D.TYPE_STR)+"," |
|||
sql += dbi.getSchemaAttribut("updauthor", D.TYPE_STR)+"," |
|||
sql += dbi.getSchemaAttribut("updtime", D.TYPE_TIME)+"," |
|||
sql += dbi.getSchemaAttribut("actual", D.TYPE_INT) |
|||
return sql |
|||
|
|||
def selectHistoryFields(self): |
|||
if B.TOPIC_NODE_DB in self.job.conf: |
|||
dbi = basic.toolHandling.getDbTool(self.job, self.testserver, self.job.conf[B.TOPIC_NODE_DB][B.ATTR_TYPE]) |
|||
else: |
|||
return "No DB in job-config" |
|||
dbi.selectRows |
|||
|
|||
def getHistoryIndex(self, table): |
|||
dbtype = self.job.conf[B.TOPIC_NODE_DB][B.ATTR_TYPE] |
|||
dbi = basic.toolHandling.getDbTool(self.job, None, dbtype) |
|||
sql = dbi.getSchemaIndex(table, "actual") + "\n" |
|||
return sql |
|||
|
|||
|
|||
def read_spec(job, testentity, testgran, specpath): |
|||
if not os.path.isfile(specpath): |
|||
return |
|||
text = tools.file_tool.read_file_text(job, specpath, job.m) |
|||
if re.match(r".*?depricated;[jJyY]", text): |
|||
return None |
|||
spec = {} |
|||
regex = re.compile(r".*\nhead:(.*?);(.+)") |
|||
for res in regex.finditer(text): |
|||
#res = re.search(r".*head:(.*?);(.+)\n", text) |
|||
key = res.group(1) |
|||
if key == B.SUBJECT_DESCRIPTION: |
|||
spec[B.SUBJECT_DESCRIPTION] = res.group(2).replace(";", "") |
|||
elif key in [B.SUBJECT_APPS, B.PAR_APP]: |
|||
apps = res.group(2).replace(";", ",").split(",") |
|||
spec[B.SUBJECT_APPS] = apps |
|||
else: |
|||
val = res.group(2).replace(";", "") |
|||
spec[key] = val |
|||
return spec |
|||
@ -0,0 +1,83 @@ |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
# Author : Ulrich Carmesin |
|||
# Source : gitea.ucarmesin.de |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
import os |
|||
import basic.toolHandling |
|||
import basic.constants as B |
|||
import model.entity |
|||
# from model.Entity import Entity |
|||
import tools.path_const as P |
|||
import tools.config_tool as config_tool |
|||
import tools.file_tool as file_tool |
|||
import tools.git_tool |
|||
|
|||
TABLE_NAMES = ["component", "co_step", "co_table", "co_artifact", "co_comps"] |
|||
DEFAULT_SYNC = model.entity.SYNC_FULL_GIT2DB |
|||
|
|||
CP_SUBJECT_COMPS = "components" |
|||
CP_SUBJECT_STEPS = "steps" |
|||
CP_SUBJECT_TABLES = "tables" |
|||
CP_SUBJECT_ARTS = B.SUBJECT_ARTS |
|||
LIST_CP_SUBJECTS = [CP_SUBJECT_COMPS, CP_SUBJECT_STEPS, CP_SUBJECT_TABLES, CP_SUBJECT_ARTS] |
|||
|
|||
REL_ATTR_TYPE = "relationtyp" |
|||
REL_ATTR_FILE = "conffile" |
|||
REL_ATTR_FTYPE = "filetyp" |
|||
REL_ATTR_IP_PATTERN = "ippattern" |
|||
REL_ATTR_HOST_PATTERN = "hostpattern" |
|||
REL_ATTR_PORT_PATTERN = "portpattern" |
|||
REL_ATTR_URL_PATTERN = "urlpattern" |
|||
LIST_REL_ATTR = [REL_ATTR_TYPE, REL_ATTR_FILE, REL_ATTR_FTYPE, |
|||
REL_ATTR_IP_PATTERN, REL_ATTR_HOST_PATTERN, REL_ATTR_PORT_PATTERN, REL_ATTR_URL_PATTERN] |
|||
|
|||
|
|||
|
|||
def select_components(job, project, application): |
|||
""" |
|||
get all project which are configured for the workspace |
|||
with all environments where the application of the project are installed |
|||
:param job: |
|||
:return: |
|||
""" |
|||
outList = [] |
|||
appl = tools.config_tool.getConfig(job, P.KEY_BASIC, B.SUBJECT_APPS) |
|||
path = job.conf[B.SUBJECT_PATH][B.ATTR_PATH_COMPS] |
|||
for p in os.listdir(path): |
|||
if p in ["catalog", "config", "test", "tools"]: |
|||
continue |
|||
if p[0:1] in [".", "_"]: |
|||
continue |
|||
if not os.path.isdir(os.path.join(path, p)): |
|||
continue |
|||
outList.append(p) |
|||
return outList |
|||
|
|||
class Component(model.entity.Entity): |
|||
def __init__(self, job, name=""): |
|||
pass |
|||
|
|||
def read_entity(self, job, name): |
|||
configPath = tools.config_tool.select_config_path(job, P.KEY_COMP, name, "") |
|||
repoPath = os.path.join(job.conf[B.SUBJECT_PATH][B.ATTR_PATH_COMPS], name) |
|||
gitresult = tools.git_tool.gitLog(job, B.ATTR_PATH_COMPS, repoPath, 1) |
|||
configTree = file_tool.read_file_dict(job, configPath, job.m) |
|||
print("ok") |
|||
return |
|||
|
|||
def write_entity(self, job, name): |
|||
return |
|||
|
|||
def remove_entity(self, job, name): |
|||
return |
|||
def select_entity(self, job, name): |
|||
return |
|||
|
|||
def update_entity(self, job, name): |
|||
return |
|||
|
|||
def delete_entity(self, job, name): |
|||
return |
|||
|
|||
def get_schema(self): |
|||
return |
|||
@ -0,0 +1,32 @@ |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
# Author : Ulrich Carmesin |
|||
# Source : gitea.ucarmesin.de |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
import os |
|||
import basic.toolHandling |
|||
import basic.constants as B |
|||
import model.entity |
|||
import tools.path_const as P |
|||
import tools.config_tool |
|||
import tools.file_tool |
|||
import tools.git_tool |
|||
|
|||
STEP_ATTR_NR = "nr" |
|||
""" unique number in test-specification / in comp the array-position """ |
|||
STEP_ATTR_GROUP = "step" |
|||
""" step-number in test-specification / in comp the block itself """ |
|||
STEP_ATTR_COMP = "comp" |
|||
""" comp-name which executes the step """ |
|||
STEP_ATTR_FCT = "fct" |
|||
""" fct-name which executes the step in the component """ |
|||
STEP_ATTR_TOOL_TYPE = "type" |
|||
""" interface of the tool, values cli, dbi """ |
|||
STEP_ATTR_TOOL_NAME = "type" |
|||
""" name of the tool, values cli, dbi """ |
|||
STEP_ATTR_ARGS = "args" |
|||
|
|||
# step |
|||
# testsuite | testcase | component |
|||
#---------------------------------- # ---------------------------------- # ---------------------------------- |
|||
# start programs # start function # |
|||
|
|||
Loading…
Reference in new issue