def pkgInfoFpBaseDir_obtain(
icmsPkgInfoBaseDir,
):
####+END:
if icmsPkgInfoBaseDir:
return os.path.abspath(
"{}/pkgInfo/fp".format(icmsPkgInfoBaseDir)
)
else:
return icm.EH_problem_usageError("Missing BaseDir")
def ticmoBaseCreate(ticmoBase=None):
""" """
if ticmoBase == None:
return icm.EH_problem_usageError()
parFullPath = ticmoBase
try:
os.makedirs(parFullPath, 0o775)
except OSError:
pass
def cmnd(
self,
interactive=False, # Can also be called non-interactively
svcSpec=None, # or Cmnd-Input
perfSap=None, # or Cmnd-Input
headers=None, # or Cmnd-Input
argsList=[], # or Args-Input
):
cmndOutcome = self.getOpOutcome()
if interactive:
if not self.cmndLineValidate(outcome=cmndOutcome):
return cmndOutcome
effectiveArgsList = G.icmRunArgsGet().cmndArgs
else:
effectiveArgsList = argsList
callParamsDict = {
'svcSpec': svcSpec,
'perfSap': perfSap,
'headers': headers,
}
if not icm.cmndCallParamsValidate(
callParamsDict, interactive, outcome=cmndOutcome):
return cmndOutcome
svcSpec = callParamsDict['svcSpec']
perfSap = callParamsDict['perfSap']
headers = callParamsDict['headers']
cmndArgsSpecDict = self.cmndArgsSpec()
if not self.cmndArgsValidate(
effectiveArgsList, cmndArgsSpecDict, outcome=cmndOutcome):
return cmndOutcome
####+END:
icm.TM_here("svcSpec={svcSpec} -- perfSap={perfSap}".format(
svcSpec=svcSpec, perfSap=perfSap))
try:
loadedSvcSpec, origin_url = loadSvcSpec(svcSpec, perfSap)
except Exception as e:
icm.EH_problem_usageError(
"wsInvokerIcm.svcOpsList Failed -- svcSpec={svcSpec}".format(
svcSpec=svcSpec, ))
icm.EH_critical_exception(e)
return
pp = pprint.PrettyPrinter(indent=4)
icm.TM_here("{}".format(pp.pformat(loadedSvcSpec)))
processSvcSpec(loadedSvcSpec, origin_url, perfSap, headers, svcSpec)
def rosListProc(rosList):
"""Process List of Remote Operations"""
@icm.subjectToTracking(fnLoc=True, fnEntry=True, fnExit=True)
def roProc(thisRo):
"""Process One Remote Operation"""
return (wsInvokerIcm.ro_opInvokeCapture(thisRo))
for thisRo in rosList:
invokedOp = roProc(thisRo)
if invokedOp:
opReport(invokedOp)
else:
icm.EH_problem_usageError("ro_opInvokeCapture Failed")
return
def withPbdNameGetRootForPlatform(pbdName):
rootDirName = None
bxPlatformConfigBase = bxPlatformThis.pkgBase_configDir()
if pbdName == "bisosRoot":
rootDirName = bxPlatformConfig.rootDir_bisos_fpObtain(bxPlatformConfigBase)
elif pbdName == "deRunRoot":
rootDirName = bxPlatformConfig.rootDir_bxo_fpObtain(bxPlatformConfigBase)
elif pbdName == "bxoRoot":
rootDirName = bxPlatformConfig.rootDir_deRun_fpObtain(bxPlatformConfigBase)
else:
icm.EH_problem_usageError("")
return rootDirName
def ticmoBxpOutputsBaseGet(targetType="bxp",
targetElem=None,
collective=None,
district=None,
targetId=None):
""" """
if targetType != "bxp":
return icm.EH_problem_usageError("Unsupported Target Type: " +
targetType)
if targetElem:
# NOTYET, Get collectivem district, ... from targetElem
if targetId == None:
targetId = targetElem.targetFqdn()
# /de/bx/ticmo/int/libreCenter/targets/bxp/bue/
return (format("/de/bx/ticmo/%s/%s/targets/%s/%s" %
(collective, district, targetType, targetId)))
def ticmoBxpOutputsBaseGetCmnd(interactive=False,
targetType="bxp",
collective=None,
district=None,
targetId=None):
""" """
try:
icm.callableEntryEnhancer(type='cmnd')
except StopIteration:
return
if targetType != "bxp":
return icm.EH_problem_usageError("Unsupported Target Type: " +
targetType)
G = icm.IcmGlobalContext()
icmRunArgs = G.icmRunArgsGet()
#icmParamDict = G.icmParamDictGet()
if interactive == True:
if not len(icmRunArgs.cmndArgs) == 0:
try:
icm.EH_runTime('Bad Number Of cmndArgs')
except RuntimeError:
return
if icmRunArgs.collective:
collective = icmRunArgs.collective
if icmRunArgs.district:
district = icmRunArgs.district
if icmRunArgs.targetType:
targetType = icmRunArgs.targetType
if icmRunArgs.targetId:
targetId = icmRunArgs.targetId
# /de/bx/ticmo/int/libreCenter/targets/bxp/bue/
return (format("/de/bx/ticmo/%s/%s/targets/%s/%s" %
(collective, district, targetType, targetId)))
def bxoRootDir_obtain(bxoId, ):
####+END:
"""
**
"""
bxoBaseDir = None
idType = bxoIdType_obtain(bxoId)
if idType == bxo_IdType.foreignBxO:
bxoBaseDir = os.path.join(
bxPlatformConfig.rootDir_foreignBxo_fpObtain(configBaseDir=None, ),
bxoId,
)
elif idType == bxo_IdType.nativeBxO:
pass
elif idType == bxo_IdType.bystarId:
pass
else:
icm.EH_problem_usageError("")
return bxoBaseDir
def panelBasePathObtain(panelBase, ):
####+END:
"""
** TODO NOTYET not fully implemented yet
"""
print panelBase
if not panelBase:
#return "/bisos/var/core/bleePlayer"
return (os.path.join(bxpBaseDir.bpbBisos_baseObtain_var(None),
"main/bleePlayer"))
if os.path.isabs(panelBase):
return panelBase
if panelBase == "here":
return os.path.abspath(".")
elif panelBase == "grouped":
return os.path.abspath(".")
elif panelBase == "pkged":
return os.path.abspath(".")
else:
return icm.EH_problem_usageError(panelBase)
def cmnd(
self,
interactive=False, # Can also be called non-interactively
svcSpec=None, # or Cmnd-Input
resource=None, # or Cmnd-Input
opName=None, # or Cmnd-Input
perfSap=None, # or Cmnd-Input
headers=None, # or Cmnd-Input
argsList=[], # or Args-Input
):
cmndOutcome = self.getOpOutcome()
if interactive:
if not self.cmndLineValidate(outcome=cmndOutcome):
return cmndOutcome
effectiveArgsList = G.icmRunArgsGet().cmndArgs
else:
effectiveArgsList = argsList
callParamsDict = {
'svcSpec': svcSpec,
'resource': resource,
'opName': opName,
'perfSap': perfSap,
'headers': headers,
}
if not icm.cmndCallParamsValidate(
callParamsDict, interactive, outcome=cmndOutcome):
return cmndOutcome
svcSpec = callParamsDict['svcSpec']
resource = callParamsDict['resource']
opName = callParamsDict['opName']
perfSap = callParamsDict['perfSap']
headers = callParamsDict['headers']
cmndArgsSpecDict = self.cmndArgsSpec()
if not self.cmndArgsValidate(
effectiveArgsList, cmndArgsSpecDict, outcome=cmndOutcome):
return cmndOutcome
####+END:
opParsList = self.cmndArgsGet("0&-1", cmndArgsSpecDict,
effectiveArgsList)
icm.TM_here("svcSpec={svcSpec} -- perfSap={perfSap}".format(
svcSpec=svcSpec, perfSap=perfSap))
#generateSvcInfo("http://localhost:8080/swagger.json")
loadedSvcSpec, origin_url = loadSvcSpec(svcSpec, perfSap)
if perfSap:
#origin_url = "http://localhost:8080"
origin_url = perfSap
pp = pprint.PrettyPrinter(indent=4)
icm.TM_here("{}".format(pp.pformat(loadedSvcSpec)))
op = getOperationWithResourceAndOpName(loadedSvcSpec, origin_url,
resource, opName)
opInvokeEvalStr = "opInvoke(headers, op, "
for each in opParsList:
parVal = each.split("=")
parValLen = len(parVal)
if parValLen == 2:
parName = parVal[0]
parValue = parVal[1]
else:
icm.EH_problem_usageError(
"Expected 2: {parValLen}".format(parValLen=parValLen))
continue
opInvokeEvalStr = opInvokeEvalStr + """{parName}="{parValue}", """.format(
parName=parName, parValue=parValue)
opInvokeEvalStr = opInvokeEvalStr + ")"
icm.TM_here("Invoking With Eval: str={opInvokeEvalStr}".format(
opInvokeEvalStr=opInvokeEvalStr, ))
eval(opInvokeEvalStr)
return
def cmnd(
self,
interactive=False, # Can also be called non-interactively
bxoId=None, # or Cmnd-Input
sr=None, # or Cmnd-Input
argsList=[], # or Args-Input
):
cmndOutcome = self.getOpOutcome()
if interactive:
if not self.cmndLineValidate(outcome=cmndOutcome):
return cmndOutcome
effectiveArgsList = G.icmRunArgsGet().cmndArgs
else:
effectiveArgsList = argsList
callParamsDict = {
'bxoId': bxoId,
'sr': sr,
}
if not icm.cmndCallParamsValidate(
callParamsDict, interactive, outcome=cmndOutcome):
return cmndOutcome
bxoId = callParamsDict['bxoId']
sr = callParamsDict['sr']
cmndArgsSpecDict = self.cmndArgsSpec()
if not self.cmndArgsValidate(
effectiveArgsList, cmndArgsSpecDict, outcome=cmndOutcome):
return cmndOutcome
####+END:
cmndArgs = self.cmndArgsGet("0&2", cmndArgsSpecDict, effectiveArgsList)
if len(cmndArgs):
if cmndArgs[0] == "all":
cmndArgsSpec = cmndArgsSpecDict.argPositionFind("0&2")
argChoices = cmndArgsSpec.argChoicesGet()
argChoices.pop(0)
cmndArgs = argChoices
retVal = bxoSr_runBaseObtain_root(
bxoId=bxoId,
sr=sr,
)
if interactive:
icm.ANN_write("{}".format(retVal))
for each in cmndArgs:
if each == "var":
icm.ANN_write("{each}".format(
each=bxoSr_runBaseObtain_var(bxoId, sr)))
elif each == "tmp":
icm.ANN_write("{each}".format(
each=bxoSr_runBaseObtain_tmp(bxoId, sr)))
elif each == "log":
icm.ANN_write("{each}".format(
each=bxoSr_runBaseObtain_log(bxoId, sr)))
else:
icm.EH_problem_usageError("")
return cmndOutcome.set(
opError=icm.notAsFailure(retVal),
opResults=retVal,
)
def cmnd(
self,
interactive=False, # Can also be called non-interactively
configBaseDir=None, # or Cmnd-Input
bisosUserName=None, # or Cmnd-Input
bisosGroupName=None, # or Cmnd-Input
rootDir_bisos=None, # or Cmnd-Input
rootDir_bxo=None, # or Cmnd-Input
rootDir_deRun=None, # or Cmnd-Input
rootDir_foreignBxo=None, # or Cmnd-Input
argsList=[], # or Args-Input
):
cmndOutcome = self.getOpOutcome()
if interactive:
if not self.cmndLineValidate(outcome=cmndOutcome):
return cmndOutcome
effectiveArgsList = G.icmRunArgsGet().cmndArgs
else:
effectiveArgsList = argsList
callParamsDict = {
'configBaseDir': configBaseDir,
'bisosUserName': bisosUserName,
'bisosGroupName': bisosGroupName,
'rootDir_bisos': rootDir_bisos,
'rootDir_bxo': rootDir_bxo,
'rootDir_deRun': rootDir_deRun,
'rootDir_foreignBxo': rootDir_foreignBxo,
}
if not icm.cmndCallParamsValidate(
callParamsDict, interactive, outcome=cmndOutcome):
return cmndOutcome
configBaseDir = callParamsDict['configBaseDir']
bisosUserName = callParamsDict['bisosUserName']
bisosGroupName = callParamsDict['bisosGroupName']
rootDir_bisos = callParamsDict['rootDir_bisos']
rootDir_bxo = callParamsDict['rootDir_bxo']
rootDir_deRun = callParamsDict['rootDir_deRun']
rootDir_foreignBxo = callParamsDict['rootDir_foreignBxo']
cmndArgsSpecDict = self.cmndArgsSpec()
if not self.cmndArgsValidate(
effectiveArgsList, cmndArgsSpecDict, outcome=cmndOutcome):
return cmndOutcome
####+END:
if not configBaseDir:
configBaseDir = configBaseDir_obtain()
basesPolicy = self.cmndArgsGet("0", cmndArgsSpecDict,
effectiveArgsList)
rootPrefix = self.cmndArgsGet("1", cmndArgsSpecDict, effectiveArgsList)
if basesPolicy == "bxoPolicy":
if not bisosUserName:
bisosUserName = bisosPolicy.bisosAccountName()
if not bisosGroupName:
bisosGroupName = bisosPolicy.bisosGroupName()
if not rootDir_bisos:
rootDir_bisos = os.path.join(rootPrefix,
bisosPolicy.rootDir_bisos())
if not rootDir_bxo:
rootDir_bxo = os.path.join(rootPrefix,
bisosPolicy.rootDir_bxo())
if not rootDir_deRun:
rootDir_deRun = os.path.join(rootPrefix,
bisosPolicy.rootDir_deRun())
elif basesPolicy == "foreignBxoPolicy":
if not bisosUserName:
return icm.EH_problem_usageError("Missing bisosUserName")
if not bisosGroupName:
return icm.EH_problem_usageError("Missing bisosGroupName")
if not rootDir_foreignBxo:
return icm.EH_problem_usageError("Missing rootDir_foreignBxo")
if not rootDir_bisos:
rootDir_bisos = os.path.join(rootPrefix,
bisosPolicy.rootDir_bisos())
if not rootDir_bxo:
rootDir_bxo = os.path.join(rootPrefix,
bisosPolicy.rootDir_bxo())
if not rootDir_deRun:
rootDir_deRun = os.path.join(rootPrefix,
bisosPolicy.rootDir_deRun())
elif basesPolicy == "externalPolicy":
if not bisosUserName:
return icm.EH_problem_usageError("Missing bisosUserName")
if not bisosGroupName:
return icm.EH_problem_usageError("Missing bisosGroupName")
if not rootDir_foreignBxo:
return icm.EH_problem_usageError("Missing rootDir_foreignBxo")
if not rootDir_bisos:
return icm.EH_problem_usageError("Missing rootDir_bisos")
if not rootDir_bxo:
return icm.EH_problem_usageError("Missing rootDir_bxo")
if not rootDir_deRun:
return icm.EH_problem_usageError("Missing rootDir_deRun")
else:
return icm.EH_critical_oops("basesPolicy={}".format(basesPolicy))
pkgInfoParsSet().cmnd(
interactive=False,
configBaseDir=configBaseDir,
bisosUserName=bisosUserName,
bisosGroupName=bisosGroupName,
rootDir_foreignBxo=rootDir_foreignBxo,
rootDir_bisos=rootDir_bisos,
rootDir_bxo=rootDir_bxo,
rootDir_deRun=rootDir_deRun,
)
def cmnd(
self,
interactive=False, # Can also be called non-interactively
rsrc=None, # or Cmnd-Input
system=None, # or Cmnd-Input
user=None, # or Cmnd-Input
passwdPolicy=None, # or Cmnd-Input
argsList=[], # or Args-Input
):
cmndOutcome = self.getOpOutcome()
if interactive:
if not self.cmndLineValidate(outcome=cmndOutcome):
return cmndOutcome
effectiveArgsList = G.icmRunArgsGet().cmndArgs
else:
effectiveArgsList = argsList
callParamsDict = {
'rsrc': rsrc,
'system': system,
'user': user,
'passwdPolicy': passwdPolicy,
}
if not icm.cmndCallParamsValidate(
callParamsDict, interactive, outcome=cmndOutcome):
return cmndOutcome
rsrc = callParamsDict['rsrc']
system = callParamsDict['system']
user = callParamsDict['user']
passwdPolicy = callParamsDict['passwdPolicy']
cmndArgsSpecDict = self.cmndArgsSpec()
if not self.cmndArgsValidate(
effectiveArgsList, cmndArgsSpecDict, outcome=cmndOutcome):
return cmndOutcome
####+END:
opError = icm.OpError.Success
passwd = None
cmndArgs = self.cmndArgsGet("0&1", cmndArgsSpecDict, effectiveArgsList)
for each in cmndArgs:
passwd = each
if not passwd:
if not passwdPolicy:
passwd = "clear"
elif passwdPolicy == "prompt":
# Prompt for password
passwd = getpass.getpass()
else:
return (icm.EH_problem_usageError(
"Bad passwdPolicy={}".passwdPolicy))
cryptoKeyring = CryptoKeyring(
system=system,
user=user,
)
opError = cryptoKeyring.passwdSet(passwd)
#cryptoKeyring.save()
return cmndOutcome.set(
opError=opError,
opResults=None,
)
def cmnd(
self,
interactive=False, # Can also be called non-interactively
bxoId=None, # or Cmnd-Input
sr=None, # or Cmnd-Input
inFile=None, # or Cmnd-Input
msg=None, # asFunc when interactive==False
):
cmndOutcome = self.getOpOutcome()
if interactive:
if not self.cmndLineValidate(outcome=cmndOutcome):
return cmndOutcome
callParamsDict = {
'bxoId': bxoId,
'sr': sr,
'inFile': inFile,
}
if not icm.cmndCallParamsValidate(
callParamsDict, interactive, outcome=cmndOutcome):
return cmndOutcome
bxoId = callParamsDict['bxoId']
sr = callParamsDict['sr']
inFile = callParamsDict['inFile']
####+END:
G = icm.IcmGlobalContext()
if not msg:
if inFile:
msg = msgIn.getMsgFromFile(inFile)
else:
# Stdin then
msg = msgIn.getMsgFromStdin()
else:
# non-interactive call with msg
if not bxoId:
icm.EH_problem_usageError("")
return cmndOutcome
icm.LOG_here(msgOut.strLogMessage(
"Msg As Input:",
msg,
))
icm.LOG_here(G.icmRunArgsGet().runMode)
outcome = msgOut.sendingRunControlSet(msg, G.icmRunArgsGet().runMode)
if outcome.isProblematic(): return (icm.EH_badOutcome(outcome))
bx822Set_setMandatoryFields(msg)
outcome = bx822Get_sendingFieldsPipelineLoad(
bxoId,
sr,
msg,
)
if outcome.isProblematic(): return (icm.EH_badOutcome(outcome))
if outcome.results != "INCOMPLETE":
icm.LOG_here("Complete Message Being Sent")
return (msgOut.sendBasedOnHeadersInfo(msg))
icm.LOG_here("Incomplete Message -- using qmail+dryrun")
msgOut.injectionParams(
msg,
injectionProgram=msgOut.InjectionProgram.qmail,
sendingRunControl=msgOut.SendingRunControl.dryRun,
)
return msgOut.sendBasedOnHeadersInfo(msg)
def cmnd(self,
interactive=False, # Can also be called non-interactively
icmsPkgName=None, # or Cmnd-Input
icmsPkgInfoBaseDir=None, # or Cmnd-Input
icmsPkgControlBaseDir=None, # or Cmnd-Input
icmsPkgRunBaseDir=None, # or Cmnd-Input
argsList=[], # or Args-Input
):
cmndOutcome = self.getOpOutcome()
if interactive:
if not self.cmndLineValidate(outcome=cmndOutcome):
return cmndOutcome
effectiveArgsList = G.icmRunArgsGet().cmndArgs
else:
effectiveArgsList = argsList
callParamsDict = {'icmsPkgName': icmsPkgName, 'icmsPkgInfoBaseDir': icmsPkgInfoBaseDir, 'icmsPkgControlBaseDir': icmsPkgControlBaseDir, 'icmsPkgRunBaseDir': icmsPkgRunBaseDir, }
if not icm.cmndCallParamsValidate(callParamsDict, interactive, outcome=cmndOutcome):
return cmndOutcome
icmsPkgName = callParamsDict['icmsPkgName']
icmsPkgInfoBaseDir = callParamsDict['icmsPkgInfoBaseDir']
icmsPkgControlBaseDir = callParamsDict['icmsPkgControlBaseDir']
icmsPkgRunBaseDir = callParamsDict['icmsPkgRunBaseDir']
cmndArgsSpecDict = self.cmndArgsSpec()
if not self.cmndArgsValidate(effectiveArgsList, cmndArgsSpecDict, outcome=cmndOutcome):
return cmndOutcome
####+END:
#G = icm.IcmGlobalContext()
#basesPolicyChoices = self.__class__.cmndArgsSpec[0]
basesPolicy = effectiveArgsList[0]
if not basesPolicy:
basesPolicy = G.icmRunArgsGet().cmndArgs[0]
print basesPolicy
print icmsPkgInfoBaseDir
pkgInfoParsSet().cmnd(
interactive=False,
icmsPkgInfoBaseDir=icmsPkgInfoBaseDir,
icmsPkgName=icmsPkgName,
)
if basesPolicy == "bisosPolicy":
if not icmsPkgControlBaseDir:
return icm.EH_problem_usageError("Missing Control BaseDir")
controlPath = icmsPkgControlBaseDir
varPath = os.path.join("/bisos", "var")
logPath = os.path.join("/bisos", "log")
tmpPath = os.path.join("/bisos", "tmp")
elif basesPolicy == "bxoPolicy":
if not icmsPkgControlBaseDir:
return icm.EH_problem_usageError("")
controlPath = icmsPkgControlBaseDir
varPath = os.path.join(icmsRunEnvBaseDir_obtain(), "var", icmsPkgName_fpObtain(icmsPkgInfoBaseDir=icmsPkgInfoBaseDir))
logPath = os.path.join(icmsRunEnvBaseDir_obtain(), "log", icmsPkgName_fpObtain(icmsPkgInfoBaseDir=icmsPkgInfoBaseDir))
tmpPath = os.path.join(icmsRunEnvBaseDir_obtain(), "tmp", icmsPkgName_fpObtain(icmsPkgInfoBaseDir=icmsPkgInfoBaseDir))
elif basesPolicy == "runBaseDirPolicy":
if not icmsPkgRunBaseDir:
return icm.EH_problem_usageError("")
if icmsPkgControlBaseDir:
controlPath = icmsPkgControlBaseDir
else:
controlPath = os.path.join(icmsPkgRunBaseDir, "control", icmsPkgName_fpObtain(icmsPkgInfoBaseDir=icmsPkgInfoBaseDir))
varPath = os.path.join(icmsPkgRunBaseDir, "var", icmsPkgName_fpObtain(icmsPkgInfoBaseDir=icmsPkgInfoBaseDir))
logPath = os.path.join(icmsPkgRunBaseDir, "log", icmsPkgName_fpObtain(icmsPkgInfoBaseDir=icmsPkgInfoBaseDir))
tmpPath = os.path.join(icmsPkgRunBaseDir, "tmp", icmsPkgName_fpObtain(icmsPkgInfoBaseDir=icmsPkgInfoBaseDir))
elif basesPolicy == "debianPolicy":
controlPath = os.path.join("/etc/bystar", icmsPkgName)
varPath = os.path.join("/var/lib/bystar/", icmsPkgName)
logPath = os.path.join("/var/log/bystar/", icmsPkgName)
tmpPath = os.path.join("/tmp/bystar", icmsPkgName)
elif basesPolicy == "centosPolicy":
controlPath = os.path.join("/etc/bystar", icmsPkgName)
varPath = os.path.join("/var/lib/bystar/", icmsPkgName)
logPath = os.path.join("/var/log/bystar/", icmsPkgName)
tmpPath = os.path.join("/tmp/bystar", icmsPkgName)
else:
return icm.EH_critical_oops("basesPolicy={}".format(basesPolicy))
pkgInfoParsSet().cmnd(
interactive=False,
icmsPkgInfoBaseDir=icmsPkgInfoBaseDir,
icmsPkgBasesPolicy=basesPolicy,
icmsPkgControlBaseDir=controlPath,
icmsPkgVarBaseDir=varPath,
icmsPkgLogBaseDir=logPath,
icmsPkgTmpBaseDir=tmpPath,
)
def opInvoke(headers, op, *args, **kwargs):
####+END:
""" NOTYET, Important, opInvoke should be layered on top of opInvokeCapture """
pp = pprint.PrettyPrinter(indent=4)
headerLines = list()
if headers:
with open(headers, 'rb') as file:
headerLines = file.readlines()
# else:
# print("Has No Headers")
headerLinesAsDict = dict()
for each in headerLines:
headerLineAsList = each.split(":")
headerLineAsListLen = len(headerLineAsList)
if headerLineAsListLen == 2:
headerLineTag = headerLineAsList[0]
headerLineValue = headerLineAsList[1]
else:
icm.EH_problem_usageError(
"Expected 2: {}".format(headerLineAsListLen))
continue
headerLinesAsDict[headerLineTag] = headerLineValue.lstrip(' ').rstrip()
requestOptions = dict()
if headerLinesAsDict:
requestOptions["headers"] = headerLinesAsDict
def bodyArgToDict(
bodyAny,
bodyFile,
bodyStr,
bodyFunc,
):
""" Returns None if all Args were None, and returns "" if one of the args was "", Otherwize a dict or {}."""
def bodyStrAsDict(bodyStr):
return ast.literal_eval(bodyStr)
def bodyFileAsDict(bodyFile):
with open(bodyFile, 'r') as myfile:
data = myfile.read().replace('\n', '')
return ast.literal_eval(data)
def bodyFuncAsDict(bodyFunc):
resDict = eval(bodyFunc)
# NOTYET, verify that we have a dict
return resDict
if bodyAny != None:
icm.TM_here("bodyAny={}".format(pp.pformat(bodyAny)))
if bodyAny == "":
return ""
# Be it file, function or string
if os.path.isfile(bodyAny):
return bodyFileAsDict(bodyAny)
elif bodyAny == "NOTYET-valid func":
return bodyFuncAsDict(bodyAny)
else:
# We then take bodyAny to be a string
return bodyStrAsDict(bodyAny)
elif bodyFile != None:
icm.TM_here("bodyFile={}".format(pp.pformat(bodyFile)))
if bodyFile == "":
return ""
if os.path.isfile(bodyAny):
return bodyFileAsDict(bodyFile)
else:
return {}
elif bodyFunc != None:
icm.TM_here("bodyFunc={}".format(pp.pformat(bodyFunc)))
if bodyFunc == "":
return ""
if bodyFunc == "NOTYET-valid func":
return bodyFuncAsDict(bodyFunc)
else:
return {}
elif bodyStr != None:
icm.TM_here("bodyStr={}".format(pp.pformat(bodyStr)))
if bodyStr == "":
return ""
bodyValue = bodyStrAsDict(bodyStr)
return bodyValue
else:
# So they were all None, meaning that no form of "body" was specified.
return None
# icm.TM_here("Args: {}".format(args))
# for key in kwargs:
# icm.TM_here("another keyword arg: %s: %s" % (key, kwargs[key]))
bodyAny = kwargs.pop('body', None)
bodyFile = kwargs.pop('bodyFile', None)
bodyStr = kwargs.pop('bodyStr', None)
bodyFunc = kwargs.pop('bodyFunc', None)
bodyValue = bodyArgToDict(bodyAny, bodyFile, bodyStr, bodyFunc)
icm.TM_here(pp.pformat(requestOptions))
if bodyValue == None:
request = construct_request(op, requestOptions, **kwargs)
elif bodyValue == "":
# Causes An Exception That Describes Expected Dictionary
request = construct_request(op, requestOptions, body=None, **kwargs)
else:
request = construct_request(op,
requestOptions,
body=bodyValue,
**kwargs)
icm.LOG_here("request={request}".format(request=pp.pformat(request)))
c = RequestsClient()
future = c.request(request)
try:
result = future.result()
except Exception as e:
#icm.EH_critical_exception(e)
result = None
if result:
icm.LOG_here("responseHeaders: {headers}".format(
headers=pp.pformat(result._delegate.headers)))
icm.ANN_write("Operation Status: {result}".format(result=result))
icm.ANN_write("Operation Result: {result}".format(
result=pp.pformat(result.json())))
def targetsAccessListGet(interactive=False,
targetFqdn=None,
accessMethod=None,
userName=None,
password=None):
""" Returns a list of path to targetSpecifiers.
If interactive args have been specified, an ephemera targetPathSpecifier
is added to list of path to be returned.
Loaded TARGET_list is appended to returnedList.
"""
try:
icm.callableEntryEnhancer(type='cmnd')
except StopIteration:
return
G = icm.IcmGlobalContext()
icmRunArgs = G.icmRunArgsGet()
#icmParamDict = G.icmParamDictGet()
#thisFunc = icm.FUNC_currentGet()
#cmndThis= thisFunc.__name__
#cmndMandatoryParams=[]
#cmndOptionalParams=[]
cmndPathTargets = []
if interactive == True:
if not len(icmRunArgs.cmndArgs) == 0:
try:
icm.EH_runTime('Bad Number Of cmndArgs')
except RuntimeError:
return
if icmRunArgs.targetFqdn:
targetFqdn = icmRunArgs.targetFqdn
if icmRunArgs.accessMethod:
accessMethod = icmRunArgs.accessMethod
if icmRunArgs.userName:
userName = icmRunArgs.userName
if icmRunArgs.password:
password = icmRunArgs.password
if targetFqdn != None:
ephemeraTargetBase = format("/tmp/ephemera-target/" + targetFqdn)
try:
os.makedirs(ephemeraTargetBase, 0o777)
except OSError:
pass
linuxTarget = TARGET_Proxy_Linux(basePath=ephemeraTargetBase)
linuxTarget.accessParamsSet(
accessMethod=accessMethod,
targetFqdn=targetFqdn,
userName=userName,
password=password,
)
cmndPathTargets.append(ephemeraTargetBase)
# Check For cmndArgs and stdin and Add Them To cmndTargets
for thisCmndArg in icmRunArgs.cmndArgs:
icm.TM_here(thisCmndArg)
cmndPathTargets.append(thisCmndArg)
# NOTYET: Check For TargetParams and Add Them To cmndTargets
tl = TARGET_List()
targetList = tl.targetListGet()
#icm.icm.TM_here(targetList)
for thisTarget in targetList:
targetType = thisTarget.targetType()
if targetType != 'bxp':
icm.EH_problem_usageError(targetType)
continue
dnType = thisTarget.dnType()
#dnQualifier = thisTarget.dnQualifier()
dnBase = thisTarget.base()
if dnType == 'path':
cmndPathTargets.append(dnBase)
else:
icm.EH_problem_usageError(dnType)
# for thisPathTarget in cmndPathTargets:
# print thisPathTarget
return cmndPathTargets
def ro_opInvokeCapture(roOp, ):
####+END:
pp = pprint.PrettyPrinter(indent=4)
#icm.TM_here("svcSpec={svcSpec} -- perfSap={perfSap}".format(svcSpec=roOp.svcSpec, perfSap=roOp.perfSap))
loadedSvcSpec, origin_url = loadSvcSpec(roOp.svcSpec, roOp.perfSap)
if roOp.perfSap:
#origin_url = "http://localhost:8080"
origin_url = roOp.perfSap
#
# NOTYET LOG level changes here
#
#icm.TM_here("{}".format(pp.pformat(loadedSvcSpec)))
opBravadoObj = getOperationWithResourceAndOpName(
loadedSvcSpec,
origin_url,
roOp.resource,
roOp.opName,
)
if not opBravadoObj:
icm.EH_problem_usageError(
"""getOperationWithResourceAndOpName Failed: resource={resource} opName={opName}"""
.format(
resource=roOp.resource,
opName=roOp.opName,
))
return None
requestOptions = dict()
params = roOp.roParams
headerParams = params.headerParams
if headerParams:
requestOptions["headers"] = headerParams
urlParams = params.urlParams
if urlParams == None:
urlParams = dict()
bodyParams = params.bodyParams
icm.TM_here("{}".format(pp.pformat(bodyParams)))
if bodyParams:
#
# With ** we achieve kwargs
#
# func(**{'type':'Event'}) is equivalent to func(type='Event')
#
request = construct_request(opBravadoObj,
requestOptions,
body=bodyParams,
**urlParams)
else:
request = construct_request(opBravadoObj, requestOptions, **urlParams)
icm.LOG_here("request={request}".format(request=pp.pformat(request)))
c = RequestsClient()
#
# This is where the invoke request goes out
#
future = c.request(request)
#
# This where the invoke response comes in
#
opResults = {}
try:
result = future.result()
except Exception as e:
#icm.EH_critical_exception(e)
opResults = None
roResults = ro.Ro_Results(
httpResultCode=500, # type=int
httpResultText="Internal Server Error", # type=str
opResults=opResults,
opResultHeaders=None,
)
if opResults != None:
#
# result
#
# 2018-10-01 -- https://github.com/Yelp/bravado/blob/master/bravado/requests_client.py
# class RequestsResponseAdapter(IncomingResponse):
#
# type(result._delegate.text) = unicode
# type(result._delegate.content) = str
#
opResults = None
if result._delegate.content:
try:
opResults = result.json()
except Exception as e:
icm.EH_critical_exception(e)
opResults = None
roResults = ro.Ro_Results(
httpResultCode=result._delegate.status_code, # type=int
httpResultText=result._delegate.reason, # type=str
opResults=opResults,
opResultHeaders=result._delegate.headers,
)
icm.LOG_here(
"RESPONSE: status_code={status_code} -- reason={reason} -- text={text}"
.format(
status_code=result._delegate.status_code,
reason=result._delegate.reason,
text=result._delegate.text,
))
icm.LOG_here("RESPONSE: responseHeaders: {headers}".format(
headers=pp.pformat(result._delegate.headers)))
roOp.roResults = roResults
return roOp
def cmnd(
self,
interactive=False, # Can also be called non-interactively
rsrc=None, # or Cmnd-Input
passwdPolicy=None, # or Cmnd-Input
argsList=[], # or Args-Input
):
cmndOutcome = self.getOpOutcome()
if interactive:
if not self.cmndLineValidate(outcome=cmndOutcome):
return cmndOutcome
effectiveArgsList = G.icmRunArgsGet().cmndArgs
else:
effectiveArgsList = argsList
callParamsDict = {
'rsrc': rsrc,
'passwdPolicy': passwdPolicy,
}
if not icm.cmndCallParamsValidate(
callParamsDict, interactive, outcome=cmndOutcome):
return cmndOutcome
rsrc = callParamsDict['rsrc']
passwdPolicy = callParamsDict['passwdPolicy']
cmndArgsSpecDict = self.cmndArgsSpec()
if not self.cmndArgsValidate(
effectiveArgsList, cmndArgsSpecDict, outcome=cmndOutcome):
return cmndOutcome
####+END:
opError = icm.OpError.Success
rsrcPath = os.path.normpath(rsrc)
rsrcParts = rsrcPath.split(os.sep)
rsrcBase = rsrcParts[0]
system = rsrcParts[1]
user = rsrcParts[2]
passwd = None
cmndArgs = self.cmndArgsGet("0&1", cmndArgsSpecDict, effectiveArgsList)
for each in cmndArgs:
passwd = each
if not passwd:
if not passwdPolicy:
passwd = "clear"
elif passwdPolicy == "prompt":
# Prompt for password
passwd = getpass.getpass()
else:
return (icm.EH_problem_usageError(
"Bad passwdPolicy={}".passwdPolicy))
cryptoKeyring = CryptoKeyring(
system=system,
user=user,
)
cryptedPasswd = cryptoKeyring.passwdSet(passwd)
if interactive:
print("cryptedPasswd={}".format(cryptedPasswd))
return cmndOutcome.set(
opError=opError,
opResults=cryptedPasswd,
)
