def send_message(self): ws = create_connection("wss://echo.websocket.org", sslopt={"cert_reqs": ssl.CERT_NONE}) user_id = six.text_type(uuid.uuid4()) start_at = time.time() json_val = { 'id': user_id, 'salutation': "Hello", 'name': "James", 'start_at': start_at } msg = json.dumps(json_val) ws.send(msg) print(f"Sent {msg}") res = ws.recv() data = json.loads(res) end_at = time.time() response_time = int((end_at - data['start_at']) * 1000) print(f"Received {res}") print(f"Got back id {data['id']}") myrandom = random.randint(1, 10) if myrandom == 1: request_failure.fire(request_type='WebSocket Response', name='ws', response_time=response_time, exception=Exception("My Exception")) else: request_success.fire(request_type='WebSocket Response', name='ws', response_time=response_time, response_length=len(res))
def run(self): log.info("Starting MobileStreamingUpdateProcessor connecting to uri: " + self._uri) self._running = True while self._running: try: init_start = time.time() messages = self._connect() for msg in messages: if not self._running: break message_ok = self.process_message(self._store, self._requester, msg) if message_ok is True and self._ready.is_set() is False: log.info("MobileStreamingUpdateProcessor initialized ok.") init_duration = int((time.time() - init_start) * 1000) request_success.fire(request_type="ld:init", name="mobile", response_time=init_duration, response_length=0) self._ready.set() except UnsuccessfulResponseException as e: log.error(http_error_message(e.status, "stream connection")) init_duration = int((time.time() - init_start) * 1000) request_failure.fire(request_type="ld:init", name="mobile", response_time=init_duration, response_length=0, exception=e) if not is_http_error_recoverable(e.status): self._ready.set() # if client is initializing, make it stop waiting; has no effect if already inited self.stop() break except Exception as e: init_duration = int((time.time() - init_start) * 1000) request_failure.fire(request_type="ld:init", name="mobile", response_time=init_duration, response_length=0, exception=e) log.warning("Caught exception. Restarting stream connection after one second. %s" % e) # no stacktrace here because, for a typical connection error, it'll just be a lengthy tour of urllib3 internals time.sleep(1)
def _receive(): sub_mapping = {} while True: start_time = time.time() try: res = ws.recv() except: log.exception("Error receiving message") break message = json.loads(res) try: sub_id = message["id"] except KeyError: pass else: try: sub_mapping[message["result"]] = sub_id continue except KeyError: pass # except TypeError: # print(sub_mapping) # print(message) # print(sub_id) end_time = time.time() # if output: # print(message) try: message["params"]["subscription"] = sub_mapping[ message["params"]["subscription"]] except KeyError: log.warning("Mapping missing for %s", message["params"]["subscription"]) end_at = time.time() response_time = int(round((end_time - start_time) * 1000)) num = len(self.sends) // 10 request_failure.fire(request_type='WebSocket Recv', name=f'gotsomething{num}', response_time=1, response_length=len(res), exception="Mapping missing for %s" % message["params"]["subscription"]) end_at = time.time() num = len(self.sends) // 10 # print("recv") # print(message) # if num == 0: # print(len(self.sends)) # print(self.sends) response_time = int(round((end_time - start_time) * 1000)) request_success.fire( request_type='WebSocket Recv', name=f'gotsomething{num}', response_time=response_time, response_length=len(res), )
def test_any(self): test_dict = random.choice(self.locust.tests) try: self.test_runner.run_test(test_dict) except (AssertionError, MyBaseError, MyBaseFailure) as ex: request_failure.fire( request_type=self.test_runner.exception_request_type, name=self.test_runner.exception_name, response_time=0, exception=ex)
def with_requests(self, url): """Get a streaming response for the given event feed using requests.""" import requests try: r = requests.get(url, stream=True) return r except requests.exceptions.RequestException as e: print(e) request_failure.fire()
def run(self, path): try: self.runner.run(path) except exceptions.MyBaseError as ex: # TODO: refactor from locust.events import request_failure request_failure.fire(request_type=test.testcase_dict.get( "request", {}).get("method"), name=test.testcase_dict.get("request", {}).get("url"), response_time=0, exception=ex)
def urlopen(self, method, url, redirect=True, **kw): is_stream = not kw.get('preload_content', True) start_time = time.time() x = urlparse(url) name = url req_type = method if method == 'GET' and (x.path.find('/meval/') == 0 or x.path.find('/users/') > -1 or x.path.find('/eval/') == 0): parts = x.path.split('/') parts.pop() parts.append('[user]') newpath = '/'.join(parts) x = x._replace(path=newpath) name = urlunparse(x) if is_stream and kw.get('headers', {}).get( 'Accept', 'lol') == 'text/event-stream': req_type = 'sse:connect' resp = None content_len = 0 try: resp = super(LocustPoolManager, self).urlopen(method, url, redirect, **kw) if is_stream: content_len = int(resp.headers.get("content-length") or 0) else: content_len = len(resp.data or b"") throw_if_unsuccessful_response(resp) except UnsuccessfulResponseException as e: request_failure.fire(request_type=req_type, name=name, exception=e, response_length=content_len, response_time=int( (time.time() - start_time) * 1000)) return resp except Exception as e: request_failure.fire(request_type=req_type, name=name, exception=e, response_length=content_len, response_time=int( (time.time() - start_time) * 1000)) raise e request_success.fire(request_type=req_type, name=name, response_length=content_len, response_time=int( (time.time() - start_time) * 1000)) return resp
def test_any(self): teststeps = random.choice(self.locust.tests) for teststep in teststeps: try: test_runner.run_test(teststep) except (MyBaseError, MyBaseFailure) as ex: request_failure.fire(request_type=teststep.get( "request", {}).get("method"), name=teststep.get("name"), response_time=0, exception=ex) break gevent.sleep(1)
def run(self): for suite in self.task_suite: for test in suite: try: test.runTest() except exception.MyBaseError as ex: from locust.events import request_failure request_failure.fire( request_type=test.testcase_dict.get("request", {}).get("method"), name=test.testcase_dict.get("request", {}).get("url"), response_time=0, exception=ex )
def run(self): for suite in self.task_suite: for test in suite: try: test.runTest() except exception.MyBaseError as ex: from locust.events import request_failure request_failure.fire( request_type=test.testcase_dict.get("request", {}).get("method"), name=test.testcase_dict.get("request", {}).get("url"), response_time=0, exception=ex)
def run(self): for suite in self.task_suite.tasks: for test in suite.tests: try: test.runTest() except p_exception.MyBaseError as e: from locust.events import request_failure request_step = test.testcase_dict["steps"][0] request_failure.fire(request_type=request_step.get( "request", {}).get("method"), name=request_step.get("request", {}).get("url"), response_time=0, exception=e)
def run(self): for suite in self.task_suite: for test in suite: try: test.runTest() except exception.MyBaseError as ex: try: from locust.events import request_failure request_failure.fire( request_type=test.testcase_dict.get( "request", {}).get("method"), name=test.testcase_dict.get("request", {}).get("url"), response_time=0, exception=ex) except ImportError: logging.exception( "Exception occured in testcase: {}".format( test.testcase_dict.get("name")))
def urlopen(self, method, url, redirect=True, **kw): is_stream = not kw.get('preload_content', True) start_time = time.time() name = clean_name(method, url) req_type = method if is_stream and kw.get('headers', {}).get( 'Accept', 'lol') == 'text/event-stream': req_type = 'sse:connect' resp = None content_len = 0 try: resp = super(LocustProxyPoolManager, self).urlopen(method, url, redirect, **kw) if is_stream: content_len = int(resp.headers.get("content-length") or 0) else: content_len = len(resp.data or b"") throw_if_unsuccessful_response(resp) except UnsuccessfulResponseException as e: request_failure.fire(request_type=req_type, name=name, exception=e, response_length=content_len, response_time=int( (time.time() - start_time) * 1000)) return resp except Exception as e: request_failure.fire(request_type=req_type, name=name, exception=e, response_length=content_len, response_time=int( (time.time() - start_time) * 1000)) raise e request_success.fire(request_type=req_type, name=name, response_length=content_len, response_time=int( (time.time() - start_time) * 1000)) return resp
def __next__(self): while not self._event_complete(): try: nextline = next(self.resp_file) # There are some bad cases where we don't always get a line: https://github.com/requests/requests/pull/2431 if not nextline: raise EOFError() self.buf += nextline.decode("utf-8") except (StopIteration, EOFError) as e: request_failure.fire( request_type='sse:disconnect', name="/meval", response_time=int( (time.time() - self._connect_start) * 1000), response_length=0, exception=e) time.sleep(self.retry / 1000.0) # The SSE spec only supports resuming from a whole message, so # if we have half a message we should throw it out. head, sep, tail = self.buf.rpartition('\n') self.buf = head + sep continue split = re.split(end_of_field, self.buf) head = split[0] tail = "".join(split[1:]) self.buf = tail msg = Event.parse(head, instance=self) # If the server requests a specific retry delay, we need to honor it. if msg.retry: self.retry = msg.retry # last_id should only be set if included in the message. It's not # forgotten if a message omits it. if msg.id: self.last_id = msg.id return msg
def put_record(self): start_at = time.time() print(start_at) try: res = self.conn.put_record(stream_name="test-stream", data="test", partition_key="partition_key1") print(res) request_success.fire( request_type='Kinesis put record', name='test-stream', response_time=int((time.time() - start_at) * 1000), response_length=len(json.dumps(res)), ) except Exception as e: print(e) request_failure.fire(request_type='Kinesis put record', name='test-stream', response_time=int( (time.time() - start_at) * 1000), exception=e)
def handle_message(self, msg, **kwargs): init_time = kwargs.get('init_time', time.time()) if "CONNECTED" in msg: logging.info("%s: Connection initiated", self.instanceId) request_success.fire(request_type='WebSocket Init', name='Init websocket connection', response_time=(time.time() - init_time) * 1000, response_length=len(msg)) elif "ERROR" in msg: logging.warning("%s: Received error: \n %s", self.instanceId, str(msg)) request_failure.fire(request_type='WebSocket Error', name='Websocket server Error', response_time=(time.time() - init_time) * 1000, response_length=len(msg), exception=InterruptTaskSet()) raise StopLocust() elif "MESSAGE" in msg: logging.info("%s: Message received: %s", self.instanceId, str(msg)) message = str(msg) idx = message.find("{") content = message[idx:-1] json_msg = json.loads(content) res = stomper.send( "/app/device", '{ "time": "' + datetime.datetime.now().isoformat() + '",' + '"status": "OK",' + '"id": "' + json_msg["id"] + '",' + '"data": ' + str([1, 0, -1, 0]) + '}', content_type="application/json") self.ws.send(res) request_success.fire(request_type='Msg Receive', name='Msg received', response_time=(time.time() - init_time) * 1000, response_length=len(msg))
def do_work(self, testfile): work = get_work(testfile, self.locust.client) for suite in work: for test in suite: test.testcase_dict['variables'].update(self.variables) test.testcase_dict['request']['group'] = test.testcase_dict[ 'name'] test.testcase_dict['request']['verify'] = False test.testcase_dict['request']['timeout'] = 30 try: test.runTest() except (MyBaseError, MyBaseFailure) as ex: from locust.events import request_failure request_failure.fire( request_type=test.testcase_dict.get("request", {}).get("method"), name=test.testcase_dict.get("request", {}).get("group"), response_time=0, exception=ex) break gevent.sleep(1)