use of com.vmware.photon.controller.model.constants.PhotonModelConstants.TAG_KEY_TYPE in project photon-model by vmware.
the class AzureTestUtil method createVMResourceFromSpec.
/**
* Separate method to create VM from given spec
*/
public static ComputeState createVMResourceFromSpec(VMResourceSpec spec) throws Throwable {
final String defaultVmRGName = spec.azureVmName;
// TODO Modify createDefaultResourceGroupState() to have only spec parameter passed
final ResourceGroupState defaultVmRG = createDefaultResourceGroupState(spec.host, defaultVmRGName, spec.computeHost, spec.endpointState, ResourceGroupStateType.AzureResourceGroup);
final String defaultVmRGLink = defaultVmRG.documentSelfLink;
if (spec.networkRGLink == null) {
// The RG where the VM is deployed is also used as RG for the Network!
spec.networkRGLink = defaultVmRGLink;
}
// The RG where the VM is deployed is also used as RG for the SecurityGroup!
final String sgRGLink = defaultVmRGLink;
// Create resource group with a different type. It should be filtered out.
ResourceGroupState azureStorageContainerRG = createDefaultResourceGroupState(spec.host, AZURE_STORAGE_CONTAINER_RG_NAME, spec.computeHost, spec.endpointState, ResourceGroupStateType.AzureStorageContainer);
final Set<String> networkRGLinks = new HashSet<>();
networkRGLinks.add(spec.networkRGLink);
networkRGLinks.add(azureStorageContainerRG.documentSelfLink);
final Set<String> sgRGLinks = new HashSet<>();
sgRGLinks.add(sgRGLink);
sgRGLinks.add(azureStorageContainerRG.documentSelfLink);
AuthCredentialsServiceState azureVMAuth = new AuthCredentialsServiceState();
azureVMAuth.userEmail = AZURE_ADMIN_USERNAME;
azureVMAuth.privateKey = AZURE_ADMIN_PASSWORD;
azureVMAuth = TestUtils.doPost(spec.host, azureVMAuth, AuthCredentialsServiceState.class, UriUtils.buildUri(spec.host, AuthCredentialsService.FACTORY_LINK));
// Create a VM desc
ComputeDescription azureVMDesc = new ComputeDescription();
azureVMDesc.id = UUID.randomUUID().toString();
azureVMDesc.documentSelfLink = azureVMDesc.id;
azureVMDesc.name = azureVMDesc.id;
azureVMDesc.regionId = AZURE_RESOURCE_GROUP_LOCATION;
azureVMDesc.authCredentialsLink = azureVMAuth.documentSelfLink;
azureVMDesc.tenantLinks = spec.endpointState.tenantLinks;
azureVMDesc.endpointLink = spec.endpointState.documentSelfLink;
azureVMDesc.endpointLinks = new HashSet<>();
azureVMDesc.endpointLinks.add(spec.endpointState.documentSelfLink);
azureVMDesc.computeHostLink = spec.endpointState.computeHostLink;
azureVMDesc.instanceType = AZURE_VM_SIZE;
azureVMDesc.environmentName = ComputeDescription.ENVIRONMENT_NAME_AZURE;
azureVMDesc.customProperties = new HashMap<>();
// set the create service to the azure instance service
azureVMDesc.instanceAdapterReference = UriUtils.buildUri(spec.host, AzureUriPaths.AZURE_INSTANCE_ADAPTER);
azureVMDesc.powerAdapterReference = UriUtils.buildUri(spec.host, AzureUriPaths.AZURE_POWER_ADAPTER);
azureVMDesc = TestUtils.doPost(spec.host, azureVMDesc, ComputeDescription.class, UriUtils.buildUri(spec.host, ComputeDescriptionService.FACTORY_LINK));
DiskState rootDisk = new DiskState();
rootDisk.name = spec.azureVmName + "-boot-disk";
rootDisk.id = UUID.randomUUID().toString();
rootDisk.documentSelfLink = rootDisk.id;
rootDisk.type = DiskType.HDD;
rootDisk.storageType = AZURE_STORAGE_DISKS;
// Custom OSDisk size of 32 GBs
rootDisk.capacityMBytes = AZURE_CUSTOM_OSDISK_SIZE;
rootDisk.bootOrder = 1;
rootDisk.endpointLink = spec.endpointState.documentSelfLink;
rootDisk.endpointLinks = new HashSet<>();
rootDisk.endpointLinks.add(spec.endpointState.documentSelfLink);
rootDisk.computeHostLink = spec.endpointState.computeHostLink;
rootDisk.tenantLinks = spec.endpointState.tenantLinks;
if (spec.isManagedDisk) {
rootDisk.tagLinks = createTagStateSet(spec.host, spec.endpointState.tenantLinks, TAG_KEY_TYPE, AzureResourceType.azure_managed_disk.name());
} else {
rootDisk.tagLinks = createTagStateSet(spec.host, spec.endpointState.tenantLinks, TAG_KEY_TYPE, AzureResourceType.azure_vhd.name());
}
rootDisk.customProperties = new HashMap<>();
rootDisk.customProperties.put(AZURE_OSDISK_CACHING, DEFAULT_OS_DISK_CACHING.name());
if (spec.imageSource.type == Type.PRIVATE_IMAGE) {
if (spec.isManagedDisk) {
rootDisk.imageLink = spec.imageSource.asImageState().documentSelfLink;
rootDisk.customProperties.put(AzureConstants.AZURE_MANAGED_DISK_TYPE, SkuName.STANDARD_LRS.toString());
}
} else if (spec.imageSource.type == Type.PUBLIC_IMAGE) {
if (spec.isManagedDisk) {
rootDisk.imageLink = spec.imageSource.asImageState().documentSelfLink;
rootDisk.customProperties.put(AzureConstants.AZURE_MANAGED_DISK_TYPE, SkuName.STANDARD_LRS.toString());
} else {
rootDisk.imageLink = spec.imageSource.asImageState().documentSelfLink;
if (spec.storageAccountName == null || spec.resourceGroupForStorageAccount == null) {
rootDisk.customProperties.put(AzureConstants.AZURE_STORAGE_ACCOUNT_NAME, (spec.azureVmName + "sa").replaceAll("[_-]", "").toLowerCase());
rootDisk.customProperties.put(AzureConstants.AZURE_STORAGE_ACCOUNT_RG_NAME, defaultVmRGName);
} else {
rootDisk.customProperties.put(AzureConstants.AZURE_STORAGE_ACCOUNT_NAME, spec.storageAccountName);
rootDisk.customProperties.put(AzureConstants.AZURE_STORAGE_ACCOUNT_RG_NAME, spec.resourceGroupForStorageAccount);
}
rootDisk.customProperties.put(AzureConstants.AZURE_STORAGE_ACCOUNT_TYPE, AZURE_STORAGE_ACCOUNT_TYPE);
}
} else if (spec.imageSource.type == Type.IMAGE_REFERENCE) {
rootDisk.sourceImageReference = URI.create(spec.imageSource.asRef());
}
rootDisk = TestUtils.doPost(spec.host, rootDisk, DiskState.class, UriUtils.buildUri(spec.host, DiskService.FACTORY_LINK));
List<String> vmDisks = new ArrayList<>();
vmDisks.add(rootDisk.documentSelfLink);
// create additional disks
if (spec.numberOfAdditionalDisks > 0) {
// TODO Need to modify createAdditionalDisks() to have only spec passed as parameter
vmDisks.addAll(createAdditionalDisks(spec.host, spec.azureVmName, spec.endpointState, spec.numberOfAdditionalDisks, spec.persistentDisks, spec.isManagedDisk));
}
// Add external existing data disks (if present) to the list for attaching
if (null != spec.externalDiskLinks && spec.externalDiskLinks.size() > 0) {
vmDisks.addAll(spec.externalDiskLinks);
}
// Create NICs
List<String> nicLinks = createDefaultNicStates(spec.host, spec.computeHost, spec.endpointState, networkRGLinks, sgRGLinks, spec.nicSpecs, spec.azureVmName).stream().map(nic -> nic.documentSelfLink).collect(Collectors.toList());
// Finally create the compute resource state to provision using all constructs above.
ComputeState computeState = new ComputeState();
computeState.id = UUID.randomUUID().toString();
computeState.name = spec.azureVmName;
computeState.parentLink = spec.computeHost.documentSelfLink;
computeState.type = ComputeType.VM_GUEST;
computeState.environmentName = ComputeDescription.ENVIRONMENT_NAME_AZURE;
computeState.descriptionLink = azureVMDesc.documentSelfLink;
computeState.resourcePoolLink = spec.computeHost.resourcePoolLink;
computeState.diskLinks = vmDisks;
computeState.networkInterfaceLinks = nicLinks;
computeState.customProperties = Collections.singletonMap(RESOURCE_GROUP_NAME, defaultVmRGName);
computeState.groupLinks = Collections.singleton(defaultVmRGLink);
computeState.endpointLink = spec.endpointState.documentSelfLink;
computeState.endpointLinks = new HashSet<>();
computeState.endpointLinks.add(spec.endpointState.documentSelfLink);
computeState.computeHostLink = spec.endpointState.computeHostLink;
computeState.tenantLinks = spec.endpointState.tenantLinks;
computeState.creationTimeMicros = TimeUnit.MILLISECONDS.toMicros(System.currentTimeMillis());
return TestUtils.doPost(spec.host, computeState, ComputeState.class, UriUtils.buildUri(spec.host, ComputeService.FACTORY_LINK));
}
use of com.vmware.photon.controller.model.constants.PhotonModelConstants.TAG_KEY_TYPE in project photon-model by vmware.
the class TestAzureEnumerationTask method testEnumeration.
@Test
public void testEnumeration() throws Throwable {
this.storageDescription = createDefaultStorageAccountDescription(this.host, this.mockedStorageAccountName, computeHost, endpointState);
this.resourceGroupState = createDefaultResourceGroupState(this.host, this.mockedStorageAccountName, computeHost, endpointState, ResourceGroupStateType.AzureResourceGroup);
this.diskState = createDefaultDiskState(this.host, this.mockedStorageAccountName, this.mockedStorageAccountName, computeHost, endpointState);
// create an Azure VM compute resource (this also creates a disk and a storage account)
this.vmState = createDefaultVMResource(this.host, azureVMName, computeHost, endpointState, NIC_SPEC);
// kick off a provision task to do the actual VM creation
ProvisionComputeTaskState provisionTask = new ProvisionComputeTaskState();
provisionTask.computeLink = this.vmState.documentSelfLink;
provisionTask.isMockRequest = this.isMock;
provisionTask.taskSubStage = SubStage.CREATING_HOST;
ProvisionComputeTaskState outTask = TestUtils.doPost(this.host, provisionTask, ProvisionComputeTaskState.class, UriUtils.buildUri(this.host, ProvisionComputeTaskService.FACTORY_LINK));
this.host.waitForFinishedTask(ProvisionComputeTaskState.class, outTask.documentSelfLink);
// Check resources have been created
// expected VM count = 2 (1 compute host instance + 1 vm compute state)
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, 2, ComputeService.FACTORY_LINK, false);
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, 1, StorageDescriptionService.FACTORY_LINK, false);
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, 1, ResourceGroupService.FACTORY_LINK, false);
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, 1, DiskService.FACTORY_LINK, false);
this.numberOfVMsToDelete++;
if (this.isMock) {
runEnumeration();
deleteVMs(this.host, this.vmState.documentSelfLink, this.isMock, 1);
this.vmState = null;
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, 1, ComputeService.FACTORY_LINK, false);
deleteServiceDocument(this.host, this.storageDescription.documentSelfLink);
this.storageDescription = null;
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, 0, StorageDescriptionService.FACTORY_LINK, true);
deleteServiceDocument(this.host, this.resourceGroupState.documentSelfLink);
this.resourceGroupState = null;
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, 0, ResourceGroupService.FACTORY_LINK, false);
deleteServiceDocument(this.host, this.diskState.documentSelfLink);
this.diskState = null;
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, 0, DiskService.FACTORY_LINK, false);
return;
}
createStaleResource();
tagAzureResources();
// stale resources + 1 compute host instance + 1 vm compute state
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_VM_RESOURCES_COUNT + 2, ComputeService.FACTORY_LINK, false);
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_STORAGE_ACCOUNTS_COUNT + 1, StorageDescriptionService.FACTORY_LINK, false);
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_CONTAINERS_COUNT + STALE_RG_COUNT + 1, ResourceGroupService.FACTORY_LINK, false);
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_DISKS_COUNT + 1, DiskService.FACTORY_LINK, false);
// 1 network per each stale vm resource + 1 network for original vm compute state.
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_VM_RESOURCES_COUNT + 1, NetworkService.FACTORY_LINK, false);
// 1 subnet per network, 1 network per each stale vm resource + 1 subnet for the original
// compute state.
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_VM_RESOURCES_COUNT + 1, SubnetService.FACTORY_LINK, false);
// 1 network per each stale vm resource + 1 network for original vm compute state.
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_VM_RESOURCES_COUNT + 1, NetworkInterfaceService.FACTORY_LINK, false);
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_SECURITY_GROUPS_COUNT, SecurityGroupService.FACTORY_LINK, false);
this.vmCount = getAzureVMCount(this.computeManagementClient);
this.host.log(Level.INFO, "Initial VM Count: %d", this.vmCount);
runEnumeration();
assertRemoteResources();
assertInternalTagResources();
assertStaleResources();
// VM count + 1 compute host instance
this.vmCount = this.vmCount + 1;
ServiceDocumentQueryResult result = ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, this.vmCount, ComputeService.FACTORY_LINK, false);
// validate type field for enumerated VMs
result.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), ComputeState.class)).filter(c -> !c.documentSelfLink.equals(computeHost.documentSelfLink));
// validate internal tags for enumerated VMs
TagService.TagState expectedInternalTypeTag = newTagState(TAG_KEY_TYPE, AzureConstants.AzureResourceType.azure_vm.toString(), EnumSet.of(SYSTEM), endpointState.tenantLinks);
result.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), ComputeState.class)).filter(c -> c.type.equals(ComputeType.VM_GUEST)).forEach(c -> {
assertNotNull("ComputeState tagLinks is NULL", c.tagLinks);
assertTrue(String.format("ComputeState doesn't contain tagLink: %s", expectedInternalTypeTag.documentSelfLink), c.tagLinks.contains(expectedInternalTypeTag.documentSelfLink));
});
// 1 network per each stale vm resource + 1 network for original vm compute state.
ServiceDocumentQueryResult networkResults = ProvisioningUtils.queryAllFactoryResources(this.host, NetworkService.FACTORY_LINK);
// validate internal tags for enumerated networks
TagService.TagState expectedNetworkInternalTypeTag = newTagState(TAG_KEY_TYPE, NETWORK_TAG_TYPE_VALUE, false, endpointState.tenantLinks);
networkResults.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), NetworkState.class)).forEach(c -> {
assertNotNull("NetworkState tagLinks is NULL", c.tagLinks);
assertTrue(String.format("NetworkState doesn't contain tagLink: %s", expectedNetworkInternalTypeTag.documentSelfLink), c.tagLinks.contains(expectedNetworkInternalTypeTag.documentSelfLink));
});
// 1 subnet per network, 1 network per each stale vm resource + 1 subnet for the original
// compute state.
ServiceDocumentQueryResult subnetResults = ProvisioningUtils.queryAllFactoryResources(this.host, SubnetService.FACTORY_LINK);
// validate internal tags for enumerated subnets
TagService.TagState expectedSubnetInternalTypeTag = newTagState(TAG_KEY_TYPE, SUBNET_TAG_TYPE_VALUE, false, endpointState.tenantLinks);
subnetResults.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), SubnetState.class)).forEach(c -> {
assertNotNull("SubnetState tagLinks is NULL", c.tagLinks);
assertTrue(String.format("SubnetState doesn't contain tagLink: %s", expectedSubnetInternalTypeTag.documentSelfLink), c.tagLinks.contains(expectedSubnetInternalTypeTag.documentSelfLink));
});
ServiceDocumentQueryResult nicResults = ProvisioningUtils.queryAllFactoryResources(this.host, NetworkInterfaceService.FACTORY_LINK);
// validate internal tags for enumerated network interfaces
TagService.TagState expectedNicInternalTypeTag = newTagState(TAG_KEY_TYPE, NETWORK_INTERFACE_TAG_TYPE_VALUE, false, endpointState.tenantLinks);
nicResults.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), NetworkInterfaceState.class)).filter(c -> c.regionId != null).forEach(c -> {
assertNotNull("NetworkInterfaceState tagLinks is NULL", c.tagLinks);
assertTrue(String.format("NetworkInterfaceState doesn't contain tagLink: %s", expectedNicInternalTypeTag.documentSelfLink), c.tagLinks.contains(expectedNicInternalTypeTag.documentSelfLink));
});
// validate internal tags for disks
ServiceDocumentQueryResult diskResults = ProvisioningUtils.queryAllFactoryResources(this.host, DiskService.FACTORY_LINK);
TagService.TagState expectedManagedDiskInternalTypeTag = newTagState(TAG_KEY_TYPE, azure_managed_disk.toString(), false, endpointState.tenantLinks);
diskResults.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), DiskState.class)).filter(d -> d.customProperties != null && d.customProperties.containsKey(AzureConstants.AZURE_MANAGED_DISK_TYPE)).forEach(c -> {
assertNotNull("tagLinks is null for disk", c.tagLinks);
assertTrue("disk doesn't contain correct internal tagLink", c.tagLinks.contains(expectedManagedDiskInternalTypeTag.documentSelfLink));
});
// validate environment name field for enumerated VMs
result.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), ComputeState.class)).forEach(c -> assertEquals(ComputeDescription.ENVIRONMENT_NAME_AZURE, c.environmentName));
// validate Security Group tagLinks
ServiceDocumentQueryResult securityGroupResults = ProvisioningUtils.queryAllFactoryResources(this.host, SecurityGroupService.FACTORY_LINK);
securityGroupResults.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), SecurityGroupService.SecurityGroupState.class)).forEach(c -> {
if (c.tagLinks != null) {
for (String tag : c.tagLinks) {
assertTrue(tag.startsWith(TagService.FACTORY_LINK));
}
}
});
for (Entry<String, Object> key : result.documents.entrySet()) {
ComputeState document = Utils.fromJson(key.getValue(), ComputeState.class);
if (!document.documentSelfLink.equals(computeHost.documentSelfLink) && !document.documentSelfLink.equals(this.vmState.documentSelfLink) && document.id.toLowerCase().contains(CUSTOM_DIAGNOSTIC_ENABLED_VM.toLowerCase())) {
this.enumeratedComputeLink = document.documentSelfLink;
break;
}
}
try {
// Test stats for the VM that was just enumerated from Azure.
this.host.log(Level.INFO, "Collecting stats for VM [%s]-[%s]", CUSTOM_DIAGNOSTIC_ENABLED_VM, this.enumeratedComputeLink);
this.host.setTimeoutSeconds(300);
if (this.enumeratedComputeLink != null) {
this.host.waitFor("Error waiting for VM stats", () -> {
try {
issueStatsRequest(this.enumeratedComputeLink, false);
} catch (Throwable t) {
return false;
}
return true;
});
}
// Test stats for the compute host.
this.host.log(Level.INFO, "Collecting stats for host [%s]", computeHost.documentSelfLink);
this.host.waitFor("Error waiting for host stats", () -> {
try {
issueStatsRequest(computeHost.documentSelfLink, true);
} catch (Throwable t) {
return false;
}
return true;
});
} catch (Throwable te) {
this.host.log(Level.SEVERE, te.getMessage());
}
// delete vm directly on azure
this.computeManagementClient.virtualMachines().beginDelete(azureVMName, azureVMName);
runEnumeration();
assertResourceDisassociated(this.host, ComputeService.FACTORY_LINK, azureVMName, true);
// clean up
this.vmState = null;
this.resourceManagementClient.resourceGroups().beginDelete(azureVMName);
}
use of com.vmware.photon.controller.model.constants.PhotonModelConstants.TAG_KEY_TYPE in project photon-model by vmware.
the class TestAzureLongRunningEnumeration method testLongRunEnumeration.
@Test
public void testLongRunEnumeration() throws Throwable {
// Log node stats at the beginning of the test
logNodeStats(this.host.getServiceStats(this.nodeStatsUri));
// 1. Provision VMs
List<ProvisionComputeTaskState> taskStates = new ArrayList<>();
for (int i = 0; i < numOfVMsToTest; i++) {
this.storageDescriptions.add(createDefaultStorageAccountDescription(this.host, this.mockedStorageAccountName, computeHost, endpointState));
this.resourceGroupStates.add(createDefaultResourceGroupState(this.host, this.mockedStorageAccountName, computeHost, endpointState, ResourceGroupStateType.AzureResourceGroup));
this.diskStates.add(createDefaultDiskState(this.host, this.mockedStorageAccountName, this.mockedStorageAccountName, computeHost, endpointState));
// create an Azure VM compute resource (this also creates a disk and a storage account)
this.vmStates.add(createDefaultVMResource(this.host, azureVMNames.get(i), computeHost, endpointState, nicSpecs.get(i)));
// kick off a provision task to do the actual VM creation
ProvisionComputeTaskState provisionTask = new ProvisionComputeTaskState();
provisionTask.computeLink = this.vmStates.get(i).documentSelfLink;
provisionTask.isMockRequest = this.isMock;
provisionTask.taskSubStage = SubStage.CREATING_HOST;
taskStates.add(TestUtils.doPost(this.host, provisionTask, ProvisionComputeTaskState.class, UriUtils.buildUri(this.host, ProvisionComputeTaskService.FACTORY_LINK)));
}
for (ProvisionComputeTaskState taskState : taskStates) {
this.host.waitForFinishedTask(ProvisionComputeTaskState.class, taskState.documentSelfLink);
}
this.host.log(Level.INFO, "VMs provisioned successfully.");
// Check resources have been created
// expected VM count = numOfVMsToTest + 1 (1 compute host instance + numOfVMsToTest vm compute state)
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, numOfVMsToTest + 1, ComputeService.FACTORY_LINK, false);
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, numOfVMsToTest, StorageDescriptionService.FACTORY_LINK, false);
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, numOfVMsToTest, ResourceGroupService.FACTORY_LINK, false);
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, numOfVMsToTest, DiskService.FACTORY_LINK, false);
Map<String, ComputeState> azLrtComputeStates = getVMComputeStatesWithPrefix();
Assert.assertEquals(numOfVMsToTest, azLrtComputeStates.size());
if (this.isMock) {
runEnumeration(this.host, computeHost.documentSelfLink, computeHost.resourcePoolLink, endpointState, this.isMock);
for (int i = 0; i < numOfVMsToTest; i++) {
deleteVMs(this.host, this.vmStates.get(i).documentSelfLink, this.isMock, 1);
this.vmStates.set(i, null);
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, numOfVMsToTest - i, ComputeService.FACTORY_LINK, false);
deleteServiceDocument(this.host, this.storageDescriptions.get(i).documentSelfLink);
this.storageDescriptions.set(i, null);
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, numOfVMsToTest - i - 1, StorageDescriptionService.FACTORY_LINK, true);
deleteServiceDocument(this.host, this.resourceGroupStates.get(i).documentSelfLink);
this.resourceGroupStates.set(i, null);
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, numOfVMsToTest - i - 1, ResourceGroupService.FACTORY_LINK, false);
deleteServiceDocument(this.host, this.diskStates.get(i).documentSelfLink);
this.diskStates.set(i, null);
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, numOfVMsToTest - i - 1, DiskService.FACTORY_LINK, false);
}
return;
}
// 2. Create extra resources
createStaleResource();
tagAzureResources();
// stale resources + 1 compute host instance + 1 vm compute state
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_VM_RESOURCES_COUNT + (numOfVMsToTest + 1), ComputeService.FACTORY_LINK, false);
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_STORAGE_ACCOUNTS_COUNT + numOfVMsToTest, StorageDescriptionService.FACTORY_LINK, false);
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_CONTAINERS_COUNT + STALE_RG_COUNT + 1, ResourceGroupService.FACTORY_LINK, false);
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_DISKS_COUNT + numOfVMsToTest, DiskService.FACTORY_LINK, false);
ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_SECURITY_GROUPS_COUNT, SecurityGroupService.FACTORY_LINK, false);
this.vmCount = getAzureVMCount(this.computeManagementClient);
this.host.log(Level.INFO, "Initial VM Count: %d", this.vmCount);
// 3. Run multiple enumerations over a period of time.
this.host.log(Level.INFO, "Waiting for multiple enumeration runs...");
ScheduledFuture<?> enums = runEnumerationAndLogNodeStatsPeriodically();
this.host.waitFor("Timeout while waiting for test run duration", () -> {
TimeUnit.MINUTES.sleep(this.testRunDurationInMinutes);
enums.cancel(false);
return true;
});
this.host.waitFor("Timeout while waiting for last enumeration to clear out.", () -> {
TimeUnit.MINUTES.sleep(1);
return true;
});
verifyResourceDuplicates();
// 4. Validate extra resources
assertRemoteResources();
assertStaleResources();
ServiceDocumentQueryResult result = ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, this.vmCount, ComputeService.FACTORY_LINK, false);
// validate type field for enumerated VMs
result.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), ComputeState.class)).filter(c -> !c.documentSelfLink.equals(computeHost.documentSelfLink)).forEach(c -> assertEquals(ComputeType.VM_GUEST, c.type));
// validate internal tags for enumerated VMs
TagService.TagState expectedInternalTypeTag = newTagState(TAG_KEY_TYPE, AzureConstants.AzureResourceType.azure_vm.toString(), false, endpointState.tenantLinks);
result.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), ComputeState.class)).filter(c -> c.type.equals(ComputeType.VM_GUEST)).forEach(c -> {
assertNotNull(c.tagLinks);
assertTrue(c.tagLinks.contains(expectedInternalTypeTag.documentSelfLink));
});
// validate environment name field for enumerated VMs
result.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), ComputeState.class)).forEach(c -> assertEquals(ComputeDescription.ENVIRONMENT_NAME_AZURE, c.environmentName));
// 5. Validate enumerated compute states have not changed.
Map<String, ComputeState> azLrtComputeStatesEnd = getVMComputeStatesWithPrefix();
assertTrue(numOfVMsToTest <= azLrtComputeStatesEnd.size());
assertComputeStatesEqual(azLrtComputeStates, azLrtComputeStatesEnd);
// 1 network per each stale vm resource + 1 network for original vm compute state.
ServiceDocumentQueryResult networkResults = ProvisioningUtils.queryAllFactoryResources(this.host, NetworkService.FACTORY_LINK);
// validate internal tags for enumerated networks
TagService.TagState expectedNetworkInternalTypeTag = newTagState(TAG_KEY_TYPE, NETWORK_TAG_TYPE_VALUE, false, endpointState.tenantLinks);
networkResults.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), NetworkState.class)).forEach(c -> {
assertNotNull(c.tagLinks);
assertTrue(c.tagLinks.contains(expectedNetworkInternalTypeTag.documentSelfLink));
});
// 1 subnet per network, 1 network per each stale vm resource + 1 subnet for the original
// compute state.
ServiceDocumentQueryResult subnetResults = ProvisioningUtils.queryAllFactoryResources(this.host, SubnetService.FACTORY_LINK);
// validate internal tags for enumerated subnets
TagService.TagState expectedSubnetInternalTypeTag = newTagState(TAG_KEY_TYPE, SUBNET_TAG_TYPE_VALUE, false, endpointState.tenantLinks);
subnetResults.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), SubnetState.class)).forEach(c -> {
assertNotNull(c.tagLinks);
assertTrue(c.tagLinks.contains(expectedSubnetInternalTypeTag.documentSelfLink));
});
ServiceDocumentQueryResult nicResults = ProvisioningUtils.queryAllFactoryResources(this.host, NetworkInterfaceService.FACTORY_LINK);
// validate internal tags for enumerated network interfaces
TagService.TagState expectedNicInternalTypeTag = newTagState(TAG_KEY_TYPE, NETWORK_INTERFACE_TAG_TYPE_VALUE, false, endpointState.tenantLinks);
nicResults.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), NetworkInterfaceState.class)).forEach(c -> {
assertNotNull(c.tagLinks);
assertTrue(c.tagLinks.contains(expectedNicInternalTypeTag.documentSelfLink));
});
for (int i = 0; i < numOfVMsToTest; i++) {
this.host.log(Level.INFO, "Deleting vm: %s", azureVMNames.get(i));
this.computeManagementClient.virtualMachines().beginDelete(azureVMNames.get(i), azureVMNames.get(i));
}
runEnumeration(this.host, computeHost.documentSelfLink, computeHost.resourcePoolLink, endpointState, this.isMock);
for (int i = 0; i < numOfVMsToTest; i++) {
assertResourceDisassociated(this.host, ComputeService.FACTORY_LINK, azureVMNames.get(i), true);
// clean up
this.vmStates.set(i, null);
this.resourceManagementClient.resourceGroups().beginDelete(azureVMNames.get(i));
this.host.log(Level.INFO, "Deleting vm resource group %s", azureVMNames.get(i));
}
// Log node stats at the end of the test
logNodeStats(this.host.getServiceStats(this.nodeStatsUri));
}
use of com.vmware.photon.controller.model.constants.PhotonModelConstants.TAG_KEY_TYPE in project photon-model by vmware.
the class AWSComputeStateCreationAdapterService method createInternalTypeTags.
private void createInternalTypeTags(AWSComputeStateCreationContext context, AWSComputeStateCreationStage next) {
// Go over the list of internal tags to be created. Find whatever already does not have an
// associated tag state and create an operation for its creation.
List<Operation> joinOperations = new ArrayList<>();
for (String resourceType : internalTagList) {
TagState typeTag = newTagState(TAG_KEY_TYPE, resourceType, false, context.request.tenantLinks);
Operation op = Operation.createPost(this, TagService.FACTORY_LINK).setBody(typeTag);
joinOperations.add(op);
}
OperationJoin.create(joinOperations).setCompletion((ops, exs) -> {
if (exs != null) {
exs.values().forEach(ex -> logWarning(() -> String.format("Error creating internal tag%s", ex.getMessage())));
context.creationStage = next;
handleComputeStateCreateOrUpdate(context);
return;
}
for (String internalTagValue : internalTagList) {
TagState tagState = newTagState(TAG_KEY_TYPE, internalTagValue, false, context.request.tenantLinks);
context.internalTagLinksMap.put(tagState.value, new HashSet<>(Arrays.asList(tagState.documentSelfLink)));
}
context.creationStage = next;
handleComputeStateCreateOrUpdate(context);
}).sendWith(this);
}
use of com.vmware.photon.controller.model.constants.PhotonModelConstants.TAG_KEY_TYPE in project photon-model by vmware.
the class AWSNetworkStateEnumerationAdapterService method createInternalTypeTags.
/**
* Method to create the internal tags for subnets and VPCs.
*/
private void createInternalTypeTags(AWSNetworkStateCreationContext context, AWSNetworkStateCreationStage next) {
// Go over the list of internal tags to be created. Find whatever already does not have an
// associated tag state and create an operation for its creation.
List<Operation> joinOperations = new ArrayList<>();
for (String resourceType : internalTagList) {
TagState typeTag = newTagState(TAG_KEY_TYPE, resourceType, false, context.request.tenantLinks);
Operation op = Operation.createPost(this, TagService.FACTORY_LINK).setBody(typeTag);
joinOperations.add(op);
}
OperationJoin.create(joinOperations).setCompletion((ops, exs) -> {
if (exs != null) {
exs.values().forEach(ex -> logWarning(() -> String.format("Error creating internal tag : %s", ex.getMessage())));
context.networkCreationStage = next;
handleNetworkStateChanges(context);
return;
}
for (String internalTagValue : internalTagList) {
TagState tagState = newTagState(TAG_KEY_TYPE, internalTagValue, false, context.request.tenantLinks);
if (internalTagValue.equalsIgnoreCase(AWSResourceType.ec2_vpc.toString())) {
context.networkInternalTagsMap.put(PhotonModelConstants.TAG_KEY_TYPE, tagState.value);
context.networkInternalTagLinksSet.add(tagState.documentSelfLink);
} else {
context.subnetInternalTagsMap.put(PhotonModelConstants.TAG_KEY_TYPE, tagState.value);
context.subnetInternalTagLinksSet.add(tagState.documentSelfLink);
}
}
context.networkCreationStage = next;
handleNetworkStateChanges(context);
}).sendWith(this);
}
Aggregations