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, )