def create_client_instance(self):
host = self._common['host']
version = self._common['api_version']
verify = self._common['verify_certs']
password = self._common['password']
username = self._common['username']
org = self._common['org']
if not org:
raise VcdError('missing required org for service_type vcd')
if not verify:
requests.packages.urllib3.disable_warnings()
if self._debug:
self.debug('Logging vcloud calls to /tmp/ansible_pyvcloud.log')
client = Client(host,
verify_ssl_certs=verify,
api_version=version,
log_file='/tmp/ansible_pyvcloud.log',
log_requests=True,
log_bodies=True,
log_headers=True)
else:
client = Client(host, verify_ssl_certs=verify, api_version=version)
try:
client.set_credentials(
BasicLoginCredentials(user=username,
org=org,
password=password))
except VcdErrorResponseException as e:
raise VcdError('Login to VCD failed', msg=e.vcd_error)
return client
def login(self):
try:
user = self.params.get('user')
password = self.params.get('password')
org = self.params.get('org')
host = self.params.get('host')
api_version = self.params.get('api_version')
verify_ssl_certs = self.params.get('verify_ssl_certs')
# giving more precedence to module level details
user = user if user else os.environ['env_user']
password = password if password else os.environ['env_password']
host = host if host else os.environ['env_host']
org = org if org else os.environ['env_org']
api_version = api_version if api_version else os.environ[
'env_api_version']
verify_ssl_certs = verify_ssl_certs if verify_ssl_certs else os.environ[
'env_verify_ssl_certs']
verify_ssl_certs = False if verify_ssl_certs == "False" else True
self.client = Client(host,
api_version=api_version,
verify_ssl_certs=verify_ssl_certs)
self.client.set_credentials(
BasicLoginCredentials(user, org, password))
except Exception as error:
error = 'Login failed for user {} to org {}'
raise VCDLoginError(error.format(user, org))
def restore_session(ctx):
profiles = Profiles.load()
token = profiles.get('token')
if token is None or len(token) == 0:
raise Exception('Can\'t restore session, please re-login.')
if not profiles.get('verify'):
if profiles.get('disable_warnings'):
pass
else:
click.secho('InsecureRequestWarning: '
'Unverified HTTPS request is being made. '
'Adding certificate verification is strongly '
'advised.', fg='yellow', err=True)
requests.packages.urllib3.disable_warnings()
client = Client(profiles.get('host'),
api_version=profiles.get('api_version'),
verify_ssl_certs=profiles.get('verify'),
log_file='vcd.log',
log_requests=profiles.get('log_request'),
log_headers=profiles.get('log_header'),
log_bodies=profiles.get('log_body')
)
client.rehydrate(profiles)
ctx.obj = {}
ctx.obj['client'] = client
ctx.obj['profiles'] = profiles
def setUpClass(cls):
config_file = 'config.yml'
if 'VCD_TEST_CONFIG_FILE' in os.environ:
config_file = os.environ['VCD_TEST_CONFIG_FILE']
with open(config_file, 'r') as f:
cls.config = yaml.safe_load(f)
if not cls.config['vcd']['verify'] and \
cls.config['vcd']['disable_ssl_warnings']:
requests.packages.urllib3.disable_warnings()
cls.client = Client(
cls.config['vcd']['host'],
api_version=cls.config['vcd']['api_version'],
verify_ssl_certs=cls.config['vcd']['verify'],
log_file='pyvcloud.log',
log_requests=True,
log_headers=True,
log_bodies=True)
cls.client.set_credentials(
BasicLoginCredentials(cls.config['vcd']['user'],
cls.config['vcd']['org'],
cls.config['vcd']['password']))
logging.basicConfig(
filename='tests.log',
level=logging.DEBUG,
format='%(asctime)s %(name)-12s %(lineno)s '
'%(levelname)-8s %(message)s',
datefmt='%m-%d %H:%M:%S')
cls.logger = logging.getLogger(__name__)
def vcdlogin(host, user, password, org):
logging.basicConfig(level=logging.DEBUG)
logging.info("login called")
client = Client(host,
api_version="27.0",
verify_ssl_certs=False,
log_file='vcd.log',
log_requests=True,
log_headers=True,
log_bodies=True)
try:
client.set_credentials(BasicLoginCredentials(user, org, password))
x = client._session.headers['x-vcloud-authorization']
logging.info(" ===== X VCloud ========\n \n" + x + "\n \n")
#pRes= catalog.isPresent(client,"c1")
#res=catalog.create(client,"c3","c2UPD")
#logging.info(" is create ===== \n \n "+ str(res.created)+ "\n \n ")
logging.info("\n\n=====callling upload ova===\n")
catalog.upload_media(client,
"c3",
"/home/iso/vcains13.ova",
item_name="vc installer 1.3")
logging.info("\n\n=====upload done ===\n ")
#logging.info(" Delete ===== \n \n "+ str(catalog.delete(client,"c3").deleted)+ "\n \n ")
#logging.info(" Delete ===== \n \n "+ str(catalog.delete(client,"c4").deleted)+ "\n \n ")
return client
except Exception as e:
print('error occured', e)
def init_environment(config_filepath=BASE_CONFIG_FILEPATH):
"""Set up module variables according to config dict.
:param str config_filepath:
"""
global AMQP_USERNAME, AMQP_PASSWORD, CLIENT, ORG_HREF, VDC_HREF, \
CATALOG_NAME, TEARDOWN_INSTALLATION, TEARDOWN_CLUSTERS, \
TEST_ALL_TEMPLATES
config = testutils.yaml_to_dict(config_filepath)
CLIENT = Client(config['vcd']['host'],
api_version=config['vcd']['api_version'],
verify_ssl_certs=config['vcd']['verify'])
credentials = BasicLoginCredentials(config['vcd']['username'],
utils.SYSTEM_ORG_NAME,
config['vcd']['password'])
CLIENT.set_credentials(credentials)
org = utils.get_org(CLIENT, org_name=config['broker']['org'])
vdc = utils.get_vdc(CLIENT, config['broker']['vdc'], org=org)
ORG_HREF = org.href
VDC_HREF = vdc.href
CATALOG_NAME = config['broker']['catalog']
AMQP_USERNAME = config['amqp']['username']
AMQP_PASSWORD = config['amqp']['password']
test_config = config.get('test')
if test_config is not None:
TEARDOWN_INSTALLATION = test_config.get('teardown_installation', True)
TEARDOWN_CLUSTERS = test_config.get('teardown_clusters', True)
TEST_ALL_TEMPLATES = test_config.get('test_all_templates', False)
def vcd_login(host, user, password, org):
logging.basicConfig(level=logging.DEBUG)
logging.info("login called")
client = Client(host,
api_version="27.0",
verify_ssl_certs=False,
log_file='vcd.log',
log_requests=True,
log_headers=True,
log_bodies=True)
try:
client.set_credentials(BasicLoginCredentials(user, org, password))
x = client._session.headers['x-vcloud-authorization']
logging.info(" ===== X VCloud ========\n \n" + x + "\n \n")
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
v = org.get_vdc('OVD2')
vdc = VDC(client, href=v.get('href'))
vapp = vdc.get_vapp('cento_vapp11_2')
nconfig_section = vapp.NetworkConfigSection
nconfig = nconfig_section.findall(
"{http://www.vmware.com/vcloud/v1.5}NetworkConfig")
for i in range(0, len(nconfig)):
print(nconfig[i].get('networkName'))
##print(etree.tostring(nconfig[0], pretty_print=True))
#pRes= catalog.isPresent(client,"c1")
# res=catalog.create(client,"c44","c44",True)
#logging.info(" is create ===== \n \n "+ str(res.created)+ "\n \n ")
#logging.info("\n\n=====callling upload ova===\n")
#catalog_item.upload_ova(client,"c44","/home/iso/tiny.ova",item_name="tiny3.ova")
#logging.info("\n\n=====upload done ===\n ")
#logging.info(" Delete ===== \n \n "+ str(catalog.delete(client,"c3").deleted)+ "\n \n ")
#logging.info(" Delete ===== \n \n "+ str(catalog.delete(client,"c4").deleted)+ "\n \n ")
#vappInfo=pyvcloudprovider_pb2.CreateVAppInfo()
#vappInfo.name="vappacc2"
#vappInfo.catalog_name="c1"
#vappInfo.template_name="cento_tmpl1"
#vapp.create(client,vappInfo)
#delVappInfo=pyvcloudprovider_pb2.DeleteVAppInfo()
#delVappInfo.name="vappacc2"
#vapp.delete(client,delVappInfo)
#ovaInfo=pyvcloudprovider_pb2.CatalogUploadOvaInfo()
#ovaInfo.item_name="item1"
#ovaInfo.catalog_name="testcata1"
#ovaInfo.file_path="/Users/srinarayana/vmws/tiny.ova"
# catalog_item.ova_check_resolved(client,ovaInfo)
#vappInfo.template_name="cento_tmpl1"
#vapp.create(client,vappInfo)
return client
except Exception as e:
print('error occured', e)
def get_client(cls, org, username, password):
"""Returns a client for a particular user.
The user is identified by the specified username-password combo in a
given organization.
:param str org: name of the organization, which the user belongs to.
:param str username: username of the user.
:param str password: password of the user.
:return: a client.
:rtype: pyvcloud.vcd.client.Client
:raises: Exception: if the basic configuration is missing.
"""
if cls._config is None:
raise Exception('Missing base configuration.')
client = Client(
cls._config['vcd']['host'],
api_version=cls._config['vcd']['api_version'],
verify_ssl_certs=cls._config['connection']['verify'],
log_file=cls._config['logging']['default_client_log_filename'],
log_requests=cls._config['logging']['log_requests'],
log_headers=cls._config['logging']['log_headers'],
log_bodies=cls._config['logging']['log_bodies'])
client.set_credentials(BasicLoginCredentials(username, org, password))
return client
def init_environment(config_filepath=BASE_CONFIG_FILEPATH):
"""Set up module variables according to config dict.
:param str config_filepath:
"""
global AMQP_USERNAME, AMQP_PASSWORD, CLIENT, ORG_HREF, VDC_HREF, \
CATALOG_NAME, TEARDOWN_INSTALLATION, TEARDOWN_CLUSTERS, \
TEMPLATE_DEFINITIONS, TEST_ALL_TEMPLATES, SYS_ADMIN_LOGIN_CMD, \
ORG_ADMIN_LOGIN_CMD, VAPP_AUTHOR_LOGIN_CMD, USER_LOGIN_CMD_MAP
config = testutils.yaml_to_dict(config_filepath)
rtm = RemoteTemplateManager(
config['broker']['remote_template_cookbook_url'])
template_cookbook = rtm.get_remote_template_cookbook()
TEMPLATE_DEFINITIONS = template_cookbook['templates']
rtm.download_all_template_scripts(force_overwrite=True)
CLIENT = Client(config['vcd']['host'],
api_version=config['vcd']['api_version'],
verify_ssl_certs=config['vcd']['verify'])
credentials = BasicLoginCredentials(config['vcd']['username'],
SYSTEM_ORG_NAME,
config['vcd']['password'])
CLIENT.set_credentials(credentials)
org = pyvcloud_utils.get_org(CLIENT, org_name=config['broker']['org'])
vdc = pyvcloud_utils.get_vdc(CLIENT,
vdc_name=config['broker']['vdc'],
org=org)
ORG_HREF = org.href
VDC_HREF = vdc.href
CATALOG_NAME = config['broker']['catalog']
AMQP_USERNAME = config['amqp']['username']
AMQP_PASSWORD = config['amqp']['password']
SYS_ADMIN_LOGIN_CMD = f"login {config['vcd']['host']} system " \
f"{config['vcd']['username']} " \
f"-iwp {config['vcd']['password']} " \
f"-V {config['vcd']['api_version']}"
ORG_ADMIN_LOGIN_CMD = f"login {config['vcd']['host']} " \
f"{config['broker']['org']}" \
f" {ORG_ADMIN_NAME} -iwp {ORG_ADMIN_PASSWORD} " \
f"-V {config['vcd']['api_version']}"
VAPP_AUTHOR_LOGIN_CMD = f"login {config['vcd']['host']} " \
f"{config['broker']['org']} " \
f"{VAPP_AUTHOR_NAME} -iwp {VAPP_AUTHOR_PASSWORD}" \
f" -V {config['vcd']['api_version']}"
USER_LOGIN_CMD_MAP = {
'sys_admin': SYS_ADMIN_LOGIN_CMD,
'org_admin': ORG_ADMIN_LOGIN_CMD,
'vapp_author': VAPP_AUTHOR_LOGIN_CMD
}
test_config = config.get('test')
if test_config is not None:
TEARDOWN_INSTALLATION = test_config.get('teardown_installation', True)
TEARDOWN_CLUSTERS = test_config.get('teardown_clusters', True)
TEST_ALL_TEMPLATES = test_config.get('test_all_templates', False)
def restore_session(ctx, vdc_required=False):
if type(ctx.obj) is dict and 'client' in ctx.obj and ctx.obj[
'client'] is not None:
return
profiles = Profiles.load()
token = profiles.get('token')
if token is None or len(token) == 0:
raise Exception('Can\'t restore session, please login again.')
if not profiles.get('verify'):
if profiles.get('disable_warnings'):
pass
else:
click.secho(
'InsecureRequestWarning: '
'Unverified HTTPS request is being made. '
'Adding certificate verification is strongly '
'advised.',
fg='yellow',
err=True)
requests.packages.urllib3.disable_warnings()
client = Client(profiles.get('host'),
api_version=profiles.get('api_version'),
verify_ssl_certs=profiles.get('verify'),
log_file='vcd.log',
log_requests=profiles.get('log_request'),
log_headers=profiles.get('log_header'),
log_bodies=profiles.get('log_body'))
client.rehydrate(profiles)
ctx.obj = {}
ctx.obj['client'] = client
ctx.obj['profiles'] = profiles
if vdc_required:
if not ctx.obj['profiles'].get('vdc_in_use') or \
not ctx.obj['profiles'].get('vdc_href'):
raise Exception('select a virtual datacenter')
def init_environment(config_filepath=BASE_CONFIG_FILEPATH):
"""Set up module variables according to config dict.
:param str config_filepath:
"""
global AMQP_USERNAME, AMQP_PASSWORD, CLIENT, ORG_HREF, VDC_HREF, \
CATALOG_NAME, DEV_MODE
config = testutils.yaml_to_dict(config_filepath)
CLIENT = Client(config['vcd']['host'],
api_version=config['vcd']['api_version'],
verify_ssl_certs=config['vcd']['verify'])
credentials = BasicLoginCredentials(config['vcd']['username'],
utils.SYSTEM_ORG_NAME,
config['vcd']['password'])
CLIENT.set_credentials(credentials)
org = utils.get_org(CLIENT, org_name=config['broker']['org'])
vdc = utils.get_vdc(CLIENT, config['broker']['vdc'], org=org)
ORG_HREF = org.href
VDC_HREF = vdc.href
CATALOG_NAME = config['broker']['catalog']
AMQP_USERNAME = config['amqp']['username']
AMQP_PASSWORD = config['amqp']['password']
try:
DEV_MODE = config['test']['developer_mode']
except KeyError:
pass
def _validate_vcd_config(
vcd_dict,
msg_update_callback=NullPrinter(),
log_file=None,
log_wire=False
):
"""Ensure that 'vcd' section of config is correct.
Checks that
* 'vcd' section of config has correct keys and value types.
* vCD is accessible.
:param dict vcd_dict: 'vcd' section of config file as a dict.
:param utils.ConsoleMessagePrinter msg_update_callback: Callback object.
:param str log_file: log_file for pyvcloud wire log.
:param bool log_wire: If pyvcloud requests should be logged.
:raises KeyError: if @vcd_dict has missing
:raises TypeError: if the value type for a @vcd_dict is incorrect.
"""
check_keys_and_value_types(
vcd_dict,
SAMPLE_VCD_CONFIG['vcd'],
location="config file 'vcd' section",
msg_update_callback=msg_update_callback
)
if not vcd_dict['verify']:
msg_update_callback.general(
'InsecureRequestWarning: Unverified HTTPS request is '
'being made. Adding certificate verification is '
'strongly advised.'
)
requests.packages.urllib3.disable_warnings()
client = None
try:
_validate_vcd_url_scheme(vcd_dict['host'])
client = Client(
vcd_dict['host'],
verify_ssl_certs=vcd_dict['verify'],
log_file=log_file,
log_requests=log_wire,
log_headers=log_wire,
log_bodies=log_wire
)
client.set_credentials(
BasicLoginCredentials(
vcd_dict['username'],
SYSTEM_ORG_NAME,
vcd_dict['password']
)
)
msg_update_callback.general(
"Connected to vCloud Director "
f"({vcd_dict['host']}:{vcd_dict['port']})"
)
finally:
if client is not None:
client.logout()
def setUpClass(cls):
"""Runs once for this class, before all test methods.
Tasks:
- Initialize client, config, and other attributes.
- Restore VCD AMQP settings to defaults.
- Delete any pre-existing CSE entities.
"""
cls._config = yaml_to_dict(BASE_CONFIG_FILEPATH)
cls._client = Client(cls._config['vcd']['host'],
api_version=cls._config['vcd']['api_version'],
verify_ssl_certs=cls._config['vcd']['verify'])
credentials = BasicLoginCredentials(cls._config['vcd']['username'],
SYSTEM_ORG_NAME,
cls._config['vcd']['password'])
cls._client.set_credentials(credentials)
assert cls._client is not None
cls._org = get_org(cls._client, org_name=cls._config['broker']['org'])
assert cls._org is not None
cls._vdc = get_vdc(cls._client,
cls._config['broker']['vdc'],
org=cls._org)
assert cls._vdc is not None
cls._api_extension = APIExtension(cls._client)
assert cls._api_extension is not None
cls._amqp_service = AmqpService(cls._client)
assert cls._amqp_service is not None
cls._runner = CliRunner()
assert cls._runner is not None
cls._ssh_key_filepath = f"{Path.home() / '.ssh' / 'id_rsa.pub'}"
configure_vcd_amqp(cls._client,
'vcdext',
cls._config['amqp']['host'],
cls._config['amqp']['port'],
'vcd',
cls._config['amqp']['ssl_accept_all'],
cls._config['amqp']['ssl'],
'/',
cls._config['amqp']['username'],
cls._config['amqp']['password'],
quiet=True)
cls._default_amqp_settings = to_dict(cls._amqp_service.get_settings())
assert cls._default_amqp_settings is not None
cls._amqp_username = cls._config['amqp']['username']
assert cls._amqp_username is not None
cls._amqp_password = cls._config['amqp']['password']
assert cls._amqp_password is not None
CSEServerInstallationTest.delete_cse_entities()
def get_all_host(host, org, user, password, vdc):
#Linux guest hosts
linux_os_list = ['CentOS 7 (64-bit)', 'Ubuntu Linux (64-bit)', 'CentOS 8 (64-bit)']
#Windows guest hosts
win_os_list = ['Microsoft Windows Server 2016 or later (64-bit)', 'Microsoft Windows Server 2019 (64-bit)']
#Host list of all Vapps
host_list = {}
client = Client(host,
verify_ssl_certs=True,#SSL
log_requests=False,
log_headers=False,
log_bodies=False)
client.set_highest_supported_version()
client.set_credentials(BasicLoginCredentials(user, org, password))
org_resource = client.get_org()
org = Org(client, resource=org_resource)
vdc_resource = org.get_vdc(vdc)
vdc = VDC(client, resource=vdc_resource)
vapps = vdc.list_resources()
win_list = []
linux_list = []
other_os_list = []
hostvars = {}
for vapp in vapps:
if vapp["type"] == "application/vnd.vmware.vcloud.vApp+xml":
currentHref = vdc.get_vapp_href(vapp["name"])
currentVapp = VApp(client, href=currentHref)
for vm in currentVapp.get_all_vms():
vmName = vm.get('name')
vmOs = VM(client, resource=vm)
vOs = vmOs.get_operating_system_section()
try:
vmIp = currentVapp.get_primary_ip(vmName)
except:
pass
if vmOs.is_powered_on():
if vOs.Description in win_os_list:
win_list.append(vmName)
hostvars.update({vmName:{'ansible_host':vmIp}})
elif vOs.Description in linux_os_list:
linux_list.append(vmName)
hostvars.update({vmName:{'ansible_host':vmIp}})
else:
other_os_list.append(vmName)
hostvars.update({vmName:{'ansible_host':vmIp}})
host_list.update({'windows':{'hosts':win_list}})
host_list.update({'linux':{'hosts':linux_list}})
host_list.update({'others':{'hosts':other_os_list}})
host_list.update({'_meta':{'hostvars':hostvars}})
return host_list
def get_telemetry_instance_id(vcd_host: str,
vcd_username: str,
vcd_password: str,
verify_ssl: bool,
is_mqtt_exchange: bool,
logger_debug=NULL_LOGGER,
msg_update_callback=NullPrinter()):
"""Get CSE AMQP or MQTT extension id which is used as instance id.
Any exception is logged as error. No exception is leaked out
of this method and does not affect the server startup.
:param str vcd_host:
:param str vcd_username:
:param str vcd_password:
:param bool verify_ssl:
:param bool is_mqtt_exchange:
:param logging.logger logger_debug: logger instance to log any error
in retrieving CSE extension id.
:param utils.ConsoleMessagePrinter msg_update_callback: Callback object.
:return instance id to use for sending data to Vmware telemetry server
:rtype str (unless no instance id found)
"""
client = None
try:
client = Client(vcd_host, verify_ssl_certs=verify_ssl)
client.set_credentials(
BasicLoginCredentials(vcd_username, SYSTEM_ORG_NAME, vcd_password))
if is_mqtt_exchange:
# Get MQTT extension uuid
mqtt_ext_manager = MQTTExtensionManager(client)
ext_info = mqtt_ext_manager.get_extension_info(
ext_name=CSE_SERVICE_NAME,
ext_version=MQTT_EXTENSION_VERSION,
ext_vendor=MQTT_EXTENSION_VENDOR)
if not ext_info:
logger_debug.debug("Failed to retrieve telemetry instance id")
return None
logger_debug.debug("Retrieved telemetry instance id")
return mqtt_ext_manager.get_extension_uuid(
ext_info[MQTTExtKey.EXT_URN_ID])
else:
# Get AMQP extension id
ext = APIExtension(client)
cse_info = ext.get_extension_info(CSE_SERVICE_NAME,
namespace=CSE_SERVICE_NAMESPACE)
logger_debug.debug("Retrieved telemetry instance id")
return cse_info.get('id')
except Exception as err:
msg = f"Cannot retrieve telemetry instance id:{err}"
msg_update_callback.general(msg)
logger_debug.error(msg, exc_info=True)
finally:
if client is not None:
client.logout()
def client(self):
if self._client is None:
self._client = Client(
self.endpoint,
api_version=self.api_version,
verify_ssl_certs=False,
)
self.client.set_credentials(
BasicLoginCredentials(self.username, self.organization,
self.password))
return self._client
def login(user, org, password):
requests.packages.urllib3.disable_warnings()
client = Client(host,
api_version='29.0',
verify_ssl_certs=False,
log_file='pyvcloud.log',
log_requests=True,
log_headers=True,
log_bodies=True)
client.set_credentials(BasicLoginCredentials(user, org, password))
return client
def check_config(config_file_name, template='*'):
click.secho('Validating CSE on vCD from file: %s' % config_file_name)
config = get_config(config_file_name)
validate_broker_config_elements(config['broker'])
amqp = config['amqp']
credentials = pika.PlainCredentials(amqp['username'], amqp['password'])
parameters = pika.ConnectionParameters(
amqp['host'], amqp['port'], '/', credentials, ssl=amqp['ssl'])
connection = pika.BlockingConnection(parameters)
click.echo('Connected to AMQP server (%s:%s): %s' %
(amqp['host'], amqp['port'], bool_to_msg(connection.is_open)))
connection.close()
v = VSphere(
config['vcs']['host'],
config['vcs']['username'],
config['vcs']['password'],
port=int(config['vcs']['port']))
v.connect()
click.echo('Connected to vCenter Server as %s '
'(%s:%s): %s' % (config['vcs']['username'],
config['vcs']['host'], config['vcs']['port'],
bool_to_msg(True)))
if not config['vcd']['verify']:
click.secho(
'InsecureRequestWarning: '
'Unverified HTTPS request is being made. '
'Adding certificate verification is strongly '
'advised.',
fg='yellow',
err=True)
requests.packages.urllib3.disable_warnings()
client = Client(
config['vcd']['host'],
api_version=config['vcd']['api_version'],
verify_ssl_certs=config['vcd']['verify'],
log_file='cse.log',
log_headers=True,
log_bodies=True)
client.set_credentials(
BasicLoginCredentials(config['vcd']['username'], 'System',
config['vcd']['password']))
click.echo('Connected to vCloud Director as system '
'administrator (%s:%s): %s' % (config['vcd']['host'],
config['vcd']['port'],
bool_to_msg(True)))
click.secho('Validating \'%s\' service broker' % config['broker']['type'])
if config['broker']['type'] == 'default':
validate_broker_config_content(config, client, template)
return config
def get_vsphere(config, vapp, vm_name, logger=None):
"""Get the VSphere object for a specific VM inside a VApp.
:param dict config: CSE config as a dictionary
:param pyvcloud.vcd.vapp.VApp vapp: VApp used to get the VM ID.
:param str vm_name:
:param logging.Logger logger: optional logger to log with.
:return: VSphere object for a specific VM inside a VApp
:rtype: vsphere_guest_run.vsphere.VSphere
"""
global cache
# get vm id from vm resource
vm_id = vapp.get_vm(vm_name).get('id')
if vm_id not in cache:
client = Client(uri=config['vcd']['host'],
api_version=config['vcd']['api_version'],
verify_ssl_certs=config['vcd']['verify'],
log_headers=True,
log_bodies=True)
credentials = BasicLoginCredentials(config['vcd']['username'],
SYSTEM_ORG_NAME,
config['vcd']['password'])
client.set_credentials(credentials)
# must recreate vapp, or cluster creation fails
vapp = VApp(client, href=vapp.href)
vm_resource = vapp.get_vm(vm_name)
vm_sys = VM(client, resource=vm_resource)
vcenter_name = vm_sys.get_vc()
platform = Platform(client)
vcenter = platform.get_vcenter(vcenter_name)
vcenter_url = urlparse(vcenter.Url.text)
cache_item = {
'hostname': vcenter_url.hostname,
'port': vcenter_url.port
}
for vc in config['vcs']:
if vc['name'] == vcenter_name:
cache_item['username'] = vc['username']
cache_item['password'] = vc['password']
break
cache[vm_id] = cache_item
if logger:
logger.debug(f"VM ID: {vm_id}, Hostname: {cache[vm_id]['hostname']}")
return VSphere(cache[vm_id]['hostname'], cache[vm_id]['username'],
cache[vm_id]['password'], cache[vm_id]['port'])
def _connect_sysadmin(self):
if not self.verify:
LOGGER.warning('InsecureRequestWarning: '
'Unverified HTTPS request is being made. '
'Adding certificate verification is strongly '
'advised.')
requests.packages.urllib3.disable_warnings()
self.client_sysadmin = Client(uri=self.host,
api_version=self.version,
verify_ssl_certs=self.verify,
log_headers=True,
log_bodies=True)
self.client_sysadmin.set_credentials(
BasicLoginCredentials(self.username, 'System', self.password))
def connect_vcd_user_via_token(tenant_auth_token):
server_config = get_server_runtime_config()
vcd_uri = server_config['vcd']['host']
version = server_config['vcd']['api_version']
verify_ssl_certs = server_config['vcd']['verify']
client_tenant = Client(uri=vcd_uri,
api_version=version,
verify_ssl_certs=verify_ssl_certs,
log_file=SERVER_DEBUG_WIRELOG_FILEPATH,
log_requests=True,
log_headers=True,
log_bodies=True)
session = client_tenant.rehydrate_from_token(tenant_auth_token)
return (client_tenant, session)
def connect_tenant(self, headers):
token = headers.get('x-vcloud-authorization')
accept_header = headers.get('Accept')
version = accept_header.split('version=')[1]
client_tenant = Client(uri=self.config['vcd']['host'],
api_version=version,
verify_ssl_certs=self.config['vcd']['verify'],
log_headers=True,
log_bodies=True)
session = client_tenant.rehydrate_from_token(token)
return (
client_tenant,
session,
)
def read_native_template_definition_from_catalog(
config: ServerConfig,
msg_update_callback=utils.NullPrinter()
):
# NOTE: If `enable_tkg_plus` in the config file is set to false,
# CSE server will skip loading the TKG+ template this will prevent
# users from performing TKG+ related operations.
msg = "Loading k8s template definition from catalog"
logger.SERVER_LOGGER.info(msg)
msg_update_callback.general_no_color(msg)
client = None
try:
log_filename = None
log_wire = \
utils.str_to_bool(config.get_value_at('service.log_wire'))
if log_wire:
log_filename = logger.SERVER_DEBUG_WIRELOG_FILEPATH
client = Client(
uri=config.get_value_at('vcd.host'),
api_version=config.get_value_at('service.default_api_version'), # noqa: E501
verify_ssl_certs=config.get_value_at('vcd.verify'),
log_file=log_filename,
log_requests=log_wire,
log_headers=log_wire,
log_bodies=log_wire
)
credentials = BasicLoginCredentials(
config.get_value_at('vcd.username'),
shared_constants.SYSTEM_ORG_NAME,
config.get_value_at('vcd.password')
)
client.set_credentials(credentials)
legacy_mode = config.get_value_at('service.legacy_mode')
org_name = config.get_value_at('broker.org')
catalog_name = config.get_value_at('broker.catalog')
k8_templates = ltm.get_valid_k8s_local_template_definition(
client=client, catalog_name=catalog_name, org_name=org_name,
legacy_mode=legacy_mode,
is_tkg_plus_enabled=server_utils.is_tkg_plus_enabled(config),
logger_debug=logger.SERVER_LOGGER,
msg_update_callback=msg_update_callback)
return k8_templates
finally:
if client:
client.logout()
def read_tkgm_template_definition_from_catalog(
config: ServerConfig,
msg_update_callback=utils.NullPrinter()
):
msg = "Loading TKGm template definition from catalog"
logger.SERVER_LOGGER.info(msg)
msg_update_callback.general_no_color(msg)
client = None
try:
log_filename = None
log_wire = utils.str_to_bool(
config.get_value_at('service.log_wire')
)
if log_wire:
log_filename = logger.SERVER_DEBUG_WIRELOG_FILEPATH
client = Client(
uri=config.get_value_at('vcd.host'),
api_version=config.get_value_at('service.default_api_version'), # noqa: E501
verify_ssl_certs=config.get_value_at('vcd.verify'),
log_file=log_filename,
log_requests=log_wire,
log_headers=log_wire,
log_bodies=log_wire
)
credentials = BasicLoginCredentials(
config.get_value_at('vcd.username'),
shared_constants.SYSTEM_ORG_NAME,
config.get_value_at('vcd.password')
)
client.set_credentials(credentials)
org_name = config.get_value_at('broker.org')
catalog_name = config.get_value_at('broker.catalog')
tkgm_templates = ttm.read_all_tkgm_template(
client=client,
org_name=org_name,
catalog_name=catalog_name,
logger=logger.SERVER_LOGGER,
msg_update_callback=msg_update_callback
)
return tkgm_templates
finally:
if client:
client.logout()
def _authenticate(self):
_password = self.templar.template(self.get_option('password'))
if not _password:
raise AnsibleError(f"Password returned None. Check and try again.")
try:
self.client = Client(
self.get_option('host'),
api_version=self.get_option('api_version'),
verify_ssl_certs=self.get_option('verify_ssl_certs'),
log_file=None)
self.client.set_credentials(
BasicLoginCredentials(self.get_option('user'),
self.get_option('org'), _password))
except Exception as e:
raise AnsibleError(f"Failed to login to endpoint. MSG: {e}")
def vcd_login(host, user, password, org):
logging.basicConfig(level=logging.DEBUG)
logging.info("login called")
client = Client(host,
api_version="27.0",
verify_ssl_certs=False,
log_file='vcd.log',
log_requests=True,
log_headers=True,
log_bodies=True)
try:
client.set_credentials(BasicLoginCredentials(user, org, password))
return client
except Exception as e:
print('error occured', e)
def cse_restore_session(ctx, vdc_required=False) -> None:
"""Restores the session with vcd client with right server api version.
Replace the vcd client in ctx.obj with new client created with server api
version. Also saves the server api version in profiles.
:param <click.core.Context> ctx: click context
:param bool vdc_required: is vdc required or not
:return:
"""
# Always override the vcd_client by new client with CSE server api version.
if type(ctx.obj) is not dict or not ctx.obj.get('client'):
profiles = Profiles.load()
token = profiles.get('token')
if token is None or len(token) == 0:
raise Exception('Can\'t restore session, please login again.')
if not profiles.get('verify'):
if not profiles.get('disable_warnings'):
click.secho(
'InsecureRequestWarning: '
'Unverified HTTPS request is being made. '
'Adding certificate verification is strongly '
'advised.',
fg='yellow',
err=True)
requests.packages.urllib3.disable_warnings()
client = Client(
profiles.get('host'),
api_version=profiles.get('api_version'),
verify_ssl_certs=profiles.get('verify'),
log_file='vcd.log',
log_requests=profiles.get('log_request'),
log_headers=profiles.get('log_header'),
log_bodies=profiles.get('log_body'))
client.rehydrate_from_token(
profiles.get('token'), profiles.get('is_jwt_token'))
ctx.obj = {}
ctx.obj['client'] = client
_override_client(ctx)
if vdc_required:
if not ctx.obj['profiles'].get('vdc_in_use') or \
not ctx.obj['profiles'].get('vdc_href'):
raise Exception('select a virtual datacenter')
def get_telemetry_instance_id(config_dict, logger_debug=NULL_LOGGER,
msg_update_callback=NullPrinter()):
"""Get CSE AMQP or MQTT extension id which is used as instance id.
Any exception is logged as error. No exception is leaked out
of this method and does not affect the server startup.
:param dict config_dict: CSE configuration
:param logging.logger logger_debug: logger instance to log any error
in retrieving CSE extension id.
:param utils.ConsoleMessagePrinter msg_update_callback: Callback object.
:return instance id to use for sending data to Vmware telemetry server
:rtype str (unless no instance id found)
"""
vcd = config_dict['vcd']
try:
client = Client(vcd['host'], api_version=vcd['api_version'],
verify_ssl_certs=vcd['verify'])
client.set_credentials(BasicLoginCredentials(
vcd['username'], SYSTEM_ORG_NAME, vcd['password']))
if should_use_mqtt_protocol(config_dict):
# Get MQTT extension uuid
mqtt_ext_manager = MQTTExtensionManager(client)
ext_info = mqtt_ext_manager.get_extension_info(
ext_name=CSE_SERVICE_NAME,
ext_version=MQTT_EXTENSION_VERSION,
ext_vendor=MQTT_EXTENSION_VENDOR)
if not ext_info:
return None
return mqtt_ext_manager.get_extension_uuid(
ext_info[MQTTExtKey.EXT_URN_ID])
else:
# Get AMQP extension id
ext = APIExtension(client)
cse_info = ext.get_extension_info(CSE_SERVICE_NAME,
namespace=CSE_SERVICE_NAMESPACE)
logger_debug.info("Retrieved telemetry instance id")
return cse_info.get('id')
except Exception as err:
msg = f"Cannot retrieve telemetry instance id:{err}"
msg_update_callback.general(msg)
logger_debug.error(msg)
finally:
if client is not None:
client.logout()
def login(self):
try:
user = self.params.get('user')
password = self.params.get('password')
org = self.params.get('org')
host = self.params.get('host')
api_version = self.params.get('api_version')
verify_ssl_certs = self.params.get('verify_ssl_certs')
self.client = Client(host,
api_version=api_version,
verify_ssl_certs=verify_ssl_certs)
self.client.set_credentials(BasicLoginCredentials(user, org, password))
except Exception as error:
error = 'Login failed for user {} to org {}'
raise VCDLoginError(error.format(user, org))
def connect(self):
""" Method connect as normal user to vCloud director.
Returns:
The return vca object that letter can be used to connect to vCloud director as admin for VDC
"""
try:
self.logger.debug("Logging in to a vcd {} as user {}".format(self.org,
self.user))
client = Client(self.url, verify_ssl_certs=False)
client.set_credentials(BasicLoginCredentials(self.user, self.org, self.password))
except Exception:
raise Exception("Can't connect to a vCloud director org: "
"{} as user: {}".format(self.org, self.user))
return client
