def get_url(vs_name,
vport,
uris,
skip_exc=0,
vip_id='0',
to_floating_vip=None):
"""Returns a URL for making http request"""
if to_floating_vip:
vip = vs_lib.get_floating_vip(vs_name, vip_id)
else:
vip = vs_lib.get_vip(vs_name, vip_id)
vport = int(vport)
proto = vs_lib.get_protocol(vs_name, vport, skip_exc)
if suite_vars.spdy_enabled and proto == 'https://':
key = '%s,%s' % (vip, vport)
# FixMe: to get fromm avi_config
#shrpx_proxy = config.shrpx_vs_map[key]
#vip, vport = tuple(shrpx_proxy.split(','))
uris = [uris] if not isinstance(uris, list) else uris
urls = []
for uri in uris:
url_elms = [proto, vip, ':', str(vport), uri.replace('&', '&')]
urls.append("".join(url_elms))
return urls
def start_httperf_on_client(client_handles, vs_name, vs_port, uri, rate, num_conns, requests_per_session, **kwargs):
"""
Runs on the main interface of the client vm
:param client_handles:
:param vs_name:
:param vs_port:
:param uri:
:param rate:
:param num_conns:
:param requests_per_session:
:param kwargs:
:return:
"""
method = kwargs.get('method', 'GET')
client_handles = traffic_manager.get_client_handles_from_range(client_handles)
vip = kwargs.get('vip', None)
if not vip:
vip = vs_lib.get_vip(vs_name)
command = 'httperf '
# --timeout 0.5
command += '--hog --server %s --port %s --wsess %s,%s,0 --rate %s --uri "%s" --method %s --recv-buffer 1240000 --send-buffer 1240000 &> /tmp/httperf.txt &' % (
vip, vs_port, num_conns, requests_per_session, rate, uri, method)
logger.info('start_httperf_on_client:'+command)
for client_handle in client_handles:
vm, ip = traffic_manager.get_client_by_handle(client_handle)
vm.execute_command(command)
def run_ab_on_client(client_handles, vs_name, vs_port, path, c, n):
"""
Runs on the main interface of the client vm
:param client_handles:
:param vs_name:
:param vs_port:
:param path:
:param c:
:param n:
:return:
"""
client_handles = traffic_manager.get_client_handles_from_range(client_handles)
vip = vs_lib.get_vip(vs_name)
vip_port = "%s:%s" % (vip, vs_port)
kill_ab = "pkill -9 -f ab"
run_ab = "ab -c %s -n %s http://%s/%s&> /tmp/ab.txt &" % \
(c, n, vip_port, path)
logger.info('start_apache_bench run_ab:'+ run_ab)
logger.info('vip_port'+ vip_port)
for client_handle in client_handles:
vm, ip = traffic_manager.get_client_by_handle(client_handle)
vm.execute_command(kill_ab, log_error=False)
vm.execute_command(run_ab)
def request(method,
vs_name,
vport,
uri,
status_code=200,
client_range='default1',
no_of_req_per_conn=1,
concurrent_conn_per_client=1,
sequential_conn_per_client=1,
concurrent_clients='True',
**kwargs):
"""
Request the selected pages from server. Internally calls the httptest
process running on clients
Arguments:
method GET, PUT, POST, DELETE?
vs_name virtual service name
vport Virtual service listener port
uri URI for the request
status_code status_code expected from request
client_range clients from where the request needs to be
sent
no_of_req_per_conn No of requests per http connection
concurrent_conn_per_client No of concurrent connections per client
sequential_conn_per_client No of sequential connections per client
timeout Timeout for every connection
concurrent_clients Concurrent connections from clients or
sequential.
Note: This function can generate exponential traffic patterns. For eg.
If concurrent_conn_per_client=5, sequential_conn_per_client=10 and
no_of_req_per_conn=5, it will create 5 concurrent connections for each
client with 5 seqeuntial connections for each concurrent connection (
IP, port combination) and 5 requests per connection.
Total = 5 * 10 * 5= 250 requests!
"""
skip_error = json_utils.str2bool(kwargs.pop('expect_error', 'False'))
think_time = kwargs.pop('think_time', None)
cps = kwargs.pop('cps', None)
rps = kwargs.pop('rps', None)
stop_traffic = kwargs.pop('stop_traffic', False)
parallel = int(ast.literal_eval(concurrent_clients.title()))
content = kwargs.get('body_contains', None)
set_cookie_session = json_utils.str2bool(
kwargs.pop('cookie_session', 'False'))
set_cookies_per_request = json_utils.str2bool(
kwargs.pop('cookies_per_request', 'False'))
skip_exc = kwargs.pop('skip_exception', 0)
custom = kwargs.pop('custom', None)
to_floating_vip = kwargs.pop('to_floating_vip', None)
if content:
traffic_obj = traffic_manager.HTTPTraffic(**kwargs)
kwargs['body_contains'] = traffic_obj.may_be_replace_vars_with_ips(
content)
urls = get_url(vs_name,
vport,
uri,
skip_exc=skip_exc,
vip_id=kwargs.pop('vip_id', '0'),
to_floating_vip=to_floating_vip)
client_vm, client_ips = traffic_manager.get_client_handles(
client_range, concurrent_conn_per_client)
if to_floating_vip:
vip = vs_lib.get_floating_vip(vs_name)
else:
vip = vs_lib.get_vip(vs_name)
out = client_vm.execute_command('arp -a | grep %s' % vip)
logger.debug('Arptable on client: %s' % out)
req_params, validations, prints = parse_input(urls, status_code, **kwargs)
time_stamp = time.strftime("%Y%m%d%H%M%S") + str(time.clock())
log_file = '/tmp/httptest_io_error_' + time_stamp + '.log'
cmd = '/root/client/tools/httptest.py '
cmd += '--urls \'%s\' ' % '\' \''.join(urls)
cmd += '--clients %s ' % ' '.join(client_ips)
cmd += '--log-file %s ' % log_file
cmd += '--method %s ' % method
cmd += '--req-params \'%s\' ' % req_params
cmd += '--validations \'%s\' ' % validations
cmd += '--prints \'%s\' ' % prints
cmd += '--requests %s ' % no_of_req_per_conn
cmd += '--connections %s ' % sequential_conn_per_client
cmd += '--concurrent %s ' % parallel
if cps:
cmd += '--connections-per-sec %s ' % cps
if rps:
cmd += '--requests-per-sec %s ' % rps
if set_cookie_session:
cmd += '--cookie-session '
if set_cookies_per_request:
cmd += '--cookies-per-request '
if think_time:
cmd += '--think-time %s ' % think_time
if custom:
_custom = custom.split(' ')
for i in range(0, len(_custom)):
if not i % 2:
cmd += '--custom %s ' % (''.join(
get_url(vs_name,
vport,
_custom[i],
skip_exc=skip_exc,
vip_id=kwargs.pop('vip_id', '0'))))
else:
cmd += '%s ' % _custom[i]
#out = client_vm.execute_command("rm -rf /tmp/httptest_traffic_check ", noerr=True)
logger.info('REQUEST cmd: %s' % cmd)
out = client_vm.execute_command(cmd, noerr=True)
# Start Http Traffic check
#search_str = "Started Http Traffic on client"
#res = start_traffic_check("/tmp/httptest_traffic_check", search_str)
#if res:
# logger.error("Traffic is not started something went wrong")
# reason = client_vm.execute_command(" tail -5 %s" % log_file)
# logger.error(" %s" % (reason))
# raise RuntimeError("Request Traffic not started")
#logger.info("Request Traffic is running, responses are logged in file: /tmp/httptest_resp_summary_time_stamp")
if skip_error is False:
is_there_IO_error(client_range, log_file, raise_exception=True)
if stop_traffic:
stop_http_traffic(client_range)
out = traffic_obj.parse_response(out)
return out
def start_http_traffic(client_range,
vs_name,
vport,
method,
stop_on_failure,
concurrent_conn_per_client=1,
uri='/',
**kwargs):
"""
Starts http traffic on range of clients specified in client_range
Arguments:
client_range Number of clients for the the traffic
generation
vs_name Virtualservice to balance the traffic
between backend servers
vport Listener port on virtual service
stop_on_failure Flag to exit on first IO failure.
Set it to 1 if you need
concurrent_conn_per_client Concurrent connections per client
uri URI of page to be requested
exact state of the system while failure
kwargs parameters passed to requests and
validations need to be
done
"""
skip_exc = kwargs.pop('skip_exception', 0)
think_time = kwargs.pop('think_time', None)
status_code = int(kwargs.pop('status_code', 200))
no_of_req_per_conn = int(kwargs.pop('no_of_req_per_conn', 1))
set_cookie_session = _bool_value(kwargs.pop('cookie_session', 'False'))
set_cookies_per_request = _bool_value(
kwargs.pop('cookies_per_request', 'False'))
to_floating_vip = kwargs.pop('to_floating_vip', None)
random_urls = int(kwargs.pop('random_urls', 0))
random_urls_repeat = int(kwargs.pop('random_urls_repeat', 0))
if random_urls:
if not random_urls_repeat:
random_urls_repeat = 1
uri = []
for i in range(random_urls):
for j in range(random_urls_repeat):
uri.append('/randomurl' + str(i))
urls = get_url(vs_name,
vport,
uri,
skip_exc=skip_exc,
vip_id=kwargs.pop('vip_id', '0'),
to_floating_vip=to_floating_vip)
client_vm, client_ips = traffic_manager.get_client_handles(
client_range, concurrent_conn_per_client)
if to_floating_vip:
vip = vs_lib.get_floating_vip(vs_name)
else:
vip = vs_lib.get_vip(vs_name)
out = client_vm.execute_command('arp -a | grep %s' % vip)
logger.debug('Arptable on client: %s' % out)
req_params, validations, prints = parse_input(urls, status_code, **kwargs)
time_stamp = time.strftime("%Y%m%d%H%M%S") + str(time.clock())
logger.info('Start traffic at' + str(datetime.now()))
log_file = '/tmp/httptest_io_error_' + time_stamp + client_range + '.log'
cmd = '/root/client/tools/httptest.py '
cmd += '--urls \'%s\' ' % '\' \''.join(urls)
cmd += '--clients %s ' % ' '.join(client_ips)
cmd += '--stop-on-failure %s ' % stop_on_failure
cmd += '--log-file %s ' % log_file
cmd += '--method %s ' % method
cmd += '--concurrent 1 '
cmd += '--requests %s ' % no_of_req_per_conn
cmd += '--req-params \'%s\' ' % req_params
cmd += '--validations \'%s\' ' % validations
cmd += '--prints \'%s\' ' % prints
if set_cookie_session:
cmd += '--cookie-session '
if set_cookies_per_request:
cmd += '--cookies-per-request '
if think_time:
cmd += '--think-time %s ' % think_time
cmd += '&> /tmp/httptest &'
logger.trace(cmd)
#out = client_vm.execute_command("rm -rf /tmp/httptest_traffic_check ", noerr=True)
out = client_vm.execute_command(cmd)
# Started Http Traffic check
#search_str = "Started Http Traffic on client"
#res = start_traffic_check("/tmp/httptest_traffic_check", search_str)
#if res:
# logger.error("HTTP Traffic is not started something went wrong")
# reason = client_vm.execute_command(" tail -5 %s" % log_file)
# logger.error(" %s" % (reason))
# reason = client_vm.execute_command(" tail -5 /tmp/httptest ")
# logger.error(" %s" % (reason))
# raise RuntimeError("HTTP Request Traffic not started")
#logger.info("HTTP Traffic is running, responses are logged in file: /tmp/httptest_resp_summary_time_stamp")
logger.debug('End traffic at %s' % str(datetime.now()))
logger.trace('out: %s' % out)
return log_file
def create_server(pool_name, server_handle, **kwargs):
""" API Helps to Create Server for given Pool"""
how_many = kwargs.pop('how_many', None)
upstream = kwargs.pop('upstream', None)
restart = kwargs.pop('restart', True)
num_ip = kwargs.pop('num_ip', None)
#Pool Properties
addr_type = kwargs.pop('addr_type', 'V4')
network = kwargs.pop('network', '${net}')
enabled = kwargs.pop('enabled', True)
port = kwargs.pop('port', 8000)
app_type = kwargs.pop('app_type', 'httptest')
if upstream:
upstream = upstream.split(':')
kwargs['upstream_ip'] = vs_lib.get_vip(upstream[0])
kwargs['upstream_port'] = int(upstream[1])
handles = []
if how_many is not None:
for i in range(int(how_many)):
handle = server_handle + str(i + 1)
handles.append(handle)
else:
handles.append(server_handle)
pool_dict = {
'ip': {
'type': addr_type,
'addr': network
},
'enabled': enabled,
'port': port,
'handle': server_handle,
'app_type': app_type
}
config = infra_utils.get_config()
context_key = config.get_context_key()
pool = config.site_objs[context_key]['pool'].get(pool_name)
count = 0
server_per_ip = None
if num_ip is not None:
server_per_ip = int(how_many) / int(num_ip)
for handle in handles:
pool_dict['handle'] = handle
pool_dict['ip']['addr'] = network
# Server Model
server = pool.newServer(handle, pool_dict, **kwargs)
#Backend Server config
server.createAppServers()
count += 1
if server_per_ip is not None and count == server_per_ip:
server.reset_aws_sub_ip_port()
server.pushBackendConfigs(restart)
if app_type in ['ixia', 'shenick']:
server.vm().check_if_servers_up()
else:
logger.info("Skip Check if server is up for app_type: %s" % app_type)
st, pool_json_ctrl = rest.get('pool', name=pool_name)
pool_server_json = []
pool_server_dict = pool.servers
for pool_server in pool_server_dict.values():
pool_server_json.append(pool_server.get_json())
pool_json_ctrl['servers'] = pool_server_json
rest.put('pool', name=pool_name, data=pool_json_ctrl)