def delete_sddc(self):
# Get SDDC ID by name
sddcs = self.vmc_client.orgs.Sddcs.list(self.org_id)
for sddc in sddcs:
if sddc.name == self.sddc_name:
self.sddc_id = sddc.id
break
else:
raise ValueError('Cannot find sddc "{}"'.format(self.sddc_name))
print('\n# Example: Delete SDDC {} from org {}'.format(
self.sddc_id, self.org_id))
try:
task = self.vmc_client.orgs.Sddcs.delete(org=self.org_id,
sddc=self.sddc_id)
except InvalidRequest as e:
# Convert InvalidRequest to ErrorResponse to get error message
error_response = e.data.convert_to(ErrorResponse)
raise Exception(error_response.error_messages)
wait_for_task(task_client=self.vmc_client.orgs.Tasks,
org_id=self.org_id,
task_id=task.id,
interval_sec=self.interval_sec)
print('\n# Example: Remaining SDDCs:')
sddcs = self.vmc_client.orgs.Sddcs.list(self.org_id)
self.print_output(sddcs)
def request_public_ip(self):
print('\n# Example: Request a new IP for SDDC')
ip_spec = SddcAllocatePublicIpSpec(names=[self.notes], count=1)
task = self.vmc_client.orgs.sddcs.Publicips.create(org=self.org_id,
sddc=self.sddc_id,
spec=ip_spec)
wait_for_task(task_client=self.vmc_client.orgs.Tasks,
org_id=self.org_id,
task_id=task.id,
interval_sec=2)
ips = self.vmc_client.orgs.sddcs.Publicips.list(org=self.org_id,
sddc=self.sddc_id)
for ip in ips:
if ip.name == self.notes:
self.ip_id = ip.allocation_id
self.public_ip = ip.public_ip
print('# Successfully requested public IP {}'.format(
ip.public_ip))
break
else:
raise Exception("Can't find public IP with notes {}".format(
self.notes))
def create_sddc(self):
print('\n# Example: Create a SDDC ({}) in org {}:'.format(
self.sddc_name, self.org_id))
provider = os.environ.get('VMC_PROVIDER', 'AWS')
sddc_config = AwsSddcConfig(region='US_WEST_2',
num_hosts=1,
name=self.sddc_name,
provider=provider)
try:
task = self.vmc_client.orgs.Sddcs.create(org=self.org_id,
sddc_config=sddc_config)
except InvalidRequest as e:
# Convert InvalidRequest to ErrorResponse to get error message
error_response = e.data.convert_to(ErrorResponse)
raise Exception(error_response.error_messages)
wait_for_task(task_client=self.vmc_client.orgs.Tasks,
org_id=self.org_id,
task_id=task.id,
interval_sec=self.interval_sec)
print('\n# Example: SDDC created:')
self.sddc_id = task.resource_id
sddc = self.vmc_client.orgs.Sddcs.get(self.org_id, self.sddc_id)
self.print_output([sddc])
def add_host(self):
print('\n# Example: Add 1 ESX hosts to SDDC {}:'.format(self.sddc_id))
esx_config = EsxConfig(1)
task = self.vmc_client.orgs.sddcs.Esxs.create(org=self.org_id,
sddc=self.sddc_id,
esx_config=esx_config)
wait_for_task(task_client=self.vmc_client.orgs.Tasks,
org_id=self.org_id,
task_id=task.id,
interval_sec=self.interval_sec)
def remove_host(self):
print('\n# Example: Remove 1 ESX host from SDDC {}:'.
format(self.sddc_id))
esx_config = EsxConfig(1)
task = self.vmc_client.orgs.sddcs.Esxs.create(org=self.org_id,
sddc=self.sddc_id,
esx_config=esx_config,
action='remove')
wait_for_task(task_client=self.vmc_client.orgs.Tasks,
org_id=self.org_id,
task_id=task.id,
interval_sec=self.interval_sec)
def create_sddc(self):
print('\n# Example: Create a SDDC ({}) in org {}:'.format(
self.sddc_name, self.org_id))
account_linking_config = None
# Get connected accounts if any
account_ids = self.vmc_client.orgs.account_link.ConnectedAccounts.get(
self.org_id)
if len(account_ids) > 0:
account_id = account_ids[0].id
vpc_map = self.vmc_client.orgs.account_link.CompatibleSubnets.get(
org=self.org_id,
linked_account_id=account_id,
region=self.region).vpc_map
customer_subnet_id = self.get_subnet_id(vpc_map)
if not customer_subnet_id:
raise ValueError('No available subnet for region {}'.format(
self.region))
account_linking_config = AccountLinkSddcConfig(
customer_subnet_ids=[customer_subnet_id],
connected_account_id=account_id)
sddc_config = AwsSddcConfig(
region=self.region,
name=self.sddc_name,
account_link_sddc_config=[account_linking_config]
if account_linking_config else None,
provider=os.environ.get('VMC_PROVIDER', SddcConfig.PROVIDER_AWS),
num_hosts=self.num_hosts,
deployment_type=SddcConfig.DEPLOYMENT_TYPE_SINGLEAZ)
try:
task = self.vmc_client.orgs.Sddcs.create(org=self.org_id,
sddc_config=sddc_config)
except InvalidRequest as e:
# Convert InvalidRequest to ErrorResponse to get error message
error_response = e.data.convert_to(ErrorResponse)
raise Exception(error_response.error_messages)
wait_for_task(task_client=self.vmc_client.orgs.Tasks,
org_id=self.org_id,
task_id=task.id,
interval_sec=self.interval_sec)
print('\n# Example: SDDC created:')
self.sddc_id = task.resource_id
sddc = self.vmc_client.orgs.Sddcs.get(self.org_id, self.sddc_id)
self.print_output([sddc])
def add_host(self):
print('\n# Example: Add 1 ESX hosts to SDDC {}:'.format(self.sddc_id))
esx_config = EsxConfig(num_hosts=1)
try:
task = self.vmc_client.orgs.sddcs.Esxs.create(
org=self.org_id, sddc=self.sddc_id, esx_config=esx_config)
except InvalidRequest as e:
# Convert InvalidRequest to ErrorResponse to get error message
error_response = e.data.convert_to(ErrorResponse)
raise Exception(error_response.error_messages)
wait_for_task(task_client=self.vmc_client.orgs.Tasks,
org_id=self.org_id,
task_id=task.id,
interval_sec=self.interval_sec)
def delete_latest_sddc(self):
try:
task = self.vmc_client.orgs.Sddcs.delete(org=self.org_id,
sddc=self.sddc_id)
except InvalidRequest as e:
# Convert InvalidRequest to ErrorResponse to get error message
error_response = e.data.convert_to(ErrorResponse)
raise Exception(error_response.error_messages)
wait_for_task(task_client=self.vmc_client.orgs.Tasks,
org_id=self.org_id,
task_id=task.id,
interval_sec=self.interval_sec)
print('\n# Example: Remaining SDDCs:'.format(self.org_id))
sddcs = self.vmc_client.orgs.Sddcs.list(self.org_id)
self.print_output(sddcs)
def delete_sddc(self):
print('\n# Example: Delete SDDC {} from org {}'.format(
self.sddc_id, self.org_id))
task = self.vmc_client.orgs.Sddcs.delete(org=self.org_id,
sddc=self.sddc_id)
wait_for_task(task_client=self.vmc_client.orgs.Tasks,
org_id=self.org_id,
task_id=task.id,
interval_sec=self.interval_sec)
print('\n# Example: Remaining SDDCs:'.format(self.org_id))
sddcs_list = self.vmc_client.orgs.Sddcs.list(self.org_id)
headers = ["ID", "Name"]
table = []
for sddc in sddcs_list:
table.append([sddc.id, sddc.name])
print(tabulate(table, headers))
def create_sddc(self):
print('\n# Example: Create a SDDC ({}) in org {}:'.
format(self.sddc_name, self.org_id))
provider = os.environ.get('VMC_PROVIDER', 'AWS')
sddc_config = AwsSddcConfig(
region='US_WEST_2', num_hosts=1, name=self.sddc_name,
provider=provider)
task = self.vmc_client.orgs.Sddcs.create(org=self.org_id,
sddc_config=sddc_config)
wait_for_task(task_client=self.vmc_client.orgs.Tasks,
org_id=self.org_id,
task_id=task.id,
interval_sec=self.interval_sec)
print('\n# Example: SDDC created:')
self.sddc_id = task.resource_id
sddc = self.vmc_client.orgs.Sddcs.get(self.org_id, self.sddc_id)
print(tabulate([[sddc.id, sddc.name]], ["ID", "Name"]))
def create_sddc(self, sddc_create_spec):
"""
Create SDDC
Parameters
----------
sddc_create_spec : dict
"""
# account_id = self.vmc_client.orgs.account_link.ConnectedAccounts.get(
# self.org_id)[0].id
account_id = sddc_create_spec['account_id']
# vpc_map = self.vmc_client.orgs.account_link.CompatibleSubnets.get(
# org=self.org_id,
# linked_account_id=account_id).vpc_map
# customer_subnet_id = self.get_subnet_id(vpc_map)
# if not customer_subnet_id:
# raise ValueError('No available subnet for region {}'.format(self.region))
# sddc_config = AwsSddcConfig(
# region=self.region,
# name=self.sddc_name,
# account_link_sddc_config=[AccountLinkSddcConfig(
# customer_subnet_ids=[customer_subnet_id],
# connected_account_id=account_id)],
# provider=os.environ.get('VMC_PROVIDER', SddcConfig.PROVIDER_AWS),
# num_hosts=1,
# deployment_type=SddcConfig.DEPLOYMENT_TYPE_SINGLEAZ)
sddc_config = AwsSddcConfig(
region=sddc_create_spec['region'],
name=sddc_create_spec['name'],
account_link_sddc_config=[
AccountLinkSddcConfig(
customer_subnet_ids=[sddc_create_spec['subnet_id']],
connected_account_id=account_id)
],
provider=sddc_create_spec['provider'],
num_hosts=int(sddc_create_spec['num_hosts']),
deployment_type=SddcConfig.DEPLOYMENT_TYPE_SINGLEAZ)
try:
task = self.vmc_client.orgs.Sddcs.create(org=self.org_id,
sddc_config=sddc_config)
except InvalidRequest as e:
# Convert InvalidRequest to ErrorResponse to get error message
error_response = e.data.convert_to(ErrorResponse)
raise Exception(error_response.error_messages)
wait_for_task(task_client=self.vmc_client.orgs.Tasks,
org_id=self.org_id,
task_id=task.id,
interval_sec=self.interval_sec)
print('\n# Example: SDDC created:')
self.sddc_id = task.resource_id
sddc = self.vmc_client.orgs.Sddcs.get(self.org_id, self.sddc_id)
self.print_output([sddc])
