def run() -> None: """Update path and run the App.""" # update the path to ensure the App has access to required modules app_lib = AppLib() app_lib.update_path() # import modules after path has been updated # third-party from app import App # pylint: disable=import-outside-toplevel from tcex import TcEx # pylint: disable=import-outside-toplevel tcex = TcEx() try: # load App class app = App(tcex) # perform prep/setup operations app.setup(**{}) # run the App logic app.run(**{}) # perform cleanup/teardown operations app.teardown(**{}) # explicitly call the exit method tcex.exit(msg=app.exit_message) except Exception as e: main_err = f'Generic Error. See logs for more details ({e}).' tcex.log.error(traceback.format_exc()) tcex.playbook.exit(1, main_err)
def run() -> None: """Update path and run the App.""" # update the path to ensure the App has access to required modules app_lib = AppLib() app_lib.update_path() # import modules after path has been updated # third-party from tcex import TcEx # pylint: disable=import-outside-toplevel # first-party from app import App # pylint: disable=import-outside-toplevel tcex = TcEx() try: # load App class app = App(tcex) # perform prep/setup operations app.setup(**{}) # run the App logic if hasattr(app.args, 'tc_action') and app.args.tc_action is not None: # if the args NameSpace has the reserved arg of "tc_action", this arg value is used to # triggers a call to the app.<tc_action>() method. an exact match to the method is # tried first, followed by a normalization of the tc_action value, and finally an # attempt is made to find the reserved "tc_action_map" property to map value to method. tc_action: str = app.args.tc_action tc_action_formatted: str = tc_action.lower().replace(' ', '_') tc_action_map = 'tc_action_map' # reserved property name for action to method map # run action method if hasattr(app, tc_action): getattr(app, tc_action)() elif hasattr(app, tc_action_formatted): getattr(app, tc_action_formatted)() elif hasattr(app, tc_action_map): app.tc_action_map.get(app.args.tc_action)() # pylint: disable=no-member else: tcex.exit( 1, f'Action method ({app.args.tc_action}) was not found.') else: # default to run method app.run(**{}) # write requested value for downstream Apps app.write_output() # pylint: disable=no-member # perform cleanup/teardown operations app.teardown(**{}) # explicitly call the exit method tcex.playbook.exit(msg=app.exit_message) except Exception as e: main_err = f'Generic Error. See logs for more details ({e}).' tcex.log.error(traceback.format_exc()) tcex.playbook.exit(1, main_err)
def run(**kwargs) -> None: """Update path and run the App.""" # update the path to ensure the App has access to required modules app_lib = AppLib() app_lib.update_path() # import modules after path has been updated # third-party from tcex import TcEx # pylint: disable=import-outside-toplevel # first-party from app import App # pylint: disable=import-outside-toplevel tcex = TcEx() try: # load App class app = App(tcex) # set app property in testing framework if callable(kwargs.get('set_app')): kwargs.get('set_app')(app) # perform prep/setup operations app.setup() # configure custom trigger message handler tcex.service.api_event_callback = app.api_event_callback # listen on channel/topic tcex.service.listen() # start heartbeat threads tcex.service.heartbeat() # inform TC that micro-service is Ready tcex.service.ready = True # loop until exit tcex.log.info('feature=app, event=loop-forever') while tcex.service.loop_forever(sleep=1): pass # perform cleanup/teardown operations app.teardown() # explicitly call the exit method tcex.exit(msg=app.exit_message) except Exception as e: main_err = f'Generic Error. See logs for more details ({e}).' tcex.log.error(traceback.format_exc()) tcex.exit(1, main_err)
def run() -> None: """Update path and run the App.""" # update the path to ensure the App has access to required modules app_lib = AppLib() app_lib.update_path() # import modules after path has been updated # third-party from tcex import TcEx # pylint: disable=import-outside-toplevel # first-party from app import App # pylint: disable=import-outside-toplevel config_file = 'app_config.json' if not os.path.isfile(config_file): print(f'Missing {config_file} config file.') tcex = TcEx(config_file=config_file) try: # load App class app = App(tcex) # perform prep/setup operations app.setup() # run the App logic app.run() # pylint: disable=no-member # perform cleanup/teardown operations app.teardown() # explicitly call the exit method tcex.exit(msg=app.exit_message) except Exception as e: main_err = f'Generic Error. See logs for more details ({e}).' tcex.log.error(traceback.format_exc()) tcex.exit(1, main_err)
# update the path to ensure the App has access to required modules _update_app_path() # import modules after path has been updated from tcex import TcEx from app import App tcex = TcEx() try: # load App class app = App(tcex) # perform prep/setup operations app.setup() # run the App logic app.run() # perform cleanup/teardown operations app.teardown() # explicitly call the exit method tcex.exit(msg=app.exit_message) except Exception as e: main_err = f'Generic Error. See logs for more details ({e}).' tcex.log.error(traceback.format_exc()) tcex.playbook.exit(1, main_err)
# tried first, followed by a normalization of the tc_action value, and finally an # attempt is made to find the reserved "tc_action_map" property to map value to method. tc_action = app.args.tc_action tc_action_formatted = tc_action.lower().replace(' ', '_') tc_action_map = 'tc_action_map' # reserved property name for action to method map try: # run action method if hasattr(app, tc_action): getattr(app, tc_action)() elif hasattr(app, tc_action_formatted): getattr(app, tc_action_formatted)() elif hasattr(app, tc_action_map): app.tc_action_map.get(app.args.tc_action)() except AttributeError: tcex.exit( 1, 'Action method ({}) was not found.'.format( app.args.tc_action)) else: # default to run method app.run() # write requested value for downstream Apps tcex.playbook.write_output() app.write_output() # pylint: disable=E1101 # perform cleanup operations app.done() # explicitly call the exit method tcex.playbook.exit(msg=app.exit_message)
tcex.playbook.create_output('json', blob.json) tcex.playbook.create_output( 'nGrams', [str(n_gram) for n_gram in blob.ngrams(n=n_gram_number)]) tcex.playbook.create_output('nounPhrases', blob.noun_phrases) tcex.playbook.create_output('npCounts', blob.np_counts[1]) tcex.playbook.create_output('polarity', blob.polarity) tcex.playbook.create_output('sentences', [str(sentence) for sentence in blob.sentences]) tcex.playbook.create_output('subjectivity', blob.subjectivity) tcex.playbook.create_output('tags', tags) tcex.playbook.create_output('tokens', blob.tokens) tcex.playbook.create_output('wordCounts', blob.word_counts[1]) tcex.playbook.create_output('words', blob.words) tcex.exit(0) if __name__ == "__main__": tcex = TcEx() try: # start the app main() except SystemExit: pass except Exception as e: # if there are any strange errors, log it to the logging in the UI err = 'Generic Error. See logs for more details ({}).'.format(e) tcex.log.error(traceback.format_exc()) tcex.message_tc(err) tcex.exit(1)
# if the args NameSpace has the reserved arg of "tc_action", this arg value is used to # triggers a call to the app.<tc_action>() method. an exact match to the method is # tried first, followed by a normalization of the tc_action value, and finally an # attempt is made to find the reserved "tc_action_map" property to map value to method. tc_action = app.args.tc_action tc_action_formatted = tc_action.lower().replace(' ', '_') tc_action_map = 'tc_action_map' # reserved property name for action to method map # run action method if hasattr(app, tc_action): getattr(app, tc_action)() elif hasattr(app, tc_action_formatted): getattr(app, tc_action_formatted)() elif hasattr(app, tc_action_map): app.tc_action_map.get(app.args.tc_action)() # pylint: disable=no-member else: tcex.exit(1, f'Action method ({app.args.tc_action}) was not found.') else: # default to run method app.run() # write requested value for downstream Apps tcex.playbook.write_output() app.write_output() # pylint: disable=no-member # perform cleanup/teardown operations app.teardown() # explicitly call the exit method tcex.playbook.exit(msg=app.exit_message) except Exception as e:
self.my_output.append(self.my_choice) self.my_output.extend(self.my_multi) self.my_output.append(str(self.my_boolean)) self.my_output.append(self.my_hidden) def write_output(self): """Write the Playbook output variables.""" tcex.log.info('writing output') tcex.playbook.create_output('mypbapp.output.0', self.my_output[0]) tcex.playbook.create_output('mypbapp.output', self.my_output) if __name__ == '__main__': try: app = MyApp(args) tcex.log.info('my_input: {}'.format(app.my_input)) # do something app.do_the_thing() # write requested value for downstream Apps app.write_output() # write message and gracefully exit the App tcex.exit(0, 'Success.') except Exception as e: main_err = 'Generic Error. See logs for more details ({}).'.format(e) tcex.log.error(traceback.format_exc()) tcex.playbook.exit(1, main_err)
app = App(tcex) # parse args app.parse_args() # perform prep/startup operations app.start() # run the App logic if hasattr(app.args, 'tc_action') and app.args.tc_action is not None: try: # run action method getattr(app, app.args.tc_action)() except AttributeError: tcex.exit( 1, 'Action method ({}) was not found.'.format( app.args.tc_action)) else: # default to run method app.run() # perform cleanup operations app.done() # explicitly call the exit method tcex.exit(msg=app.exit_message) except Exception as e: main_err = 'Generic Error. See logs for more details ({}).'.format(e) tcex.log.error(traceback.format_exc()) tcex.playbook.exit(1, main_err)
self.my_output.append(self.args.password) self.my_output.append(self.args.my_choice) self.my_output.extend(self.args.my_multi) self.my_output.append(str(self.args.my_boolean)) self.my_output.append(self.args.my_hidden) if __name__ == '__main__': try: # get app init timestamp for last_run last_run = time.time() # get MyApp instance app = MyApp(args) tcex.log.info('username: {}'.format(args.username)) # do something app.do_the_thing() # store persistent value tcex.results_tc('last_run', last_run) # write message and gracefully exit the App tcex.exit(0, 'Success.') except Exception as e: tcex.results_tc('last_run', args.last_run) main_err = 'Generic Error. See logs for more details ({}).'.format(e) tcex.log.error(traceback.format_exc()) tcex.exit(1, main_err)