def addResource(apiInstance, appInstance, baseModel=None, echo=False): apiInstance.repository = SqlAlchemyProxy(baseModel, apiInstance.globals, echo=echo) if ObjectHelper.isNotNone(apiInstance.repository): log.success(addResource, 'SqlAlchemyProxy database connection created') return apiInstance.repository
def mustLogWithoutColors(): # Arrange noExceptionThrown = 'exception not thrown' someLogMessage = 'some log message' someExceptionMessage = 'some exception message' someInnerExceptionMessage = 'some inner exception message' exception = None someExceptionMessageWithStackTrace = f'{someExceptionMessage} with stacktrace' someExceptionMessageWithoutStackTrace = f'{someExceptionMessage} without stacktrace' def controlableException(logType, muteStackTrace=False): try: raise Exception( someExceptionMessageWithoutStackTrace if muteStackTrace else someExceptionMessageWithStackTrace) except Exception as exception: if logType in OPTIONAL_EXCEPTION_LOG_TYPES: logType(logType, someLogMessage, exception=exception, muteStackTrace=muteStackTrace) else: logType(logType, someLogMessage, exception, muteStackTrace=muteStackTrace) # Act log.success(log.success, someLogMessage) log.setting(log.setting, someLogMessage) log.debug(log.debug, someLogMessage) log.warning(log.warning, someLogMessage) controlableException(log.log) controlableException(log.debug) controlableException(log.warning) controlableException(log.wraper) controlableException(log.failure) controlableException(log.error) controlableException(log.test) controlableException(log.log, muteStackTrace=True) controlableException(log.debug, muteStackTrace=True) controlableException(log.warning, muteStackTrace=True) controlableException(log.wraper, muteStackTrace=True) controlableException(log.failure, muteStackTrace=True) controlableException(log.error, muteStackTrace=True) controlableException(log.test, muteStackTrace=True) log.log(log.log, someLogMessage, None) log.debug(log.debug, someLogMessage, None) log.warning(log.warning, someLogMessage, None) log.wraper(log.wraper, noExceptionThrown, None) log.failure(log.failure, noExceptionThrown, None) log.error(log.error, noExceptionThrown, None) log.test(log.test, someLogMessage, None) # Assert assert 'my environment' == EnvironmentHelper.get( SettingHelper.ACTIVE_ENVIRONMENT)
def shutdown(apiInstance, appInstance): try: apiInstance.repository.close() except Exception as exception: log.failure( shutdown, 'Not possible to close SqlAlchemyProxy database connection', exception) log.success(shutdown, 'SqlAlchemyProxy database connection successfully closed')
def runApi(*args, api=None, **kwargs): if ObjectHelper.isNone(api): api = getApi() muteLogs(api.app) if 'host' not in kwargs and api.host: kwargs['host'] = api.host if 'port' not in kwargs and api.port: kwargs['port'] = api.port apiUrl = getApiUrl(api) log.success(runApi, f'Api will run at {apiUrl}') log.success(runApi, f'Documentation will be available at {apiUrl}/swagger') api.app.run(*args, **kwargs)
def initialize(apiInstance, appInstance): @apiInstance.securityManager.token_in_blacklist_loader def verifyAuthorizaionAccess(decriptedToken): return decriptedToken[JwtConstant.KW_JTI] in BLACK_LIST @apiInstance.securityManager.revoked_token_loader def invalidAccess(): log.log(initialize, 'Access revoked', exception=None) return {'message': 'Unauthorized'}, HttpStatus.UNAUTHORIZED if ObjectHelper.isNotNone(apiInstance.securityManager): log.success(initialize, 'SecurityManager is running')
def handleSystemArgumentValue(self, commandList, externalFunction): globals = self.globals try: if self.apiClassSet: apiClass = self.apiClassSet.get(commandList[self._0_API_KEY]) if apiClass and apiClass in [self.__class__, GitCommitter]: log.success(self.__class__, f'running {commandList} command list') return self.handleCommandList(commandList) elif apiClass: globals.overrideApiTree(apiClass.__name__, package=apiClass.__name__) api = apiClass(*self.args, **self.kwargs) log.success( self.__class__, f'running {apiClass.__name__}({self.args}, {self.kwargs})' ) return api.handleCommandList(commandList) else: log.failure( self.__class__, f'''couldn't instance api class of {commandList[self._0_API_KEY]}''', c.NOTHING) else: log.debug( self.__class__, f'{commandList[self._0_API_KEY]} key called and running all alone' ) return externalFunction(commandList, globals, **self.kwargs) except Exception as exception: errorMessage = str(exception) if self.MISSING_REQUIRED_ARGUMENT in errorMessage: newArgs = *self.args, self.globals try: api = apiClass(*newArgs, **self.kwargs) log.success( self.__class__, f'running {apiClass.__name__}({self.args}, {self.kwargs})' ) return api.handleCommandList(commandList) except Exception as exception: secondErrorMessage = f', after first try: {str(exception)}' newArgs = *self.args, self.session, self.globals try: api = apiClass(*newArgs, **self.kwargs) log.success( self.__class__, f'running {apiClass.__name__}({self.args}, {self.kwargs})' ) return api.handleCommandList(commandList) except Exception as exception: thirdErrorMessage = f', after second try: {str(exception)}' else: secondErrorMessage = '' thirdErrorMessage = '' globals.error( self.__class__, f'error processing "{commandList[self._0_API_KEY]}" call{secondErrorMessage}{thirdErrorMessage}', errorMessage)
def addResource(apiInstance, appInstance) : scheduler = APScheduler() globals = apiInstance.globals scheduler.api_enabled = globals.getApiSetting(ConfigurationKeyConstant.API_SCHEDULER_ENABLE) is True scheduler.timezone = ConverterStatic.getValueOrDefault( globals.getApiSetting(ConfigurationKeyConstant.API_SCHEDULER_TIMEZONE), SchedulerConstant.DEFAULT_TIMEZONE ) ###- guess scheduler.zone = scheduler.timezone ###- guess appInstance.config[SchedulerConstant.KW_SCHEDULER_API_ENABLED] = scheduler.api_enabled appInstance.config[SchedulerConstant.KW_SCHEDULER_TIMEZONE] = scheduler.timezone apiInstance.schedulerManager = scheduler if ObjectHelper.isNotNone(apiInstance.schedulerManager): log.success(addResource, f'APScheduler schedulers created{"" if apiInstance.schedulerManager.api_enabled else ". But are disabled"}') return scheduler
def addResource(apiInstance, appInstance): apiInstance.sessionManager = None try: apiInstance.sessionManager = getJwtMannager( appInstance, apiInstance.globals.getApiSetting( ConfigurationKeyConstant.API_SESSION_SECRET), algorithm=apiInstance.globals.getApiSetting( ConfigurationKeyConstant.API_SESSION_ALGORITHM), headerName=apiInstance.globals.getApiSetting( ConfigurationKeyConstant.API_SESSION_HEADER), headerType=apiInstance.globals.getApiSetting( ConfigurationKeyConstant.API_SESSION_TYPE)) apiInstance.sessionManager.api = apiInstance except Exception as exception: log.warning(addResource, 'Not possible to add SessionManager', exception=exception) if ObjectHelper.isNotNone(apiInstance.sessionManager): log.success(initialize, 'SessionManager created') return apiInstance.sessionManager
def runApi(*args, api=None, **kwargs): if ObjectHelper.isNone(api): api = FlaskUtil.getApi() muteLogs(api) if 'host' not in kwargs and api.host: kwargs['host'] = api.host if not 'localhost' == api.host else '0.0.0.0' if 'port' not in kwargs and api.port: kwargs['port'] = api.port apiUrl = getApiUrl(api) documentationUrl = OpenApiManager.getDocumentationUrl(api) healthCheckUrl = f'{documentationUrl[:-len(OpenApiManager.DOCUMENTATION_ENDPOINT)]}{HealthCheckConstant.URI}' log.success(runApi, f'Api will run at {apiUrl}') log.success(runApi, f'Health check will be available at {healthCheckUrl}') log.success(runApi, f'Documentation will be available at {documentationUrl}') api.app.run(*args, **kwargs) SessionManager.onShutdown(api, api.app) ApiKeyManager.onShutdown(api, api.app) SecurityManager.onShutdown(api, api.app) SchedulerManager.onShutdown(api, api.app) SqlAlchemyProxy.onShutdown(api, api.app) log.success(runApi, f'{api.globals.apiName} successfully shutdown')
def success(self, message): if c.TRUE == self.successStatus: log.success(self.__class__, message)
def shutdown(apiInstance, appInstance): try: apiInstance.schedulerManager.shutdown(wait=False) except Exception as exception: log.failure(shutdown, 'Not possible to close APScheduler schedulers', exception) log.success(shutdown, 'APScheduler schedulers successfully closed')
def initialize(apiInstance, appInstance) : apiInstance.schedulerManager.init_app(appInstance) apiInstance.schedulerManager.start() log.success(initialize, f'APScheduler schedulers initialized{"" if apiInstance.schedulerManager.api_enabled else ". But are disabled"}')
def shutdown(apiInstance, appInstance): log.success(shutdown, 'SessionManager successfully closed')
def initialize(apiInstance, appInstance): if ObjectHelper.isNotNone(apiInstance.sessionManager): log.success(initialize, 'SessionManager is running')
def initialize(apiInstance, appInstance): apiInstance.repository.run() log.success(initialize, 'SqlAlchemyProxy database is running')