def test_ssl_vs(self):
papi = ApiSession(api.avi_credentials.controller,
api.avi_credentials.username,
api.avi_credentials.password,
api_version=api.avi_credentials.api_version,
verify=False, data_log=True)
ssl_vs_cfg = gSAMPLE_CONFIG["SSL-VS"]
vs_obj = ssl_vs_cfg["vs_obj"]
pool_name = gSAMPLE_CONFIG["SSL-VS"]["pool_obj"]["name"]
resp = papi.post('pool', data=gSAMPLE_CONFIG["SSL-VS"]["pool_obj"])
assert resp.status_code == 201
pool_ref = papi.get_obj_ref(resp.json())
cert, key, _, _ = get_sample_ssl_params \
(folder_path=os.path.abspath(
os.path.join(os.path.dirname(__file__), '..',
'samples')) + os.sep)
api_utils = ApiUtils(papi)
try:
resp = api_utils.import_ssl_certificate("ssl-vs-kc", key, cert)
ssl_kc = resp.json()
except:
ssl_kc = api.get_object_by_name('sslkeyandcertificate',
'ssl-vs-kc')
ssl_key_and_cert_ref = [papi.get_obj_ref(ssl_kc)]
vs_obj["pool_ref"] = pool_ref
vs_obj["ssl_key_and_certificate_refs"] = ssl_key_and_cert_ref
resp = papi.post('virtualservice', data=json.dumps(vs_obj))
assert resp.status_code < 300
resp = papi.delete_by_name('virtualservice', vs_obj['name'])
assert resp.status_code in (200, 204)
resp = papi.delete_by_name("pool", pool_name)
assert resp.status_code in (200, 204)
resp = api.delete_by_name('sslkeyandcertificate', 'ssl-vs-kc')
assert resp.status_code in (200, 204)
def setup():
global API
API = ApiSession.get_session('127.0.0.1',
'admin',
'avi123',
tenant='admin')
ApiUtils(API).import_ssl_certificate('MyCert', server_key, server_cert)
def __init__(self,
controller_ip,
user='******',
passwd='avi123',
tenant='admin'):
sdk_path = avi.sdk.__path__[0]
with open(sdk_path + '/samples/certs/server.crt') as f:
self.server_crt = f.read()
with open(sdk_path + '/samples/certs/server.key') as f:
self.server_key = f.read()
with open(sdk_path + '/samples/certs/cakey.pem') as f:
self.ca_key = f.read()
with open(sdk_path + '/samples/certs/cacert.pem') as f:
self.ca_cert = f.read()
self.sess = ApiSession.get_session(controller_ip,
user,
passwd,
tenant=tenant)
try:
ApiUtils(self.sess).import_ssl_certificate('MyCert',
self.server_key,
self.server_crt)
except:
pass
self.tenant = tenant
def test_ssl_vs(self):
papi = ApiSession('10.10.25.42',
'admin',
'avi123',
verify=False,
api_version="17.2.1")
ssl_vs_cfg = gSAMPLE_CONFIG["SSL-VS"]
vs_obj = ssl_vs_cfg["vs_obj"]
pool_name = gSAMPLE_CONFIG["SSL-VS"]["pool_obj"]["name"]
resp = papi.post('pool', data=gSAMPLE_CONFIG["SSL-VS"]["pool_obj"])
assert resp.status_code == 201
pool_ref = papi.get_obj_ref(resp.json())
cert, key, _, _ = get_sample_ssl_params(folder_path='../samples/')
api_utils = ApiUtils(papi)
try:
resp = api_utils.import_ssl_certificate("ssl-vs-kc", key, cert)
print resp.text
ssl_kc = resp.json()
except:
ssl_kc = api.get_object_by_name('sslkeyandcertificate',
'ssl-vs-kc')
ssl_key_and_cert_ref = [papi.get_obj_ref(ssl_kc)]
vs_obj["pool_ref"] = pool_ref
vs_obj["ssl_key_and_certificate_refs"] = ssl_key_and_cert_ref
resp = papi.post('virtualservice', data=json.dumps(vs_obj))
print resp, resp.text
assert resp.status_code < 300
resp = papi.delete_by_name('virtualservice', vs_obj['name'])
assert resp.status_code in (200, 204)
resp = papi.delete_by_name("pool", pool_name)
assert resp.status_code in (200, 204)
resp = api.delete_by_name('sslkeyandcertificate', 'ssl-vs-kc')
assert resp.status_code in (200, 204)
def setupApiSession(self):
self.api = None
api = ApiSession.get_session(self.controller_ip,
self.user,
self.password,
tenant=self.tenant)
server_cert, server_key, _, _ = get_sample_ssl_params()
ApiUtils(api).import_ssl_certificate('MyCert', server_key, server_cert)
self.api = api
return api
def metrics(vs_uuid, m_id, tenant, step, limits):
mq = {
'metric_id': m_id,
'tenant': 'admin',
'step': step,
'limit': limits,
'entity_uuid': vs_uuid
}
api_utils = ApiUtils(api)
rsp = api_utils.get_metrics_collection(metric_requests=[mq])
total_value = 0
for data in rsp['series'][vs_uuid][0]['data']:
total_value += data['value']
return total_value/limits
def fetch_data(api_ssn, cloud, tenant, metric_ids):
"""
:param api_ssn:
:param cloud:
:param tenant:
:param metric_ids:
:return:
"""
api_utils = ApiUtils(api_ssn)
api_params = {
'cloud_ref.name': cloud,
'include_name': '',
'metric_id': metric_ids
}
vs_results = api_ssn.get('virtualservice-inventory',
params=api_params,
tenant=tenant).json()
results = []
for vs in vs_results['results']:
config = vs['config']
pool_names = [pool.split('#')[1] for pool in vs.get('pools', [])]
pool_refs = vs.get('pools', [])
domain_name = config.get('vh_domain_name')
vh_parent_vs_ref = config.get('vh_parent_vs_ref', '')
vh_parent_vs_name = (vh_parent_vs_ref.split('#')[1]
if vh_parent_vs_ref else '')
metrics = vs['metrics']
vs_data = VSData(name=config['name'],
uuid=config['uuid'],
domain_name=domain_name,
pool_names=pool_names,
pool_refs=pool_refs,
vh_parent_vs_name=vh_parent_vs_name,
metrics=metrics)
results.append(vs_data)
return results
help='number of values',
type=int, default=2)
parser.add_argument('-c', '--controller',
help='controller ip', default='127.0.0.1')
parser.add_argument('-u', '--username',
help='user name', default='admin')
parser.add_argument('-p', '--password',
help='password', default='abc')
args = parser.parse_args()
print('parsed args', args)
mq = {
'metric_id': args.vs_metrics,
'serviceengine_uuid': args.se_uuid,
'tenant': (args.tenant if args.tenant else 'admin'),
'step': args.step,
'limit': args.limit,
'aggregate_entity': not args.per_vs_metrics,
'entity_uuid': '*',
'pad_missing_data': False
}
api_ssn = ApiSession(args.controller, args.username, args.password,
args.tenant)
api_utils = ApiUtils(api_ssn)
rsp = api_utils.get_metrics_collection(tenant=args.tenant,
metric_requests=[mq])
print ('metrics query', mq)
print (json.dumps(rsp, indent=2))
ca_key = f.read()
with open('../certs/cacert.pem') as f:
ca_cert = f.read()
# Read the tenant config from apic/apic_tenant_config.json
load_tenant_config()
# Establish session with the Avi Controller in 'admin' tenant for
# configuration
try:
admin_session = create_avi_endpoint(tenant='admin')
except Exception:
print('login failed to Avi Controller!')
sys.exit(0)
ApiUtils(admin_session).import_ssl_certificate('MyCert', server_key,
server_crt)
create_pki_profile(admin_session, 'MyPKIProfile', certs=[ca_cert])
create_application_profile(admin_session, 'MyAppProfile', 'MyPKIProfile')
# Establish session with the APIC
apic_config = get_avi_apic_config()
apic_session = APICClient(apic_config['ip'], apic_config['username'],
apic_config['password'])
create_apic_topology()
print('------------------------------------------------------')
print('Creating objects in Avi for Tenant %s' % (tenant_config['Tenant']))
print('------------------------------------------------------')
avi_tenant_session = create_avi_endpoint(tenant=tenant_config['Tenant'])
# Create Ip Address Group if present
create_avi_ipaddrgroup(avi_tenant_session)
'--user',
type=str,
required=True,
help='Username to authenticate against Avi Controller')
parser.add_argument('-p',
'--password',
type=str,
required=True,
help='Password to authenticate against Avi Controller')
args = parser.parse_args()
api = ApiSession.get_session(args.controller,
args.user,
args.password,
tenant=args.tenant)
api_utils = ApiUtils(api)
def get_metrics(entity_type, entity_name, metric_id, step, tenant):
try:
metrics_dict = api_utils.get_metrics(entity_type,
entity_name,
metric_id=metric_id,
step=step,
limit=1,
tenant=tenant,
timeout=5)
return metrics_dict['series'][0]['data'][0]['value']
except:
print 'Error in getting %s metric for %s name: %s' % (
metric_id, entity_type, entity_name)
def __init__(self, api):
self.api = api
self.api_utils = ApiUtils(api)
def __init__(self, api_session):
self.api_session = api_session
self.api_util = ApiUtils(api_session)