14 changed files with 55 additions and 663 deletions
@ -1,281 +0,0 @@ |
|||
#!/usr/bin/python |
|||
# -*- coding: utf-8 -*- |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
# Author : Ulrich Carmesin |
|||
# Source : gitea.ucarmesin.de |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
# managing the components |
|||
# ----------------------------------------------------------------------------- |
|||
""" |
|||
component has to be created in relation of the application (basis.yml). |
|||
Each componente could be created mostly once, but not everytime: |
|||
* the same instance of a component is used in different contexts |
|||
* there could be exist more instances |
|||
* there could be alternatives of an instance |
|||
Each kind of instance has its component-class and for each use should be an object be created. |
|||
Each crated component-onject are documented in the parameter-file. |
|||
""" |
|||
import tools.config_tool |
|||
import tools.conn_tool |
|||
import basic.program |
|||
import basic.message |
|||
import basic.component |
|||
import importlib |
|||
import copy |
|||
import basic.constants as B |
|||
import tools.data_const as D |
|||
|
|||
comps = {} |
|||
PARAM_NOSUBNODE = [B.SUBJECT_ARTS, "components", "instance"] |
|||
DEFAULT_INST_CNT = 1 |
|||
DEFAULT_INST_SGL = "y" |
|||
|
|||
|
|||
def getInstanceAttributes(conf): |
|||
""" |
|||
the attributes for instancing the component are set from configuration or from default |
|||
:param conf: |
|||
:return: a complete set of these attributes |
|||
""" |
|||
out = { |
|||
B.ATTR_INST_CNT: DEFAULT_INST_CNT, |
|||
B.ATTR_INST_SGL: DEFAULT_INST_SGL |
|||
} |
|||
if B.SUBJECT_INST in conf: |
|||
for attr in [B.ATTR_INST_CNT, B.ATTR_INST_SGL]: |
|||
if attr in conf[B.SUBJECT_INST]: |
|||
out[attr] = conf[B.SUBJECT_INST][attr] |
|||
return out |
|||
|
|||
|
|||
def getComponents(job, mainfct): |
|||
#job = basic.program.Job.getInstance() |
|||
verify = -2 + job.getDebugLevel("job_tool") |
|||
job.debug(verify, "getComponents " + mainfct) |
|||
out = [] |
|||
for c in comps: |
|||
job.debug(verify, "getComponents " + c + ": " + str(comps[c].conf)) |
|||
print("getComponents " + c + ": " + str(comps[c].conf)) |
|||
if mainfct in comps[c].conf["function"]: |
|||
out.append(c) |
|||
return out |
|||
|
|||
|
|||
class ComponentManager: |
|||
__instance = None |
|||
__instances = {} |
|||
""" |
|||
initializes the Manager with all necessary components |
|||
""" |
|||
|
|||
def __init__(self, job, option=""): |
|||
#job = basic.program.Job.getInstance() |
|||
job.m.logDebug("applicationscomponente -- " + str(type(job.par))) |
|||
self.components = {} |
|||
self.comps = {} |
|||
self.job = job |
|||
ComponentManager.__instances[job.jobid] = self |
|||
ComponentManager.__instance = self |
|||
print ("init ComponentHandling "+str(self)) |
|||
|
|||
|
|||
def initComponents(self): |
|||
# sets components the first time |
|||
# afterwards set components from parameter-file |
|||
job = self.job # basic.program.Job.getInstance() |
|||
anw = job.par.application |
|||
job.m.logDebug("applicationscomponente -- " + str(type(job.par))) |
|||
if not job.conf.confs[B.SUBJECT_APPS].get(anw): |
|||
job.m.setFatal("application " + job.par.application + " is not configured") |
|||
return |
|||
for k in job.conf.confs[B.SUBJECT_APPS].get(anw): |
|||
if k == B.ATTR_APPS_PROJECT: |
|||
continue |
|||
job.m.logDebug("applicationscomponente -- " + k + ":") |
|||
print("applicationscomponente -- " + k + ":") |
|||
self.createComponent(k, 0, "") |
|||
|
|||
|
|||
def getComponent(self, compobjname): |
|||
job = self.job #basic.program.Job.getInstance() |
|||
verify = -2 + job.getDebugLevel("job_tool") |
|||
job.debug(verify, "getComponents " + compobjname) |
|||
if compobjname in self.comps: |
|||
return self.comps[compobjname] |
|||
return None |
|||
|
|||
|
|||
def getComponents(self, mainfct): |
|||
job = self.job #basic.program.Job.getInstance() |
|||
verify = -2 + job.getDebugLevel("job_tool") |
|||
job.debug(verify, "getComponents " + mainfct) |
|||
out = [] |
|||
for c in self.comps: |
|||
job.debug(verify, "getComponents " + c + ": " + str(self.comps[c].conf)) |
|||
#print("getComponents " + c + ": " + str(self.comps[c].conf)) |
|||
if mainfct in self.comps[c].conf["function"]: |
|||
out.append(c) |
|||
return out |
|||
|
|||
|
|||
@staticmethod |
|||
def getInstance(job, init="N"): |
|||
if (job.jobid in ComponentManager.__instances): |
|||
return ComponentManager.__instances[job.jobid] |
|||
else: |
|||
return ComponentManager(job) |
|||
|
|||
|
|||
def createComponent(self, componentName, nr, suffix): |
|||
""" |
|||
in order to create a component it must be loaded |
|||
* knogwedge of the application - which components should be created |
|||
* technical-knowledge of the instanciated component, especially the connection, user, password |
|||
* business-knowledge of the component, especially of their interfaces resp. artifacts |
|||
:param componentName: Name of the component |
|||
:param nr: for numbered instance if component is multiple |
|||
:param suffix: suffix for specific context of the component |
|||
:return: |
|||
""" |
|||
job = self.job #basic.program.Job.getInstance() |
|||
verify = job.getDebugLevel("job_tool") |
|||
componentName = componentName.lower() |
|||
job.debug(verify, "createComponent " + componentName) |
|||
confs = tools.config_tool.getConfig(job, "comp", componentName) |
|||
conns = tools.conn_tool.getConnections(job, componentName) |
|||
instAttr = getInstanceAttributes(confs) |
|||
job.debug(verify, "createComponent -91- " + componentName + " : " + str(confs)) |
|||
if nr > 0 and int(instAttr[B.ATTR_INST_CNT]) > 1: |
|||
job.m.setError("for multiple callers are multiple calls not implemented ") |
|||
if nr > 0 and len(conns) == 0: |
|||
job.m.setError("for multiple calls has only one call configured") |
|||
#print(confs) |
|||
parContent = job.loadParameter() |
|||
if len(conns) == 1: |
|||
c = self.createInstance(componentName, parContent, confs, conns, 0) |
|||
#print("createComponent 3 a " + componentName) |
|||
self.createSubComponents(c, nr, suffix) |
|||
else: |
|||
i = 1 |
|||
#print("createComponent 3 b " + componentName) |
|||
for cn in conns: |
|||
c = self.createInstance(componentName, parContent, confs, conns, i) |
|||
self.createSubComponents(c, i, suffix) |
|||
i = i + 1 |
|||
#print("createComponent 9 " + componentName) |
|||
#print(self.comps) |
|||
|
|||
|
|||
def createInstance(self, compName, parContent, confs, conns, nr): |
|||
""" |
|||
instance a component |
|||
:param compName: name without suffix or number |
|||
:param parContent: content of the parameter-file which is dumped from a pre-step |
|||
:param confs: configuration of the component |
|||
:param conns: connection-attributes for the specific environment |
|||
:param nr: number if component is multiple |
|||
:return: instance of the component with all necessary attributes |
|||
""" |
|||
job = self.job #basic.program.Job.getInstance() |
|||
cmodul = importlib.import_module(getComponentPath(compName)) |
|||
class_ = getattr(cmodul, getComponentClass(compName)) |
|||
c = class_() |
|||
if nr > 0: |
|||
name = compName + "_0" + str(nr) |
|||
i = nr - 1 |
|||
else: |
|||
name = compName |
|||
i = 0 |
|||
c.name = name |
|||
c.classname = compName |
|||
|
|||
c.m = basic.message.Message(job, basic.message.LIMIT_DEBUG, "logTime", name) |
|||
c.conf = tools.config_tool.mergeConn(c.m, confs["conf"], conns[i]) |
|||
c.conf[B.SUBJECT_CONN] = conns[i] |
|||
c.init(job) |
|||
if parContent is not None: |
|||
print("createComponent 5 a " + compName + " : " + str(parContent)) |
|||
if B.SUBJECT_COMPS in parContent and compName in parContent[B.SUBJECT_COMPS]: |
|||
for k in parContent[B.SUBJECT_COMPS][compName].keys(): |
|||
c.conf[k] = parContent[B.SUBJECT_COMPS][compName][k] |
|||
if B.SUBJECT_ARTS in c.conf and B.TOPIC_NODE_DB in c.conf[B.SUBJECT_ARTS]: |
|||
if not B.DATA_NODE_DDL in c.conf: |
|||
c.conf[B.DATA_NODE_DDL] = {} |
|||
for table in c.conf[B.SUBJECT_ARTS][B.TOPIC_NODE_DB]: |
|||
if table in B.LIST_DB_ATTR: |
|||
continue |
|||
conf = tools.config_tool.getConfig(job, D.DDL_FILENAME, compName, table) |
|||
if B.DATA_NODE_TABLES in conf and table in conf[B.DATA_NODE_TABLES]: |
|||
c.conf[B.DATA_NODE_DDL][table] = conf[B.DATA_NODE_TABLES][table] |
|||
elif table in conf: |
|||
c.conf[B.DATA_NODE_DDL][table] = conf[table] |
|||
else: |
|||
c.conf[B.DATA_NODE_DDL][table] = conf |
|||
comps[name] = c |
|||
self.comps[name] = c |
|||
return c |
|||
|
|||
|
|||
def createSubComponents(self, comp, nr, suffix): |
|||
job = self.job #basic.program.Job.getInstance() |
|||
verify = -2 + job.getDebugLevel("job_tool") |
|||
job.debug(verify, "getComponents " + str(comp.conf[B.ATTR_INST_SUBCOMP])) |
|||
for c in comp.conf[B.ATTR_INST_SUBCOMP].keys(): |
|||
if c == "none": |
|||
continue |
|||
self.createComponent(c, nr, suffix) |
|||
|
|||
|
|||
def getComponentDict(self): |
|||
job = self.job #basic.program.Job.getInstance() |
|||
verify = -2 + job.getDebugLevel("job_tool") |
|||
job.debug(verify, "getComponents ") |
|||
out = {} |
|||
for c in self.comps: |
|||
out[self.comps[c].name] = {} |
|||
for k in self.comps[c].conf.keys(): |
|||
if isParameterSubnode(k): # B.SUBJECT_ARTS in k or "components" in k or "instance" in k: |
|||
out[self.comps[c].name][k] = copy.deepcopy(self.comps[c].conf[k]) |
|||
return out |
|||
|
|||
|
|||
def getComponentFolder(comp): |
|||
return comp.lower() |
|||
|
|||
|
|||
def getComponentModul(comp): |
|||
return comp[0:1].upper() + comp[1:].lower() |
|||
|
|||
|
|||
def getComponentClass(comp): |
|||
return comp[0:1].upper() + comp[1:].lower() |
|||
|
|||
|
|||
def getComponentPath(comp): |
|||
return "components." + getComponentFolder(comp) + "." + getComponentModul(comp) |
|||
|
|||
|
|||
def getComponentDict(job = None): |
|||
#job = basic.program.Job.getInstance() |
|||
#verify = -2 + job.getDebugLevel("job_tool") |
|||
#job.debug(verify, "getComponents ") |
|||
out = {} |
|||
for c in comps: |
|||
out[comps[c].name] = {} |
|||
for k in comps[c].conf.keys(): |
|||
if isParameterSubnode(k): # B.SUBJECT_ARTS in k or "components" in k or "instance" in k: |
|||
out[comps[c].name][k] = copy.deepcopy(comps[c].conf[k]) |
|||
return out |
|||
|
|||
|
|||
def isParameterSubnode(key): |
|||
for k in PARAM_NOSUBNODE: |
|||
if key in k: |
|||
return False |
|||
return True |
|||
|
|||
|
|||
def getPlainCompname(name): |
|||
if "_0" in name: |
|||
return name[0:-3] |
|||
return name |
|||
@ -1,320 +0,0 @@ |
|||
#!/usr/bin/python |
|||
# -*- coding: utf-8 -*- |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
# Author : Ulrich Carmesin |
|||
# Source : gitea.ucarmesin.de |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
""" In diesem Modul werden alle Funktionen zusammengefasst zur Generierung und Ermittlung von pathsn """ |
|||
import os.path |
|||
import sys |
|||
import basic.program |
|||
import utils.config_tool |
|||
import re |
|||
import basic.constants as B |
|||
import utils.path_const as P |
|||
import utils.date_tool |
|||
import getpass |
|||
TOOL_NAME = "path_tool" |
|||
|
|||
def getHome(): |
|||
home = os.getcwd() |
|||
if home[-4:] == "test" and home[-6:] != "datest": |
|||
home = home[0:-5] |
|||
if home[-10:] == "components": |
|||
home = home[0:-11] |
|||
if home[-6:] == "datest": |
|||
prgdir = home[-6:] |
|||
home = home[0:-7] |
|||
elif home[-7:] == "program": |
|||
prgdir = home[-7:] |
|||
home = home[0:-8] |
|||
return home |
|||
|
|||
|
|||
def getBasisConfigPath(): |
|||
home = os.getcwd() |
|||
a = home.split(os.path.sep) |
|||
for i in range(1, len(a)): |
|||
path = os.path.sep.join(a[0:-i]) |
|||
path = os.path.join(path, P.VAL_CONFIG, B.BASIS_FILE) |
|||
for format in utils.config_tool.CONFIG_FORMAT: |
|||
filepath = path+"."+format |
|||
if os.path.isfile(filepath): |
|||
return filepath |
|||
if os.path.exists(filepath): |
|||
return filepath |
|||
raise Exception("no basis-configuration found") |
|||
|
|||
|
|||
def getActualJsonPath(job): |
|||
username = getpass.getuser() |
|||
path = os.path.join(job.conf.confs[B.SUBJECT_PATH][B.ATTR_PATH_DEBUG], username+"Job.json") |
|||
print("------ path "+path) |
|||
#if os.path.exists(path): |
|||
# return path |
|||
return path |
|||
|
|||
def getKeyValue(job, key, comp=None): |
|||
""" |
|||
this function gets the value for the key which relates to an attribute in the job or in the component |
|||
:param key: |
|||
:param comp: |
|||
:return: |
|||
""" |
|||
#job = basic.program.Job.getInstance() |
|||
try: |
|||
verify = job.getDebugLevel(TOOL_NAME)-4 |
|||
except: |
|||
verify = False |
|||
pt = PathConf.getInstance(job) |
|||
if verify: job.debug(verify, "getKeyValue " + key) |
|||
if 'job.par' in key: |
|||
val = job.getParameter(key[8:]) |
|||
return val |
|||
elif 'job.conf' in key: |
|||
val = job.conf.confs[B.SUBJECT_PATH][key[9:]] |
|||
if verify: job.debug(verify, val) |
|||
return val |
|||
elif 'job.' in key: |
|||
a = key[4:].split(":") |
|||
val = getattr(job, a[0]) |
|||
# only date with hours |
|||
if a[0] in ["start"]: |
|||
print("++++++++++++++"+str(val)) |
|||
val = utils.date_tool.formatParsedDate(str(val), utils.date_tool.F_LOG) |
|||
print("++++++++++++++"+val) |
|||
if len(a) > 1 and a[1] == "H": |
|||
val = val[0:-4]+"00" |
|||
if verify: job.debug(verify, val) |
|||
return val |
|||
# return job.conf.confs["paths"][key[9:]] |
|||
elif 'comp.' in key: |
|||
if comp is None: |
|||
raise Exception(P.EXP_COMP_MISSING.format(key)) |
|||
if utils.config_tool.hasAttr(comp.conf, key[5:]): |
|||
return utils.config_tool.getAttr(comp.conf, key[5:]) |
|||
if utils.config_tool.hasAttr(comp, key[5:]): |
|||
return utils.config_tool.getAttr(comp, key[5:]) |
|||
return "" |
|||
elif 'env.' in key: |
|||
if key[4:] in comp.conf["conn"]: |
|||
return comp.conf["conn"][key[4:]] |
|||
pass |
|||
elif key in pt.pattern: |
|||
return pt.pattern[key] |
|||
elif "time" in key and hasattr(job, "start"): |
|||
return getattr(job, "start") |
|||
else: |
|||
return "xx-"+key+"-xx" |
|||
|
|||
|
|||
def composePath(job, pathname, comp): |
|||
""" |
|||
this function composes a concrete path by the structured pathname |
|||
- the key of pathname is declared in path_const and the structure is configurated in config/path.yml. |
|||
:param pathname - plain keyword |
|||
:param comp: |
|||
:return: |
|||
""" |
|||
#job = basic.program.Job.getInstance() |
|||
verify = job.getDebugLevel(TOOL_NAME) |
|||
pt = PathConf.getInstance(job) |
|||
job.debug(verify, "composePath " + pathname + " zu " + str(pt) + "mit ") |
|||
job.debug(verify, str(pt.pattern)) |
|||
if pt.pattern[pathname]: |
|||
return composePattern(job, pt.pattern[pathname], comp) |
|||
else: |
|||
job.debug(verify, "in Pattern nicht vorhanden: " + pathname) |
|||
|
|||
|
|||
def composePattern(job, pattern, comp): |
|||
""" |
|||
the function composes the pattern to the standardarized path with the attributes |
|||
which are stored in the job and the component |
|||
- the key of pathname is declared in path_const and the structure is configurated in config/path.yml. |
|||
:param pattern: - keyword surroundet with {} |
|||
:param comp: |
|||
:return: path |
|||
""" |
|||
#job = basic.program.Job.getInstance() |
|||
try: |
|||
verify = job.getDebugLevel(TOOL_NAME) |
|||
except: |
|||
verify = False |
|||
verbose = not False |
|||
#job.debug(verify, "composePattern " + pattern) |
|||
max=5 |
|||
l = re.findall('\{.*?\}', pattern) |
|||
#job.debug(verify, l) |
|||
print(l) |
|||
for pat in l: |
|||
if verbose: print(str(max) + ": " + pattern + ": " + pat) |
|||
pit = getKeyValue(job, pat[1:-1], comp) |
|||
if verbose: print(str(pit) + ": " + pattern + ": " + pat) |
|||
#job.debug(verify, str(max) + ": " + pattern + ": " + pat + ": " + pit) |
|||
pattern = pattern.replace(pat, pit) |
|||
#job.debug(verify, str(max) + ": " + pattern + ": " + pat + ": " + pit) |
|||
while ("{" in pattern): |
|||
max = max-1 |
|||
#job.debug(verify, str(max) + ": " + pattern + ": " + pat + ": " + pit) |
|||
pattern = composePattern(job, pattern, comp) |
|||
#job.debug(verify, str(max) + ": " + pattern + ": " + pat + ": " + pit) |
|||
if (max < 3) : |
|||
break |
|||
return pattern |
|||
|
|||
|
|||
def rejoinPath(a, b="", c="", d="", e="", f=""): |
|||
""" |
|||
this function concatenates the arguments to a path in the correct format for the operating-system |
|||
:param a: |
|||
:param b: optional |
|||
:param c: optional |
|||
:param d: optional |
|||
:param e: optional |
|||
:param f: optional |
|||
:return: path |
|||
""" |
|||
work = a+"/"+b+"/"+c+"/"+d+"/"+e+"/"+f |
|||
if a.find("://") > 1: |
|||
protocol = True |
|||
else: |
|||
protocol = False |
|||
work = re.sub(r'\\', '/', work) |
|||
work = re.sub(r'\/', '/', work) |
|||
work = re.sub(r'//', '/', work) |
|||
while work[-1:] == "/": |
|||
work = work[0:-1] |
|||
l = work.split("/") |
|||
out = "" |
|||
for x in l: |
|||
if len(x) < 1: |
|||
continue |
|||
if protocol: |
|||
if len(out) < 1: |
|||
out = x |
|||
else: |
|||
out = out+"/"+x |
|||
else: |
|||
out = os.path.join(out, x) |
|||
if out[1:2] == ":" and out[2:3] != "\\": |
|||
out = out[0:2]+"\\"+out[2:] |
|||
elif protocol: |
|||
if "://" not in out or out.index("://") > 8 or out.index("://") < 1: |
|||
i = out.index(":/") |
|||
out = out[0:i+1] + "/" + out[i+1:] |
|||
pass |
|||
if not protocol and out.count("\\") < 1 and out[0:1] != "/" and out[0:2] != "..": |
|||
out = "/"+out |
|||
return out |
|||
|
|||
|
|||
def extractPattern(job, pathtyp, comp=None): |
|||
""" |
|||
this function extracts recoursively all parts of the pathstrucure as key and gets the values from the |
|||
job-parameter and job-configuration |
|||
:param pathtyp: the name of the path-structure |
|||
:param comp: |
|||
:return: dictionary of all part (key) with their valuess |
|||
""" |
|||
#job = basic.program.Job.getInstance() |
|||
verify = job.getDebugLevel(TOOL_NAME) |
|||
out = [] |
|||
pt = PathConf.getInstance(job) |
|||
pattern = pt.pattern[pathtyp] |
|||
work = pattern |
|||
while "{" in work: |
|||
i = work.index("{") |
|||
j = work.index("}") |
|||
pre = work[0:i] |
|||
pat = work[i+1:j] |
|||
job.debug(verify, work + " von " + str(i) + "-" + str(j) + " pre " + pre + "pat " + pat) |
|||
pit = getKeyValue(job, pat, comp) |
|||
tup = (pre, pat, pit) |
|||
out.append(tup) |
|||
work = work[j+1:] |
|||
return out |
|||
|
|||
def extractPath(job, pathtyp, path): |
|||
""" |
|||
this function extracts parts of a concrete structered path and stores the parts |
|||
as attributes into the actual job. So these attributes can read from the concrete |
|||
path instead of the related parameter-arguments. |
|||
It stores the values into the job-parameter |
|||
:param pathtyp: the structure of the concrete path |
|||
:param path: the concrete path - it should be the directory in the parameter of the job |
|||
:return: |
|||
""" |
|||
#job = basic.program.Job.getInstance() |
|||
patterlist = extractPattern(job, pathtyp) |
|||
verbose = False |
|||
work = path |
|||
i = 0 |
|||
if verbose: print("-- extractPatternList -- " + pathtyp + ":" + str(patterlist)) |
|||
for p in patterlist: |
|||
if len(p) < 1 : continue |
|||
delim = p[0] |
|||
key = p[1] |
|||
val = p[2] |
|||
nextdelim = "" |
|||
if i >= len(patterlist) - 1: |
|||
nextdelim = "" |
|||
else: |
|||
nextdelim = patterlist[i+1][0] |
|||
if verbose: print("xPath delim " + delim + " " + str(len(delim)) + ", " + nextdelim + " work " + work) |
|||
work = work[len(delim):] |
|||
if verbose: print("xPath key " + key + " i " + str(i) + " work " + work) |
|||
if val is not None: |
|||
if verbose: print("val not none " + val) |
|||
if val in work: |
|||
if verbose: print("val ok") |
|||
work = work.replace(val, "") |
|||
elif "time" in key and "job.par" in key: |
|||
prop = "" |
|||
if i < len(patterlist) - 1: |
|||
prop = work[0:work.index(nextdelim)] |
|||
else: |
|||
prop = work |
|||
key = key[8:] |
|||
if verbose: print("setprop " + key + " = " + prop) |
|||
if hasattr(job.par, key): delattr(job.par, key) |
|||
setattr(job.par, key, val) |
|||
else: |
|||
if verbose: print("val not not ok " + val + " zu " + key) |
|||
elif "job.par" in key: |
|||
prop = "" |
|||
if i < len(patterlist) - 1: |
|||
if verbose: print("job.par nextdelim " + nextdelim) |
|||
prop = work[0:work.index(nextdelim)] |
|||
else: |
|||
prop = work |
|||
key = key[8:] |
|||
if verbose: print("setprop " + key + " = " + prop) |
|||
if hasattr(job.par, key): delattr(job.par, key) |
|||
setattr(job.par, key, prop) |
|||
work = work.replace(prop, "") |
|||
else: |
|||
if verbose: print("val is none " + key) |
|||
i = i +1 |
|||
|
|||
|
|||
class PathConf: |
|||
""" |
|||
this class contains the structure-informations of the testrelevant directories |
|||
""" |
|||
__instance = None |
|||
def __init__(self, job=None): |
|||
#print('init pathConf') |
|||
confs = utils.config_tool.getConfig(job, "tool", "path") |
|||
self.pattern = confs["pattern"] |
|||
#print(self.pattern) |
|||
PathConf.__instance = self |
|||
|
|||
@staticmethod |
|||
def getInstance(job = None): |
|||
#print("PathConf getInstance " + str(PathConf.__instance)) |
|||
if (PathConf.__instance is None): |
|||
PathConf(job) |
|||
#print("PathConf getInstance " + str(PathConf.__instance)) |
|||
return PathConf.__instance |
|||
|
|||
Loading…
Reference in new issue