def subtest_setup(self):
# Create a VCN
vcn_name = util.random_name('cli_test_compute_vcn')
cidr_block = "10.0.0.0/16"
vcn_dns_label = util.random_name('vcn', insert_underscore=False)
result = util.invoke_command([
'network', 'vcn', 'create', '--compartment-id',
util.COMPARTMENT_ID, '--display-name', vcn_name, '--cidr-block',
cidr_block, '--dns-label', vcn_dns_label
])
self.vcn_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
util.wait_until(['network', 'vcn', 'get', '--vcn-id', self.vcn_ocid],
'AVAILABLE',
max_wait_seconds=300)
# Create a subnet
subnet_name = util.random_name('cli_test_compute_subnet')
subnet_dns_label = util.random_name('subnet', insert_underscore=False)
result = util.invoke_command([
'network', 'subnet', 'create', '--compartment-id',
util.COMPARTMENT_ID, '--availability-domain',
util.availability_domain(), '--display-name', subnet_name,
'--vcn-id', self.vcn_ocid, '--cidr-block', cidr_block,
'--dns-label', subnet_dns_label
])
self.subnet_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
util.wait_until(
['network', 'subnet', 'get', '--subnet-id', self.subnet_ocid],
'AVAILABLE',
max_wait_seconds=300)
def subtest_setup(self):
# Create a VCN
vcn_name = util.random_name('cli_test_compute_vcn')
cidr_block = "10.0.0.0/16"
result = self.invoke([
'network', 'vcn', 'create', '--compartment-id',
util.COMPARTMENT_ID, '--display-name', vcn_name, '--dns-label',
'clivcn', '--cidr-block', cidr_block
])
self.vcn_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
util.wait_until(['network', 'vcn', 'get', '--vcn-id', self.vcn_ocid],
'AVAILABLE',
max_wait_seconds=300)
# Create a subnet
subnet_name = util.random_name('cli_test_compute_subnet')
result = self.invoke([
'network',
'subnet',
'create',
'--compartment-id',
util.COMPARTMENT_ID,
'--availability-domain',
util.availability_domain(),
'--display-name',
subnet_name,
'--dns-label',
'clisubnet',
'--vcn-id',
self.vcn_ocid,
'--cidr-block',
cidr_block,
])
self.subnet_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
util.wait_until(
['network', 'subnet', 'get', '--subnet-id', self.subnet_ocid],
'AVAILABLE',
max_wait_seconds=300)
# Create a volume
volume_name = util.random_name('cli_test_compute_volume')
result = self.invoke([
'bv', 'volume', 'create', '--availability-domain',
util.availability_domain(), '--compartment-id',
util.COMPARTMENT_ID, '--display-name', volume_name
])
util.validate_response(result)
self.volume_ocid = util.find_id_in_response(result.output)
util.wait_until(
['bv', 'volume', 'get', '--volume-id', self.volume_ocid],
'AVAILABLE',
max_wait_seconds=180)
def subtest_instance_operations(self):
instance_name = util.random_name('cli_test_instance')
fault_domain = 'FAULT-DOMAIN-1'
image_id = util.oracle_linux_image()
shape = 'VM.Standard1.1'
result = self.invoke(
['compute', 'instance', 'launch',
'--compartment-id', util.COMPARTMENT_ID,
'--availability-domain', util.availability_domain(),
'--display-name', instance_name,
'--fault-domain', fault_domain,
'--subnet-id', self.subnet_ocid,
'--image-id', image_id,
'--shape', shape,
'--metadata', util.remove_outer_quotes(oci_cli_compute.compute_cli_extended.compute_instance_launch_metadata_example)])
self.instance_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
util.wait_until(['compute', 'instance', 'get', '--instance-id', self.instance_ocid], 'RUNNING',
max_wait_seconds=600)
result = self.invoke(['compute', 'instance', 'list', '--compartment-id', util.COMPARTMENT_ID])
util.validate_response(result)
# list with compartment shortcut
result = self.invoke(['compute', 'instance', 'list', '-c', util.COMPARTMENT_ID])
util.validate_response(result)
instance_name = instance_name + "_updated"
result = self.invoke(['compute', 'instance', 'update', '--instance-id', self.instance_ocid, '--display-name', instance_name])
util.validate_response(result, expect_etag=True)
result = self.invoke(['compute', 'instance', 'get', '--instance-id', self.instance_ocid])
util.validate_response(result, expect_etag=True)
result = self.invoke(
['compute', 'instance', 'launch',
'--compartment-id', util.COMPARTMENT_ID,
'--availability-domain', util.availability_domain(),
'--display-name', instance_name + "_2",
'--fault-domain', fault_domain,
'--subnet-id', self.subnet_ocid,
'--image-id', image_id,
'--shape', shape,
'--metadata',
util.remove_outer_quotes(oci_cli_compute.compute_cli_extended.compute_instance_launch_metadata_example),
'--wait-for-state', 'RUNNING',
'--max-wait-seconds', '20',
'--wait-interval-seconds', '5'])
self.instance_ocid_2 = util.find_id_in_response(result.output[result.output.index('{'):])
assert result.exit_code != 0
def subtest_drg_attachment_operations(self):
if hasattr(self, 'drg_capacity_issue'):
print('Unable to execute subtest_drg_attachment_operations as a DRG is not available')
return
drg_attachment_name = util.random_name('cli_test_drg_attachment')
result = self.invoke(
['drg-attachment', 'create',
'--drg-id', self.drg_ocid,
'--vcn-id', self.vcn_ocid,
'--display-name', drg_attachment_name
])
self.drg_attachment_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
util.wait_until(['network', 'drg-attachment', 'get', '--drg-attachment-id', self.drg_attachment_ocid], 'ATTACHED')
result = self.invoke(['drg-attachment', 'list', '--compartment-id', util.COMPARTMENT_ID])
util.validate_response(result)
drg_attachment_name = drg_attachment_name + "_updated"
result = self.invoke(['drg-attachment', 'update', '--drg-attachment-id', self.drg_attachment_ocid, '--display-name', drg_attachment_name])
util.validate_response(result, expect_etag=True)
result = self.invoke(['drg-attachment', 'get', '--drg-attachment-id', self.drg_attachment_ocid])
util.validate_response(result, expect_etag=True)
def subtest_drg_operations(self):
drg_name = util.random_name('cli_test_drg')
result = self.invoke(
['drg', 'create',
'--compartment-id', util.COMPARTMENT_ID,
'--display-name', drg_name
])
# If we have hit a limit, skip the test
if 'Limit vcn-tenant-drg' in result.output or 'Limit tenant-drg' in result.output:
self.drg_capacity_issue = True
print('Unable to execute subtest_drg_operations as a DRG is not available')
return
self.drg_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
util.wait_until(['network', 'drg', 'get', '--drg-id', self.drg_ocid], 'AVAILABLE',
max_wait_seconds=600)
result = self.invoke(['drg', 'list', '--compartment-id', util.COMPARTMENT_ID])
util.validate_response(result)
drg_name = drg_name + "_updated"
result = self.invoke(['drg', 'update', '--drg-id', self.drg_ocid, '--display-name', drg_name])
util.validate_response(result, expect_etag=True)
result = self.invoke(['drg', 'get', '--drg-id', self.drg_ocid])
util.validate_response(result, expect_etag=True)
def subtest_image_operations(self):
image_name = util.random_name('cli_test_image')
result = self.invoke([
'compute', 'image', 'create', '--display-name', image_name,
'--instance-id', self.instance_ocid, '--compartment-id',
util.COMPARTMENT_ID
])
self.image_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
# Waiting for the image can take 20 or 30 minutes. Instead, we'll just delete the instance
# while it's still taking the snapshot. Uncomment the wait below to wait for the image to finish.
# util.wait_until(['compute', 'image', 'get', '--image-id', self.image_ocid], 'AVAILABLE', max_wait_seconds=2700)
result = self.invoke([
'compute', 'image', 'list', '--compartment-id', util.COMPARTMENT_ID
])
util.validate_response(result)
result = self.invoke(
['compute', 'image', 'get', '--image-id', self.image_ocid])
util.validate_response(result, expect_etag=True)
image_name = image_name + "_updated"
result = self.invoke([
'compute', 'image', 'update', '--image-id', self.image_ocid,
'--display-name', image_name
])
util.validate_response(result, expect_etag=True)
def subtest_windows_instance_operations(self):
instance_name = util.random_name('cli_test_instance')
image_id = util.windows_vm_image()
shape = 'VM.Standard1.1'
result = self.invoke(
['compute', 'instance', 'launch',
'--compartment-id', util.COMPARTMENT_ID,
'--availability-domain', util.availability_domain(),
'--display-name', instance_name,
'--subnet-id', self.subnet_ocid,
'--image-id', image_id,
'--shape', shape])
self.windows_instance_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
util.wait_until(['compute', 'instance', 'get', '--instance-id', self.windows_instance_ocid], 'RUNNING',
max_wait_seconds=600)
result = self.invoke(['compute', 'instance', 'get', '--instance-id', self.windows_instance_ocid])
util.validate_response(result, expect_etag=True)
result = self.invoke(
['compute', 'instance', 'get-windows-initial-creds', '--instance-id', self.windows_instance_ocid])
util.validate_response(result)
credentials = json.loads(result.output)['data']
assert credentials['username'] == 'opc'
assert 'password' in credentials
result = self.invoke(
['compute', 'instance', 'terminate', '--instance-id', self.windows_instance_ocid, '--force'])
util.validate_response(result)
def subtest_group_operations(self):
self.group_name = util.random_name('cli_test_group')
self.group_description = 'Created by CLI identity tests.'
result = self.invoke([
'group', 'create', '--compartment-id', util.TENANT_ID, '--name',
self.group_name, '--description', self.group_description
])
self.group_ocid = util.find_id_in_response(result.output)
self.validate_response(result,
extra_validation=self.validate_group,
expect_etag=True)
result = self.invoke([
'group', 'list', '--compartment-id', util.TENANT_ID, '--limit',
'1000'
])
self.validate_response(result, extra_validation=self.validate_group)
result = self.invoke(['group', 'list', '--limit', '1000'])
self.validate_response(result, extra_validation=self.validate_group)
self.group_description = 'UPDATED ' + self.user_description
result = self.invoke([
'group', 'update', '--group-id', self.group_ocid, '--description',
self.group_description
])
self.validate_response(result,
extra_validation=self.validate_group,
expect_etag=True)
result = self.invoke(['group', 'get', '--group-id', self.group_ocid])
self.validate_response(result,
extra_validation=self.validate_group,
expect_etag=True)
def subtest_volume_group_backup_operations(self):
# create a volume group backup, perform get & list, update it & restore from it
backup_name = util.random_name('cli_test_volume_group_backup')
result = self.invoke([
'volume-group-backup', 'create', '--volume-group-id',
self.volume_group, '--display-name', backup_name
])
util.validate_response(result)
self.volume_group_backup_id = util.find_id_in_response(result.output)
util.wait_until([
'bv', 'volume-group-backup', 'get', '--volume-group-backup-id',
self.volume_group_backup_id
],
'AVAILABLE',
max_wait_seconds=600)
result = self.invoke([
'volume-group-backup', 'get', '--volume-group-backup-id',
self.volume_group_backup_id
])
util.validate_response(result)
parsed_result = json.loads(result.output)
assert parsed_result['data']['size-in-mbs'] is not None
assert parsed_result['data']['unique-size-in-mbs'] is not None
result = self.invoke([
'volume-group-backup', 'list', '--compartment-id',
util.COMPARTMENT_ID
])
util.validate_response(result)
result = self.invoke([
'volume-group-backup', 'list', '--compartment-id',
util.COMPARTMENT_ID, '--volume-group-id', self.volume_group
])
util.validate_response(result)
self.assertEquals(1, len(json.loads(result.output)['data']))
backup_name = backup_name + "_UPDATED"
result = self.invoke([
'volume-group-backup', 'update', '--volume-group-backup-id',
self.volume_group_backup_id, '--display-name', backup_name
])
util.validate_response(result)
volume_group_name = util.random_name('cli_test_volume_group_restore')
source_details = {
'type': 'volumeGroupBackupId',
'volumeGroupBackupId': self.volume_group_backup_id
}
params = [
'volume-group', 'create', '--availability-domain',
util.availability_domain(), '--compartment-id',
util.COMPARTMENT_ID, '--display-name', volume_group_name,
'--source-details',
json.dumps(source_details)
]
self.volume_group_restored, self.restored_volumes = self.volume_group_operations_internal(
volume_group_name, params)
def subtest_internet_gateway_operations(self):
ig_name = util.random_name('cli_test_ig')
result = self.invoke([
'internet-gateway', 'create', '--compartment-id',
util.COMPARTMENT_ID, '--is-enabled', "False", '--display-name',
ig_name, '--vcn-id', self.vcn_ocid
])
self.ig_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
util.wait_until(
['network', 'internet-gateway', 'get', '--ig-id', self.ig_ocid],
'AVAILABLE',
max_wait_seconds=300)
result = self.invoke([
'internet-gateway', 'list', '--compartment-id',
util.COMPARTMENT_ID, '--vcn-id', self.vcn_ocid
])
util.validate_response(result)
self.run_list_filter_verification('internet-gateway', ig_name)
ig_name = ig_name + "_updated"
result = self.invoke([
'internet-gateway', 'update', '--ig-id', self.ig_ocid,
'--display-name', ig_name
])
util.validate_response(result, expect_etag=True)
result = self.invoke(
['internet-gateway', 'get', '--ig-id', self.ig_ocid])
util.validate_response(result, expect_etag=True)
def subtest_launch_instance_merges_user_data_file_param_with_metadata(
self):
instance_name = util.random_name('cli_test_instance_options')
image_id = util.oracle_linux_image()
shape = 'VM.Standard1.2'
hostname_label = util.random_name('bminstance',
insert_underscore=False)
launch_instance_result = util.invoke_command([
'compute', 'instance', 'launch', '--compartment-id',
util.COMPARTMENT_ID, '--availability-domain',
util.availability_domain(), '--display-name', instance_name,
'--subnet-id', self.subnet_ocid, '--image-id', image_id, '--shape',
shape, '--hostname-label', hostname_label + "4",
'--user-data-file', USER_DATA_FILE, '--metadata',
util.remove_outer_quotes(oci_cli_compute.compute_cli_extended.
compute_instance_launch_metadata_example)
])
util.validate_response(launch_instance_result, expect_etag=True)
temp_instance_ocid = util.find_id_in_response(
launch_instance_result.output)
self.instance_ocids.append(temp_instance_ocid)
response = json.loads(launch_instance_result.output)
instance_metadata = response['data']['metadata']
assert instance_metadata['user_data']
assert instance_metadata['ssh_authorized_keys']
self.delete_instance(temp_instance_ocid)
def subtest_vcn_operations(self):
vcn_name = util.random_name('cli_test_vcn')
cidr_block = "10.0.0.0/16"
vcn_dns_label = util.random_name('vcn', insert_underscore=False)
result = self.invoke([
'vcn', 'create', '--compartment-id', util.COMPARTMENT_ID,
'--display-name', vcn_name, '--cidr-block', cidr_block,
'--dns-label', vcn_dns_label
])
self.vcn_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
util.wait_until(['network', 'vcn', 'get', '--vcn-id', self.vcn_ocid],
'AVAILABLE',
max_wait_seconds=300)
result = self.invoke(
['vcn', 'list', '--compartment-id', util.COMPARTMENT_ID])
util.validate_response(result)
vcn_name = vcn_name + "_updated"
result = self.invoke([
'vcn', 'update', '--vcn-id', self.vcn_ocid, '--display-name',
vcn_name
])
util.validate_response(result, expect_etag=True)
result = self.invoke(['vcn', 'get', '--vcn-id', self.vcn_ocid])
util.validate_response(result, expect_etag=True)
vcn_response = json.loads(result.output)
assert vcn_response['data']['dns-label'] == vcn_dns_label
def subtest_cpe_operations(self):
cpe_name = util.random_name('cli_test_cpe')
ip_address = "137.254.4.11"
result = self.invoke([
'cpe',
'create',
'--compartment-id',
util.COMPARTMENT_ID,
'--display-name',
cpe_name,
'--ip-address',
ip_address,
])
self.cpe_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
result = self.invoke(
['cpe', 'list', '--compartment-id', util.COMPARTMENT_ID])
util.validate_response(result)
cpe_name = cpe_name + "_updated"
result = self.invoke([
'cpe', 'update', '--cpe-id', self.cpe_ocid, '--display-name',
cpe_name
])
util.validate_response(result, expect_etag=True)
result = self.invoke(['cpe', 'get', '--cpe-id', self.cpe_ocid])
util.validate_response(result, expect_etag=True)
def subtest_console_history_operations(self):
result = self.invoke(['compute', 'console-history', 'capture', '--instance-id', self.instance_ocid, '--display-name', 'Original'])
parsed_result = json.loads(result.output)
self.assertEquals('Original', parsed_result['data']['display-name'])
self.ch_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
util.wait_until(['compute', 'console-history', 'get', '--instance-console-history-id', self.ch_ocid], 'SUCCEEDED', max_wait_seconds=300)
result = self.invoke(['compute', 'console-history', 'update', '--instance-console-history-id', self.ch_ocid, '--display-name', 'Updated'])
parsed_result = json.loads(result.output)
self.assertEquals('Updated', parsed_result['data']['display-name'])
result = self.invoke(['compute', 'console-history', 'list', '--compartment-id', util.COMPARTMENT_ID, '--instance-id', self.instance_ocid])
util.validate_response(result)
result = self.invoke(['compute', 'console-history', 'get', '--instance-console-history-id', self.ch_ocid])
util.validate_response(result, expect_etag=True)
if os.path.exists(CONSOLE_HISTORY_FILENAME):
os.remove(CONSOLE_HISTORY_FILENAME)
result = self.invoke(['compute', 'console-history', 'get-content', '--instance-console-history-id', self.ch_ocid, '--file', CONSOLE_HISTORY_FILENAME])
util.validate_response(result)
with open(CONSOLE_HISTORY_FILENAME, 'rb') as file:
# Make sure that we got at least some minimum amount of content.
assert (len(file.read()) > 500)
def subtest_clone_operations(self):
volume_name = util.random_name('cli_test_clone_vol')
params = [
'volume', 'create', '--source-volume-id', self.volume_id,
'--display-name', volume_name, '--size-in-gbs', '60'
]
result = self.invoke(params)
util.validate_response(result)
parsed_result = json.loads(result.output)
source_details = {'id': self.volume_id, 'type': 'volume'}
assert source_details == parsed_result['data']['source-details']
assert util.availability_domain(
) == parsed_result['data']['availability-domain']
assert 60 == int(
parsed_result['data']['size-in-gbs']
) # We initially created a 50GB volume, now increasing to 60
volume_id = util.find_id_in_response(result.output)
util.wait_until(['bv', 'volume', 'get', '--volume-id', volume_id],
'AVAILABLE',
max_wait_seconds=180)
util.wait_until(['bv', 'volume', 'get', '--volume-id', volume_id],
True,
max_wait_seconds=360,
state_property_name="is-hydrated")
result = self.invoke(
['volume', 'delete', '--volume-id', volume_id, '--force'])
util.validate_response(result)
def subtest_volume_attachment_operations(self):
va_name = util.random_name('cli_test_va')
result = self.invoke([
'compute', 'volume-attachment', 'attach', '--display-name',
va_name, '--type', 'iscsi', '--instance-id', self.instance_ocid,
'--volume-id', self.volume_ocid
])
self.va_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
util.wait_until([
'compute', 'volume-attachment', 'get', '--volume-attachment-id',
self.va_ocid
],
'ATTACHED',
max_wait_seconds=300)
result = self.invoke([
'compute', 'volume-attachment', 'list', '--compartment-id',
util.COMPARTMENT_ID, '--instance-id', self.instance_ocid
])
util.validate_response(result)
result = self.invoke([
'compute', 'volume-attachment', 'get', '--volume-attachment-id',
self.va_ocid
])
util.validate_response(result, expect_etag=True)
result = self.invoke([
'compute', 'volume-attachment', 'detach', '--volume-attachment-id',
self.va_ocid, '--force'
])
util.validate_response(result)
util.wait_until([
'compute', 'volume-attachment', 'get', '--volume-attachment-id',
self.va_ocid
],
'DETACHED',
max_wait_seconds=300)
result = self.invoke([
'compute', 'volume-attachment', 'attach', '--display-name',
va_name, '--type', 'iscsi', '--instance-id', self.instance_ocid,
'--volume-id', self.volume_ocid, '--wait-for-state', 'ATTACHED',
'--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS
])
util.validate_response(result,
expect_etag=True,
json_response_expected=False)
self.va_ocid = util.get_json_from_mixed_string(
result.output)['data']['id']
result = self.invoke([
'compute', 'volume-attachment', 'detach', '--volume-attachment-id',
self.va_ocid, '--force', '--wait-for-state', 'DETACHED',
'--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS
])
util.validate_response(result, json_response_expected=False)
def subtest_dhcp_option_operations(self):
dhcp_options_name = util.random_name('cli_test_dhcp_options')
options = util.remove_outer_quotes(oci_cli_virtual_network.virtualnetwork_cli_extended.network_create_dhcp_options_options_example)
result = self.invoke(
['dhcp-options', 'create',
'--compartment-id', util.COMPARTMENT_ID,
'--vcn-id', self.vcn_ocid,
'--display-name', dhcp_options_name,
'--options', options
])
util.validate_response(result, expect_etag=True)
self.dhcp_options_ocid = util.find_id_in_response(result.output)
util.wait_until(['network', 'dhcp-options', 'get', '--dhcp-id', self.dhcp_options_ocid], 'AVAILABLE')
result = self.invoke(['dhcp-options', 'list', '--compartment-id', util.COMPARTMENT_ID, '--vcn-id', self.vcn_ocid])
util.validate_response(result)
self.run_list_filter_verification('dhcp-options', dhcp_options_name)
result = self.invoke(['dhcp-options', 'get', '--dhcp-id', self.dhcp_options_ocid])
util.validate_response(result, expect_etag=True)
dhcp_options_name = dhcp_options_name + "_updated"
options_v2 = """[{"type": "DomainNameServer", "customDnsServers": ["202.44.61.10"], "serverType": "CustomDnsServer"},
{"searchDomainNames": ["testvcn.oraclevcn.com"], "type":"SearchDomain"}]"""
# update display name only - does not show a confirmation prompt
result = self.invoke(['dhcp-options', 'update', '--dhcp-id', self.dhcp_options_ocid, '--display-name', dhcp_options_name])
util.validate_response(result, expect_etag=True)
# update options, confirm y
result = self.invoke(
['dhcp-options', 'update', '--dhcp-id', self.dhcp_options_ocid, '--options', options_v2], input='y')
util.validate_response(result, json_response_expected=False)
# update options, confirm n
result = self.invoke(
['dhcp-options', 'update', '--dhcp-id', self.dhcp_options_ocid, '--options', options], input='n')
assert result.exit_code != 0
util.vcr_mode_aware_sleep(20)
# update options, force
result = self.invoke(
['dhcp-options', 'update', '--dhcp-id', self.dhcp_options_ocid, '--options', options_v2, '--force'])
util.validate_response(result, expect_etag=True)
response = json.loads(result.output)
# validate response contains SearchDomain option
response_has_search_domain_option = False
for option in response["data"]["options"]:
if option["type"] == "SearchDomain":
response_has_search_domain_option = True
assert option["search-domain-names"][0] == "testvcn.oraclevcn.com"
assert response_has_search_domain_option, "Options response should contain option of type 'SearchDomain'."
def subtest_ip_sec_connection_operations(self):
if hasattr(self, 'drg_capacity_issue'):
print(
'Unable to execute subtest_ip_sec_connection_operations as a DRG is not available'
)
return
ipsc_name = util.random_name('cli_test_ipsc')
routes = util.remove_outer_quotes(
oci_cli_virtual_network.virtualnetwork_cli_extended.
network_create_ip_sec_connection_static_routes_example)
result = self.invoke([
'ip-sec-connection', 'create', '--compartment-id',
util.COMPARTMENT_ID, '--display-name', ipsc_name, '--cpe-id',
self.cpe_ocid, '--drg-id', self.drg_ocid, '--static-routes', routes
])
if 'Limit tenant-ipsec-vpn-connection' in result.output:
self.drg_capacity_issue = True
print(
'Unable to execute subtest_ip_sec_connection_operations as an IPSec Connection is not available'
)
return
self.ipsc_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
util.wait_until([
'network', 'ip-sec-connection', 'get', '--ipsc-id', self.ipsc_ocid
],
'AVAILABLE',
max_wait_seconds=600)
result = self.invoke([
'ip-sec-connection', 'list', '--compartment-id',
util.COMPARTMENT_ID
])
util.validate_response(result)
ipsc_name = ipsc_name + "_updated"
result = self.invoke([
'ip-sec-connection', 'update', '--ipsc-id', self.ipsc_ocid,
'--display-name', ipsc_name
])
util.validate_response(result, expect_etag=True)
result = self.invoke(
['ip-sec-connection', 'get', '--ipsc-id', self.ipsc_ocid])
util.validate_response(result, expect_etag=True)
result = self.invoke(
['ip-sec-connection', 'get-config', '--ipsc-id', self.ipsc_ocid])
util.validate_response(result)
result = self.invoke(
['ip-sec-connection', 'get-status', '--ipsc-id', self.ipsc_ocid])
util.validate_response(result)
def volume_operations_internal(self, volume_name, command_params, size_gb,
size_mb):
params_to_use = list(command_params)
if size_gb:
params_to_use.extend(['--size-in-gbs', size_gb])
elif size_mb:
params_to_use.extend(['--size-in-mbs', size_mb])
result = self.invoke(params_to_use)
util.validate_response(result)
parsed_result = json.loads(result.output)
if size_gb:
assert str(parsed_result['data']['size-in-gbs']) == size_gb
elif size_mb:
assert str(parsed_result['data']['size-in-mbs']) == size_mb
volume_id = util.find_id_in_response(result.output)
util.wait_until(['bv', 'volume', 'get', '--volume-id', volume_id],
'AVAILABLE',
max_wait_seconds=180)
result = self.invoke(['volume', 'get', '--volume-id', volume_id])
util.validate_response(result)
parsed_result = json.loads(result.output)
if size_gb:
assert str(parsed_result['data']['size-in-gbs']) == size_gb
elif size_mb:
assert str(parsed_result['data']['size-in-mbs']) == size_mb
result = self.invoke(
['volume', 'list', '--compartment-id', util.COMPARTMENT_ID])
util.validate_response(result)
if size_gb:
new_size_gb = int(size_gb) + 10
volume_name = volume_name + "_UPDATED"
result = self.invoke([
'volume', 'update', '--volume-id', volume_id, '--display-name',
volume_name, '--size-in-gbs',
str(new_size_gb)
])
util.validate_response(result)
util.wait_until(['bv', 'volume', 'get', '--volume-id', volume_id],
'AVAILABLE',
max_wait_seconds=180)
result = self.invoke(['volume', 'get', '--volume-id', volume_id])
util.validate_response(result)
parsed_result = json.loads(result.output)
assert str(
parsed_result['data']['size-in-gbs']) == str(new_size_gb)
return volume_id
def set_up_vcn_and_vlan(self, cidr_block):
# Create a VCN
vcn_name = util.random_name('cli_test_compute_vcn')
result = self.invoke([
'network', 'vcn', 'create', '--compartment-id',
util.COMPARTMENT_ID, '--display-name', vcn_name, '--dns-label',
'clivcn', '--cidr-block', cidr_block
])
util.validate_response(result, expect_etag=True)
self.vcn_ocid = util.find_id_in_response(result.output)
util.wait_until(['network', 'vcn', 'get', '--vcn-id', self.vcn_ocid],
'AVAILABLE',
max_wait_seconds=300)
# Create a vlan
vlan_name = util.random_name('cli_test_compute_vlan')
result = self.invoke([
'network',
'vlan',
'create',
'--compartment-id',
util.COMPARTMENT_ID,
'--availability-domain',
util.availability_domain(),
'--display-name',
vlan_name,
'--vcn-id',
self.vcn_ocid,
'--cidr-block',
cidr_block,
])
util.validate_response(result, expect_etag=True)
self.vlan_ocid = util.find_id_in_response(result.output)
util.wait_until(
['network', 'vlan', 'get', '--vlan-id', self.vlan_ocid],
'AVAILABLE',
max_wait_seconds=300)
def subtest_route_table_operations(self):
rt_name = util.random_name('cli_test_route_table')
rules = util.remove_outer_quotes(oci_cli_virtual_network.virtualnetwork_cli_extended.network_create_route_table_route_rules_example.format(ig_id=self.ig_ocid))
result = self.invoke(
['route-table', 'create',
'--compartment-id', util.COMPARTMENT_ID,
'--display-name', rt_name,
'--vcn-id', self.vcn_ocid,
'--route-rules', rules
])
self.rt_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
util.wait_until(['network', 'route-table', 'get', '--rt-id', self.rt_ocid], 'AVAILABLE',
max_wait_seconds=300)
result = self.invoke(['route-table', 'list', '--compartment-id', util.COMPARTMENT_ID, '--vcn-id', self.vcn_ocid])
util.validate_response(result)
self.run_list_filter_verification('route-table', rt_name)
result = self.invoke(['route-table', 'get', '--rt-id', self.rt_ocid])
util.validate_response(result, expect_etag=True)
rt_name = rt_name + "_updated"
rules_v2 = """[{{"cidrBlock":"0.0.0.0/1","networkEntityId":"{ig_id}"}}]""".format(ig_id=self.ig_ocid)
# update display name only - does not show a prompt
result = self.invoke(['route-table', 'update', '--rt-id', self.rt_ocid, '--display-name', rt_name])
util.validate_response(result, expect_etag=True)
util.vcr_mode_aware_sleep(20)
# update route-rules, confirm y
result = self.invoke(
['route-table', 'update', '--rt-id', self.rt_ocid, '--route-rules', rules_v2], input='y')
util.validate_response(result, json_response_expected=False)
# update route-rules, confirm n
result = self.invoke(
['route-table', 'update', '--rt-id', self.rt_ocid, '--route-rules', rules_v2], input='n')
assert result.exit_code != 0
util.vcr_mode_aware_sleep(20)
# update route-rules, force
result = self.invoke(
['route-table', 'update', '--rt-id', self.rt_ocid, '--route-rules', rules, '--force'])
util.validate_response(result, expect_etag=True)
def subtest_subnet_operations(self):
subnet_name = util.random_name('cli_test_subnet')
cidr_block = "10.0.0.0/16"
security_list_ids = util.remove_outer_quotes(
oci_cli_virtual_network.virtualnetwork_cli_extended.
network_create_subnet_security_list_ids_example.format(
sl_id=self.sl_ocid))
subnet_dns_label = util.random_name('subnet', insert_underscore=False)
result = self.invoke([
'subnet', 'create', '--compartment-id', util.COMPARTMENT_ID,
'--availability-domain',
util.availability_domain(), '--display-name', subnet_name,
'--vcn-id', self.vcn_ocid, '--cidr-block', cidr_block,
'--security-list-ids', security_list_ids, '--dns-label',
subnet_dns_label
])
self.subnet_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
util.wait_until(
['network', 'subnet', 'get', '--subnet-id', self.subnet_ocid],
'AVAILABLE',
max_wait_seconds=300)
result = self.invoke([
'subnet', 'list', '--compartment-id', util.COMPARTMENT_ID,
'--vcn-id', self.vcn_ocid
])
util.validate_response(result)
self.run_list_filter_verification('subnet', subnet_name)
subnet_name = subnet_name + "_updated"
result = self.invoke([
'subnet', 'update', '--subnet-id', self.subnet_ocid,
'--display-name', subnet_name
])
util.validate_response(result, expect_etag=True)
result = self.invoke(
['subnet', 'get', '--subnet-id', self.subnet_ocid])
util.validate_response(result, expect_etag=True)
subnet_response = json.loads(result.output)
assert subnet_response['data']['dns-label'] == subnet_dns_label
def volume_group_operations_internal(self, volume_group_name,
command_params):
params_to_use = list(command_params)
result = self.invoke(params_to_use)
util.validate_response(result)
parsed_result = json.loads(result.output)
volume_group_id = util.find_id_in_response(result.output)
volume_ids = parsed_result['data']['volume-ids']
assert len(volume_ids) > 0
util.wait_until([
'bv', 'volume-group', 'get', '--volume-group-id', volume_group_id
],
'AVAILABLE',
max_wait_seconds=180)
result = self.invoke(
['volume-group', 'get', '--volume-group-id', volume_group_id])
util.validate_response(result)
parsed_result = json.loads(result.output)
assert parsed_result['data']['size-in-mbs'] is not None
assert parsed_result['data']['time-created'] is not None
result = self.invoke(
['volume-group', 'list', '--compartment-id', util.COMPARTMENT_ID])
util.validate_response(result)
volume_group_name = volume_group_name + "_UPDATED"
# if we have more than a single volume in the group, remove one and update
if len(volume_ids) > 1:
volume_ids.remove(volume_ids[len(volume_ids) - 1])
result = self.invoke([
'volume-group', 'update', '--volume-group-id', volume_group_id,
'--display-name', volume_group_name, '--volume-ids',
json.dumps(volume_ids), '--force'
])
util.validate_response(result)
parsed_result = json.loads(result.output)
assert len(parsed_result['data']['volume-ids']) == len(volume_ids)
else:
result = self.invoke([
'volume-group', 'update', '--volume-group-id', volume_group_id,
'--display-name', volume_group_name
])
util.validate_response(result)
return volume_group_id, volume_ids
def subtest_subnet_secondary_ip_operations(self):
self.set_up_vcn_and_subnet("10.0.0.0/16")
available_ip_addresses = self.get_ip_addresses_from_cidr("10.0.0.0/16")
# First we need to launch two instances and get their VNICs. We get two instances
# so that we can move the secondary private IP around. The instances need to be
# in the same subnet for the secondary private IP address moves to be valid
image_id = util.oracle_linux_image()
shape = 'VM.Standard1.1'
first_instance_name = util.random_name('cli_test_instance')
result = self.invoke([
'compute', 'instance', 'launch', '--compartment-id',
util.COMPARTMENT_ID, '--availability-domain',
util.availability_domain(), '--display-name', first_instance_name,
'--subnet-id', self.subnet_ocid, '--image-id', image_id, '--shape',
shape
])
self.first_instance_id = util.find_id_in_response(result.output)
second_instance_name = util.random_name('cli_test_instance')
result = self.invoke([
'compute', 'instance', 'launch', '--compartment-id',
util.COMPARTMENT_ID, '--availability-domain',
util.availability_domain(), '--display-name', second_instance_name,
'--subnet-id', self.subnet_ocid, '--image-id', image_id, '--shape',
shape
])
self.second_instance_id = util.find_id_in_response(result.output)
util.wait_until([
'compute', 'instance', 'get', '--instance-id',
self.first_instance_id
],
'RUNNING',
max_wait_seconds=600)
util.wait_until([
'compute', 'instance', 'get', '--instance-id',
self.second_instance_id
],
'RUNNING',
max_wait_seconds=600)
vnics_on_instance_result = self.invoke([
'compute', 'instance', 'list-vnics', '--instance-id',
self.first_instance_id
])
vnics = json.loads(vnics_on_instance_result.output)
first_vnic_id = vnics['data'][0]['id']
first_vnic_primary_private_ip = vnics['data'][0]['private-ip']
# So we don't try and re-use the IP address unintentionally
available_ip_addresses.remove(first_vnic_primary_private_ip)
vnics_on_instance_result = self.invoke([
'compute', 'instance', 'list-vnics', '--instance-id',
self.second_instance_id
])
vnics = json.loads(vnics_on_instance_result.output)
second_vnic_id = vnics['data'][0]['id']
second_vnic_primary_private_ip = vnics['data'][0]['private-ip']
available_ip_addresses.remove(second_vnic_primary_private_ip)
# Running the assign command against a non-existent VNIC fails
fudged_vnic_id = self.fudge_ocid(first_vnic_id)
result = self.invoke([
'network', 'vnic', 'assign-private-ip', '--vnic-id', fudged_vnic_id
])
self.assertNotEqual(0, result.exit_code)
assert 'Either VNIC with ID {} does not exist or you are not authorized to access it.'.format(
fudged_vnic_id) in result.output
# Most basic call with VNIC only - in this case we assign the IP automatically
result = self.invoke([
'network', 'vnic', 'assign-private-ip', '--vnic-id', first_vnic_id
])
first_secondary_private_ip_data = json.loads(result.output)['data']
first_secondary_private_ip_id = first_secondary_private_ip_data['id']
first_secondary_private_ip_address = first_secondary_private_ip_data[
'ip-address']
available_ip_addresses.remove(first_secondary_private_ip_address)
# Assign a new secondary IP with all parameters given
second_secondary_private_ip_address = available_ip_addresses.pop()
result = self.invoke([
'network',
'vnic',
'assign-private-ip',
'--vnic-id',
first_vnic_id,
'--ip-address',
second_secondary_private_ip_address,
'--display-name',
'My second secondary',
'--hostname-label',
'secondary-1',
# The --unassign-if-already-assigned should not have an impact as the IP address doesn't exist
'--unassign-if-already-assigned'
])
second_secondary_private_ip_data = json.loads(result.output)['data']
second_secondary_private_ip_id = second_secondary_private_ip_data['id']
self.assertEqual(second_secondary_private_ip_address,
second_secondary_private_ip_data['ip-address'])
# Checkpoint by listing the private IPs. Our created secondaries should be there
result = self.invoke(
['network', 'private-ip', 'list', '--vnic-id', first_vnic_id])
private_ips = json.loads(result.output)['data']
self.assertEqual(3, len(private_ips))
self.find_private_ip_and_do_assertions(
private_ips, first_secondary_private_ip_id,
first_secondary_private_ip_address, None, None)
self.find_private_ip_and_do_assertions(
private_ips, second_secondary_private_ip_id,
second_secondary_private_ip_address, 'My second secondary',
'secondary-1')
# Trying to assign the same private IP to the same VNIC is a no-op
result = self.invoke([
'network', 'vnic', 'assign-private-ip', '--vnic-id', first_vnic_id,
'--ip-address', first_secondary_private_ip_address
])
assert 'Taking no action as IP address {} is already assigned to VNIC {}'.format(
first_secondary_private_ip_address, first_vnic_id) in result.output
# Trying to move a primary IP fails
result = self.invoke([
'network', 'vnic', 'assign-private-ip', '--vnic-id', first_vnic_id,
'--ip-address', second_vnic_primary_private_ip,
'--unassign-if-already-assigned'
])
self.assertNotEqual(0, result.exit_code)
result = self.invoke([
'network', 'vnic', 'assign-private-ip', '--vnic-id',
second_vnic_id, '--ip-address', first_vnic_primary_private_ip,
'--unassign-if-already-assigned'
])
self.assertNotEqual(0, result.exit_code)
# Trying to move an existing IP address without saying "unassign" fails
result = self.invoke([
'network', 'vnic', 'assign-private-ip', '--vnic-id',
second_vnic_id, '--ip-address', first_secondary_private_ip_address
])
target_message = 'IP address {} is already assigned to a different VNIC: {}. To reassign it, re-run this command with the --unassign-if-already-assigned option'.format(
first_secondary_private_ip_address, first_vnic_id)
assert target_message in result.output
self.assertNotEqual(0, result.exit_code)
# Move the secondary IP and also update some information
result = self.invoke([
'network', 'vnic', 'assign-private-ip', '--vnic-id',
second_vnic_id, '--ip-address', first_secondary_private_ip_address,
'--display-name', 'My first secondary', '--hostname-label',
'moved-first-secondary-1', '--unassign-if-already-assigned'
])
private_ip_data_after_move = json.loads(result.output)['data']
self.assertEqual(first_secondary_private_ip_id,
private_ip_data_after_move['id'])
self.assertEqual(first_secondary_private_ip_address,
private_ip_data_after_move['ip-address'])
self.assertEqual('My first secondary',
private_ip_data_after_move['display-name'])
self.assertEqual('moved-first-secondary-1',
private_ip_data_after_move['hostname-label'])
# List each VNIC - we expect 2 results per list call (1 x primary private and 1 x secondary private per VNIC) after moving stuff around
result = self.invoke(
['network', 'private-ip', 'list', '--vnic-id', first_vnic_id])
private_ips = json.loads(result.output)['data']
self.assertEqual(2, len(private_ips))
self.ensure_private_ip_record_not_present(
private_ips, first_secondary_private_ip_id)
self.find_private_ip_and_do_assertions(
private_ips, second_secondary_private_ip_id,
second_secondary_private_ip_address, 'My second secondary',
'secondary-1')
result = self.invoke(
['network', 'private-ip', 'list', '--vnic-id', second_vnic_id])
private_ips = json.loads(result.output)['data']
self.assertEqual(2, len(private_ips))
self.ensure_private_ip_record_not_present(
private_ips, second_secondary_private_ip_id)
self.find_private_ip_and_do_assertions(
private_ips, first_secondary_private_ip_id,
first_secondary_private_ip_address, 'My first secondary',
'moved-first-secondary-1')
# Listing by subnet should give us 4 records (2 x primary private and 2 x secondary private) as it queries across all VNICs in the subnet
result = self.invoke(
['network', 'private-ip', 'list', '--subnet-id', self.subnet_ocid])
private_ips = json.loads(result.output)['data']
self.assertEqual(4, len(private_ips))
self.find_private_ip_and_do_assertions(
private_ips, first_secondary_private_ip_id,
first_secondary_private_ip_address, 'My first secondary',
'moved-first-secondary-1')
self.find_private_ip_and_do_assertions(
private_ips, second_secondary_private_ip_id,
second_secondary_private_ip_address, 'My second secondary',
'secondary-1')
# Update the display name and hostname
result = self.invoke([
'network', 'private-ip', 'update', '--private-ip-id',
second_secondary_private_ip_id, '--display-name',
'batman display name', '--hostname-label', 'batman-secondary-1'
])
updated_private_ip_info = json.loads(result.output)['data']
self.assertEqual(second_secondary_private_ip_id,
updated_private_ip_info['id'])
self.assertEqual(second_secondary_private_ip_address,
updated_private_ip_info['ip-address'])
self.assertEqual(first_vnic_id, updated_private_ip_info['vnic-id'])
self.assertEqual('batman display name',
updated_private_ip_info['display-name'])
self.assertEqual('batman-secondary-1',
updated_private_ip_info['hostname-label'])
# Do a get and confirm the information which we receive
result = self.invoke([
'network', 'private-ip', 'get', '--private-ip-id',
second_secondary_private_ip_id
])
private_ip_info_from_get = json.loads(result.output)['data']
self.assertEqual(second_secondary_private_ip_id,
private_ip_info_from_get['id'])
self.assertEqual(second_secondary_private_ip_address,
private_ip_info_from_get['ip-address'])
self.assertEqual(first_vnic_id, private_ip_info_from_get['vnic-id'])
self.assertEqual('batman display name',
private_ip_info_from_get['display-name'])
self.assertEqual('batman-secondary-1',
private_ip_info_from_get['hostname-label'])
# Running the unassign command against a non-existent VNIC fails
# Listing by VNIC should give us one record (the primary private IP) per call
result = self.invoke([
'network', 'vnic', 'unassign-private-ip', '--vnic-id',
fudged_vnic_id, '--ip-address', second_secondary_private_ip_address
])
self.assertNotEqual(0, result.exit_code)
# The error message from the service is not being sent correctly to the CLI. The Error code is correct.
# This needs to be investigated
# assert 'Either VNIC with ID {} does not exist or you are not authorized to access it.'.format(fudged_vnic_id) in result.output
# Unassigning an IP address not in the VNIC fails
result = self.invoke([
'network', 'vnic', 'unassign-private-ip', '--vnic-id',
second_vnic_id, '--ip-address', second_secondary_private_ip_address
])
assert 'IP address {} was not found on VNIC {}'.format(
second_secondary_private_ip_address,
second_vnic_id) in result.output
self.assertNotEqual(0, result.exit_code)
# Unassigning a primary private IP address is not supported
result = self.invoke([
'network', 'vnic', 'unassign-private-ip', '--vnic-id',
second_vnic_id, '--ip-address', second_vnic_primary_private_ip
])
assert 'Taking no action as {} is the primary private IP on VNIC {}'.format(
second_vnic_primary_private_ip, second_vnic_id) in result.output
self.assertNotEqual(0, result.exit_code)
# Unassign a secondary private IP
result = self.invoke([
'network', 'vnic', 'unassign-private-ip', '--vnic-id',
second_vnic_id, '--ip-address', first_secondary_private_ip_address
])
assert 'Unassigned IP address {} from VNIC {}'.format(
first_secondary_private_ip_address,
second_vnic_id) in result.output
# Delete a secondary private IP (by its OCID)
result = self.invoke([
'network', 'private-ip', 'delete', '--private-ip-id',
second_secondary_private_ip_id, '--force'
])
self.assertEqual(0, result.exit_code)
# Listing by VNIC should give us one record (the primary private IP) per call
result = self.invoke(
['network', 'private-ip', 'list', '--vnic-id', first_vnic_id])
private_ips = json.loads(result.output)['data']
self.assertEqual(1, len(private_ips))
self.assertTrue(private_ips[0]['is-primary'])
result = self.invoke(
['network', 'private-ip', 'list', '--vnic-id', second_vnic_id])
private_ips = json.loads(result.output)['data']
self.assertEqual(1, len(private_ips))
self.assertTrue(private_ips[0]['is-primary'])
# Listing by subnet should give us two records (the primary private IP for each VNIC)
result = self.invoke(
['network', 'private-ip', 'list', '--subnet-id', self.subnet_ocid])
private_ips = json.loads(result.output)['data']
self.assertEqual(2, len(private_ips))
self.assertTrue(private_ips[0]['is-primary'])
self.assertTrue(private_ips[1]['is-primary'])
def oce_cluster(runner, config_file, config_profile):
# Set-up of cross-connect group
cluster_id = None
with test_config_container.create_vcr(
cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette(
'test_oce_fixture_cluster.yml'):
# Create a VCN for Kubernetes cluster
vcn_name = util.random_name('cli_test_oce_vcn')
vcn_cidr_block = "10.0.0.0/16"
pod_cidr_block = "10.96.0.0/16"
kub_svcs_cidr_block = "10.240.0.0/16"
params = [
'network', 'vcn', 'create', '--compartment-id',
util.COMPARTMENT_ID, '--display-name', vcn_name, '--cidr-block',
vcn_cidr_block
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
vcn_ocid = util.find_id_in_response(result.output)
util.wait_until(['network', 'vcn', 'get', '--vcn-id', vcn_ocid],
'AVAILABLE',
max_wait_seconds=PROVISIONING_TIME_SEC)
# Create 5 subnets: 1st 3 subnets for Kubernetes worker nodes and last 2 subnets for load balancers
subnet_cidrs = [
"10.0.1.0/24", "10.0.2.0/24", "10.0.3.0/24", "10.0.4.0/24",
"10.0.5.0/24"
]
subnet_names = list()
subnet_ocids = list()
for idx, subnet_cidr_block in enumerate(subnet_cidrs):
subnet_names.append(util.random_name('cli_test_compute_subnet'))
params = [
'network',
'subnet',
'create',
'--compartment-id',
util.COMPARTMENT_ID,
'--availability-domain',
util.availability_domain(),
'--display-name',
subnet_names[idx],
'--vcn-id',
vcn_ocid,
'--cidr-block',
subnet_cidr_block,
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
subnet_ocids.append(util.find_id_in_response(result.output))
util.wait_until(
['network', 'subnet', 'get', '--subnet-id', subnet_ocids[idx]],
'AVAILABLE',
max_wait_seconds=PROVISIONING_TIME_SEC)
regional_subnet_name = util.random_name('cli_test_compute_subnet')
subnet_names.append(regional_subnet_name)
params = [
'network',
'subnet',
'create',
'--compartment-id',
util.COMPARTMENT_ID,
'--display-name',
regional_subnet_name,
'--vcn-id',
vcn_ocid,
'--cidr-block',
"10.0.6.0/24",
]
# Create a public regional subnet for the cluster endpoint
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
regional_subnet_ocid = util.find_id_in_response(result.output)
subnet_ocids.append(regional_subnet_ocid)
util.wait_until(
['network', 'subnet', 'get', '--subnet-id', regional_subnet_ocid],
'AVAILABLE',
max_wait_seconds=PROVISIONING_TIME_SEC)
# Find Supported Kubernetes versions
params = ['ce', 'cluster-options', 'get', '--cluster-option-id', 'all']
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
# Pick the first version in the response to be used for the test cluster
kub_version = json.loads(
result.output)['data']['kubernetes-versions'][0]
kub_upgrade_version = json.loads(
result.output)['data']['kubernetes-versions'][1]
# Create a cluster
cluster_lb_subnets = '["' + subnet_ocids[3] + '", "' + subnet_ocids[
4] + '"]'
cluster_name = util.random_name('cli_oce_cluster_name')
params = [
'ce', 'cluster', 'create', '--compartment-id', util.COMPARTMENT_ID,
'--name', cluster_name, '--vcn-id', vcn_ocid,
'--kubernetes-version', kub_version, '--dashboard-enabled', 'true',
'--tiller-enabled', 'true', '--pods-cidr', pod_cidr_block,
'--services-cidr', kub_svcs_cidr_block, '--service-lb-subnet-ids',
cluster_lb_subnets, '--endpoint-subnet-id', regional_subnet_ocid
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
# Create cluster returns work request. Get work request response to obtain cluster OCID.
response = json.loads(result.output)
work_request_id = response['opc-work-request-id']
get_work_request_result = util.wait_until(
[
'ce', 'work-request', 'get', '--work-request-id',
work_request_id
],
'SUCCEEDED',
state_property_name='status',
max_wait_seconds=CLUSTER_CREATE_PROVISIONING_TIME_SEC)
util.validate_response(get_work_request_result)
cluster_id = json.loads(get_work_request_result.output
)['data']['resources'][0]['identifier']
# Get a cluster using cluster ID
get_params = ['ce', 'cluster', 'get', '--cluster-id', cluster_id]
result = invoke(runner, config_file, config_profile, get_params)
util.validate_response(result)
# Check the kubeconfig file generation
params = [
'ce', 'cluster', 'create-kubeconfig', '--cluster-id', cluster_id,
'--file', 'kubeconfig'
]
invoke(runner, config_file, config_profile, params)
# Validate the kubernetes config is in valid YAML format
with open('kubeconfig', 'r') as config:
config_data = config.read()
yaml.safe_load(config_data)
if os.path.exists('kubeconfig'):
os.remove('kubeconfig')
# Get the list of clusters in the compartment
params = [
'ce', 'cluster', 'list', '--compartment-id', util.COMPARTMENT_ID
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
assert len(json.loads(result.output)['data']) > 0
# Update the cluster using cluster ID
cluster_name = util.random_name('cli_test_oce_cluster')
params = [
'ce', 'cluster', 'update', '--cluster-id', cluster_id, '--name',
cluster_name, '--kubernetes-version', kub_upgrade_version
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
# Update cluster returns work request. Get work request response to check the command succeeded
response = json.loads(result.output)
work_request_id = response['opc-work-request-id']
get_work_request_result = util.wait_until(
[
'ce', 'work-request', 'get', '--work-request-id',
work_request_id
],
'SUCCEEDED',
state_property_name='status',
max_wait_seconds=CLUSTER_UPDATE_TIME_SEC)
util.validate_response(get_work_request_result)
# Get the list of work request logs
params = [
'ce', 'work-request-log-entry', 'list', '--work-request-id',
work_request_id, '--compartment-id', util.COMPARTMENT_ID
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
# Update a cluster endpoint
params = [
'ce', 'cluster', 'update-endpoint-config', '--cluster-id',
cluster_id, '--is-public-ip-enabled', 'true', '--nsg-ids', '[]'
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
# Update endpoint config returns a work request. Get work request response to check the command succeeded
response = json.loads(result.output)
work_request_id = response['opc-work-request-id']
get_work_request_result = util.wait_until(
[
'ce', 'work-request', 'get', '--work-request-id',
work_request_id
],
'SUCCEEDED',
state_property_name='status',
max_wait_seconds=CLUSTER_UPDATE_TIME_SEC)
util.validate_response(get_work_request_result)
yield cluster_id, subnet_ocids[0], subnet_ocids[1], subnet_ocids[2]
# Tear down sequence
with test_config_container.create_vcr(
cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette(
'test_oce_fixture_cluster_delete.yml'):
# Delete the cluster
params = [
'ce', 'cluster', 'delete', '--cluster-id', cluster_id, '--force'
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
# Get the cluster and check that it moves to DELETED state
invoke(runner, config_file, config_profile, get_params)
util.wait_until(get_params,
'DELETED',
max_wait_seconds=DELETION_TIME_SEC)
# Delete the subnets
for subnet_id in subnet_ocids:
params = [
'network', 'subnet', 'delete', '--subnet-id', subnet_id,
'--wait-for-state', 'TERMINATED', '--force'
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result, json_response_expected=False)
# Delete the VCN
params = [
'network', 'vcn', 'delete', '--vcn-id', vcn_ocid,
'--wait-for-state', 'TERMINATED', '--force'
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result, json_response_expected=False)
if os.path.isdir(
os.path.expandvars(os.path.expanduser(USER_KUBECONFIG_DIR))):
shutil.rmtree(USER_KUBECONFIG_DIR)
def subtest_launch_instance_ipxe_script_file_and_extended_metadata(self):
instance_name = util.random_name('cli_test_instance_options')
image_id = util.oracle_linux_image()
shape = 'VM.Standard1.2'
hostname_label = util.random_name('bminstance',
insert_underscore=False)
vnic_display_name = 'vnic_display_name'
private_ip = '10.0.0.15'
assign_public_ip = 'true'
extended_metadata = '{"a": "1", "b": {"c": "3", "d": {}}}'
launch_instance_result = util.invoke_command([
'compute', 'instance', 'launch', '--compartment-id',
util.COMPARTMENT_ID, '--availability-domain',
util.availability_domain(), '--display-name', instance_name,
'--subnet-id', self.subnet_ocid, '--image-id', image_id, '--shape',
shape, '--ipxe-script-file', IPXE_SCRIPT_FILE, '--hostname-label',
hostname_label + "1", '--private-ip', private_ip,
'--assign-public-ip', assign_public_ip, '--vnic-display-name',
vnic_display_name, '--extended-metadata', extended_metadata
])
temp_instance_ocid = util.find_id_in_response(
launch_instance_result.output)
self.instance_ocids.append(temp_instance_ocid)
util.validate_response(launch_instance_result, expect_etag=True)
extended_metadata_result = json.loads(
launch_instance_result.output)['data']['extended-metadata']
assert extended_metadata_result['a'] == '1'
assert extended_metadata_result['b']['c'] == '3'
# This can be in ATTACHING state for some time
try:
util.wait_until([
'compute', 'vnic-attachment', 'list', '--compartment-id',
util.COMPARTMENT_ID, '--instance-id', temp_instance_ocid
],
'ATTACHED',
max_wait_seconds=60,
item_index_in_list_response=0)
except Exception:
try:
# If it is ATTACHING we will consider it good enough
util.wait_until([
'compute', 'vnic-attachment', 'list', '--compartment-id',
util.COMPARTMENT_ID, '--instance-id', temp_instance_ocid
],
'ATTACHING',
max_wait_seconds=30,
item_index_in_list_response=0)
except Exception:
# If it is not ATTACHING, double check that it didn't go to ATTACHED
util.wait_until([
'compute', 'vnic-attachment', 'list', '--compartment-id',
util.COMPARTMENT_ID, '--instance-id', temp_instance_ocid
],
'ATTACHED',
max_wait_seconds=30,
item_index_in_list_response=0)
# get vnic attachments for given instance
list_vnics_result = util.invoke_command([
'compute', 'vnic-attachment', 'list', '--compartment-id',
util.COMPARTMENT_ID, '--instance-id', temp_instance_ocid
])
vnic_id = json.loads(list_vnics_result.output)['data'][0]['vnic-id']
# get full data for vnic attached to new instance (which includes hostname-label)
get_vnic_result = util.invoke_command(
['network', 'vnic', 'get', '--vnic-id', vnic_id])
vnic = json.loads(get_vnic_result.output)['data']
assert vnic['hostname-label'] == hostname_label + "1"
assert vnic['display-name'] == vnic_display_name
assert vnic['public-ip']
content = None
with open(IPXE_SCRIPT_FILE, mode='r') as file:
content = file.read()
assert 'ipxe-script' in launch_instance_result.output
# Just look at the first few characters. Once we hit a line break the formatting will differ.
assert content[:5] in launch_instance_result.output
self.delete_instance(temp_instance_ocid)
def subtest_security_list_operations(self):
sl_name = util.random_name('cli_test_security_list')
egress_rules = util.remove_outer_quotes(
oci_cli_virtual_network.virtualnetwork_cli_extended.
network_create_security_list_egress_security_rules_example)
ingress_rules = util.remove_outer_quotes(
oci_cli_virtual_network.virtualnetwork_cli_extended.
network_create_security_list_ingress_security_rules_example)
result = self.invoke([
'security-list', 'create', '--compartment-id', util.COMPARTMENT_ID,
'--display-name', sl_name, '--vcn-id', self.vcn_ocid,
'--egress-security-rules', egress_rules,
'--ingress-security-rules', ingress_rules
])
self.sl_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
util.wait_until([
'network', 'security-list', 'get', '--security-list-id',
self.sl_ocid
],
'AVAILABLE',
max_wait_seconds=300)
result = self.invoke([
'security-list', 'list', '--compartment-id', util.COMPARTMENT_ID,
'--vcn-id', self.vcn_ocid
])
util.validate_response(result)
self.run_list_filter_verification('security-list', sl_name)
result = self.invoke(
['security-list', 'get', '--security-list-id', self.sl_ocid])
util.validate_response(result, expect_etag=True)
sl_name = sl_name + "_updated"
egress_rules_v2 = """[{"destination": "10.0.2.0/24", "protocol": "6", "tcpOptions": {"destinationPortRange": {"max": 1522, "min": 1522}}}]"""
ingress_rules_v2 = """[{"protocol": "6", "source": "10.0.1.0/25", "tcpOptions": {"destinationPortRange": {"max": 1521, "min": 1521}}}]"""
# TODO: A short sleep before every security list update to allow for replication.
util.vcr_mode_aware_sleep(20)
# Force update on all fields
result = self.invoke([
'security-list', 'update', '--security-list-id', self.sl_ocid,
'--display-name', sl_name, '--egress-security-rules', egress_rules,
'--ingress-security-rules', ingress_rules, '--force'
])
util.validate_response(result, expect_etag=True)
util.vcr_mode_aware_sleep(20)
# update display name only - does not show a prompt
result = self.invoke([
'security-list', 'update', '--security-list-id', self.sl_ocid,
'--display-name', sl_name
])
util.validate_response(result, expect_etag=True)
util.vcr_mode_aware_sleep(20)
# update egress-rules, confirm y
result = self.invoke([
'security-list', 'update', '--security-list-id', self.sl_ocid,
'--egress-security-rules', egress_rules_v2
],
input='y')
util.validate_response(result, json_response_expected=False)
util.vcr_mode_aware_sleep(20)
# update ingress-rules, confirm y
result = self.invoke([
'security-list', 'update', '--security-list-id', self.sl_ocid,
'--ingress-security-rules', ingress_rules_v2
],
input='y')
util.validate_response(result, json_response_expected=False)
util.vcr_mode_aware_sleep(20)
# update both, confirm y
result = self.invoke([
'security-list', 'update', '--security-list-id', self.sl_ocid,
'--ingress-security-rules', ingress_rules,
'--egress-security-rules', egress_rules
],
input='y')
util.validate_response(result, json_response_expected=False)
util.vcr_mode_aware_sleep(20)
# update egress-rules, confirm n
result = self.invoke([
'security-list', 'update', '--security-list-id', self.sl_ocid,
'--egress-security-rules', egress_rules_v2
],
input='n')
assert result.exit_code != 0
# update egress-rules, force
result = self.invoke([
'security-list', 'update', '--security-list-id', self.sl_ocid,
'--egress-security-rules', egress_rules_v2, '--force'
])
util.validate_response(result, expect_etag=True)
def set_up_resources(self):
# Grab the Object Storage namespace
result = self.invoke(['os', 'ns', 'get'])
self.object_storage_namespace = json.loads(result.output)['data']
# Create a bucket
print("Creating bucket")
self.bucket_name = util.random_name('CliImageImportExport')
result = self.invoke(
['os', 'bucket', 'create',
'--compartment-id', util.COMPARTMENT_ID,
'--namespace', self.object_storage_namespace,
'--name', self.bucket_name])
util.validate_response(result, expect_etag=True)
# Create a VCN
print("Creating VCN")
vcn_name = util.random_name('cli_test_compute_vcn')
result = self.invoke(
['network', 'vcn', 'create',
'--compartment-id', util.COMPARTMENT_ID,
'--display-name', vcn_name,
'--dns-label', 'clivcn',
'--cidr-block', '10.0.0.0/16'])
util.validate_response(result, expect_etag=True)
self.vcn_ocid = util.find_id_in_response(result.output)
util.wait_until(['network', 'vcn', 'get', '--vcn-id', self.vcn_ocid], 'AVAILABLE', max_wait_seconds=300)
# Create a subnet
print("Creating subnet")
subnet_name = util.random_name('cli_test_compute_subnet')
result = self.invoke(
['network', 'subnet', 'create',
'--compartment-id', util.COMPARTMENT_ID,
'--availability-domain', util.availability_domain(),
'--display-name', subnet_name,
'--dns-label', 'clisubnet',
'--vcn-id', self.vcn_ocid,
'--cidr-block', '10.0.0.0/16',
])
util.validate_response(result, expect_etag=True)
self.subnet_ocid = util.find_id_in_response(result.output)
util.wait_until(['network', 'subnet', 'get', '--subnet-id', self.subnet_ocid], 'AVAILABLE', max_wait_seconds=300)
# Create an instance
image_id = util.oracle_linux_image()
shape = 'VM.Standard1.1'
instance_name = util.random_name('cli_test_instance')
print("Creating instance " + instance_name)
result = self.invoke(
['compute', 'instance', 'launch',
'--compartment-id', util.COMPARTMENT_ID,
'--availability-domain', util.availability_domain(),
'--display-name', instance_name,
'--subnet-id', self.subnet_ocid,
'--image-id', image_id,
'--shape', shape])
util.validate_response(result, expect_etag=True)
self.instance_id = util.find_id_in_response(result.output)
util.wait_until(['compute', 'instance', 'get', '--instance-id', self.instance_id], 'RUNNING', max_wait_seconds=600)
# Export an image from the instance to use in tests
print("Exporting image")
result = self.invoke(
['compute', 'image', 'create',
'--compartment-id', util.COMPARTMENT_ID,
'--instance-id', self.instance_id])
util.validate_response(result, expect_etag=True)
self.custom_image_id = util.find_id_in_response(result.output)
util.wait_until(['compute', 'image', 'get', '--image-id', self.custom_image_id], 'AVAILABLE', max_wait_seconds=3600)
def subtest_policy_operations(self):
policy_name = util.random_name('cli_test_policy')
policy_description = 'Created by CLI identity tests.'
statement_a_policy_base = 'Allow group {} to inspect volume-family in compartment'.format(
self.group_name)
statement_a = "{policy_base} {compartment_name}".format(
policy_base=statement_a_policy_base,
compartment_name=util.COMPARTMENT_NAME)
statement_b_policy_base = 'Allow group {} to inspect virtual-network-family in compartment'.format(
self.group_name)
statement_b = "{policy_base} {compartment_name}".format(
policy_base=statement_b_policy_base,
compartment_name=util.COMPARTMENT_NAME)
result = self.invoke([
'policy', 'create', '--name', policy_name, '--compartment-id',
util.TENANT_ID, '--description', policy_description,
'--statements', '["{statement}"]'.format(statement=statement_a)
])
policy_ocid = util.find_id_in_response(result.output)
self.validate_response(result, expect_etag=True)
self.check_policy_statements_case_insensitive(statement_a_policy_base,
result.output)
# Update description only.
policy_description = policy_description + "UPDATED!"
result = self.invoke([
'policy', 'update', '--policy-id', policy_ocid, '--description',
policy_description
])
self.validate_response(result, expect_etag=True)
self.check_policy_statements_case_insensitive(statement_a_policy_base,
result.output)
statements = '["{statement_a}", "{statement_b}"]'.format(
statement_a=statement_a, statement_b=statement_b)
version_date = "2016-01-01"
# Try to update statements only - should fail.
result = self.invoke([
'policy', 'update', '--policy-id', policy_ocid, '--statements',
statements
])
assert result.exit_code != 0
# Try to update statements only - should fail.
result = self.invoke([
'policy', 'update', '--policy-id', policy_ocid, '--statements',
statements
])
assert result.exit_code != 0
# Update statements and version_date, but don't confirm.
result = self.invoke([
'policy', 'update', '--policy-id', policy_ocid, '--statements',
statements, '--version-date', version_date
])
assert result.exit_code != 0
# Update statements and version_date
result = self.invoke([
'policy', 'update', '--policy-id', policy_ocid, '--statements',
statements, '--version-date', version_date, '--force'
])
self.validate_response(result, expect_etag=True)
self.check_policy_statements_case_insensitive(statement_a_policy_base,
result.output)
self.check_policy_statements_case_insensitive(statement_b_policy_base,
result.output)
assert version_date in result.output
etag = json.loads(result.output)['etag']
# Set incorrect etag when updating statements
result = self.invoke([
'policy', 'update', '--policy-id', policy_ocid, '--statements',
statements, '--version-date', version_date, '--if-match',
'incorrect_etag'
'--force'
])
assert result.exit_code != 0
# Set incorrect etag when updating description
policy_description = policy_description + " updated again"
result = self.invoke([
'policy', 'update', '--policy-id', policy_ocid, '--description',
policy_description, '--if-match', 'incorrect_etag'
])
assert result.exit_code != 0
# Set correct etag when updating statements.
# Remove statement a, clear the version date
statements = '["{statement_b}"]'.format(statement_b=statement_b)
result = self.invoke([
'policy', 'update', '--policy-id', policy_ocid, '--statements',
statements, '--version-date', "", '--if-match', etag, '--force'
])
self.validate_response(result, expect_etag=True)
self.check_policy_statements_case_insensitive(statement_a_policy_base,
result.output,
check_not_in=True)
self.check_policy_statements_case_insensitive(statement_b_policy_base,
result.output)
assert version_date not in result.output
# Set correct etag when updating description
etag = json.loads(result.output)['etag']
policy_description = policy_description + " updated again"
result = self.invoke([
'policy', 'update', '--policy-id', policy_ocid, '--description',
policy_description, '--if-match', etag
])
self.validate_response(result, expect_etag=True)
assert policy_description in result.output
self.check_policy_statements_case_insensitive(statement_a_policy_base,
result.output,
check_not_in=True)
self.check_policy_statements_case_insensitive(statement_b_policy_base,
result.output)
assert version_date not in result.output
# Get policy
result = self.invoke(['policy', 'get', '--policy-id', policy_ocid])
self.validate_response(result, expect_etag=True)
assert policy_description in result.output
self.check_policy_statements_case_insensitive(statement_a_policy_base,
result.output,
check_not_in=True)
self.check_policy_statements_case_insensitive(statement_b_policy_base,
result.output)
assert version_date not in result.output
# List policies
result = self.invoke([
'policy', 'list', '--compartment-id', util.TENANT_ID, '--limit',
'1000'
])
self.validate_response(result)
assert policy_description in result.output
self.check_policy_statements_case_insensitive(statement_a_policy_base,
result.output,
check_not_in=True)
self.check_policy_statements_case_insensitive(statement_b_policy_base,
result.output)
result = self.invoke([
'policy', 'list', '--compartment-id', util.TENANT_ID, '--limit',
'1'
])
self.validate_response(result)
assert len(json.loads(result.output)['data']) == 1
self.update_policy_with_tags(policy_ocid)
# Delete policy
result = self.invoke(
['policy', 'delete', '--policy-id', policy_ocid, '--force'])
self.validate_response(result)
def subtest_volume_backup_operations(self):
backup_name = util.random_name('cli_test_backup')
result = self.invoke([
'backup', 'create', '--volume-id', self.volume_id,
'--display-name', backup_name
])
util.validate_response(result)
self.backup_id = util.find_id_in_response(result.output)
util.wait_until(
['bv', 'backup', 'get', '--volume-backup-id', self.backup_id],
'AVAILABLE',
max_wait_seconds=600)
result = self.invoke(
['backup', 'get', '--volume-backup-id', self.backup_id])
util.validate_response(result)
parsed_result = json.loads(result.output)
assert parsed_result['data']['size-in-gbs'] is not None
assert parsed_result['data']['size-in-mbs'] is not None
assert parsed_result['data']['unique-size-in-gbs'] is not None
assert parsed_result['data']['unique-size-in-mbs'] is not None
result = self.invoke(
['backup', 'list', '--compartment-id', util.COMPARTMENT_ID])
util.validate_response(result)
result = self.invoke([
'backup', 'list', '--compartment-id', util.COMPARTMENT_ID,
'--volume-id', self.volume_id
])
util.validate_response(result)
self.assertEquals(1, len(json.loads(result.output)['data']))
retrieve_list_and_ensure_sorted([
'bv', 'backup', 'list', '-c', util.COMPARTMENT_ID, '--sort-by',
'DISPLAYNAME', '--sort-order', 'asc'
], 'display-name', 'asc')
retrieve_list_and_ensure_sorted([
'bv', 'backup', 'list', '-c', util.COMPARTMENT_ID, '--sort-by',
'DISPLAYNAME', '--sort-order', 'desc'
], 'display-name', 'desc')
retrieve_list_and_ensure_sorted([
'bv', 'backup', 'list', '-c', util.COMPARTMENT_ID, '--sort-by',
'TIMECREATED', '--sort-order', 'asc', '--all'
], 'time-created', 'asc')
retrieve_list_and_ensure_sorted([
'bv', 'backup', 'list', '-c', util.COMPARTMENT_ID, '--sort-by',
'TIMECREATED', '--sort-order', 'desc', '--all'
], 'time-created', 'desc')
backup_name = backup_name + "_UPDATED"
result = self.invoke([
'backup', 'update', '--volume-backup-id', self.backup_id,
'--display-name', backup_name
])
util.validate_response(result)
result = self.invoke([
'volume', 'create', '--volume-backup-id', self.backup_id,
'--availability-domain',
util.second_availability_domain()
])
util.validate_response(result)
parsed_result = json.loads(result.output)
source_details = {'id': self.backup_id, 'type': 'volumeBackup'}
assert source_details == parsed_result['data']['source-details']
assert util.second_availability_domain(
) == parsed_result['data']['availability-domain']
assert 50 == int(parsed_result['data']
['size-in-gbs']) # We initially created a 50GB volume
volume_id = util.find_id_in_response(result.output)
util.wait_until(['bv', 'volume', 'get', '--volume-id', volume_id],
'AVAILABLE',
max_wait_seconds=600)
result = self.invoke(
['volume', 'delete', '--volume-id', volume_id, '--force'])
util.validate_response(result)
# Make sure we're still in a good state before deleting.
util.wait_until(
['bv', 'backup', 'get', '--volume-backup-id', self.backup_id],
'AVAILABLE',
max_interval_seconds=180)
