def __init__(self, account, transactions, args):
self.operation = Operation(**args)
if self.operation.is_account:
AccountAuthorizer(account, args)
if self.operation.is_transaction:
TransactionAuthorizer(account, transactions, args)
def _parse(self, model: Dict[str, Any]) -> bool:
# Store process_id: service_name
process_ids = {}
# Store span_id: span
span_ids = {}
traces = model['data']
for trace in traces:
# Identify all services (processes)
for process_id, process in trace['processes'].items():
service_name = process['serviceName']
self._services[service_name] = Service(service_name)
process_ids[process_id] = service_name
# Add operations to the corresponding services.
for span in trace['spans']:
span_ids[span['spanID']] = span
operation_name = span['operationName']
pid = span['processID']
# Unknown process
if pid not in process_ids:
return False
service_name = process_ids[pid]
operation = Operation(operation_name)
self._services[service_name].add_operation(operation)
# Add dependencies
for span in trace['spans']:
for reference in span['references']:
if reference['refType'] == 'CHILD_OF':
# Callee
pid = span['processID']
service_name = process_ids[pid]
operation_name = span['operationName']
operation = self._services[service_name].operations[
operation_name]
# Caller
parent_id = reference['spanID']
parent_span = span_ids[parent_id]
parent_pid = parent_span['processID']
parent_service_name = process_ids[parent_pid]
parent_operation_name = parent_span['operationName']
parent_operation = self._services[
parent_service_name].operations[
parent_operation_name]
parent_operation.add_dependency(operation)
return True
def create_request(self, operation, requestor, timeseries, missing_values,
data_range_from, data_range_to):
operation_found = Operation.get_operation(operation)
analytics = RequestAnalytics(user_id=requestor,
operation_id=operation_found.id,
timeseries=timeseries,
missing_values=missing_values,
data_range_from=data_range_from,
data_range_to=data_range_to,
status='Accepted')
analytics.save()
return analytics.id
def _parse(self, model: Dict[str, Any]) -> bool:
try:
microservices = model['microservices'] or []
# Iterate over all services.
for ms in microservices:
ms_name = ms['name']
ms_operations = ms['operations'] or []
service = Service(ms_name)
# Iterate over all operations.
for ms_operation in ms_operations:
ms_operation_name = ms_operation['name']
operation = Operation(ms_operation_name)
service.add_operation(operation)
self._services[service.name] = service
# Assign all dependencies
for ms in microservices:
ms_name = ms['name']
ms_operations = ms['operations'] or []
for ms_operation in ms_operations:
ms_operation_name = ms_operation['name']
ms_operation_dependencies = ms_operation[
'dependencies'] or []
for dependency in ms_operation_dependencies:
dependency_service = dependency['service']
dependency_operation = dependency['operation']
try:
operation = self._services[
dependency_service].operations[
dependency_operation]
self._services[ms_name].operations[
ms_operation_name].add_dependency(operation)
except KeyError:
raise UnknownOperation(dependency_service,
dependency_operation)
return True
except WrongFormatException as e:
print(e)
return False
except UnknownOperation as e:
print(e)
return False
def add_operation(managed_asset: asset.Asset,
asset_operation: operation.Operation):
"""Adds a new operation to the asset and updates position.
Args:
managed_asset: Asset for which operation happened.
asset_operation: Operation was made.
Raises:
ValueError: operation already added to position.
"""
asset_operations = get_operations(managed_asset)
if asset_operation in asset_operations.values():
raise ValueError(
f'{asset_operation} already exists in {managed_asset}.')
asset_operations[asset_operation.get_id()] = asset_operation
def delete_operation(managed_asset: asset.Asset,
asset_operation: operation.Operation):
"""Removes an existing operation from the asset and updates position.
Args:
managed_asset: Asset for which operation is undone.
asset_operation: Operation was undone.
Raises:
ValueError: operation does not exist for given asset and portfolio.
"""
asset_operations = get_operations(managed_asset)
if asset_operation not in asset_operations.values():
raise ValueError(
f'{asset_operation} does not exist for {managed_asset}.')
operation_id = asset_operation.get_id()
del asset_operations[operation_id]
def Operation(self, price, description):
return Operation(price, description)
def _parse(self, model: List[Dict[str, Any]]) -> bool:
# Store ip: service_name
service_ips = {}
# Store span_id: span
span_ids = {}
# Store all services with their respective endpoint ip's
for span in model:
span_ids[span['id']] = span
local = span['localEndpoint'] if 'localEndpoint' in span else {}
remote = span['remoteEndpoint'] if 'remoteEndpoint' in span else {}
source_name = local['serviceName'] if 'serviceName' in local else ''
target_name = remote[
'serviceName'] if 'serviceName' in remote else ''
if source_name:
if source_name not in self._services:
source = Service(source_name)
self._services[source_name] = source
service_ips[local['ipv4']] = source_name
if target_name:
if target_name not in self._services:
source = Service(target_name)
self._services[target_name] = source
service_ips[remote['ipv4']] = target_name
# Add operations
for span in model:
local = span['localEndpoint'] if 'localEndpoint' in span else {}
if local['ipv4'] in service_ips:
service = service_ips[local['ipv4']]
elif 'serviceName' in local and local[
'serviceName'] in self._services:
service = local['serviceName']
# Unknown service
else:
return False
self._services[service].add_operation(Operation(span['name']))
# Add dependencies
for span in model:
if 'parentId' in span:
# Callee
service_name = span['localEndpoint']['serviceName']
operation_name = span['name']
operation = self._services[service_name].operations[
operation_name]
# Caller
parent_id = span['parentId']
parent_span = span_ids[parent_id]
local = parent_span['localEndpoint']
parent_service_name = service_ips[local['ipv4']]
parent_operation_name = parent_span['name']
parent_operation = self._services[
parent_service_name].operations[parent_operation_name]
parent_operation.add_dependency(operation)
return True
def remove_operation(self, operation: Operation):
del self._operations[operation.name]
operation.service = None
def add_operation(self, operation: Operation):
self._operations[operation.name] = operation
operation.service = self