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, \
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 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 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 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 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 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 _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()
class VcdAnsibleModule(AnsibleModule):
def __init__(self, *args, **kwargs):
argument_spec = vcd_argument_spec()
argument_spec.update(kwargs.get('argument_spec', dict()))
kwargs['argument_spec'] = argument_spec
super(VcdAnsibleModule, self).__init__(*args, **kwargs)
self.login()
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 execute_task(self, task):
task_monitor = self.client.get_task_monitor()
task_state = task_monitor.wait_for_status(task=task,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS,
TaskStatus.ABORTED,
TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
task_status = task_state.get('status')
if task_status != TaskStatus.SUCCESS.value:
raise Exception(etree.tostring(task_state, pretty_print=True))
return 1
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 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 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 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)
class VcdAnsibleModule(AnsibleModule):
def __init__(self, *args, **kwargs):
argument_spec = vcd_argument_spec()
argument_spec.update(kwargs.get('argument_spec', dict()))
kwargs['argument_spec'] = argument_spec
super(VcdAnsibleModule, self).__init__(*args, **kwargs)
self.login()
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:
self.fail_json(
msg='Login failed for user {} to org {}'.format(user, org))
def execute_task(self, task):
task_monitor = self.client.get_task_monitor()
task_state = task_monitor.wait_for_status(task=task,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS,
TaskStatus.ABORTED,
TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
task_status = task_state.get('status')
if task_status != TaskStatus.SUCCESS.value:
raise Exception(etree.tostring(task_state, pretty_print=True))
return 1
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 get_vsphere(config, vapp, vm_name):
"""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:
:param str vm_name:
:return: VSphere object for a specific VM inside a VApp
:rtype: vsphere_guest_run.vsphere.VSphere
"""
global cache
vm_resource = vapp.get_vm(vm_name)
vm_id = vm_resource.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)
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
else:
LOGGER.debug(f"vCenter retrieved from cache\nVM ID: {vm_id}"
f"\nHostname: {cache[vm_id]['hostname']}")
return VSphere(cache[vm_id]['hostname'], cache[vm_id]['username'],
cache[vm_id]['password'], cache[vm_id]['port'])
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
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)
class VcdAnsibleModule(AnsibleModule):
def __init__(self, *args, **kwargs):
argument_spec = vcd_argument_spec()
argument_spec.update(kwargs.get('argument_spec', dict()))
kwargs['argument_spec'] = argument_spec
super(VcdAnsibleModule, self).__init__(*args, **kwargs)
self.login()
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 execute_task(self, task):
task_monitor = self.client.get_task_monitor()
task_state = task_monitor.wait_for_status(
task=task,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
task_status = task_state.get('status')
if task_status != TaskStatus.SUCCESS.value:
raise Exception(etree.tostring(task_state, pretty_print=True))
return 1
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 " + x)
# catalog.create(client,"c2","c2desc")
return client
except Exception as e:
print('error occured', e)
def get_sys_admin_client():
server_config = get_server_runtime_config()
if not server_config['vcd']['verify']:
LOGGER.warning("InsecureRequestWarning: Unverified HTTPS "
"request is being made. Adding certificate "
"verification is strongly advised.")
requests.packages.urllib3.disable_warnings()
client = Client(uri=server_config['vcd']['host'],
api_version=server_config['vcd']['api_version'],
verify_ssl_certs=server_config['vcd']['verify'],
log_file=SERVER_DEBUG_WIRELOG_FILEPATH,
log_requests=True,
log_headers=True,
log_bodies=True)
credentials = BasicLoginCredentials(server_config['vcd']['username'],
SYSTEM_ORG_NAME,
server_config['vcd']['password'])
client.set_credentials(credentials)
return client
def get_telemetry_instance_id(vcd,
logger_instance=None,
msg_update_callback=None):
"""Get CSE 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 vcd: 'vcd' section of config file as a dict.
:param logging.logger logger_instance: logger instance to log any error
in retrieving CSE extension id.
:param utils.ConsoleMessagePrinter msg_update_callback: Callback object
that writes messages onto console.
:return instance id to use for sending data to Vmware telemetry server
:rtype str
:raises Exception: if any exception happens while retrieving CSE
extension id
"""
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']))
ext = APIExtension(client)
cse_info = ext.get_extension_info(CSE_SERVICE_NAME,
namespace=CSE_SERVICE_NAMESPACE)
if logger_instance:
logger_instance.info("Retrieved telemetry instance id")
return cse_info.get('id')
except Exception as err:
msg = f"Cannot retrieve telemetry instance id:{err}"
if msg_update_callback:
msg_update_callback.general(msg)
if logger_instance:
logger_instance.error(msg)
finally:
if client is not None:
client.logout()
def uninstall_cse(ctx, config_file_name, template_name):
click.secho('Uninstalling CSE from vCD from file: %s, template: %s' %
(config_file_name, template_name))
config = get_config(config_file_name)
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)))
ctx.obj = {}
ctx.obj['client'] = client
if config['broker']['type'] == 'default':
ctx.obj = {}
ctx.obj['client'] = client
orgs = client.get_org_list()
for org in [o for o in orgs.Org if hasattr(orgs, 'Org')]:
if org.get('name') == config['broker']['org']:
org_href = org.get('href')
org = Org(client, href=org_href)
click.echo('Find org \'%s\': %s' % (org.get_name(), bool_to_msg(True)))
vdc_resource = org.get_vdc(config['broker']['vdc'])
click.echo('Find vdc \'%s\': %s' % (vdc_resource.get('name'),
bool_to_msg(True)))
vdc = VDC(client, resource=vdc_resource)
assert vdc
for template in config['broker']['templates']:
if template_name == '*' or template['name'] == template_name:
click.secho('Deleting template: %s (%s:%s)' %
(template['name'], config['broker']['catalog'],
template['catalog_item']))
org.delete_catalog_item(config['broker']['catalog'],
template['catalog_item'])
def login_as_system_admin():
"""Create and returns a new session with the service account for the proxy.
Returns:
pyvcloud.vcd.client.Client: Session as service account.
"""
client = Client(conf('global.vcloud.hostname'),
api_version=conf('global.vcloud.api_version'),
verify_ssl_certs=conf('global.vcloud.ssl_verify', True),
log_file=conf("global.pyvcloud.log_file"),
log_requests=conf("global.pyvcloud.log_requests"),
log_headers=conf("global.pyvcloud.log_headers"),
log_bodies=conf("global.pyvcloud.log_bodies"))
credentials = BasicLoginCredentials(conf('global.vcloud.username'),
conf('global.vcloud.system_org'),
conf('global.vcloud.password'))
client.set_credentials(credentials)
logger.info(
f"Connected to vCD as system administrator: {conf('global.vcloud.hostname')}"
)
return client
def get_vsphere(config, vapp, vm_name):
global cache
vm_resource = vapp.get_vm(vm_name)
vm_id = vm_resource.get('id')
if vm_id not in cache:
client_sysadmin = Client(uri=config['vcd']['host'],
api_version=config['vcd']['api_version'],
verify_ssl_certs=config['vcd']['verify'],
log_headers=True,
log_bodies=True)
client_sysadmin.set_credentials(
BasicLoginCredentials(config['vcd']['username'], 'System',
config['vcd']['password']))
vapp_sys = VApp(client_sysadmin, href=vapp.href)
vm_resource = vapp_sys.get_vm(vm_name)
vm_sys = VM(client_sysadmin, resource=vm_resource)
vcenter_name = vm_sys.get_vc()
platform = Platform(client_sysadmin)
vcenter = platform.get_vcenter(vcenter_name)
vcenter_url = urlparse(vcenter.Url.text)
cache_item = {
'hostname': vcenter_url.hostname,
'username': vcenter.Username.text,
'port': vcenter_url.port
}
for vc in config['vcs']:
if vc['name'] == vcenter_name:
cache_item['password'] = vc['password']
break
cache[vm_id] = cache_item
else:
LOGGER.debug('vCenter retrieved from cache: %s / %s' %
(vm_id, cache[vm_id]['hostname']))
v = VSphere(cache[vm_id]['hostname'], cache[vm_id]['username'],
cache[vm_id]['password'], cache[vm_id]['port'])
return v
def login(session_id=None):
log_requests = True if config['log'] == True else False
log_headers = True if config['log'] == True else False
log_bodies = True if config['log'] == True else False
client = Client(config['host'],
api_version=config['api_version'],
verify_ssl_certs=config['verify_ssl_certs'],
log_file=config['log_file'],
log_requests=log_requests,
log_headers=log_headers,
log_bodies=log_bodies)
if not config['verify_ssl_certs']:
requests.packages.urllib3.disable_warnings()
try:
if session_id is not None:
client.rehydrate_from_token(session_id)
else:
client.set_credentials(
BasicLoginCredentials(config['username'], config['org'],
config['password']))
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
org_url = "https://%s/cloud/org/%s" % (config['host'], logged_in_org)
the_vdc = org.get_vdc(config['vdc'])
# Set contextual data:
ctx.client = client
ctx.vdc = VDC(client, href=the_vdc.get('href'))
ctx.token = client._session.headers['x-vcloud-authorization']
except Exception as e:
if config['debug'] == True:
print("Exception: {}\n".format(e))
return False
return True
def vcd_login(context, lc):
logging.info("__INIT__vcd_login [%s]", lc)
login_path = ""
client = Client(
lc.ip,
api_version="27.0",
verify_ssl_certs=not lc.allow_insecure_flag,
log_file='vcd.log',
log_requests=True,
log_headers=True,
log_bodies=True)
try:
if lc.use_vcd_cli_profile:
login_path = "rehydrate_from_token"
profiles = Profiles.load()
token = profiles.get('token')
client.rehydrate_from_token(token)
else:
login_path = "set_credentials"
client.set_credentials(
BasicLoginCredentials(lc.username, lc.org, lc.password))
vref = VCDClientRef()
vref.set_ref(client)
logging.debug('LOGIN VIA :[{0}] ARG :[{1}]'.format(
login_path, str(lc)))
return client
except Exception as e:
traceback.print_exc()
error_message = 'ERROR IN LOGIN .. Exception [{0}] LOGIN VIA :[{1}] ARG :[{2}]'.format(
str(e), login_path, str(lc))
error_message = error_message.replace('\n', ' ')
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
raise
def vcd_login(context, lc):
logging.info("__INIT__vcd_login [%s]", lc)
login_path = ""
client = Client(lc.ip,
api_version="27.0",
verify_ssl_certs=not lc.allow_insecure_flag,
log_file='vcd.log',
log_requests=True,
log_headers=True,
log_bodies=True)
try:
if lc.use_vcd_cli_profile:
login_path = "rehydrate_from_token"
profiles = Profiles.load()
token = profiles.get('token')
client.rehydrate_from_token(token)
else:
login_path = "set_credentials"
client.set_credentials(
BasicLoginCredentials(lc.username, lc.org, lc.password))
vref = VCDClientRef()
vref.set_ref(client)
logging.debug('LOGIN VIA :[{0}] ARG :[{1}]'.format(
login_path, str(lc)))
return client
except Exception as e:
traceback.print_exc()
error_message = 'ERROR IN LOGIN .. Exception [{0}] LOGIN VIA :[{1}] ARG :[{2}]'.format(
str(e), login_path, str(lc))
error_message = error_message.replace('\n', ' ')
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
raise
def Authenticate(parameters):
"""
Authenenticate with vCloud Director
"""
try:
print("INFO: Authenticating With vCloud Director")
client = Client(parameters['VCD_HOST'],
api_version=parameters['VCD_API_VERSION'],
verify_ssl_certs=parameters['VCD_SSL_VERIFY'],
log_file='pyvcloud.log',
log_requests=True,
log_headers=True,
log_bodies=True)
client.set_credentials(
BasicLoginCredentials(parameters['VCD_USER'],
parameters['VCD_ORG'],
parameters['VCD_PASSWORD']))
return client
except Exception as e:
print("ERROR: Failed To Authenticate With vCloud Director")
print(e)
exit(1)
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 login(ctx, user, host, password, api_version, org, verify_ssl_certs,
disable_warnings, vdc, session_id, use_browser_session):
"""Login to vCloud Director
\b
Login to a vCloud Director service.
\b
Examples
vcd login mysp.com org1 usr1
Login to host 'mysp.com'.
\b
vcd login test.mysp.com org1 usr1 -i -w
Login to a host with self-signed SSL certificate.
\b
vcd login mysp.com org1 usr1 --use-browser-session
Login using active session from browser.
\b
vcd login session list chrome
List active session ids from browser.
\b
vcd login mysp.com org1 usr1 \\
--session-id ee968665bf3412d581bbc6192508eec4
Login using active session id.
\b
Environment Variables
VCD_PASSWORD
If this environment variable is set, the command will use its value
as the password to login and will not ask for one. The --password
option has precedence over the environment variable.
"""
if not verify_ssl_certs:
if 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()
if host == 'session' and org == 'list':
sessions = []
if user == 'chrome':
cookies = browsercookie.chrome()
for c in cookies:
if c.name == 'vcloud_session_id':
sessions.append({'host': c.domain, 'session_id': c.value})
stdout(sessions, ctx)
return
client = Client(
host,
api_version=api_version,
verify_ssl_certs=verify_ssl_certs,
log_file='vcd.log',
log_requests=True,
log_headers=True,
log_bodies=True)
try:
if api_version is None:
api_version = client.set_highest_supported_version()
if session_id is not None or use_browser_session:
if use_browser_session:
browser_session_id = None
cookies = browsercookie.chrome()
for c in cookies:
if c.name == 'vcloud_session_id' and \
c.domain == host:
browser_session_id = c.value
break
if browser_session_id is None:
raise Exception('Session not found in browser.')
session_id = browser_session_id
client.rehydrate_from_token(session_id)
else:
if password is None:
password = click.prompt('Password', hide_input=True, type=str)
client.set_credentials(BasicLoginCredentials(user, org, password))
wkep = {}
for endpoint in _WellKnownEndpoint:
if endpoint in client._session_endpoints:
wkep[endpoint.name] = client._session_endpoints[endpoint]
profiles = Profiles.load()
logged_in_org = client.get_org()
org_href = logged_in_org.get('href')
vdc_href = ''
in_use_vdc = ''
if vdc is None:
for v in get_links(logged_in_org, media_type=EntityType.VDC.value):
in_use_vdc = v.name
vdc_href = v.href
break
else:
for v in get_links(logged_in_org, media_type=EntityType.VDC.value):
if vdc == v.name:
in_use_vdc = v.name
vdc_href = v.href
break
if len(in_use_vdc) == 0:
raise Exception('VDC not found')
profiles.update(
host,
org,
user,
client._session.headers['x-vcloud-authorization'],
api_version,
wkep,
verify_ssl_certs,
disable_warnings,
vdc=in_use_vdc,
org_href=org_href,
vdc_href=vdc_href,
log_request=True,
log_header=True,
log_body=True,
vapp='',
vapp_href='')
alt_text = '%s logged in, org: \'%s\', vdc: \'%s\'' % \
(user, org, in_use_vdc)
stdout({
'user': user,
'org': org,
'vdc': in_use_vdc,
'logged_in': True
}, ctx, alt_text)
except Exception as e:
try:
profiles = Profiles.load()
profiles.set('token', '')
except Exception:
pass
stderr(e, ctx)
sys.exit(1)
vcd_host = sys.argv[1]
org = sys.argv[2]
user = sys.argv[3]
password = sys.argv[4]
# Disable warnings from self-signed certificates.
requests.packages.urllib3.disable_warnings()
# Login. SSL certificate verification is turned off to allow self-signed
# certificates. You should only do this in trusted environments.
print("Logging in: host={0}, org={1}, user={2}".format(vcd_host, org, user))
client = Client(vcd_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))
print("Fetching vCD installation info...")
results = client.get_resource(
client._session_endpoints[_WellKnownEndpoint.ADMIN])
for k, v in results.items():
print("Key: {0} Value: {1}".format(k, v))
# Log out.
print("Logging out")
client.logout()
#!/usr/bin/env python3
import os
from pyvcloud.vcd.client import BasicLoginCredentials
from pyvcloud.vcd.client import Client
from pyvcloud.vcd.client import EntityType
from pyvcloud.vcd.org import Org
from pyvcloud.vcd.vdc import VDC
import requests
requests.packages.urllib3.disable_warnings()
client = Client('bos1-vcd-sp-static-202-34.eng.vmware.com',
verify_ssl_certs=False)
client.set_highest_supported_version()
client.set_credentials(BasicLoginCredentials('usr1', 'org1', 'ca$hc0w'))
org = Org(client, resource=client.get_org())
vdc = VDC(client, resource=org.get_vdc('vdc1'))
for resource in vdc.list_resources():
print('%s%s' % (resource['name'].ljust(40),
resource['type']))
client.logout()
config_dict = yaml.safe_load(config_file)
cfg = namedtuple('ConfigObject', config_dict.keys())(**config_dict)
# Disable warnings from self-signed certificates.
requests.packages.urllib3.disable_warnings()
# Login. SSL certificate verification is turned off to allow self-signed
# certificates. You should only do this in trusted environments.
print("Logging in...")
client = Client(cfg.vcd_host, verify_ssl_certs=False,
log_file='pyvcloud.log',
log_requests=True,
log_headers=True,
log_bodies=True)
client.set_highest_supported_version()
client.set_credentials(BasicLoginCredentials(cfg.vcd_admin_user,
"System", cfg.vcd_admin_password))
# Ensure the org exists.
print("Fetching org...")
try:
# This call gets a record that we can turn into an Org class.
org_record = client.get_org_by_name(cfg.org)
org = Org(client, href=org_record.get('href'))
print("Org already exists: {0}".format(org.get_name()))
except Exception:
print("Org does not exist, creating: {0}".format(cfg.org))
sys_admin_resource = client.get_admin()
system = System(client, admin_resource=sys_admin_resource)
admin_org_resource = system.create_org(cfg.org, "Test Org", True)
org_record = client.get_org_by_name(cfg.org)
org = Org(client, href=org_record.get('href'))
