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