Examples with ComputeDescription com.vmware.photon.controller.model.resources.ComputeDescriptionService.ComputeDescription used on opensource projects

Example 61 with ComputeDescription

use of com.vmware.photon.controller.model.resources.ComputeDescriptionService.ComputeDescription in project photon-model by vmware.

the class StatsCollectionTaskServiceTest method testCustomStatsAdapter.

@Test
public void testCustomStatsAdapter() throws Throwable {
    ResourcePoolState rpState = new ResourcePoolState();
    rpState.name = UUID.randomUUID().toString();
    ResourcePoolState rpReturnState = postServiceSynchronously(ResourcePoolService.FACTORY_LINK, rpState, ResourcePoolState.class);
    ComputeDescription desc = new ComputeDescription();
    desc.name = rpState.name;
    desc.statsAdapterReferences = Collections.singleton(UriUtils.buildUri(this.host, CustomStatsAdapter.SELF_LINK));
    ComputeDescription descReturnState = postServiceSynchronously(ComputeDescriptionService.FACTORY_LINK, desc, ComputeDescription.class);
    ComputeState computeState = new ComputeState();
    computeState.name = rpState.name;
    computeState.descriptionLink = descReturnState.documentSelfLink;
    computeState.resourcePoolLink = rpReturnState.documentSelfLink;
    List<String> computeLinks = new ArrayList<>();
    for (int i = 0; i < this.numResources; i++) {
        ComputeState res = postServiceSynchronously(ComputeService.FACTORY_LINK, computeState, ComputeState.class);
        computeLinks.add(res.documentSelfLink);
    }
    // create a stats collection scheduler task
    StatsCollectionTaskState statCollectionState = new StatsCollectionTaskState();
    statCollectionState.resourcePoolLink = rpReturnState.documentSelfLink;
    statCollectionState.statsAdapterReference = UriUtils.buildUri(this.host, CustomStatsAdapter.SELF_LINK);
    statCollectionState.options = EnumSet.of(TaskOption.SELF_DELETE_ON_COMPLETION);
    ScheduledTaskState statsCollectionTaskState = new ScheduledTaskState();
    statsCollectionTaskState.factoryLink = StatsCollectionTaskService.FACTORY_LINK;
    statsCollectionTaskState.initialStateJson = Utils.toJson(statCollectionState);
    statsCollectionTaskState.intervalMicros = TimeUnit.MILLISECONDS.toMicros(500);
    statsCollectionTaskState = postServiceSynchronously(ScheduledTaskService.FACTORY_LINK, statsCollectionTaskState, ScheduledTaskState.class);
    ServiceDocumentQueryResult res = this.host.getFactoryState(UriUtils.buildExpandLinksQueryUri(UriUtils.buildUri(this.host, ScheduledTaskService.FACTORY_LINK)));
    assertTrue(res.documents.size() > 0);
    // get stats from resources
    for (int i = 0; i < computeLinks.size(); i++) {
        String statsUriPath = UriUtils.buildUriPath(computeLinks.get(i), ServiceHost.SERVICE_URI_SUFFIX_STATS);
        this.host.waitFor("Error waiting for stats", () -> {
            ServiceStats resStats = getServiceSynchronously(statsUriPath, ServiceStats.class);
            boolean returnStatus = false;
            // was populated in the in memory stats
            for (ServiceStat stat : resStats.entries.values()) {
                if (stat.name.startsWith(UriUtils.getLastPathSegment(CustomStatsAdapter.SELF_LINK))) {
                    returnStatus = true;
                    break;
                }
            }
            return returnStatus;
        });
    }
    // clean up
    deleteServiceSynchronously(statsCollectionTaskState.documentSelfLink);
}

Example 62 with ComputeDescription

use of com.vmware.photon.controller.model.resources.ComputeDescriptionService.ComputeDescription in project photon-model by vmware.

the class StatsCollectionTaskServiceTest method testStatsCollection.

private void testStatsCollection(boolean testOnCluster) throws Throwable {
    VerificationHost metricHost = null;
    if (testOnCluster) {
        metricHost = this.setupMetricHost();
    }
    // Use this.host if metricHost is null.
    VerificationHost verificationHost = (metricHost == null ? this.host : metricHost);
    // create a metric host
    // create a compute description for all the computes
    ComputeDescription cDesc = new ComputeDescription();
    cDesc.name = UUID.randomUUID().toString();
    cDesc.statsAdapterReference = UriUtils.buildUri(this.host, MockStatsAdapter.SELF_LINK);
    ComputeDescription descReturnState = postServiceSynchronously(ComputeDescriptionService.FACTORY_LINK, cDesc, ComputeDescription.class);
    // create multiple computes
    ComputeState computeState = new ComputeState();
    computeState.name = UUID.randomUUID().toString();
    computeState.descriptionLink = descReturnState.documentSelfLink;
    List<String> computeLinks = new ArrayList<>(this.numResources);
    for (int i = 0; i < this.numResources; i++) {
        ComputeState res = postServiceSynchronously(ComputeService.FACTORY_LINK, computeState, ComputeState.class);
        computeLinks.add(res.documentSelfLink);
    }
    // create a resource pool including all the created computes
    ResourcePoolState rpState = new ResourcePoolState();
    rpState.name = UUID.randomUUID().toString();
    rpState.properties = EnumSet.of(ResourcePoolProperty.ELASTIC);
    rpState.query = Query.Builder.create().addKindFieldClause(ComputeState.class).addInClause(ServiceDocument.FIELD_NAME_SELF_LINK, computeLinks).build();
    ResourcePoolState rpReturnState = postServiceSynchronously(ResourcePoolService.FACTORY_LINK, rpState, ResourcePoolState.class);
    // create a stats collection scheduler task
    StatsCollectionTaskState statCollectionState = new StatsCollectionTaskState();
    statCollectionState.resourcePoolLink = rpReturnState.documentSelfLink;
    statCollectionState.options = EnumSet.of(TaskOption.SELF_DELETE_ON_COMPLETION);
    ScheduledTaskState statsCollectionTaskState = new ScheduledTaskState();
    statsCollectionTaskState.factoryLink = StatsCollectionTaskService.FACTORY_LINK;
    statsCollectionTaskState.initialStateJson = Utils.toJson(statCollectionState);
    statsCollectionTaskState.intervalMicros = TimeUnit.SECONDS.toMicros(2);
    statsCollectionTaskState = postServiceSynchronously(ScheduledTaskService.FACTORY_LINK, statsCollectionTaskState, ScheduledTaskState.class);
    ServiceDocumentQueryResult res = this.host.getFactoryState(UriUtils.buildExpandLinksQueryUri(UriUtils.buildUri(this.host, ScheduledTaskService.FACTORY_LINK)));
    assertTrue(res.documents.size() > 0);
    // the last successful collection time should be populated as an in memory stat.
    for (int i = 0; i < this.numResources; i++) {
        String statsUriPath = UriUtils.buildUriPath(computeLinks.get(i), ServiceHost.SERVICE_URI_SUFFIX_STATS);
        this.host.waitFor("Error waiting for in memory stats", () -> {
            ServiceStats resStats = getServiceSynchronously(statsUriPath, ServiceStats.class);
            boolean returnStatus = false;
            for (ServiceStat stat : resStats.entries.values()) {
                if (stat.latestValue > 0) {
                    returnStatus = true;
                    break;
                }
            }
            return returnStatus;
        });
    }
    host.log(Level.INFO, "Successfully verified that all the last collection time is available in memory.");
    // persisted at a per metric level along with the last collection run time
    for (String computeLink : computeLinks) {
        ResourceMetrics metric = getResourceMetrics(verificationHost, computeLink, MockStatsAdapter.KEY_1);
        assertNotNull("The resource metric for" + MockStatsAdapter.KEY_1 + " should not be null ", metric);
        assertEquals(metric.entries.size(), 1);
        assertEquals(metric.customProperties.get("prop1"), "val1");
        ResourceMetrics metric2 = getResourceMetrics(verificationHost, computeLink, MockStatsAdapter.KEY_2);
        assertNotNull("The resource metric for" + MockStatsAdapter.KEY_2 + "should not be null ", metric2);
        assertEquals(metric2.entries.size(), 1);
        String lastSuccessfulRunMetricKey = UriUtils.getLastPathSegment(MockStatsAdapter.SELF_LINK) + StatsUtil.SEPARATOR + PhotonModelConstants.LAST_SUCCESSFUL_STATS_COLLECTION_TIME;
        ResourceMetrics metricLastRun = getResourceMetrics(verificationHost, computeLink, lastSuccessfulRunMetricKey);
        assertNotNull("The resource metric for" + lastSuccessfulRunMetricKey + " should not be null ", metricLastRun);
    }
    host.log(Level.INFO, "Successfully verified that the required resource metrics are persisted in the resource metrics table");
    // Verify sorted order of the metrics versions by timestamp
    for (String computeLink : computeLinks) {
        // get all versions
        QueryTask qt = QueryTask.Builder.createDirectTask().addOption(QueryOption.EXPAND_CONTENT).addOption(QueryOption.SORT).orderAscending(ServiceDocument.FIELD_NAME_SELF_LINK, TypeName.STRING).setQuery(Query.Builder.create().addKindFieldClause(ResourceMetrics.class).addFieldClause(ServiceDocument.FIELD_NAME_SELF_LINK, UriUtils.buildUriPath(ResourceMetricsService.FACTORY_LINK, UriUtils.getLastPathSegment(computeLink)), MatchType.PREFIX).addRangeClause(QuerySpecification.buildCompositeFieldName(ResourceMetrics.FIELD_NAME_ENTRIES, MockStatsAdapter.KEY_1), NumericRange.createDoubleRange(Double.MIN_VALUE, Double.MAX_VALUE, true, true)).build()).build();
        verificationHost.createQueryTaskService(qt, false, true, qt, null);
        ResourceMetrics prevMetric = null;
        for (String documentLink : qt.results.documentLinks) {
            ResourceMetrics metric = Utils.fromJson(qt.results.documents.get(documentLink), ResourceMetrics.class);
            if (prevMetric == null) {
                prevMetric = metric;
                continue;
            }
            assertTrue(prevMetric.timestampMicrosUtc < metric.timestampMicrosUtc);
        }
    }
    // verify that the aggregation tasks have been deleted
    this.host.waitFor("Timeout waiting for task to expire", () -> {
        ServiceDocumentQueryResult collectRes = this.host.getFactoryState(UriUtils.buildUri(this.host, StatsCollectionTaskService.FACTORY_LINK));
        if (collectRes.documentLinks.size() == 0) {
            return true;
        }
        return false;
    });
    if (testOnCluster) {
        this.cleanUpMetricHost(metricHost);
    }
}

Example 63 with ComputeDescription

use of com.vmware.photon.controller.model.resources.ComputeDescriptionService.ComputeDescription in project photon-model by vmware.

the class AzureTestUtil method createDefaultVMResource.

public static ComputeState createDefaultVMResource(VerificationHost host, String azureVMName, ComputeState computeHost, EndpointState endpointState, AzureNicSpecs nicSpecs, String networkRGLink, ImageSource imageSource, int numberOfAdditionalDisks, ComputeDescription azureVMDesc, String azureRgName) throws Throwable {
    if (azureRgName == null) {
        azureRgName = azureVMName;
    }
    final ResourceGroupState defaultVmRG = createDefaultResourceGroupState(host, azureRgName, computeHost, endpointState, ResourceGroupStateType.AzureResourceGroup);
    final String defaultVmRGLink = defaultVmRG.documentSelfLink;
    if (networkRGLink == null) {
        // The RG where the VM is deployed is also used as RG for the Network!
        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(host, AZURE_STORAGE_CONTAINER_RG_NAME, computeHost, endpointState, ResourceGroupStateType.AzureStorageContainer);
    final Set<String> networkRGLinks = new HashSet<>();
    networkRGLinks.add(networkRGLink);
    networkRGLinks.add(azureStorageContainerRG.documentSelfLink);
    final Set<String> sgRGLinks = new HashSet<>();
    sgRGLinks.add(sgRGLink);
    sgRGLinks.add(azureStorageContainerRG.documentSelfLink);
    if (azureVMDesc == null) {
        azureVMDesc = buildComputeDescription(host, computeHost, endpointState, null);
    }
    List<String> vmDisks = new ArrayList<>();
    DiskState rootDisk = new DiskState();
    rootDisk.name = azureVMName + "-boot-disk";
    rootDisk.id = UUID.randomUUID().toString();
    rootDisk.documentSelfLink = rootDisk.id;
    rootDisk.type = DiskType.HDD;
    // Custom OSDisk size of 32 GBs
    rootDisk.capacityMBytes = AZURE_CUSTOM_OSDISK_SIZE;
    if (imageSource.type == Type.PRIVATE_IMAGE || imageSource.type == Type.PUBLIC_IMAGE) {
        rootDisk.imageLink = imageSource.asImageState().documentSelfLink;
    } else if (imageSource.type == Type.IMAGE_REFERENCE) {
        rootDisk.sourceImageReference = URI.create(imageSource.asRef());
    }
    rootDisk.bootOrder = 1;
    rootDisk.endpointLink = endpointState.documentSelfLink;
    rootDisk.endpointLinks = new HashSet<>();
    rootDisk.endpointLinks.add(endpointState.documentSelfLink);
    rootDisk.computeHostLink = computeHost.documentSelfLink;
    rootDisk.tenantLinks = endpointState.tenantLinks;
    rootDisk.storageType = AZURE_STORAGE_DISKS;
    rootDisk.tagLinks = createTagStateSet(host, endpointState.tenantLinks, TAG_KEY_TYPE, AzureResourceType.azure_vhd.name());
    rootDisk.customProperties = new HashMap<>();
    rootDisk.customProperties.put(AZURE_OSDISK_CACHING, DEFAULT_OS_DISK_CACHING.name());
    rootDisk.customProperties.put(AzureConstants.AZURE_STORAGE_ACCOUNT_NAME, (azureVMName + "sa").replaceAll("[_-]", "").toLowerCase());
    rootDisk.customProperties.put(AzureConstants.AZURE_STORAGE_ACCOUNT_RG_NAME, azureRgName);
    rootDisk.customProperties.put(AzureConstants.AZURE_STORAGE_ACCOUNT_TYPE, AZURE_STORAGE_ACCOUNT_TYPE);
    rootDisk = TestUtils.doPost(host, rootDisk, DiskState.class, UriUtils.buildUri(host, DiskService.FACTORY_LINK));
    vmDisks.add(rootDisk.documentSelfLink);
    // create additional disks
    vmDisks.addAll(createAdditionalDisks(host, azureVMName, endpointState, numberOfAdditionalDisks, VMResourceSpec.PersistentDisks.NONE, false));
    // Create NICs
    List<String> nicLinks = createDefaultNicStates(host, computeHost, endpointState, networkRGLinks, sgRGLinks, nicSpecs, 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 = azureVMName;
    computeState.parentLink = computeHost.documentSelfLink;
    computeState.type = ComputeType.VM_GUEST;
    computeState.environmentName = ComputeDescription.ENVIRONMENT_NAME_AZURE;
    computeState.descriptionLink = azureVMDesc.documentSelfLink;
    computeState.resourcePoolLink = computeHost.resourcePoolLink;
    computeState.diskLinks = vmDisks;
    computeState.networkInterfaceLinks = nicLinks;
    computeState.customProperties = Collections.singletonMap(RESOURCE_GROUP_NAME, azureRgName);
    computeState.groupLinks = Collections.singleton(defaultVmRGLink);
    computeState.endpointLink = endpointState.documentSelfLink;
    computeState.endpointLinks = new HashSet<>();
    computeState.endpointLinks.add(endpointState.documentSelfLink);
    computeState.computeHostLink = computeHost.documentSelfLink;
    computeState.tenantLinks = endpointState.tenantLinks;
    computeState.tagLinks = createTagStateSet(host, endpointState.tenantLinks, TAG_KEY_TYPE, AzureConstants.AzureResourceType.azure_vm.toString());
    computeState.creationTimeMicros = TimeUnit.MILLISECONDS.toMicros(System.currentTimeMillis());
    return TestUtils.doPost(host, computeState, ComputeState.class, UriUtils.buildUri(host, ComputeService.FACTORY_LINK));
}

Example 64 with ComputeDescription

use of com.vmware.photon.controller.model.resources.ComputeDescriptionService.ComputeDescription in project photon-model by vmware.

the class AzureTestUtil method createDefaultComputeHost.

/**
 * Create a compute host description for an Azure instance
 */
public static ComputeState createDefaultComputeHost(VerificationHost host, String resourcePoolLink, EndpointState endpointState) throws Throwable {
    ComputeDescription azureHostDescription = new ComputeDescription();
    azureHostDescription.id = UUID.randomUUID().toString();
    azureHostDescription.name = azureHostDescription.id;
    azureHostDescription.environmentName = ComputeDescription.ENVIRONMENT_NAME_AZURE;
    azureHostDescription.documentSelfLink = azureHostDescription.id;
    azureHostDescription.supportedChildren = new ArrayList<>();
    azureHostDescription.supportedChildren.add(ComputeType.VM_GUEST.name());
    azureHostDescription.instanceAdapterReference = UriUtils.buildUri(host, AzureUriPaths.AZURE_INSTANCE_ADAPTER);
    azureHostDescription.enumerationAdapterReference = UriUtils.buildUri(host, AzureUriPaths.AZURE_ENUMERATION_ADAPTER);
    azureHostDescription.statsAdapterReference = UriUtils.buildUri(host, AzureUriPaths.AZURE_STATS_ADAPTER);
    azureHostDescription.authCredentialsLink = endpointState.authCredentialsLink;
    azureHostDescription.endpointLink = endpointState.documentSelfLink;
    azureHostDescription.endpointLinks = new HashSet<>();
    azureHostDescription.endpointLinks.add(endpointState.documentSelfLink);
    azureHostDescription.computeHostLink = endpointState.computeHostLink;
    azureHostDescription.tenantLinks = endpointState.tenantLinks;
    azureHostDescription = TestUtils.doPost(host, azureHostDescription, ComputeDescription.class, UriUtils.buildUri(host, ComputeDescriptionService.FACTORY_LINK));
    ComputeState azureComputeHost = new ComputeState();
    azureComputeHost.id = UUID.randomUUID().toString();
    azureComputeHost.documentSelfLink = azureComputeHost.id;
    azureComputeHost.type = ComputeType.ENDPOINT_HOST;
    azureComputeHost.environmentName = ComputeDescription.ENVIRONMENT_NAME_AZURE;
    azureComputeHost.name = azureHostDescription.name;
    azureComputeHost.descriptionLink = azureHostDescription.documentSelfLink;
    azureComputeHost.resourcePoolLink = resourcePoolLink;
    azureComputeHost.endpointLink = endpointState.documentSelfLink;
    azureComputeHost.endpointLinks = new HashSet<>();
    azureComputeHost.endpointLinks.add(endpointState.documentSelfLink);
    azureComputeHost.tenantLinks = endpointState.tenantLinks;
    return TestUtils.doPost(host, azureComputeHost, ComputeState.class, UriUtils.buildUri(host, ComputeService.FACTORY_LINK));
}

Example 65 with ComputeDescription

use of com.vmware.photon.controller.model.resources.ComputeDescriptionService.ComputeDescription in project photon-model by vmware.

the class GCPEnumerationAdapterService method updateHelper.

/**
 * This function will update the root disk data of a compute state. If the
 * instance on the cloud does not have any disks or does not have a boot
 * disk, the update will skip this instance. After all local vms are updated
 * it will jump to create stage.
 *
 * So far we update ip address, power state in compute state and instance type
 * in compute description and disk custom properties
 * @param ctx The Enumeration Context.
 * @param computeState The compute state to be updated.
 * @param vm The virtual machine used to update compute state.
 * @param numOfUpdates The number of remaining compute states to be updated.
 */
private void updateHelper(EnumerationContext ctx, ComputeState computeState, GCPInstance vm, AtomicInteger numOfUpdates) {
    List<Operation> operations = new ArrayList<>();
    ComputeState computeStatePatch = new ComputeState();
    assignIPAddress(computeStatePatch, vm);
    assignPowerState(computeStatePatch, vm.status);
    operations.add(Operation.createPatch(getHost(), computeState.documentSelfLink).setBody(computeStatePatch));
    ComputeDescription computeDescription = new ComputeDescription();
    computeDescription.instanceType = extractActualInstanceType(vm.machineType);
    operations.add(Operation.createPatch(getHost(), computeState.descriptionLink).setBody(computeDescription));
    if (vm.disks != null && !vm.disks.isEmpty()) {
        for (GCPDisk gcpDisk : vm.disks) {
            if (gcpDisk.boot) {
                DiskState diskState = new DiskState();
                diskState.customProperties = new HashMap<>();
                diskState.customProperties.put(DISK_AUTO_DELETE, gcpDisk.autoDelete.toString());
                diskState.documentSelfLink = computeState.diskLinks.get(0);
                operations.add(Operation.createPatch(getHost(), diskState.documentSelfLink).setBody(diskState));
                break;
            }
        }
    }
    OperationJoin.create(operations).setCompletion((ops, exs) -> {
        if (exs != null) {
            exs.values().forEach(ex -> logWarning(() -> String.format("Error: %s", ex.getMessage())));
        }
        countAndFinishUpdating(ctx, numOfUpdates);
    }).sendWith(this);
}