def addSync(sync_dict):
try:
Json_evaluation.updateJson(dict=sync_dict,filename=__syncFile__)
log("Adding "+str(sync_dict.keys())+" Parameter ")
pass
except Exception as e:
log("Error_Sync_addSync@"+str(e))
def getInbuiltParam(stepName, path=__guidePath__):
try:
stepData = Json_evaluation.getJsonByKey(key=stepName,
filename=__stepsFile__,
path=path)
if str(stepData["stepType"]) in "1,4":
print(stepData["stepType"])
stepStr = stepData["statement"]
index = stepStr.find("@")
inbulitParaData = []
while index != -1:
tempStr = stepStr[index + 1:]
end = str(tempStr).find("@")
inbulitParaData.insert(0,
stepStr[index + 1:index + end + 1])
stepStr = stepStr[index + end + 2:]
index = stepStr.find("@")
return inbulitParaData
except Exception as e:
log("Error_getInbuitParam@" + str(e))
def callApi(
filePath=__storagePath__,
filename="",
url="http://sussociety.cc:8080/bower_components/images/banner.jpg"
):
try:
extn = ""
_filename = ""
extn = (url[-5:].split('.')[1])
if filename == "":
_filename = str(url[-10:].split('.')[0])
_filename = _filename.replace('/', '_')
#print(_filename)
else:
_filename = filename
if extn is None or extn == "":
return "Http path is not valid!!"
#print(filePath+"/"+_filename+"."+extn)
_filename = Generic.prefixTimeStamp(_filename, "_")
_filename = _filename.replace(' ', '_').replace(':', '.')
fileContent = urllib.request.urlopen(url)
with open(filePath + "/" + _filename + "." + extn, 'wb') as output:
output.write(fileContent.read())
return str(filePath + "/" + _filename + "." + extn)
except Exception as e:
log("Error_Url_callApi@" + str(e))
return "-1"
def connection(con_name=""):
data = Json_evaluation.readJSON(__guidePath__, __connectionFile__)
if data[con_name]["connType"] == "MySql":
try:
con = pymysql.connect(data[con_name]["server"],
data[con_name]["user"],
data[con_name]["password"],
data[con_name]["database"],
charset=data[con_name]["charset"],
use_unicode=data[con_name]["use_unicode"],
port=data[con_name]["port"])
except Exception as e:
log("Error_sqlConn_mySQLCon@" + e)
return con
elif data[con_name]["connType"] == "MS Sql Server":
data = Json_evaluation.readJSON(__guidePath__, __connectionFile__)
try:
con = pymssql.connect(data[con_name]["server"],
data[con_name]["user"],
data[con_name]["password"],
data[con_name]["database"],
port=data[con_name]["port"])
except Exception as e:
log("Error_sqlConn_msSQLCon@" + e)
return con
def updateNextRun(jobData):
try:
interval = int(jobData["interval"])
if jobData["lastRunDate"] == "-1":
if interval < 0:
jobData["nextRunTime"] = Generic.addTime(
Generic.strToTime(jobData["scheuledTime"]),
(-1 * interval))
#print(jobData["nextRunTime"])
jobData["nextRunDate"] = Generic.getDate()
else:
jobData["nextRunTime"] = jobData["scheuledTime"]
jobData["nextRunDate"] = Generic.dateToStr(
Generic.addDate(Generic.strToDate(Generic.getDate()),
interval))
else:
if interval < 0:
jobData["nextRunTime"] = Generic.addTime(
Generic.strToTime(jobData["nextRunTime"]),
(-1 * interval))
#print(jobData["nextRunTime"])
jobData["nextRunDate"] = Generic.getDate()
else:
jobData["nextRunTime"] = jobData["scheuledTime"]
jobData["nextRunDate"] = Generic.dateToStr(
Generic.addDate(
Generic.strToDate(jobData["nextRunDate"]),
interval))
return jobData
except Exception as e:
log("Error_Jobs_updateNextRun@" + str(e))
def updateParamValue(paramName="Willdo", value=""):
try:
data = Json_evaluation.getJsonByKey(key=paramName,
filename=__parameterFile__)
data["paramValue"] = value
data = {paramName: data}
Json_evaluation.updateJson(dict=data, filename=__parameterFile__)
except Exception as e:
log("Error_Parameter_updateParamValue@" + str(e))
def addStep(jobName, step_dict, path=__guidePath__, logPath=__logPath__):
try:
Json_evaluation.updateJson(step_dict, __stepsFile__, path=path)
log("Adding " + str(step_dict.keys()) + " step under job " +
jobName,
path=logPath)
pass
except Exception as e:
log("Error_Jobs_addStep@" + str(e))
def addSmpt(smpt_dict, path=__guidePath__, logPath=__logPath__):
try:
Json_evaluation.updateJson(dict=smpt_dict,
filename=__emailFile__,
path=path)
log("Adding " + str(smpt_dict.keys()) + " smpt ", path=logPath)
pass
except Exception as e:
log("Error_Email_addSmpt@" + str(e), path=logPath)
async def executeJob(job_name):
try:
steps = Job.getStepsByJob(job_name)
for step in steps:
#print(str(step))
await ExecuteStep.executeStep(str(step))
Job.lastRunUpdate(job_name)
Job.notificationJobAction(job_name)
except Exception as e:
log("Error_Jobs_executeJob@" + str(e))
def getParamValue(data, subType):
try:
for key in data:
if int(key[-1:]) == subType:
return key
return "-1"
except Exception as e:
log("Error_Parameter_getParamValue@" + str(e))
def addParam(param_dict, path=__guidePath__, logPath=__logPath__):
try:
Json_evaluation.updateJson(dict=param_dict,
filename=__parameterFile__,
path=path)
log("Adding " + str(param_dict.keys()) + " Parameter ",
path=logPath)
pass
except Exception as e:
log("Error_Parameter_addParam@" + str(e))
def getStepsByJob(job_name, path=__guidePath__):
try:
#print(job_name)
steps = []
data = Json_evaluation.readJSON(filename=__stepsFile__, path=path)
for key in data.keys():
if str(key.split('|')[0]).strip() == str(job_name).strip():
steps.insert(int(data[key]["stepNo"]), key)
return steps
except Exception as e:
log("Error_Jobs_getStepsByJob@" + str(e))
def validateJobName(jobName):
try:
data = Json_evaluation.getJsonByKey(filename=__jobFile__,
key=jobName)
if data != -1:
return 0
return 1
#log("Job "+jobName+" last Run Updated!!")
except Exception as e:
log("Error_Jobs_validateJobName@" + str(e))
def getParamByJob(jobName, path=__guidePath__):
try:
data = Json_evaluation.readJSON(filename=__parameterFile__,
path=path)
params = []
for key in data.keys():
if data[key]["jobName"] == jobName:
params.insert(0, key)
return params
except Exception as e:
log("Error_Parameter_getParamByJob@" + str(e))
def executeJob(nearestJobName, nearestJob):
try:
#print(nearestJobName,nearestJob)
if int(nearestJob[nearestJobName]["remainingSec"]) == 0:
log(nearestJobName + " Job Execution has been started!!")
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.run_until_complete(Job.executeJob(nearestJobName))
except Exception as e:
log(" Warning: Scheduler is free- No job for this instance" + str(e))
def getSchedulerStatus(remote_dict,path=__guidePath__,logPath=__logPath__):
try:
#dateTime=Generic.getDateTime()
status="OFF"
#print(len(Sync.remoteSearchSchedulerCall(remote_dict,logPath=logPath)))
if len(Sync.remoteSearchSchedulerCall(remote_dict,logPath=logPath))>1:
status="ON"
#print(status)
Json_evaluation.updateJson({"schedulerStatus":status},filename=__schedulerTimeStampFile__,path=path)
except Exception as e:
log("Error_setSchedulerTimeStap"+str(e),path=logPath)
def evaluateJob(path=__guidePath__):
try:
#step_data=Json_evaluation.readJSON(filename=__stepsFile__)
return Json_evaluation.readJSON(filename=__jobFile__, path=path)
#print(job_data["conName"])
#con_data=Json_evaluation.readJSON(filename=__connectionFile__)
#sjc_data={**step_data,**job_data,**con_data}
#print(sjc_data)
pass
except Exception as e:
log("Error_Job_evaluateJob@" + str(e))
def validateConName(conName):
try:
data = Json_evaluation.getJsonByKey(filename=__connectionFile__,
key=conName)
if int(data) != -1:
return 0
return 1
#log("Job "+jobName+" last Run Updated!!")
except Exception as e:
log("Error_insertConnection_validateJobName@" + str(e))
return 0
def lastRunUpdate(jobName):
try:
data = Json_evaluation.getJsonByKey(filename=__jobFile__,
key=jobName)
data = Job.updateNextRun(data)
data["lastRunDate"] = Generic.getDate()
n_data = {}
n_data[jobName] = data #Next scheduled time update
Json_evaluation.updateJson(dict=n_data, filename=__jobFile__)
log("Job " + jobName + " last Run Updated!!")
except Exception as e:
log("Error_Jobs_lastRunUpdate@" + str(e))
def setSchedulerTimeStap():
try:
dateTime = Generic.currentTimestamp()
Json_evaluation.updateJson(
{
"schedulerTimeStamp": str(dateTime),
"schedulerStatus": "ON"
},
filename=__schedulerTimeStampFile__)
log("Scheduler Restarted at " + str(dateTime))
except Exception as e:
log("Error_setSchedulerTimeStap" + str(e))
def insertConnection(con_dict, path=__guidePath__, logPath=__logPath__):
try:
Json_evaluation.updateJson(con_dict,
filename=__connectionFile__,
path=path)
#data=Json_evaluation.readJSON(filename=__connectionFile__,path=path)
#data = {"Con_1":{"server":"94.156.144.217","user":"******","password":"******","database":"hotels","charset":"utf8","port":3306,"use_unicode":"True"}}
#data.update(con_dict)
#Json_evaluation.writeJSON(data=data,filename=__connectionFile__,path=path)
log("Adding " + str(con_dict.keys()) + " Connetions", path=logPath)
pass
except Exception as e:
print("Error_insertConnection_insertConnection@" + str(e))
def getActiveJobs(path=__guidePath__):
try:
data = Job.evaluateJob(path)
#print(data)
curDate = Generic.strToDate(Generic.getDate())
activeJobs = {}
for key in data.keys():
if Generic.strToDate(data[key]["startDate"]
) <= curDate and Generic.strToDate(
data[key]["endDate"]) >= curDate and (
data[key]["isActive"] == 1
or data[key]["isActive"] == "on"):
activeJobs[key] = data[key]
return activeJobs
except Exception as e:
log("Error_Jobs_isJobEligibleToRun@" + str(e))
return 0
def getFileFromRemote(remote_dict,remoteFilePath,filename):
try:
ssh=Sync.sshCall(remote_dict)
ftp_client=ssh.open_sftp()
try:
ftp_client.get(remoteFilePath,Generic.getCurrentPath()+pathConnector+__storagePath__+pathConnector+filename)
#ftp_client.mkdir(__installationDirName__)
return str(Generic.getCurrentPath()+pathConnector+__storagePath__+pathConnector+filename)
except (IOError,Exception) as e:
log("Error_Sync_getFileFromRemote_CmdError@"+str(e))
except (Exception,paramiko.SSHException,paramiko.AuthenticationException,paramiko.BadHostKeyException,socket.error) as e:
log("Error_Sync_remoteName@"+str(e))
return -1
def prepareJobQueue():
try:
todayList = {}
data = Job.evaluateJob()
#print(data)
curDate = Generic.strToDate(Generic.getDate())
curTime = Generic.strToTime(Generic.getTime())
#print(curTime)
for key in data.keys():
timeKeyword = ""
lastRunDate = data[key]["lastRunDate"]
if data[key]["lastRunDate"] == "-1":
timeKeyword = "scheuledTime"
else:
timeKeyword = "nextRunTime"
if Generic.strToDate(
data[key]
["startDate"]) <= curDate and Generic.strToDate(
data[key]["endDate"]) >= curDate and (
data[key]["isActive"] == 1
or data[key]["isActive"] == "on") and (
lastRunDate == "-1" or Job.isJobEligibleToRun(
int(data[key]["interval"]), curDate,
curTime, data[key][timeKeyword])
== 1) and Generic.strToTime(
data[key][timeKeyword]) >= curTime:
todayList[key] = {
"scheduledTime":
data[key][timeKeyword],
"remainingSec":
Generic.timeDiff(Generic.getTime(),
data[key][timeKeyword]),
"nextRunDate":
"-" if timeKeyword == "scheuledTime" else
data[key]['nextRunDate'],
"nextRunTime":
"-" if timeKeyword == "scheuledTime" else
data[key]['nextRunTime']
}
#print(todayList)
Json_evaluation.writeJSON(data=todayList, filename=__jobQueue__)
log("Job Queue Prepared....")
except Exception as e:
log("Error_Jobs_prepareJobQueue@" + str(e))
def isJobEligibleToRun(interval, curDate, curTime, lastRunDateTime):
try:
return 1 #Disabled this function in version 3.0!!
if lastRunDateTime == "-1":
return 1
if interval < 0:
#print(Generic.strToTime(Generic.addTime(Generic.strToTime(lastRunDateTime),(-1*interval))))
if Generic.strToTime(
Generic.addTime(Generic.strToTime(lastRunDateTime),
(-1 * interval))) >= curTime:
return 1
elif Generic.addDate(Generic.strToDate(lastRunDateTime),
interval) >= curDate and interval > 0:
return 1
else:
return 0
except Exception as e:
log("Error_Jobs_isJobEligibleToRun@" + str(e))
return 0
def getParamByStep(data):
try:
paramData = {}
if len(data["parameter"]) > 0:
params = data["parameter"].split('|')
paramFlag = 1
if len(params) > 1:
for key in params:
paramDataTemp = Json_evaluation.getJsonByKey(
filename=__parameterFile__, key=key[:-1])
paramData[key] = paramDataTemp
else:
paramDataTemp = Json_evaluation.getJsonByKey(
filename=__parameterFile__, key=params[0][:-1])
paramData = {params[0]: paramDataTemp}
return paramData, params
except Exception as e:
log("Error_Parameter_getParamByStep@" + str(e))
def getParamOptions(stepName, path=__guidePath__, logPath=__logPath__):
try:
#data=Json_evaluation.getJsonByKey(key=stepName,filename=__stepsFile__,path=path)
optionData = {}
paramOptionData = Json_evaluation.readJSON(
filename=__paramOptionFile__, path=path)
stepData = Json_evaluation.getJsonByKey(key=stepName,
filename=__stepsFile__,
path=path)
stepType = stepData['stepType']
for paramKey in paramOptionData.keys():
if str(stepType) in str(paramOptionData[paramKey]['stepType']):
optionData[paramOptionData[paramKey]['name']] = paramKey
return optionData
except Exception as e:
log("Error_Parameter_getParamOptions@" + str(e))
return "-1"
def stopWebServer(remote_dict):
try:
ssh=Sync.sshCall(remote_dict)
#ftp_client=ssh.open_sftp()
try:
for o in Sync.remoteSearchWebServerCall(remote_dict):
stdin, stdout, stderr = ssh.exec_command(__webServerStopCmd__.replace('#pid',o))
#ftp_client.get(__installationDirName__+pathConnector+__logPath__+pathConnector+__logFile__,"log.txt")
#ftp_client.mkdir(__installationDirName__)
return 1
except (IOError,Exception) as e:
log("Error_Sync_stopScheduler_CmdError@"+str(e))
except (Exception,paramiko.SSHException,paramiko.AuthenticationException,paramiko.BadHostKeyException,socket.error) as e:
log("Error_Sync_stopScheduler@"+str(e))
return -1
def setJob(job_dict,
isNew=0,
path=__guidePath__,
histoyPath=__historyPath__,
logPath=__logPath__):
try:
Json_evaluation.updateJson(job_dict, __jobFile__, path=path)
if isNew == 1:
for x in job_dict.keys():
Json_evaluation.writeText(
filename=str(x) + ".txt",
path=histoyPath,
data=Generic.prefixTimeStamp("Job Created!!"))
log("Adding " + str(job_dict.keys()) + " Job", path=logPath)
else:
log("Update made on " + str(job_dict.keys()) + " Job",
path=logPath)
for x in job_dict.keys():
History.addJobHistory(filename=str(x + ".txt"),
path=histoyPath,
data=Generic.prefixTimeStamp(
str("Job has been updated!!")))
pass
except Exception as e:
log("Error_Jobs_setJob@" + str(e), path=logPath)
def getNearestJob(): #Disabled in v3.0
try:
data = Json_evaluation.readJSON(filename=__jobQueue__)
#print(data)
jobCache = ""
curDate = Generic.strToDate(Generic.getDate())
lesserTime = -1
for key in data.keys():
if lesserTime == -1 and Generic.strToTime(
data[key]["scheduledTime"]) >= Generic.strToTime(
Generic.getTime()):
lesserTime = data[key]["remainingSec"]
jobCache = key
if lesserTime > int(
data[key]["remainingSec"]) and Generic.strToTime(
data[key]["scheduledTime"]) >= Generic.strToTime(
Generic.getTime()):
lesserTime = data[key]["remainingSec"]
jobCache = key
return jobCache
except Exception as e:
log("Error_Jobs_getNearestJob@" + str(e))
