def __init__(self,
metadata: dict = {},
transaction: Transaction = None,
**kwargs):
self.func_name = None
self.is_with_statement = False
if transaction:
self.transaction = transaction
else:
self.transaction = Transaction(metadata)
if config.get_global('SET_LOGGING', True):
set_logger(transaction=self.transaction)
self.locator = Locator(self.transaction)
self.handler = {
'authentication': {
'handlers': [],
'methods': []
},
'authorization': {
'handlers': [],
'methods': []
},
'mutation': {
'handlers': [],
'methods': []
},
'event': {
'handlers': [],
'methods': []
},
}
def __init__(self, single_task: dict):
self.locator = single_task['locator']
self.name = single_task['name']
self.metadata = single_task['metadata']
self.method = single_task['method']
self.params = single_task['params']
transaction = Transaction(meta=self.metadata)
self._locator = Locator(transaction)
def __init__(self, transaction: Transaction = None):
if transaction:
self.transaction = transaction
else:
self.transaction = Transaction()
self.locator = Locator(self.transaction)
def __init__(self, queue, interval):
super().__init__(queue, interval)
self.count = self._init_count()
self.locator = Locator()
self.TOKEN = self._update_token()
self.domain_id = _get_domain_id_from_token(self.TOKEN)
self.schedule_info = {}
self.idx = 0
def __init__(self,
experimental_non_blocking=True,
experimental_thread_pool=None):
super().__init__(experimental_non_blocking, experimental_thread_pool)
locator = Locator()
self.actuator = locator.get_actuator('Health')
self.actuator.add_health_update(self)
self.actuator.check()
def __init__(
self,
interval=1,
):
self.config = self.parse_config(interval)
self.count = self._init_count()
self.locator = Locator()
self.TOKEN = self._update_token()
self.domain_id = _get_domain_id_from_token(self.TOKEN)
def __init__(self, transaction=None, **kwargs):
if transaction:
self.transaction = transaction
else:
self.transaction = Transaction()
self.locator = Locator(self.transaction)
for k, v in kwargs.items():
setattr(self, k, v)
async def webhook(webhook_id: str, access_key: str, request: Request):
locator = Locator()
data = await request.json()
event_service = locator.get_service('EventService')
event_service.create({
'webhook_id': webhook_id,
'access_key': access_key,
'data': data or {}
})
return {}
def __init__(self, *args, **kwargs):
self.transaction = Transaction()
self.locator = Locator(self.transaction)
if hasattr(current_app.conf, "spaceone_scheduler_service"):
self.service_name = current_app.conf.get("spaceone_scheduler_service")
else:
raise SpaceOneSchedulerError("can not find CELERY.spaceone_scheduler_service config")
self.Service = self.locator.get_service(self.service_name, metadata=self.metadata)
self._schedule = {}
self._last_updated = None
Scheduler.__init__(self, *args, **kwargs)
self.max_interval = (kwargs.get('max_interval')
or self.app.conf.CELERYBEAT_MAX_LOOP_INTERVAL or 5)
def __init__(self, metadata={}, transaction=None):
self.func_name = None
self.is_with_statement = False
if transaction:
self.transaction = transaction
else:
self.transaction = Transaction(metadata)
set_logger(transaction=self.transaction)
self.locator = Locator(self.transaction)
self.handler = {
'authentication': {'handlers': [], 'methods': []},
'authorization': {'handlers': [], 'methods': []},
'event': {'handlers': [], 'methods': []},
}
async def create_event(webhook_id: str, access_key: str, request: Request):
locator = Locator()
try:
try:
data = await request.json()
except Exception as e:
_LOGGER.debug(f'JSON Parsing Error: {e}')
raise ERROR_UNKNOWN(message='JSON Parsing Error: Request body requires JSON format.')
event_service: EventService = locator.get_service('EventService')
event_service.create({
'webhook_id': webhook_id,
'access_key': access_key,
'data': data or {}
})
return {}
except ERROR_BASE as e:
raise HTTPException(status_code=500, detail=e.message)
except Exception as e:
raise HTTPException(status_code=500, detail=f'Unknown Error: {str(e)}')
def _change_secret_id_filter(condition):
value = condition.get('v') or condition.get('value')
operator = condition.get('o') or condition.get('operator')
map_query = {'filter': [{'k': 'secret_id', 'v': value, 'o': operator}]}
locator = Locator()
secret_group_map_model = locator.get_model('SecretGroupMap')
map_vos, total_count = secret_group_map_model.query(**map_query)
return {
'k':
'secret_group_id',
'v':
list(
map(lambda map_vo: map_vo.secret_group.secret_group_id,
map_vos)),
'o':
'in'
}
def _update_alert_state(alert_id, access_key, state):
locator = Locator()
try:
alert_service: AlertService = locator.get_service('AlertService')
alert_vo: Alert = alert_service.update_state({
'alert_id': alert_id,
'access_key': access_key,
'state': state
})
return {
'alert_number': alert_vo.alert_number,
'alert_id': alert_vo.alert_id,
'title': alert_vo.title,
'state': alert_vo.state,
'assignee': alert_vo.assignee,
'urgency': alert_vo.urgency
}
except ERROR_BASE as e:
raise HTTPException(status_code=500, detail=e.message)
except Exception as e:
raise HTTPException(status_code=500, detail=f'Unknown Error: {str(e)}')
def __init__(self, *args, **kwargs):
transaction = Transaction()
self.locator = Locator(transaction)
def __init__(self):
locator = Locator()
self.actuator = locator.get_actuator('ServerInfo')
def __init__(self, queue, **kwargs):
BaseWorker.__init__(self, queue, **kwargs)
self.locator = Locator()
def __init__(self, queue, interval, minute=':00'):
super().__init__(queue, interval, minute)
self.count = self._init_count()
self.locator = Locator()
self.TOKEN = self._update_token()
self.domain_id = _get_domain_id_from_token(self.TOKEN)
def __init__(self, queue, interval):
super().__init__(queue, interval)
self.locator = Locator()
self._init_config()
self._create_metadata()
with open(config_path, 'r') as f:
_set_file_config(f)
def print_schedules(schedules: List[SpaceoneTaskData]):
print(f"id | schedule | total_run_count | last_run")
for sch in schedules:
print(
f"{sch.schedule_id} | {sch.schedule_info} | {sch.total_run_count} | {sch.last_run_at}"
)
print('\n\n')
if __name__ == '__main__':
config_server()
locator = Locator()
svc = locator.get_service('ScheduleService')
print('list all schedules')
print_schedules(svc.list())
print('add schedule')
sch_name = f"test_sche_{randint(1, 1000)}"
svc.add({
'domain_id': "sample",
'enabled': True,
'task': 'spaceone.core.celery.tasks.test_task',
'name': sch_name,
'interval': {
'period': 'seconds',
'every': randint(6, 12)
},
class BaseAPI(object):
locator = Locator()
def __init__(self):
self._check_variables()
self._set_grpc_method()
@property
def name(self):
return self.__class__.__name__
@property
def pb2_grpc_module(self):
return self.pb2_grpc
@property
def service_name(self):
return self.pb2.DESCRIPTOR.services_by_name[
self.__class__.__name__].full_name
def _check_variables(self):
if not hasattr(self, 'pb2'):
raise Exception(
f'gRPC Servicer has not set <pb2> variable. (servicer={self.__class__.__name__})'
)
if not hasattr(self, 'pb2_grpc'):
raise Exception(
f'gRPC Servicer has not set <pb2_grpc> variable. (servicer={self.__class__.__name__})'
)
def _get_grpc_servicer(self):
grpc_servicer = None
for base_class in self.__class__.__bases__:
if base_class.__module__ == self.pb2_grpc.__name__:
grpc_servicer = base_class
if grpc_servicer is None:
raise Exception(
f'gRPC servicer is not set. (servicer={self.__class__.__name__})'
)
return grpc_servicer
def _set_grpc_method(self):
grpc_servicer = self._get_grpc_servicer()
for f_name, f_object in inspect.getmembers(
self.__class__, predicate=inspect.isfunction):
if hasattr(grpc_servicer, f_name):
setattr(self, f_name,
self._grpc_method(f_object, config.get_service()))
@staticmethod
def get_minimal(params):
return params.get('query', {}).get('minimal', False)
@staticmethod
def _error_method(error, context):
is_logging = False
if not isinstance(error, ERROR_BASE):
error = ERROR_UNKNOWN(message=error)
is_logging = True
elif error.meta.get('type') == 'service':
is_logging = True
if is_logging:
_LOGGER.error(f'(Error) => {error.message} {error}',
extra={
'error_code': error.error_code,
'error_message': error.message,
'traceback': traceback.format_exc()
})
details = f'{error.error_code}: {error.message}'
context.abort(grpc.StatusCode[error.status_code], details)
def _generate_response(self, response_iterator, context):
try:
for response in response_iterator:
yield response
except Exception as e:
self._error_method(e, context)
def _grpc_method(self, func, service_name):
def wrapper(request_or_iterator, context):
try:
context.api_info = {
'service': service_name,
'resource': self.__class__.__name__,
'verb': func.__name__
}
response_or_iterator = func(self, request_or_iterator, context)
if isinstance(response_or_iterator, types.GeneratorType):
return self._generate_response(response_or_iterator,
context)
else:
return response_or_iterator
except Exception as e:
self._error_method(e, context)
return wrapper
@staticmethod
def _convert_message(request):
return MessageToDict(request, preserving_proto_field_name=True)
@staticmethod
def _get_metadata(context):
metadata = {}
for key, value in context.invocation_metadata():
metadata[key.strip()] = value.strip()
metadata.update(context.api_info)
# TODO: This is experimental log. Please confirm peer information is useful on k8s.
metadata.update({'peer': context.peer()})
return metadata
def _generate_message(self, request_iterator):
for request in request_iterator:
yield self._convert_message(request)
def parse_request(self, request_or_iterator, context):
if isinstance(request_or_iterator, collections.Iterable):
return self._generate_message(
request_or_iterator), self._get_metadata(context)
else:
return self._convert_message(
request_or_iterator), self._get_metadata(context)