Examples with ProvisionComputeTaskState com.vmware.photon.controller.model.tasks.ProvisionComputeTaskService.ProvisionComputeTaskState used on opensource projects

Example 1 with ProvisionComputeTaskState

use of com.vmware.photon.controller.model.tasks.ProvisionComputeTaskService.ProvisionComputeTaskState in project photon-model by vmware.

the class TestAWSProvisionTask method testProvision.

// Creates a AWS instance via a provision task.
@Test
public void testProvision() throws Throwable {
    initResourcePoolAndComputeHost();
    // create a AWS VM compute resoruce
    boolean addNonExistingSecurityGroup = true;
    this.vmState = createAWSVMResource(this.host, this.computeHost, this.endpointState, this.getClass(), this.currentTestName.getMethodName() + "_vm1", zoneId, regionId, null, /* tagLinks */
    this.singleNicSpec, addNonExistingSecurityGroup, this.awsTestContext);
    // set placement link
    String zoneId = TestAWSSetupUtils.zoneId + avalabilityZoneIdentifier;
    ComputeState zoneComputeState = createAWSComputeHost(this.host, this.endpointState, zoneId, regionId, this.isAwsClientMock, this.awsMockEndpointReference, null);
    zoneComputeState.id = zoneId;
    zoneComputeState = TestUtils.doPatch(this.host, zoneComputeState, ComputeState.class, UriUtils.buildUri(this.host, zoneComputeState.documentSelfLink));
    if (this.vmState.customProperties == null) {
        this.vmState.customProperties = new HashMap<>();
    }
    this.vmState.customProperties.put(PLACEMENT_LINK, zoneComputeState.documentSelfLink);
    TestUtils.doPatch(this.host, this.vmState, ComputeState.class, UriUtils.buildUri(this.host, this.vmState.documentSelfLink));
    // kick off a provision task to do the actual VM creation
    ProvisionComputeTaskState provisionTask = new ProvisionComputeTaskService.ProvisionComputeTaskState();
    provisionTask.computeLink = this.vmState.documentSelfLink;
    provisionTask.isMockRequest = this.isMock;
    provisionTask.taskSubStage = ProvisionComputeTaskState.SubStage.CREATING_HOST;
    // Wait for default request timeout in minutes for the machine to be powered ON before
    // reporting failure to the parent task.
    provisionTask.documentExpirationTimeMicros = Utils.getNowMicrosUtc() + TimeUnit.MINUTES.toMicros(AWS_VM_REQUEST_TIMEOUT_MINUTES);
    provisionTask.tenantLinks = this.endpointState.tenantLinks;
    provisionTask = TestUtils.doPost(this.host, provisionTask, ProvisionComputeTaskState.class, UriUtils.buildUri(this.host, ProvisionComputeTaskService.FACTORY_LINK));
    this.host.waitForFinishedTask(ProvisionComputeTaskState.class, provisionTask.documentSelfLink);
    // check that the VM has been created
    ProvisioningUtils.queryComputeInstances(this.host, 3);
    if (!this.isMock) {
        ComputeState compute = getCompute(this.host, this.vmState.documentSelfLink);
        List<Instance> instances = getAwsInstancesByIds(this.client, this.host, Collections.singletonList(compute.id));
        Instance instance = instances.get(0);
        assertTags(Collections.emptySet(), instance, this.vmState.name);
        assertVmNetworksConfiguration(instance);
        assertStorageConfiguration(this.client, instance, compute);
        assertEquals(zoneId, instance.getPlacement().getAvailabilityZone());
    }
    this.host.setTimeoutSeconds(600);
    this.host.waitFor("Error waiting for stats with default collection windows", () -> {
        try {
            this.host.log(Level.INFO, "Issuing stats request for VM with default collection window.");
            issueStatsRequest(this.vmState, null);
        } catch (Throwable t) {
            return false;
        }
        return true;
    });
    // store the network links and disk links for removal check later
    List<String> resourcesToDelete = new ArrayList<>();
    if (this.vmState.diskLinks != null) {
        resourcesToDelete.addAll(this.vmState.diskLinks);
    }
    if (this.vmState.networkInterfaceLinks != null) {
        resourcesToDelete.addAll(this.vmState.networkInterfaceLinks);
    }
    // delete vm
    TestAWSSetupUtils.deleteVMs(this.vmState.documentSelfLink, this.isMock, this.host);
    // validates the local documents of network links and disk links have been removed
    verifyRemovalOfResourceState(this.host, resourcesToDelete);
    // create another AWS VM
    List<String> instanceIdList = new ArrayList<>();
    Set<TagState> tags = createTags(null, "testProvisionKey1", "testProvisionValue1", "testProvisionKey2", "testProvisionValue2");
    Set<String> tagLinks = tags.stream().map(t -> t.documentSelfLink).collect(Collectors.toSet());
    addNonExistingSecurityGroup = false;
    this.vmState = createAWSVMResource(this.host, this.computeHost, this.endpointState, this.getClass(), this.currentTestName.getMethodName() + "_vm2", TestAWSSetupUtils.zoneId, regionId, tagLinks, this.singleNicSpec, addNonExistingSecurityGroup, this.awsTestContext);
    TestAWSSetupUtils.provisionMachine(this.host, this.vmState, this.isMock, instanceIdList);
    if (!this.isMock) {
        ComputeState compute = getCompute(this.host, this.vmState.documentSelfLink);
        List<Instance> instances = getAwsInstancesByIds(this.client, this.host, Collections.singletonList(compute.id));
        assertTags(tags, instances.get(0), this.vmState.name);
        assertVmNetworksConfiguration(instances.get(0));
        assertStorageConfiguration(this.client, instances.get(0), compute);
        // reach out to AWS and get the current state
        TestAWSSetupUtils.getBaseLineInstanceCount(this.host, this.client, null);
    }
    // delete just the local representation of the resource
    TestAWSSetupUtils.deleteVMs(this.vmState.documentSelfLink, this.isMock, this.host, true);
    if (!this.isMock) {
        try {
            TestAWSSetupUtils.getBaseLineInstanceCount(this.host, this.client, null);
        } finally {
            TestAWSSetupUtils.deleteVMsUsingEC2Client(this.client, this.host, instanceIdList);
            deleteSecurityGroupUsingEC2Client(this.client, this.host, this.sgToCleanUp);
        }
    }
    this.vmState = null;
    this.sgToCleanUp = null;
}

Example 2 with ProvisionComputeTaskState

use of com.vmware.photon.controller.model.tasks.ProvisionComputeTaskService.ProvisionComputeTaskState in project photon-model by vmware.

the class TestVSphereProvisionFromImageLink method provisionVMAndGetState.

private ComputeState provisionVMAndGetState() throws Throwable {
    if (isMock()) {
        return null;
    }
    // Create a resource pool where the VM will be housed
    this.resourcePool = createResourcePool();
    this.auth = createAuth();
    this.computeHostDescription = createComputeDescription();
    this.computeHost = createComputeHost(this.computeHostDescription);
    EndpointState ep = createEndpointState(this.computeHost, this.computeHostDescription);
    this.endpoint = TestUtils.doPost(this.host, ep, EndpointState.class, UriUtils.buildUri(this.host, EndpointService.FACTORY_LINK));
    enumerateComputes(this.computeHost, this.endpoint);
    doRefresh();
    snapshotFactoryState("images", ImageService.class);
    String imageLink = findImage();
    ComputeDescription desc = createVmDescription();
    ComputeState vm = createVmState(desc, imageLink);
    // kick off a provision task to do the actual VM creation
    ProvisionComputeTaskState outTask = createProvisionTask(vm);
    awaitTaskEnd(outTask);
    return getComputeState(vm);
}

Example 3 with ProvisionComputeTaskState

use of com.vmware.photon.controller.model.tasks.ProvisionComputeTaskService.ProvisionComputeTaskState in project photon-model by vmware.

the class TestVSphereProvisionWithCloudConfigTask method deployFromTemplateUsingCloudConfig.

@Test
public void deployFromTemplateUsingCloudConfig() throws Throwable {
    ComputeState vm = null;
    try {
        // Create a resource pool where the VM will be housed
        this.resourcePool = createResourcePool();
        this.auth = createAuth();
        this.computeHostDescription = createComputeHostDescription();
        this.computeHost = createComputeHost();
        // enumerate all resources hoping to find the template
        doRefresh();
        // find the template by vm name
        // template must have vm-tools and cloud-config installed
        ComputeState template = findTemplate();
        // create instance by cloning
        ComputeDescription vmDescription = createVmDescription();
        vm = createVmState(vmDescription, template.documentSelfLink);
        // kick off a provision task to do the actual VM creation
        ProvisionComputeTaskState outTask = createProvisionTask(vm);
        awaitTaskEnd(outTask);
        vm = getComputeState(vm);
    } finally {
        if (vm != null) {
            deleteVmAndWait(vm);
        }
    }
}

Example 4 with ProvisionComputeTaskState

use of com.vmware.photon.controller.model.tasks.ProvisionComputeTaskService.ProvisionComputeTaskState in project photon-model by vmware.

the class AWSRebootServiceTest method provisionSingleAWS.

private void provisionSingleAWS() throws Throwable {
    initResourcePoolAndComputeHost();
    // create a AWS VM compute resource
    boolean addNonExistingSecurityGroup = true;
    this.vmState = createAWSVMResource(this.host, this.computeHost, this.endpointState, this.getClass(), this.currentTestName.getMethodName() + "_vm1", zoneId, regionId, null, /* tagLinks */
    this.singleNicSpec, addNonExistingSecurityGroup, this.awsTestContext);
    // kick off a provision task to do the actual VM creation
    ProvisionComputeTaskState provisionTask = new ProvisionComputeTaskService.ProvisionComputeTaskState();
    provisionTask.computeLink = this.vmState.documentSelfLink;
    provisionTask.isMockRequest = this.isMock;
    provisionTask.taskSubStage = ProvisionComputeTaskState.SubStage.CREATING_HOST;
    // Wait for default request timeout in minutes for the machine to be powered ON before
    // reporting failure to the parent task.
    provisionTask.documentExpirationTimeMicros = Utils.getNowMicrosUtc() + TimeUnit.MINUTES.toMicros(AWS_VM_REQUEST_TIMEOUT_MINUTES);
    provisionTask.tenantLinks = this.endpointState.tenantLinks;
    provisionTask = TestUtils.doPost(this.host, provisionTask, ProvisionComputeTaskState.class, UriUtils.buildUri(this.host, ProvisionComputeTaskService.FACTORY_LINK));
    this.host.waitForFinishedTask(ProvisionComputeTaskState.class, provisionTask.documentSelfLink);
}

Example 5 with ProvisionComputeTaskState

use of com.vmware.photon.controller.model.tasks.ProvisionComputeTaskService.ProvisionComputeTaskState 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);
}