def __call__(self, *args, **kwargs):
assert self.runtime_config
url = self.url_object
http = HTTPClient(url.host, headers=self.runtime_config["agent"].get_as_dict())
response = http.get(url.path)
code = response.status_code
log.debug("%s %s", self.url, code)
body = response.read()
http.close()
def verify_login(token):
sig = md5(APP_KEY + token).hexdigest()
url = '%stokenKey=%s&sign=%s' % (KUAIYONG_URL, token, sig)
logger.debug('kuaiyong url:%s', url)
url = URL(url)
http = HTTPClient(url.host, port=url.port)
response = eval(http.get(url.request_uri).read())
http.close()
return response
def verify_login(token):
sig = md5(APP_KEY + token).hexdigest()
url = '%stokenKey=%s&sign=%s' % (KUAIYONG_URL, token, sig)
logger.debug('kuaiyong url:%s', url)
url = URL(url)
http = HTTPClient(url.host, port=url.port)
response = eval(http.get(url.request_uri).read())
http.close()
return response
def test_https():
href = u'https://192.168.1.136:8080/stream/webrtc'
url = URL(href)
cli = HTTPClient(url.host, port=url.port, ssl=True, ssl_options={'ca_certs': 'ssl_certificate.crt'},
connection_timeout=5.0, network_timeout=10.0)
response = cli.get(url.request_uri)
s = response.read()
cli.close()
print(s)
def verify_login(session, appid):
"""
登陆校验
"""
url = "%ssession=%s&appid=%s" % (TBT_URL, session, appid)
url = URL(url)
http = HTTPClient(url.host, port=url.port)
response = eval(http.get(url.request_uri).read())
http.close()
return response
def verify_login(session, appid):
"""
登陆校验
"""
url = "%ssession=%s&appid=%s" % (TBT_URL, session, appid)
url = URL(url)
http = HTTPClient(url.host, port=url.port)
response = eval(http.get(url.request_uri).read())
http.close()
return response
def __login(passport):
"""login """
logger.info('player login passport:%s' % passport)
domain = '%s:%s' % (SERVER_MA_URL, SERVERS_MA_WEBPORT)
url = '%s/verify?passport=%s' % (domain, passport)
url = URL(url)
http = HTTPClient(url.host, port=url.port)
response = eval(http.get(url.request_uri).read())
http.close()
if response.get('result') is True:
return str({'result': True, 'account_id': '\'%s\'' % passport})
return str({'result': False})
def beehive_ping(self, subsystem=None, vassal=None):
"""Ping beehive instance
:param server: host name
:param port: server port [default=6379]
"""
path_inventory = u'%s/inventories/%s' % (self.ansible_path,
self.environment)
path_lib = u'%s/library/beehive/' % (self.ansible_path)
runner = Runner(inventory=path_inventory, verbosity=self.verbosity,
module=path_lib)
hosts, vars = runner.get_inventory_with_vars(u'beehive')
vars = runner.variable_manager.get_vars(runner.loader, host=hosts[0])
instances = vars.get(u'instance')
vassals = []
if subsystem is not None and vassal is not None:
vassals.append([subsystem, vassal])
else:
for instance in instances:
vassals.append(instance.split(u'-'))
resp = []
for vassal in vassals:
port = instances.get(u'%s-%s' % tuple(vassal)).get(u'port')
for host in hosts:
url = URL(u'http://%s:%s/v1.0/server/ping/' % (host, port))
http = HTTPClient(url.host, port=url.port)
try:
# issue a get request
response = http.get(url.request_uri)
# read status_code
response.status_code
# read response body
res = json.loads(response.read())
# close connections
http.close()
if response.status_code == 200:
resp.append({u'subsystem':vassal[0], u'instance':vassal[1],
u'host':host, u'port':port, u'ping':True,
u'status':u'UP'})
else:
resp.append({u'subsystem':vassal[0], u'instance':vassal[1],
u'host':host, u'port':port, u'ping':False,
u'status':u'UP'})
except gevent.socket.error as ex:
resp.append({u'subsystem':vassal[0], u'instance':vassal[1],
u'host':host, u'port':port, u'ping':False,
u'status':u'DOWN'})
self.result(resp, headers=[u'subsystem', u'instance', u'host', u'port',
u'ping', u'status'])
def __login(passport):
"""login """
logger.info('player login passport:%s' % passport)
domain = '%s:%s' % (SERVER_MA_URL, SERVERS_MA_WEBPORT)
url = '%s/verify?passport=%s' % (domain, passport)
url = URL(url)
http = HTTPClient(url.host, port=url.port)
response = eval(http.get(url.request_uri).read())
http.close()
if response.get('result') is True:
return str({'result': True, 'account_id': '\'%s\'' % passport})
return str({'result': False})
def test_https():
href = u'https://192.168.1.136:8080/stream/webrtc'
url = URL(href)
cli = HTTPClient(url.host,
port=url.port,
ssl=True,
ssl_options={'ca_certs': 'ssl_certificate.crt'},
connection_timeout=5.0,
network_timeout=10.0)
response = cli.get(url.request_uri)
s = response.read()
cli.close()
print(s)
class UserTsak(TaskSet):
def on_start(self):
'''初始化数据'''
url = URL(host)
# 若为https请求，ssl设置为True
self.http = HTTPClient(url.host,url.port,ssl=False,connection_timeout=20,network_timeout=20)
@task
def test(self):
try:
start_time = time.time()
# get 请求
res = self.http.get("/sz/api2/test")
# post 请求示例
# body = json.dumps({"username":"******","password":"******"})
# res = self.http.post("/sz/api2/login",body = body)
data = res.read()
end_time = time.time()
response_time =int((end_time - start_time)*1000)
response_length = len(data)
assert json.loads(data)['Error'] == 0
if res.status_code == 200:
# 统计正常的请求
events.request_success.fire(request_type="GET", name="test_success", response_time = response_time, response_length=response_length)
# 统计断言失败的请求
except AssertionError:
end_time = time.time()
response_time =int((end_time - start_time)*1000)
events.request_failure.fire(request_type="GET", name="test_failure", response_time=response_time,response_length=0,
exception="断言错误。status_code：{}。接口返回：{}。".format(res.status_code,json.loads(data)))
# 统计超时异常
except socket.timeout:
events.locust_error.fire(locust_instance=UserTsak, exception='Timeout', tb =sys.exc_info()[2])
# 统计其他异常
except Exception as e:
events.locust_error.fire(locust_instance=UserTsak, exception='Error:{}。\nstatus_code：{}。\n接口返回：{}。'.format(e,res.status_code,data), tb=sys.exc_info()[2])
def on_stop(self):
'''运行结束，关闭http/https连接'''
self.http.close()
def test_beehive(self, server, port):
"""Test redis instance
:param server: host name
:param port: server port [default=6379]
"""
url = URL(u'http://%s:%s/v1.0/server/ping/' % (server, port))
http = HTTPClient(url.host, port=url.port)
# issue a get request
response = http.get(url.request_uri)
# read status_code
response.status_code
# read response body
res = json.loads(response.read())
# close connections
http.close()
if res[u'status'] == u'ok':
resp = True
else:
resp = False
self.logger.info(u'Ping beehive %s : %s' % (url.request_uri, resp))
self.json = u'Ping beehive %s : %s' % (url.request_uri, resp)
def get_cdkey_gift_1123(data, player):
request = cdkey_pb2.CdkeyRequest()
request.ParseFromString(data)
response = cdkey_pb2.CdkeyResqonse()
url = '%s/verify?area_id=%s&uid=%s&code=%s&token=%s' % \
(CDKEY_URL, SERVER_NO, player.base_info.id,
request.cdkey, SERVER_TOKEN)
logger.debug('cdkey url:%s', url)
url = URL(url)
http = HTTPClient(url.host, port=url.port)
url_response = eval(http.get(url.request_uri).read())
http.close()
logger.debug('cdkey url result:%s', url_response)
# gain_data = tomorrow_gift['reward']
# return_data = gain(player, gain_data, const.TOMORROW_GIFT)
# get_return(player, return_data, response.gain)
response.res.result = True
response.res.result_no = url_response.get('success')
response.res.message = str(url_response.get('message'))
return response.SerializeToString()
# -*- coding: utf-8 -*-
from geventhttpclient import HTTPClient
from geventhttpclient import URL
url = URL("http://gevent.org/")
print url.request_uri
print url.path
http = HTTPClient(url.host)
response = http.get(url.path)
print response.status_code
print response.get('url')
print response.headers
#print response.read()
http.close()
# -*- coding: utf-8 -*-
from geventhttpclient import HTTPClient
from geventhttpclient import URL
url = URL("http://gevent.org/")
print url.request_uri
print url.path
http = HTTPClient(url.host)
response = http.get(url.path)
print response.status_code
print response.get('url')
print response.headers
#print response.read()
http.close()
class THttpClient(TTransportBase):
__custom_headers: Dict[str, str]
__wbuf: BytesIO
__response: Optional[HTTPSocketPoolResponse] = None
__looped: bool = False
__concurrency: int
__url: URL
__once_client: HTTPClient
client: HTTPClient
code: Optional[int] = None
message: Optional[str] = None
headers: Optional[str] = None
def __init__(self,
url: str,
headers: Dict[str, str],
concurrency: int = 30,
client: Optional[HTTPClient] = None):
self.__url = URL(url)
self.__custom_headers = headers
self.__concurrency = concurrency
if not client:
self.client = HTTPClient(self.__url.host,
self.__url.port,
concurrency=self.__concurrency,
ssl=True)
else:
self.client = client
if self.__url.path != LONG_POLLING_V4_PATH:
self.flush = self.__flush
else:
self.open()
self.flush = self.__flush_and_reconnect
self.__wbuf = BytesIO()
def __flush_and_reconnect(self):
if not self.__looped:
self.close()
self.open()
self.__looped = True
else:
self.flush = self.__flush
self.close()
self.flush()
return
data = self.__get_data()
headers = self.__get_headers(data)
self.__response = self.__once_client.request("POST",
self.__url.path,
body=data,
headers=headers)
self.__set_response(self.__response)
def __flush(self):
data = self.__get_data()
headers = self.__get_headers(data)
self.__response = self.client.request("POST",
self.__url.path,
body=data,
headers=headers)
self.__set_response(self.__response)
def __get_data(self) -> bytes:
data = self.__wbuf.getvalue()
self.__wbuf = BytesIO()
return data
def __get_headers(self, data: bytes) -> Dict[str, str]:
headers = {
"Content-Type": "application/x-thrift",
"Content-Length": str(len(data)),
'connection': 'keep-alive',
}
headers.update(self.__custom_headers)
return headers
def __set_response(self, response: HTTPSocketPoolResponse):
self.code = response.status_code
self.message = response.status_message
self.headers = response.headers
def open(self):
self.__once_client = HTTPClient(self.__url.host,
self.__url.port,
concurrency=self.__concurrency,
ssl=True)
def close(self):
self.__once_client.close()
self.__response = None
def read(self, sz: int) -> bytes:
return self.__response.read(sz)
def write(self, buf: bytes):
self.__wbuf.write(buf)
