Examples with Operation com.vmware.xenon.common.Operation used on opensource projects

Example 71 with Operation

use of com.vmware.xenon.common.Operation in project photon-model by vmware.

the class AzureInstanceService method getVMDisks.

/**
 * Method will retrieve disks for targeted image
 */
private void getVMDisks(AzureInstanceContext ctx, AzureInstanceStage nextStage) {
    if (ctx.child.diskLinks == null || ctx.child.diskLinks.size() == 0) {
        handleError(ctx, new IllegalStateException("a minimum of 1 disk is required"));
        return;
    }
    Collection<Operation> operations = new ArrayList<>();
    // iterate thru disks and create operations
    operations.addAll(ctx.child.diskLinks.stream().map(disk -> Operation.createGet(UriUtils.buildExpandLinksQueryUri(UriUtils.buildUri(this.getHost(), disk)))).collect(Collectors.toList()));
    OperationJoin operationJoin = OperationJoin.create(operations).setCompletion((ops, exc) -> {
        if (exc != null) {
            handleError(ctx, new IllegalStateException("Error getting disk information", exc.values().iterator().next()));
            return;
        }
        ctx.dataDiskStates = new ArrayList<>();
        ctx.externalDataDisks = new ArrayList<>();
        ctx.persistentDisks = new ArrayList<>();
        for (Operation op : ops.values()) {
            DiskService.DiskStateExpanded disk = op.getBody(DiskService.DiskStateExpanded.class);
            // We treat the first disk in the boot order as the boot disk.
            if (disk.bootOrder != null && disk.bootOrder == 1) {
                if (ctx.bootDiskState != null) {
                    handleError(ctx, new IllegalStateException("Only 1 boot disk is allowed"));
                    return;
                }
                ctx.bootDiskState = disk;
                // default to false
                if (ctx.bootDiskState.persistent == null) {
                    ctx.bootDiskState.persistent = false;
                }
            } else {
                if (disk.status == DiskService.DiskStatus.AVAILABLE) {
                    // external disks are always
                    disk.persistent = true;
                    // persistent
                    ctx.externalDataDisks.add(disk);
                } else {
                    if (disk.persistent == null) {
                        // Default to non persistent disk
                        disk.persistent = false;
                    }
                    ctx.dataDiskStates.add(disk);
                }
            }
        }
        if (ctx.bootDiskState == null) {
            handleError(ctx, new IllegalStateException("Boot disk is required"));
            return;
        }
        if (!validateDiskStates(ctx)) {
            handleError(ctx, new IllegalStateException("Azure VMs can either " + "have managed disk or un-managed disk. Not Both."));
            return;
        }
        handleAllocation(ctx, nextStage);
    });
    operationJoin.sendWith(this);
}

Example 72 with Operation

use of com.vmware.xenon.common.Operation in project photon-model by vmware.

the class AzureInstanceService method updateComputeState.

/**
 * Update {@code computeState.address} with Public IP, if presented.
 */
private DeferredResult<AzureInstanceContext> updateComputeState(AzureInstanceContext ctx) {
    if (ctx.getPrimaryNic().publicIP == null) {
        // Do nothing.
        return DeferredResult.completed(ctx);
    }
    ComputeState computeState = new ComputeState();
    computeState.address = ctx.getPrimaryNic().publicIP.ipAddress();
    computeState.name = ctx.vmName;
    Operation updateCS = Operation.createPatch(ctx.computeRequest.resourceReference).setBody(computeState);
    return ctx.service.sendWithDeferredResult(updateCS).thenApply(ignore -> {
        logFine(() -> String.format("Updating Compute state [%s] with Public IP [%s]: SUCCESS", ctx.vmName, computeState.address));
        return ctx;
    });
}

Example 73 with Operation

use of com.vmware.xenon.common.Operation in project photon-model by vmware.

the class AzureInstanceService method createDiskToUpdate.

/**
 * Creates and returns a new diskState object which is updated with id, LUN, status and documentSelfLink
 */
private DeferredResult<Operation> createDiskToUpdate(AzureInstanceContext ctx, Optional<DiskState> diskOpt, DataDisk azureDataDisk) {
    // update VHD uri or disk id respectively for un-managed and managed disks
    DiskState diskState = diskOpt.get();
    final DiskState diskStateToUpdate = new DiskState();
    diskStateToUpdate.documentSelfLink = diskState.documentSelfLink;
    diskStateToUpdate.persistent = diskState.persistent;
    if (ctx.useManagedDisks()) {
        diskStateToUpdate.id = azureDataDisk.managedDisk().id();
    } else {
        diskStateToUpdate.id = AzureUtils.canonizeId(azureDataDisk.vhd().uri());
    }
    // The LUN value of disk
    if (diskStateToUpdate.customProperties == null) {
        diskStateToUpdate.customProperties = new HashMap<>();
    }
    diskStateToUpdate.customProperties.put(DISK_CONTROLLER_NUMBER, String.valueOf(azureDataDisk.lun()));
    diskStateToUpdate.status = DiskService.DiskStatus.ATTACHED;
    diskStateToUpdate.regionId = ctx.provisionedVm.location();
    diskStateToUpdate.endpointLink = ctx.endpoint.documentSelfLink;
    AdapterUtils.addToEndpointLinks(diskStateToUpdate, ctx.endpoint.documentSelfLink);
    Operation updateDiskState = Operation.createPatch(createInventoryUri(getHost(), diskStateToUpdate.documentSelfLink)).setBody(diskStateToUpdate);
    DeferredResult<Operation> updateDR = ctx.service.sendWithDeferredResult(updateDiskState).whenComplete((op, exc) -> {
        if (exc != null) {
            logSevere(() -> String.format("Updating data DiskState [%s] with VHD URI [%s]: FAILED with %s", diskState.name, diskStateToUpdate.id, Utils.toString(exc)));
        } else {
            logFine(() -> String.format("Updating data DiskState [%s] with VHD URI [%s]: SUCCESS", diskState.name, diskStateToUpdate.id));
        }
    });
    return updateDR;
}

Example 74 with Operation

use of com.vmware.xenon.common.Operation in project photon-model by vmware.

the class EndpointAllocationTaskService method getAdapterUri.

/**
 * Retrieves the Adapter Reference from the Photon Adapter Registry
 *
 * @return DeferredResult<URI> URI can be null
 */
private DeferredResult<URI> getAdapterUri(AdapterTypePath adapterTypePath, String endpointType) {
    // Use 'endpointType' (such as aws, azure) as AdapterConfig id/selfLink!
    String configLink = UriUtils.buildUriPath(PhotonModelAdaptersConfigAccessService.SELF_LINK, endpointType);
    Operation getConfigOp = Operation.createGet(this, configLink);
    return sendWithDeferredResult(getConfigOp, PhotonModelAdapterConfig.class).thenApply(adapterConfig -> {
        String ref = null;
        if (adapterConfig != null && adapterConfig.adapterEndpoints != null) {
            ref = adapterConfig.adapterEndpoints.get(adapterTypePath.key);
        }
        final URI uri = ref != null ? UriUtils.buildUri(ref) : null;
        logInfo(() -> String.format("[getAdapterUri] adapterRef = %s: SUCCESS", uri));
        return uri;
    });
}

Example 75 with Operation

use of com.vmware.xenon.common.Operation in project photon-model by vmware.

the class EndpointAllocationTaskService method createEndpoint.

private void createEndpoint(EndpointAllocationTaskState currentState) {
    List<String> createdDocumentLinks = new ArrayList<>();
    EndpointState es = currentState.endpointState;
    Map<String, String> endpointProperties = currentState.endpointState.endpointProperties;
    es.endpointProperties = null;
    if (es.documentSelfLink == null) {
        es.documentSelfLink = UriUtils.buildUriPath(EndpointService.FACTORY_LINK, this.getHost().nextUUID());
    }
    // merge endpoint and task tenant links
    if (es.tenantLinks == null || es.tenantLinks.isEmpty()) {
        es.tenantLinks = currentState.tenantLinks;
    } else if (currentState.tenantLinks != null) {
        currentState.tenantLinks.forEach(tl -> {
            if (!es.tenantLinks.contains(tl)) {
                es.tenantLinks.add(tl);
            }
        });
    }
    Operation endpointOp = Operation.createPost(this, EndpointService.FACTORY_LINK);
    ComputeDescription computeDescription = configureDescription(currentState, es);
    ComputeState computeState = configureCompute(currentState, es, endpointProperties);
    Operation cdOp = createComputeDescriptionOp(currentState, computeDescription.documentSelfLink);
    Operation compOp = createComputeStateOp(currentState, computeState.documentSelfLink);
    // pool link
    if (currentState.enumerationRequest != null && currentState.enumerationRequest.resourcePoolLink != null) {
        es.resourcePoolLink = currentState.enumerationRequest.resourcePoolLink;
        computeState.resourcePoolLink = es.resourcePoolLink;
    }
    OperationSequence sequence;
    if (es.authCredentialsLink == null) {
        AuthCredentialsServiceState auth = configureAuth(es);
        Operation authOp = Operation.createPost(createInventoryUri(this.getHost(), AuthCredentialsService.FACTORY_LINK)).setBody(auth);
        sequence = OperationSequence.create(authOp).setCompletion((ops, exs) -> {
            if (exs != null) {
                long firstKey = exs.keySet().iterator().next();
                exs.values().forEach(ex -> logWarning(() -> String.format("Error in " + "sequence to create auth credentials: %s", ex.getMessage())));
                sendFailurePatch(this, currentState, exs.get(firstKey));
                return;
            }
            Operation o = ops.get(authOp.getId());
            AuthCredentialsServiceState authState = o.getBody(AuthCredentialsServiceState.class);
            computeDescription.authCredentialsLink = authState.documentSelfLink;
            es.authCredentialsLink = authState.documentSelfLink;
            cdOp.setBody(computeDescription);
        }).next(cdOp);
    } else {
        cdOp.setBody(computeDescription);
        sequence = OperationSequence.create(cdOp);
    }
    sequence = sequence.setCompletion((ops, exs) -> {
        if (exs != null) {
            long firstKey = exs.keySet().iterator().next();
            exs.values().forEach(ex -> logWarning(() -> String.format("Error in " + "sequence to create compute description: %s", ex.getMessage())));
            sendFailurePatch(this, currentState, exs.get(firstKey));
            return;
        }
        Operation o = ops.get(cdOp.getId());
        ComputeDescription desc = o.getBody(ComputeDescription.class);
        if (!currentState.accountAlreadyExists) {
            createdDocumentLinks.add(desc.documentSelfLink);
        }
        computeState.descriptionLink = desc.documentSelfLink;
        es.computeDescriptionLink = desc.documentSelfLink;
    });
    // Don't create resource pool, if a resource pool link was passed.
    if (es.resourcePoolLink == null) {
        Operation poolOp = createResourcePoolOp(es);
        sequence = sequence.next(poolOp).setCompletion((ops, exs) -> {
            if (exs != null) {
                long firstKey = exs.keySet().iterator().next();
                exs.values().forEach(ex -> logWarning(() -> String.format("Error creating resource" + " pool: %s", ex.getMessage())));
                sendFailurePatch(this, currentState, exs.get(firstKey));
                return;
            }
            Operation o = ops.get(poolOp.getId());
            ResourcePoolState poolState = o.getBody(ResourcePoolState.class);
            createdDocumentLinks.add(poolState.documentSelfLink);
            es.resourcePoolLink = poolState.documentSelfLink;
            computeState.resourcePoolLink = es.resourcePoolLink;
            compOp.setBody(computeState);
        });
    } else {
        Operation getPoolOp = Operation.createGet(this, es.resourcePoolLink);
        sequence = sequence.next(getPoolOp).setCompletion((ops, exs) -> {
            if (exs != null) {
                long firstKey = exs.keySet().iterator().next();
                exs.values().forEach(ex -> logWarning(() -> String.format("Error retrieving resource" + " pool: %s", ex.getMessage())));
                sendFailurePatch(this, currentState, exs.get(firstKey));
                return;
            }
            Operation o = ops.get(getPoolOp.getId());
            ResourcePoolState poolState = o.getBody(ResourcePoolState.class);
            if (poolState.customProperties != null) {
                String endpointLink = poolState.customProperties.get(ENDPOINT_LINK_PROP_NAME);
                if (endpointLink != null && endpointLink.equals(es.documentSelfLink)) {
                    sendFailurePatch(this, currentState, new IllegalStateException("Passed resource pool is associated with a different endpoint."));
                    return;
                }
            }
            es.resourcePoolLink = poolState.documentSelfLink;
            computeState.resourcePoolLink = es.resourcePoolLink;
            compOp.setBody(computeState);
        });
    }
    sequence.next(compOp).setCompletion((ops, exs) -> {
        if (exs != null) {
            long firstKey = exs.keySet().iterator().next();
            exs.values().forEach(ex -> logWarning(() -> String.format("Error in " + "sequence to create compute state: %s", ex.getMessage())));
            sendFailurePatch(this, currentState, exs.get(firstKey));
            return;
        }
        Operation csOp = ops.get(compOp.getId());
        ComputeState c = csOp.getBody(ComputeState.class);
        if (!currentState.accountAlreadyExists) {
            createdDocumentLinks.add(c.documentSelfLink);
        }
        es.computeLink = c.documentSelfLink;
        endpointOp.setBody(es);
    }).next(endpointOp).setCompletion((ops, exs) -> {
        if (exs != null) {
            long firstKey = exs.keySet().iterator().next();
            exs.values().forEach(ex -> logWarning(() -> String.format("Error in " + "sequence to create endpoint state: %s", ex.getMessage())));
            sendFailurePatch(this, currentState, exs.get(firstKey));
            return;
        }
        Operation esOp = ops.get(endpointOp.getId());
        EndpointState endpoint = esOp.getBody(EndpointState.class);
        createdDocumentLinks.add(endpoint.documentSelfLink);
        // propagate the endpoint properties to the next stage
        endpoint.endpointProperties = endpointProperties;
        EndpointAllocationTaskState state = createUpdateSubStageTask(SubStage.INVOKE_ADAPTER);
        state.endpointState = endpoint;
        state.createdDocumentLinks = createdDocumentLinks;
        sendSelfPatch(state);
    }).sendWith(this);
}