Examples with EMPTY org.apache.commons.lang3.StringUtils.EMPTY used on opensource projects

Example 41 with EMPTY

use of org.apache.commons.lang3.StringUtils.EMPTY in project photon-model by vmware.

the class AzureNetworkEnumerationAdapterService method createUpdateSubnetStates.

/**
 * Create new subnet states or updates matching subnet states with the actual state in Azure.
 */
private void createUpdateSubnetStates(NetworkEnumContext context, NetworkEnumStages next) {
    if (context.subnets.size() == 0) {
        logFine(() -> "No network states available for update.");
        handleSubStage(context, next);
        return;
    }
    Stream<Operation> operations = context.subnets.keySet().stream().map(subnetId -> {
        SubnetStateWithParentVNetId subnetStateWithParentVNetId = context.subnets.get(subnetId);
        SubnetState subnetState = subnetStateWithParentVNetId.subnetState;
        if (!context.subnetStates.containsKey(subnetId)) {
            // set internal tags as tagLinks for subnets to be newly created.
            setTagLinksToResourceState(subnetState, context.subnetInternalTagsMap, false);
        } else {
            // for already existing subnets, add internal tags only if missing
            if (subnetState.tagLinks == null || subnetState.tagLinks.isEmpty()) {
                setTagLinksToResourceState(subnetState, context.subnetInternalTagsMap, false);
            } else {
                context.subnetInternalTagLinksSet.stream().filter(tagLink -> !subnetState.tagLinks.contains(tagLink)).map(tagLink -> subnetState.tagLinks.add(tagLink)).collect(Collectors.toSet());
            }
        }
        // Update networkLink with "latest" (either created or updated)
        // NetworkState.documentSelfLink
        NetworkState networkState = context.networkStates.get(subnetStateWithParentVNetId.parentVNetId);
        if (networkState != null) {
            subnetState.networkLink = networkState.documentSelfLink;
        } else {
            logWarning(() -> String.format("Network state corresponding to subnet with" + " name [%s] was not found. Network Link is left empty.", subnetState.name));
        }
        if (StringUtils.isEmpty(subnetState.endpointLink)) {
            subnetState.endpointLink = context.request.endpointLink;
        }
        subnetState.computeHostLink = context.parentCompute.documentSelfLink;
        AdapterUtils.addToEndpointLinks(subnetState, context.request.endpointLink);
        return context.subnetStates.containsKey(subnetId) ? // Update case
        Operation.createPatch(this, context.subnetStates.get(subnetId)).setBody(subnetState) : // Create case.
        Operation.createPost(getHost(), SubnetService.FACTORY_LINK).setBody(subnetState);
    });
    OperationJoin.create(operations).setCompletion((ops, failures) -> {
        if (failures != null) {
            // We don't want to fail the whole data collection if some of the
            // operation fails.
            failures.values().forEach(ex -> logWarning(() -> String.format("Error: %s", ex.getMessage())));
        }
        // Process successful operations.
        ops.values().stream().filter(operation -> failures != null && !failures.containsKey(operation.getId())).filter(operation -> operation.getStatusCode() != Operation.STATUS_CODE_NOT_MODIFIED).forEach(operation -> {
            SubnetState subnetState = operation.getBody(SubnetState.class);
            context.subnets.get(subnetState.id).subnetState = subnetState;
        });
        if (context.enumNextPageLink != null) {
            logFine(() -> "Fetch next page of Virtual Networks from Azure.");
            handleSubStage(context, NetworkEnumStages.GET_VNETS);
            return;
        }
        logFine(() -> "Finished updating network states");
        handleSubStage(context, next);
    }).sendWith(this);
}

Example 42 with EMPTY

use of org.apache.commons.lang3.StringUtils.EMPTY in project photon-model by vmware.

the class ClientUtils method attachDiskToVM.

public static String attachDiskToVM(ArrayOfVirtualDevice devices, ManagedObjectReference vm, DiskService.DiskStateExpanded diskState, ManagedObjectReference diskDatastore, Connection connection, VimPortType vimPort) throws Exception {
    String diskPath = VimUtils.uriToDatastorePath(diskState.sourceImageReference);
    String diskFullPath = CustomProperties.of(diskState).getString(DISK_FULL_PATH, null);
    Boolean insertCdRom = CustomProperties.of(diskState).getBoolean(INSERT_CDROM, false);
    VirtualDeviceConfigSpec deviceConfigSpec = null;
    if (diskState.type == DiskService.DiskType.HDD) {
        VirtualSCSIController scsiController = getFirstScsiController(devices);
        // Get available free unit numbers for the given scsi controller.
        Integer[] scsiUnits = findFreeScsiUnit(scsiController, devices.getVirtualDevice());
        List<VirtualMachineDefinedProfileSpec> pbmSpec = getPbmProfileSpec(diskState);
        deviceConfigSpec = createHdd(scsiController.getKey(), scsiUnits[0], diskState, diskFullPath, diskDatastore, pbmSpec, false);
    } else if (diskState.type == DiskService.DiskType.CDROM) {
        if (insertCdRom) {
            if (diskPath == null) {
                throw new IllegalStateException(String.format("Cannot insert empty iso file into CD-ROM"));
            }
            // Find first available CD ROM to insert the iso file
            VirtualCdrom cdrom = devices.getVirtualDevice().stream().filter(d -> d instanceof VirtualCdrom).map(d -> (VirtualCdrom) d).findFirst().orElse(null);
            if (cdrom == null) {
                throw new IllegalStateException(String.format("Could not find Virtual CD ROM to insert %s.", diskPath));
            }
            insertCdrom(cdrom, diskPath);
            deviceConfigSpec = new VirtualDeviceConfigSpec();
            deviceConfigSpec.setDevice(cdrom);
            deviceConfigSpec.setOperation(VirtualDeviceConfigSpecOperation.EDIT);
        } else {
            VirtualDevice ideController = getFirstIdeController(devices);
            int ideUnit = findFreeUnit(ideController, devices.getVirtualDevice());
            int availableUnitNumber = nextUnitNumber(ideUnit);
            deviceConfigSpec = createCdrom(ideController, availableUnitNumber);
            fillInControllerUnitNumber(diskState, availableUnitNumber);
            if (diskPath != null) {
                // mount iso image
                insertCdrom((VirtualCdrom) deviceConfigSpec.getDevice(), diskPath);
            }
            // Live add of cd-rom is not possible. Hence it needs to be powered off
            // Power off is needed to ADD cd-rom
            powerOffVm(connection, vimPort, vm);
        }
    } else if (diskState.type == DiskService.DiskType.FLOPPY) {
        VirtualDevice sioController = getFirstSioController(devices);
        int sioUnit = findFreeUnit(sioController, devices.getVirtualDevice());
        int availableUnitNumber = nextUnitNumber(sioUnit);
        deviceConfigSpec = createFloppy(sioController, availableUnitNumber);
        fillInControllerUnitNumber(diskState, availableUnitNumber);
        if (diskPath != null) {
            insertFloppy((VirtualFloppy) deviceConfigSpec.getDevice(), diskPath);
        }
        // Power off is needed to ADD floppy
        powerOffVm(connection, vimPort, vm);
    }
    VirtualMachineConfigSpec spec = new VirtualMachineConfigSpec();
    spec.getDeviceChange().add(deviceConfigSpec);
    ManagedObjectReference reconfigureTask = vimPort.reconfigVMTask(vm, spec);
    TaskInfo info = VimUtils.waitTaskEnd(connection, reconfigureTask);
    if (info.getState() == TaskInfoState.ERROR) {
        VimUtils.rethrow(info.getError());
    }
    if (!insertCdRom && diskState.type != DiskService.DiskType.HDD) {
        // This means it is CDROM or Floppy. Hence power on the VM as it is powered off to
        // perform the operation
        powerOnVM(connection, vimPort, vm);
    }
    return diskFullPath;
}

Example 43 with EMPTY

use of org.apache.commons.lang3.StringUtils.EMPTY in project syncope by apache.

the class AnyOperations method diff.

/**
 * Calculate modifications needed by first in order to be equal to second.
 *
 * @param updated updated UserTO
 * @param original original UserTO
 * @param incremental perform incremental diff (without removing existing info)
 * @return UserPatch containing differences
 */
public static UserPatch diff(final UserTO updated, final UserTO original, final boolean incremental) {
    UserPatch result = new UserPatch();
    diff(updated, original, result, incremental);
    // 1. password
    if (updated.getPassword() != null && (original.getPassword() == null || !original.getPassword().equals(updated.getPassword()))) {
        result.setPassword(new PasswordPatch.Builder().value(updated.getPassword()).resources(updated.getResources()).build());
    }
    // 2. username
    result.setUsername(replacePatchItem(updated.getUsername(), original.getUsername(), new StringReplacePatchItem()));
    // 3. security question / answer
    if (updated.getSecurityQuestion() == null) {
        result.setSecurityQuestion(null);
        result.setSecurityAnswer(null);
    } else if (!updated.getSecurityQuestion().equals(original.getSecurityQuestion()) || StringUtils.isNotBlank(updated.getSecurityAnswer())) {
        result.setSecurityQuestion(new StringReplacePatchItem.Builder().value(updated.getSecurityQuestion()).build());
        result.setSecurityAnswer(new StringReplacePatchItem.Builder().value(updated.getSecurityAnswer()).build());
    }
    result.setMustChangePassword(replacePatchItem(updated.isMustChangePassword(), original.isMustChangePassword(), new BooleanReplacePatchItem()));
    // 4. roles
    if (!incremental) {
        original.getRoles().stream().filter(role -> !updated.getRoles().contains(role)).forEach(toRemove -> {
            result.getRoles().add(new StringPatchItem.Builder().operation(PatchOperation.DELETE).value(toRemove).build());
        });
    }
    updated.getRoles().stream().filter(role -> !original.getRoles().contains(role)).forEach(toAdd -> {
        result.getRoles().add(new StringPatchItem.Builder().operation(PatchOperation.ADD_REPLACE).value(toAdd).build());
    });
    // 5. relationships
    Map<Pair<String, String>, RelationshipTO> updatedRels = EntityTOUtils.buildRelationshipMap(updated.getRelationships());
    Map<Pair<String, String>, RelationshipTO> originalRels = EntityTOUtils.buildRelationshipMap(original.getRelationships());
    updatedRels.entrySet().stream().filter(entry -> (!originalRels.containsKey(entry.getKey()))).forEachOrdered(entry -> {
        result.getRelationships().add(new RelationshipPatch.Builder().operation(PatchOperation.ADD_REPLACE).relationshipTO(entry.getValue()).build());
    });
    if (!incremental) {
        originalRels.keySet().stream().filter(relationship -> !updatedRels.containsKey(relationship)).forEach(key -> {
            result.getRelationships().add(new RelationshipPatch.Builder().operation(PatchOperation.DELETE).relationshipTO(originalRels.get(key)).build());
        });
    }
    // 6. memberships
    Map<String, MembershipTO> updatedMembs = EntityTOUtils.buildMembershipMap(updated.getMemberships());
    Map<String, MembershipTO> originalMembs = EntityTOUtils.buildMembershipMap(original.getMemberships());
    updatedMembs.entrySet().stream().map(entry -> {
        MembershipPatch membershipPatch = new MembershipPatch.Builder().operation(PatchOperation.ADD_REPLACE).group(entry.getValue().getGroupKey()).build();
        MembershipTO omemb;
        if (originalMembs.containsKey(entry.getKey())) {
            // get the original membership
            omemb = originalMembs.get(entry.getKey());
        } else {
            // create an empty one to generate the patch
            omemb = new MembershipTO.Builder().group(entry.getKey()).build();
        }
        diff(entry.getValue(), omemb, membershipPatch, incremental);
        return membershipPatch;
    }).forEachOrdered(membershipPatch -> {
        result.getMemberships().add(membershipPatch);
    });
    if (!incremental) {
        originalMembs.keySet().stream().filter(membership -> !updatedMembs.containsKey(membership)).forEach(key -> {
            result.getMemberships().add(new MembershipPatch.Builder().operation(PatchOperation.DELETE).group(originalMembs.get(key).getGroupKey()).build());
        });
    }
    return result;
}

Example 44 with EMPTY

use of org.apache.commons.lang3.StringUtils.EMPTY in project syncope by apache.

the class AbstractPropagationTaskExecutor method createOrUpdate.

protected Uid createOrUpdate(final PropagationTask task, final ConnectorObject beforeObj, final Connector connector, final AtomicReference<Boolean> propagationAttempted) {
    // set of attributes to be propagated
    Set<Attribute> attributes = new HashSet<>(task.getAttributes());
    // check if there is any missing or null / empty mandatory attribute
    Set<Object> mandatoryAttrNames = new HashSet<>();
    Attribute mandatoryMissing = AttributeUtil.find(MANDATORY_MISSING_ATTR_NAME, task.getAttributes());
    if (mandatoryMissing != null) {
        attributes.remove(mandatoryMissing);
        if (beforeObj == null) {
            mandatoryAttrNames.addAll(mandatoryMissing.getValue());
        }
    }
    Attribute mandatoryNullOrEmpty = AttributeUtil.find(MANDATORY_NULL_OR_EMPTY_ATTR_NAME, task.getAttributes());
    if (mandatoryNullOrEmpty != null) {
        attributes.remove(mandatoryNullOrEmpty);
        mandatoryAttrNames.addAll(mandatoryNullOrEmpty.getValue());
    }
    if (!mandatoryAttrNames.isEmpty()) {
        throw new IllegalArgumentException("Not attempted because there are mandatory attributes without value(s): " + mandatoryAttrNames);
    }
    Uid result;
    if (beforeObj == null) {
        LOG.debug("Create {} on {}", attributes, task.getResource().getKey());
        result = connector.create(new ObjectClass(task.getObjectClassName()), attributes, null, propagationAttempted);
    } else {
        // 1. check if rename is really required
        Name newName = AttributeUtil.getNameFromAttributes(attributes);
        LOG.debug("Rename required with value {}", newName);
        if (newName != null && newName.equals(beforeObj.getName()) && !newName.getNameValue().equals(beforeObj.getUid().getUidValue())) {
            LOG.debug("Remote object name unchanged");
            attributes.remove(newName);
        }
        // 2. check wether anything is actually needing to be propagated, i.e. if there is attribute
        // difference between beforeObj - just read above from the connector - and the values to be propagated
        Map<String, Attribute> originalAttrMap = beforeObj.getAttributes().stream().collect(Collectors.toMap(attr -> attr.getName().toUpperCase(), attr -> attr));
        Map<String, Attribute> updateAttrMap = attributes.stream().collect(Collectors.toMap(attr -> attr.getName().toUpperCase(), attr -> attr));
        // Only compare attribute from beforeObj that are also being updated
        Set<String> skipAttrNames = originalAttrMap.keySet();
        skipAttrNames.removeAll(updateAttrMap.keySet());
        new HashSet<>(skipAttrNames).forEach(attrName -> {
            originalAttrMap.remove(attrName);
        });
        Set<Attribute> originalAttrs = new HashSet<>(originalAttrMap.values());
        if (originalAttrs.equals(attributes)) {
            LOG.debug("Don't need to propagate anything: {} is equal to {}", originalAttrs, attributes);
            result = AttributeUtil.getUidAttribute(attributes);
        } else {
            LOG.debug("Attributes that would be updated {}", attributes);
            Set<Attribute> strictlyModified = new HashSet<>();
            attributes.stream().filter(attr -> (!originalAttrs.contains(attr))).forEachOrdered(attr -> {
                strictlyModified.add(attr);
            });
            // 3. provision entry
            LOG.debug("Update {} on {}", strictlyModified, task.getResource().getKey());
            result = connector.update(beforeObj.getObjectClass(), new Uid(beforeObj.getUid().getUidValue()), strictlyModified, null, propagationAttempted);
        }
    }
    return result;
}

Example 45 with EMPTY

use of org.apache.commons.lang3.StringUtils.EMPTY in project batfish by batfish.

the class CommonUtil method initRemoteBgpNeighbors.

/**
 * Initialize BGP neighbors for all nodes.
 *
 * @param configurations map of all configurations, keyed by hostname
 * @param ipOwners mapping of Ips to a set of nodes (hostnames) that owns those IPs
 * @param checkReachability whether bgp neighbor reachability should be checked
 * @param flowProcessor dataplane plugin to use to check reachability. Must not be {@code null} if
 *     {@code checkReachability = true}
 * @param dp dataplane to use to check reachability. Must not be {@code null} if {@code
 *     checkReachability = true}
 */
public static void initRemoteBgpNeighbors(Map<String, Configuration> configurations, Map<Ip, Set<String>> ipOwners, boolean checkReachability, @Nullable FlowProcessor flowProcessor, @Nullable DataPlane dp) {
    // TODO: handle duplicate ips on different vrfs
    Map<BgpNeighbor, Ip> remoteAddresses = new IdentityHashMap<>();
    Map<Ip, Set<BgpNeighbor>> localAddresses = new HashMap<>();
    /*
     * Construct maps indicating which neighbor owns which Ip Address
     */
    for (Configuration node : configurations.values()) {
        String hostname = node.getHostname();
        for (Vrf vrf : node.getVrfs().values()) {
            BgpProcess proc = vrf.getBgpProcess();
            if (proc == null) {
                // nothing to do if no bgp process on this VRF
                continue;
            }
            for (BgpNeighbor bgpNeighbor : proc.getNeighbors().values()) {
                /*
           * Begin by initializing candidate neighbors to an empty set
           */
                bgpNeighbor.initCandidateRemoteBgpNeighbors();
                // Skip things we don't handle
                if (bgpNeighbor.getPrefix().getPrefixLength() < Prefix.MAX_PREFIX_LENGTH) {
                    throw new BatfishException(hostname + ": Do not support dynamic bgp sessions at this time: " + bgpNeighbor.getPrefix());
                }
                Ip remoteAddress = bgpNeighbor.getAddress();
                if (remoteAddress == null) {
                    throw new BatfishException(hostname + ": Could not determine remote address of bgp neighbor: " + bgpNeighbor);
                }
                Ip localAddress = bgpNeighbor.getLocalIp();
                if (localAddress == null || !ipOwners.containsKey(localAddress) || !ipOwners.get(localAddress).contains(hostname)) {
                    // Local address is not owned by anybody
                    continue;
                }
                remoteAddresses.put(bgpNeighbor, remoteAddress);
                // Add this neighbor as owner of its local address
                localAddresses.computeIfAbsent(localAddress, k -> Collections.newSetFromMap(new IdentityHashMap<>())).add(bgpNeighbor);
            }
        }
    }
    /*
     * For each neighbor, construct the set of candidate neighbors, then filter out impossible
     * sessions.
     */
    for (Entry<BgpNeighbor, Ip> e : remoteAddresses.entrySet()) {
        BgpNeighbor bgpNeighbor = e.getKey();
        Ip remoteAddress = e.getValue();
        Ip localAddress = bgpNeighbor.getLocalIp();
        int localLocalAs = bgpNeighbor.getLocalAs();
        int localRemoteAs = bgpNeighbor.getRemoteAs();
        /*
       * Let the set of candidate neighbors be set of neighbors that own the remoteAddress
       */
        Set<BgpNeighbor> remoteBgpNeighborCandidates = localAddresses.get(remoteAddress);
        if (remoteBgpNeighborCandidates == null) {
            // No possible remote neighbors
            continue;
        }
        /*
       * Filter the set of candidate neighbors based on these checks:
       * - Remote neighbor's remote address is the same as our local address
       * - Remote neighbor's remote AS is the same as our local AS (and vice-versa)
       */
        for (BgpNeighbor remoteBgpNeighborCandidate : remoteBgpNeighborCandidates) {
            int remoteLocalAs = remoteBgpNeighborCandidate.getLocalAs();
            int remoteRemoteAs = remoteBgpNeighborCandidate.getRemoteAs();
            Ip reciprocalRemoteIp = remoteBgpNeighborCandidate.getAddress();
            if (localAddress.equals(reciprocalRemoteIp) && localLocalAs == remoteRemoteAs && localRemoteAs == remoteLocalAs) {
                /*
           * Fairly confident establishing the session is possible here, but still check
           * reachability if needed.
           * We should check reachability only for eBgp multihop or iBgp
           */
                if (checkReachability && (bgpNeighbor.getEbgpMultihop() || localLocalAs == remoteLocalAs)) {
                    /*
             * Ensure that the session can be established by running traceroute in both directions
             */
                    if (flowProcessor == null || dp == null) {
                        throw new BatfishException("Cannot compute neighbor reachability without a dataplane");
                    }
                    Flow.Builder fb = new Flow.Builder();
                    fb.setIpProtocol(IpProtocol.TCP);
                    fb.setTag("neighbor-resolution");
                    fb.setIngressNode(bgpNeighbor.getOwner().getHostname());
                    fb.setSrcIp(localAddress);
                    fb.setDstIp(remoteAddress);
                    fb.setSrcPort(NamedPort.EPHEMERAL_LOWEST.number());
                    fb.setDstPort(NamedPort.BGP.number());
                    Flow forwardFlow = fb.build();
                    fb.setIngressNode(remoteBgpNeighborCandidate.getOwner().getHostname());
                    fb.setSrcIp(forwardFlow.getDstIp());
                    fb.setDstIp(forwardFlow.getSrcIp());
                    fb.setSrcPort(forwardFlow.getDstPort());
                    fb.setDstPort(forwardFlow.getSrcPort());
                    Flow backwardFlow = fb.build();
                    SortedMap<Flow, Set<FlowTrace>> traces = flowProcessor.processFlows(dp, ImmutableSet.of(forwardFlow, backwardFlow));
                    if (traces.values().stream().map(fts -> fts.stream().allMatch(ft -> ft.getDisposition() != FlowDisposition.ACCEPTED)).anyMatch(Predicate.isEqual(true))) {
                        /*
               * If either flow has all traceroutes fail, do not consider the neighbor valid
               */
                        continue;
                    }
                    bgpNeighbor.getCandidateRemoteBgpNeighbors().add(remoteBgpNeighborCandidate);
                } else {
                    bgpNeighbor.getCandidateRemoteBgpNeighbors().add(remoteBgpNeighborCandidate);
                }
            }
        }
        Set<BgpNeighbor> finalCandidates = bgpNeighbor.getCandidateRemoteBgpNeighbors();
        if (finalCandidates.size() > 1) {
            /* If we still have not narrowed it down to a single neighbor,
         * pick based on sorted hostnames
         */
            SortedMap<String, BgpNeighbor> hostnameToNeighbor = finalCandidates.stream().collect(ImmutableSortedMap.toImmutableSortedMap(String::compareTo, k -> k.getOwner().getHostname(), Function.identity()));
            bgpNeighbor.setRemoteBgpNeighbor(hostnameToNeighbor.get(hostnameToNeighbor.firstKey()));
        } else if (finalCandidates.size() == 1) {
            bgpNeighbor.setRemoteBgpNeighbor(finalCandidates.iterator().next());
        } else {
            bgpNeighbor.setRemoteBgpNeighbor(null);
        }
    }
}