def __init__(self, connections, username, password, project_fq_name,
inputs, cfgm_ip, openstack_ip):
self.connections = connections
httpclient = None
self.heat_port = '8004'
self.heat_api_version = '1'
self.username = username
self.password = password
self.vnc_lib_h = self.connections.vnc_lib
self.project_obj = self.vnc_lib_h.project_read(fq_name=project_fq_name)
self.project_id = get_plain_uuid(self.project_obj.uuid)
self.cfgm_ip = cfgm_ip
insecure = bool(os.getenv('OS_INSECURE', True))
self.openstack_ip = openstack_ip
self.inputs = inputs
self.openstack_ip = self.inputs.host_data[self.openstack_ip]['host_ip']
self.obj = None
self.heat_url = 'http://%s:%s/v1/%s' % (
self.openstack_ip, self.heat_port, self.project_id)
self.auth_url = inputs.auth_url
self.kc = ksclient.Client(username=self.inputs.stack_user,
password=self.inputs.stack_password,
tenant_name=self.inputs.project_name,
auth_url=self.auth_url,
insecure=insecure)
self.logger = self.inputs.logger
def _reauthenticate_keystone(self):
if self.token:
self.keystone = keystoneclient.Client(token=self.token,
endpoint=self.endpoint)
else:
self.keystone = ksclient.Client(
username=self.inputs.stack_user,
password=self.inputs.stack_password,
tenant_name=self.inputs.project_name,
auth_url=self.auth_url)
def create_vm(self):
connections = self.connections
#credentials = self.credentials
tenant_name = self.tenant_name
name = self.vm_name
image_id = self.image_id
flavor_id = self.flavor_id
sg_id = self.sg_id
nw_id = self.vn_id
auth_url = self.auth_url
ukai_url = self.ukai_url
env_admin = self.env_admin
env_non_admin = self.env_non_admin
env_vm = self.env_vm
env_cli = env_vm + "export OS_TENANT_NAME=%s; " %(tenant_name)
keystone = ks_client.Client(username=username, password=password,tenant_name=admin_tenant_name,auth_url=auth_url)
if sg_id =='None':
cmd = 'ukai client server create --name %s --image_id %s --network_id %s --flavor_id %s' %(name,image_id,nw_id,flavor_id)
cmd = env_cli+cmd
output = self.inputs.run_cmd_on_server(gc_host, cmd, username = gc_user_name , password = gc_user_pwd)
else:
cmd = 'ukai client server create --name %s --image_id %s --network_id %s --flavor_id %s --security_group_id %s' %(name,image_id,nw_id,flavor_id,sg_id)
cmd = env_cli+cmd
output = self.inputs.run_cmd_on_server(gc_host, cmd, username = gc_user_name , password = gc_user_pwd)
#wait for vm to be UP before checking the uuid
time.sleep(20)
response, servers = keystone.get(ukai_url + "v1.0/servers")
if not response.ok:
print response.reason
os.exit()
for server in servers['servers']:
print server['name']
response, local_servers = keystone.get("%sv1.0/servers/%s/local_servers" % (ukai_url, server['id']))
if not response.ok:
print response.reason
for local_server in local_servers['local_servers']:
print local_server['status'], local_server['instance_id']
if local_server ['server']['name'] == name:
if local_server ['location']['address'] == "99.1.1.13":
uuid = local_server['instance_id']
break
return uuid
def __init__(self, username=None, password=None, tenant=None,
auth_url=None, token=None, endpoint=None,
insecure=True, region_name=None,
logger=None):
self.logger = logger or contrail_logging.getLogger(__name__)
if token:
self.keystone = keystoneclient.Client(
token=token, endpoint=endpoint)
else:
self.keystone = keystone_client.Client(
username=username, password=password, tenant_name=tenant, auth_url=auth_url,
insecure=insecure, region_name=region_name or 'RegionOne')
def keystone_create_users(self, user_list):
cleanup_cmds = []
user_pass = {}
user_role = {}
user_set = set()
role_set = set()
for (n, p, r) in user_list:
user_pass[n] = p
user_role[n] = r
user_set.add(n)
role_set.add(r)
auth_url = os.getenv('OS_AUTH_URL') or \
'http://' + self.inputs.openstack_ip + ':5000/v2.0'
insecure = bool(os.getenv('OS_INSECURE', True))
kc = ksclient.Client(username=self.inputs.stack_user,
password=self.inputs.stack_password,
tenant_name=self.inputs.project_name,
auth_url=auth_url,
insecure=insecure)
users = set([user.name for user in kc.users.list()])
roles = set([user.name for user in kc.roles.list()])
tenants = kc.tenants.list()
admin_tenant = [
x for x in tenants if x.name == self.inputs.stack_tenant
][0]
create_user_set = user_set - users
create_role_set = role_set - roles
# create missing roles
for rolename in create_role_set:
created_role = kc.roles.create(rolename)
self.addCleanup(kc.roles.delete, created_role)
# rebuild name->role dictionary from keystone
role_dict = {}
for role in kc.roles.list():
role_dict[role.name] = role
for name in create_user_set:
user = kc.users.create(name,
user_pass[name],
'',
tenant_id=admin_tenant.id)
self.addCleanup(kc.users.delete, user)
kc.roles.add_user_role(user, role_dict[user_role[name]],
admin_tenant)
self.addCleanup(kc.roles.remove_user_role, user,
role_dict[user_role[name]], admin_tenant)
def __init__(self,
username=None,
password=None,
tenant=None,
auth_url=None,
token=None,
endpoint=None,
insecure=True):
if token:
self.keystone = keystoneclient.Client(token=token,
endpoint=endpoint)
else:
self.keystone = keystone_client.Client(username=username,
password=password,
tenant_name=tenant,
auth_url=auth_url,
insecure=insecure)
def __init__(self,
connections,
username=None,
password=None,
tenant=None,
role='admin',
token=None,
endpoint=None):
self.inputs = connections.inputs
self.connections = connections
self.logger = self.inputs.logger
if self.inputs.orchestrator == 'vcenter':
# No concept of user in vcenter, However we satisfy the test infra
# with dummy fixture objects
return
insecure = bool(os.getenv('OS_INSECURE', True))
if not self.inputs.ha_setup:
self.auth_url = os.getenv('OS_AUTH_URL') or \
'http://%s:5000/v2.0' % (self.inputs.openstack_ip)
else:
self.auth_url = os.getenv('OS_AUTH_URL') or \
'http://%s:5000/v2.0' % (self.inputs.auth_ip)
self.already_present = False
self.username = username
self.password = password
self.tenant = tenant
self.role = role
self.email = str(username) + "@example.com"
self.token = token
self.endpoint = endpoint
self.verify_is_run = False
if self.token:
self.keystone = keystoneclient.Client(token=self.token,
endpoint=self.endpoint)
else:
self.keystone = ksclient.Client(
username=self.inputs.stack_user,
password=self.inputs.stack_password,
tenant_name=self.inputs.project_name,
auth_url=self.auth_url,
insecure=insecure)
def get_client(self, scope='domain'):
return ks_client.Client(version=self.version,
session=self.get_session(scope),
auth_url=self.auth_url,
region_name=self.region_name)
def reauth(self):
self.keystone = ksclient.Client(username=self.user,
password=self.passwd,
tenant_name=self.project,
auth_url=self.auth_url,
insecure=self.insecure)
