def _set_scenario_result(
scenario_id: str,
output: Any,
exception: Any,
logs: str,
time_taken: float,
succeeded: int,
failed: int,
address: str = DEFAULT_BACKEND_ADDRESS,
):
with grpc.insecure_channel(address,
compression=grpc.Compression.Gzip) as channel:
stub = backend_pb2_grpc.BackendStub(channel)
request = backend_pb2.SetScenarioResultRequest(
scenarioID=scenario_id,
output=wrappers_pb2.StringValue(value=json.dumps(output)),
exception=wrappers_pb2.StringValue(value=json.dumps(
str(exception) if exception is not None else None)),
logs=logs,
timeTaken=time_taken,
succeeded=succeeded,
failed=failed,
)
stub.SetScenarioResult(request)
def _get_metric_statistics(
scenario_id: str,
name: str,
address: str = DEFAULT_BACKEND_ADDRESS,
) -> Optional[dict]:
with grpc.insecure_channel(address,
compression=grpc.Compression.Gzip) as channel:
try:
stub = backend_pb2_grpc.BackendStub(channel)
request = backend_pb2.GetMetricRequest(
scenarioID=scenario_id,
name=name,
)
response = stub.GetMetricStatistics(request)
# FEATURE: type for metric statistics
return {
"min": response.min,
"max": response.max,
"median": response.median,
"average": response.average,
"len": response.len,
}
except grpc.RpcError as err:
if err.code() == grpc.StatusCode.NOT_FOUND:
return None
else:
raise err
def _move_scenario_result(
scenario_id: str,
address: str = DEFAULT_BACKEND_ADDRESS) -> Optional[dict]:
with grpc.insecure_channel(address,
compression=grpc.Compression.Gzip) as channel:
try:
stub = backend_pb2_grpc.BackendStub(channel)
request = backend_pb2.MoveScenarioResultRequest(
scenarioID=scenario_id, )
response = stub.MoveScenarioResult(request)
return {
"id": response.id,
"output": json.loads(response.output.value),
"exception": json.loads(response.exception.value),
"logs": response.logs,
"timestamp": response.timestamp,
"time_taken": response.timeTaken,
"succeeded": response.succeeded,
"failed": response.failed,
}
except grpc.RpcError as err:
if err.code() == grpc.StatusCode.NOT_FOUND:
return None
else:
raise err
def _clean_test_instances(test_id: str,
address: str = DEFAULT_BACKEND_ADDRESS):
with grpc.insecure_channel(address,
compression=grpc.Compression.Gzip) as channel:
stub = backend_pb2_grpc.BackendStub(channel)
request = backend_pb2.CleanTestInstancesRequest(testID=test_id)
stub.CleanTestInstances(request)
def _get_user_work(user_manager_id: str,
address: str = DEFAULT_BACKEND_ADDRESS) -> int:
with grpc.insecure_channel(address,
compression=grpc.Compression.Gzip) as channel:
stub = backend_pb2_grpc.BackendStub(channel)
request = backend_pb2.GetUserWorkRequest(userManagerID=user_manager_id)
response = stub.GetUserWork(request)
return response.work
def _distribute_work(scenario_id: str,
amount: int,
address: str = DEFAULT_BACKEND_ADDRESS):
with grpc.insecure_channel(address,
compression=grpc.Compression.Gzip) as channel:
stub = backend_pb2_grpc.BackendStub(channel)
request = backend_pb2.DistributeWorkRequest(scenarioID=scenario_id,
amount=amount)
stub.DistributeWork(request)
def _stop_users(
scenario_id: str,
amount: int,
address: str = DEFAULT_BACKEND_ADDRESS,
):
with grpc.insecure_channel(address,
compression=grpc.Compression.Gzip) as channel:
stub = backend_pb2_grpc.BackendStub(channel)
request = backend_pb2.StopUsersRequest(scenarioID=scenario_id,
amount=amount)
stub.StopUsers(request)
def _add_user_results(user_manager_id: str,
results: List[Result],
address: str = DEFAULT_BACKEND_ADDRESS):
with grpc.insecure_channel(address,
compression=grpc.Compression.Gzip) as channel:
stub = backend_pb2_grpc.BackendStub(channel)
request = backend_pb2.AddUserResultsRequest(
userManagerID=user_manager_id,
results=[pickle.dumps(result) for result in results],
)
stub.AddUserResults(request)
def _check_test_instance(test_id: str,
instance_id: str,
address: str = DEFAULT_BACKEND_ADDRESS):
with grpc.insecure_channel(address,
compression=grpc.Compression.Gzip) as channel:
stub = backend_pb2_grpc.BackendStub(channel)
request = backend_pb2.CheckTestInstanceRequest(testID=test_id,
instanceID=instance_id)
response = stub.CheckTestInstance(request)
return response.running
def _move_user_results(
scenario_id: str,
limit: int = 500,
address: str = DEFAULT_BACKEND_ADDRESS,
) -> List[Result]:
with grpc.insecure_channel(address,
compression=grpc.Compression.Gzip) as channel:
stub = backend_pb2_grpc.BackendStub(channel)
request = backend_pb2.MoveUserResultsRequest(scenarioID=scenario_id,
limit=limit)
response = stub.MoveUserResults(request)
return [pickle.loads(result) for result in response.results] # nosec
def _get_test_events(
test_id: str,
address: str = DEFAULT_BACKEND_ADDRESS) -> List[TestEvent]:
with grpc.insecure_channel(address,
compression=grpc.Compression.Gzip) as channel:
stub = backend_pb2_grpc.BackendStub(channel)
request = backend_pb2.GetEventsRequest(id=test_id)
response = stub.GetTestEvents(request)
return [
TestEvent(kind=event.kind,
payload=pickle.loads(event.payload)) # nosec
for event in response.events
]
def _get_user_events(user_manager_id: str,
kind: str,
address: str = DEFAULT_BACKEND_ADDRESS):
with grpc.insecure_channel(address,
compression=grpc.Compression.Gzip) as channel:
stub = backend_pb2_grpc.BackendStub(channel)
request = backend_pb2.GetEventsRequest(id=user_manager_id, kind=kind)
response = stub.GetUserEvents(request)
return [
UserEvent(kind=event.kind,
payload=json.loads(event.payload.decode("utf-8")))
for event in response.events
]
def _create_users(
test_id: str,
scenario_id: str,
amount: int,
address: str = DEFAULT_BACKEND_ADDRESS,
) -> List[str]:
with grpc.insecure_channel(address,
compression=grpc.Compression.Gzip) as channel:
stub = backend_pb2_grpc.BackendStub(channel)
request = backend_pb2.CreateUsersRequest(testID=test_id,
scenarioID=scenario_id,
amount=amount)
response = stub.CreateUsers(request)
return response.userManagerIDs
def _add_metric(
scenario_id: str,
name: str,
value: float,
address: str = DEFAULT_BACKEND_ADDRESS,
):
with grpc.insecure_channel(address,
compression=grpc.Compression.Gzip) as channel:
stub = backend_pb2_grpc.BackendStub(channel)
request = backend_pb2.AddMetricRequest(
scenarioID=scenario_id,
name=name,
value=value,
)
stub.AddMetric(request)
def _add_test_event(
test_id: str,
event: TestEvent,
address: str = DEFAULT_BACKEND_ADDRESS,
):
with grpc.insecure_channel(address,
compression=grpc.Compression.Gzip) as channel:
stub = backend_pb2_grpc.BackendStub(channel)
request = backend_pb2.AddEventRequest(
id=test_id,
event=backend_pb2.Event(
kind=event.kind,
payload=pickle.dumps(event.payload),
),
)
stub.AddTestEvent(request)
def _add_user_event(
scenario_id: str,
kind: str,
payload: dict,
address: str = DEFAULT_BACKEND_ADDRESS,
):
with grpc.insecure_channel(address,
compression=grpc.Compression.Gzip) as channel:
stub = backend_pb2_grpc.BackendStub(channel)
request = backend_pb2.AddEventRequest(
id=scenario_id,
event=backend_pb2.Event(
kind=kind,
payload=json.dumps(payload).encode("utf-8"),
),
)
stub.AddUserEvent(request)
def _create_test(
scheduling_metadata: str,
tags: List[str],
env: Dict[str, str],
backend_address: str,
address: str = DEFAULT_BACKEND_ADDRESS,
) -> str:
with grpc.insecure_channel(address,
compression=grpc.Compression.Gzip) as channel:
stub = backend_pb2_grpc.BackendStub(channel)
request = backend_pb2.CreateTestRequest(
backendAddress=backend_address,
schedulingMetadata=scheduling_metadata,
tags=tags,
env=env,
)
response = stub.CreateTest(request)
return response.testID
def _get_last_metric(
scenario_id: str,
name: str,
address: str = DEFAULT_BACKEND_ADDRESS,
) -> Optional[float]:
with grpc.insecure_channel(address,
compression=grpc.Compression.Gzip) as channel:
try:
stub = backend_pb2_grpc.BackendStub(channel)
request = backend_pb2.GetMetricRequest(
scenarioID=scenario_id,
name=name,
)
response = stub.GetLastMetric(request)
return response.last
except grpc.RpcError as err:
if err.code() == grpc.StatusCode.NOT_FOUND:
return None
else:
raise err
def _create_scenario(
test_id: str,
scenario_name: str,
context: str,
users_per_instance: int,
tags: List[str],
address: str = DEFAULT_BACKEND_ADDRESS,
) -> str:
with grpc.insecure_channel(address,
compression=grpc.Compression.Gzip) as channel:
stub = backend_pb2_grpc.BackendStub(channel)
request = backend_pb2.CreateScenarioRequest(
testID=test_id,
scenarioName=scenario_name,
context=context,
usersPerInstance=users_per_instance,
tags=tags,
)
response = stub.CreateScenario(request)
return response.scenarioID