class MyLocust(HttpLocust):
task_set = Tito
sock = None
wait_time = between(5, 15)
def __init__(self):
super(MyLocust, self).__init__()
self.sock = socket.socket()
wavefrontProxy = os.environ.get("WAVEFRONT_PROXY")
self.sock.connect((wavefrontProxy, 2878))
locust.events.request_success += self.hook_request_success
locust.events.request_failure += self.hook_request_fail
atexit.register(self.exit_handler)
def hook_request_success(self, request_type, name, response_time,
response_length):
myHost = self.host
myHost = myHost.replace("http://", "")
met_locustRequest = 'locust.response.success' + ' ' + str(
response_time) + ' ' + str(time.time(
)) + ' ' + 'source=' + myHost + ' ' + 'app=Tito' + ' \n'
try:
self.sock.sendall(met_locustRequest.encode('utf-8'))
except BrokenPipeError:
# Don't be surprised if the socket is in "not
# connected" state.
#print(met_locustRequest)
pass
#print(met_locustRequest)
def hook_request_fail(self, request_type, name, response_time, exception):
myHost = self.host
myHost = myHost.replace("http://", "")
met_locustRequestFailed = 'locust.response.failed' + ' ' + str(
response_time) + ' ' + str(time.time(
)) + ' ' + 'source=' + myHost + ' ' + 'app=Tito' + ' \n'
try:
self.sock.sendall(met_locustRequestFailed.encode('utf-8'))
except BrokenPipeError:
# Don't be surprised if the socket is in "not
# connected" state.
#print(met_locustRequestFailed)
pass
#print(met_locustRequestFailed)
def exit_handler(self):
try:
self.sock.shutdown(socket.SHUT_RDWR)
self.sock.close()
except IOError:
# Don't be surprised if the socket is in "not
# connected" state.
pass
else:
self.sock.close()
class Seller(OdooLocust.OdooLocust):
host = os.getenv('HOST')
database = os.getenv('DATABASE')
port = int(os.getenv('PORT'))
login = os.getenv('LOGIN')
password = os.getenv('PASSWORD')
wait_time = between(0.500, 4)
weight = 3
task_set = SellerTaskSet
class MyTestLocust(Locust):
task_set = MyTaskSet
wait_time = between(1, 1)
class User(Locust):
host = "127.0.0.1"
wait_time = between(0.001, 0.1)
class MyTestLocust(Locust):
tasks = [MyTaskSet]
wait_time = between(1, 1)
class PublishRecord(FastHttpLocust):
def __init__(self):
FastHttpLocust.__init__(self)
task_set = PublishRecordTaskSet
wait_time = between(1, 2)
class InitializeClient(TaskSequence):
"""
Initial loading of cellxgene - when the user hits the main route.
Currently this sequence skips some of the static assets, which are quite
small and should be served by the HTTP server directly.
1. load index.html, etc.
2. concurrently load /config, /schema
3. concurrently load /layout/obs, /annotations/var?annotation-name=<the index>
-- does intitial render --
4. concurrently load all /annotations/obs
-- fully initialized --
"""
# users hit all of the init routes as fast as they can, subject to the ordering constraints
# and network latency
wait_time = between(0.01, 0.1)
def on_start(self):
self.dataset = self.parent.dataset
self.client.verify = False
@seq_task(1)
def index(self):
self.client.get(f"{self.dataset}/", stream=True).close()
@seq_task(2)
def loadConfigSchema(self):
def config():
self.client.get(f"{self.dataset}{API}/config", stream=True).close()
def schema():
self.client.get(f"{self.dataset}{API}/schema", stream=True).close()
group = Group()
group.spawn(config)
group.spawn(schema)
group.join()
@seq_task(3)
def loadBootstrapData(self):
def layout():
self.client.get(
f"{self.dataset}{API}/layout/obs", headers={"Accept": "application/octet-stream"}, stream=True
).close()
def varAnnotationIndex():
self.client.get(
f"{self.dataset}{API}/annotations/var?annotation-name={self.parent.var_index_name()}",
headers={"Accept": "application/octet-stream"},
stream=True,
).close()
group = Group()
group.spawn(layout)
group.spawn(varAnnotationIndex)
group.join()
@seq_task(4)
def loadObsAnnotations(self):
def obs_annotation(name):
self.client.get(
f"{self.dataset}{API}/annotations/obs?annotation-name={name}",
headers={"Accept": "application/octet-stream"},
stream=True,
).close()
obs_names = self.parent.obs_annotation_names()
group = Group()
for name in obs_names:
group.spawn(obs_annotation, name)
group.join()
@seq_task(5)
def done(self):
self.interrupt()
class CellxgeneUser(HttpLocust):
task_set = ViewDataset
# most ops do not require back-end interaction, so slow cadence
# for users
wait_time = between(10, 60)
class ApiTest(FastHttpLocust):
host = ''
task_set = PressureTest
wait_time = between(0.0, 0.0)
class TaskSet2(TaskSet):
wait_time = between(20.0, 21.0)
class User(Locust):
wait_time = between(3, 9)
