Feature - TargetType compatibility check

hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/TargetManagement.java

@@ -21,21 +21,22 @@
 import org.eclipse.hawkbit.im.authentication.SpPermission.SpringEvalExpressions;
 import org.eclipse.hawkbit.repository.builder.TargetCreate;
 import org.eclipse.hawkbit.repository.builder.TargetUpdate;
+import org.eclipse.hawkbit.repository.exception.AssignmentQuotaExceededException;
 import org.eclipse.hawkbit.repository.exception.EntityAlreadyExistsException;
 import org.eclipse.hawkbit.repository.exception.EntityNotFoundException;
-import org.eclipse.hawkbit.repository.exception.AssignmentQuotaExceededException;
 import org.eclipse.hawkbit.repository.exception.RSQLParameterSyntaxException;
 import org.eclipse.hawkbit.repository.exception.RSQLParameterUnsupportedFieldException;
 import org.eclipse.hawkbit.repository.model.DistributionSet;
+import org.eclipse.hawkbit.repository.model.DistributionSetType;
 import org.eclipse.hawkbit.repository.model.MetaData;
 import org.eclipse.hawkbit.repository.model.RolloutGroup;
 import org.eclipse.hawkbit.repository.model.Tag;
 import org.eclipse.hawkbit.repository.model.Target;
 import org.eclipse.hawkbit.repository.model.TargetFilterQuery;
 import org.eclipse.hawkbit.repository.model.TargetMetadata;
 import org.eclipse.hawkbit.repository.model.TargetTag;
-import org.eclipse.hawkbit.repository.model.TargetType;
 import org.eclipse.hawkbit.repository.model.TargetTagAssignmentResult;
+import org.eclipse.hawkbit.repository.model.TargetType;
 import org.eclipse.hawkbit.repository.model.TargetUpdateStatus;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
@@ -137,7 +138,7 @@ long countByFilters(Collection<TargetUpdateStatus> status, Boolean overdueState,
      *             if distribution set with given ID does not exist
      */
     @PreAuthorize(SpringEvalExpressions.HAS_AUTH_READ_TARGET + SpringEvalExpressions.HAS_AUTH_OR
-                          + SpringEvalExpressions.HAS_AUTH_READ_REPOSITORY)
+            + SpringEvalExpressions.HAS_AUTH_READ_REPOSITORY)
     boolean existsByInstalledOrAssignedDistributionSet(long distId);
 
     /**
@@ -232,9 +233,9 @@ long countByFilters(Collection<TargetUpdateStatus> status, Boolean overdueState,
     void deleteByControllerID(@NotEmpty String controllerID);
 
     /**
-     * Finds all targets for all the given parameter {@link TargetFilterQuery}
-     * and that don't have the specified distribution set in their action
-     * history.
+     * Finds all targets for all the given parameter {@link TargetFilterQuery} and
+     * that don't have the specified distribution set in their action history and
+     * are compatible with the passed {@link DistributionSetType}.
      *
      * @param pageRequest
      *            the pageRequest to enhance the query for paging and sorting
@@ -248,13 +249,13 @@ long countByFilters(Collection<TargetUpdateStatus> status, Boolean overdueState,
      *             if distribution set with given ID does not exist
      */
     @PreAuthorize(SpringEvalExpressions.HAS_AUTH_READ_TARGET)
-    Page<Target> findByTargetFilterQueryAndNonDS(@NotNull Pageable pageRequest, long distributionSetId,
+    Page<Target> findByTargetFilterQueryAndNonDSAndCompatible(@NotNull Pageable pageRequest, long distributionSetId,
             @NotNull String rsqlParam);
 
     /**
-     * Counts all targets for all the given parameter {@link TargetFilterQuery}
-     * and that don't have the specified distribution set in their action
-     * history.
+     * Counts all targets for all the given parameter {@link TargetFilterQuery} and
+     * that don't have the specified distribution set in their action history and
+     * are compatible with the passed {@link DistributionSetType}.
      *
      * @param distributionSetId
      *            id of the {@link DistributionSet}
@@ -266,36 +267,46 @@ Page<Target> findByTargetFilterQueryAndNonDS(@NotNull Pageable pageRequest, long
      *             if distribution set with given ID does not exist
      */
     @PreAuthorize(SpringEvalExpressions.HAS_AUTH_READ_TARGET)
-    long countByRsqlAndNonDS(long distributionSetId, @NotNull String rsqlParam);
+    long countByRsqlAndNonDSAndCompatible(long distributionSetId, @NotNull String rsqlParam);
 
     /**
-     * Finds all targets for all the given parameter {@link TargetFilterQuery}
-     * and that are not assigned to one of the {@link RolloutGroup}s
+     * Finds all targets for all the given parameter {@link TargetFilterQuery} and
+     * that are not assigned to one of the {@link RolloutGroup}s and are compatible
+     * with the passed {@link DistributionSetType}.
      *
      * @param pageRequest
      *            the pageRequest to enhance the query for paging and sorting
      * @param groups
      *            the list of {@link RolloutGroup}s
      * @param rsqlParam
      *            filter definition in RSQL syntax
+     * @param distributionSetType
+     *            type of the {@link DistributionSet} the targets must be compatible
+     *            with
      * @return a page of the found {@link Target}s
      */
     @PreAuthorize(SpringEvalExpressions.HAS_AUTH_READ_TARGET)
-    Page<Target> findByTargetFilterQueryAndNotInRolloutGroups(@NotNull Pageable pageRequest,
-            @NotEmpty Collection<Long> groups, @NotNull String rsqlParam);
+    Page<Target> findByTargetFilterQueryAndNotInRolloutGroupsAndCompatible(@NotNull Pageable pageRequest,
+            @NotEmpty Collection<Long> groups, @NotNull String rsqlParam,
+            @NotNull DistributionSetType distributionSetType);
 
     /**
-     * Counts all targets for all the given parameter {@link TargetFilterQuery}
-     * and that are not assigned to one of the {@link RolloutGroup}s
+     * Counts all targets for all the given parameter {@link TargetFilterQuery} and
+     * that are not assigned to one of the {@link RolloutGroup}s and are compatible
+     * with the passed {@link DistributionSetType}.
      *
      * @param groups
      *            the list of {@link RolloutGroup}s
      * @param rsqlParam
      *            filter definition in RSQL syntax
+     * @param distributionSetType
+     *            type of the {@link DistributionSet} the targets must be compatible
+     *            with
      * @return count of the found {@link Target}s
      */
     @PreAuthorize(SpringEvalExpressions.HAS_AUTH_READ_TARGET)
-    long countByRsqlAndNotInRolloutGroups(@NotEmpty Collection<Long> groups, @NotNull String rsqlParam);
+    long countByRsqlAndNotInRolloutGroupsAndCompatible(@NotEmpty Collection<Long> groups, @NotNull String rsqlParam,
+            @NotNull DistributionSetType distributionSetType);
 
     /**
      * Finds all targets of the provided {@link RolloutGroup} that have no

hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/JpaDeploymentManagement.java

@@ -15,6 +15,7 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.EnumMap;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -41,6 +42,7 @@
 import org.eclipse.hawkbit.repository.TenantConfigurationManagement;
 import org.eclipse.hawkbit.repository.event.remote.TargetAssignDistributionSetEvent;
 import org.eclipse.hawkbit.repository.exception.CancelActionNotAllowedException;
+import org.eclipse.hawkbit.repository.exception.DistributionSetTypeNotInTargetTypeException;
 import org.eclipse.hawkbit.repository.exception.EntityNotFoundException;
 import org.eclipse.hawkbit.repository.exception.ForceQuitActionNotAllowedException;
 import org.eclipse.hawkbit.repository.exception.IncompleteDistributionSetException;
@@ -225,10 +227,36 @@ private List<DeploymentRequest> validateRequestForAssignments(List<DeploymentReq
             deploymentRequests = deploymentRequests.stream().distinct().collect(Collectors.toList());
             checkIfRequiresMultiAssignment(deploymentRequests);
         }
+        checkForTargetTypeCompatibility(deploymentRequests);
         checkQuotaForAssignment(deploymentRequests);
         return deploymentRequests;
     }
 
+    private void checkForTargetTypeCompatibility(final List<DeploymentRequest> deploymentRequests) {
+        final Map<String, Long> targetDistSetAssignments = new HashMap<>();
+        for (final DeploymentRequest deploymentRequest : deploymentRequests) {
+            targetDistSetAssignments.put(deploymentRequest.getControllerId(), deploymentRequest.getDistributionSetId());
+        }
+
+        final List<JpaTarget> allTargets = targetRepository.findAll(TargetSpecifications
+                .hasControllerIdIn(targetDistSetAssignments.keySet()).and(TargetSpecifications.hasTargetType()));
+        final Map<Long, JpaDistributionSet> allDistSets = distributionSetRepository
+                .findAllById(targetDistSetAssignments.values()).stream()
+                .collect(Collectors.toMap(JpaDistributionSet::getId, jpaDistributionSet -> jpaDistributionSet));
+
+        for (final JpaTarget target : allTargets) {
+            final Long distId = targetDistSetAssignments.get(target.getControllerId());
+            final JpaDistributionSet jpaDistributionSet = allDistSets.get(distId);
+            if (jpaDistributionSet == null) {
+                throw new EntityNotFoundException(DistributionSet.class, distId);
+            }
+            if (!target.getTargetType().containsCompatibleDistributionSetType(jpaDistributionSet.getType().getId())) {
+                throw new DistributionSetTypeNotInTargetTypeException(target.getTargetType().getId(),
+                        jpaDistributionSet.getType().getId());
+            }
+        }
+    }
+
     private static Map<Long, List<TargetWithActionType>> convertRequest(
             final Collection<DeploymentRequest> deploymentRequests) {
         return deploymentRequests.stream().collect(Collectors.groupingBy(DeploymentRequest::getDistributionSetId,
@@ -252,17 +280,17 @@ private DistributionSetAssignmentResult assignDistributionSetToTargetsWithRetry(
     }
 
     /**
-     * method assigns the {@link DistributionSet} to all {@link Target}s by
-     * their IDs with a specific {@link ActionType} and {@code forcetime}.
+     * method assigns the {@link DistributionSet} to all {@link Target}s by their
+     * IDs with a specific {@link ActionType} and {@code forcetime}.
      * 
      * 
      * In case the update was executed offline (i.e. not managed by hawkBit) the
      * handling differs my means that:<br/>
      * A. it ignores targets completely that are in
      * {@link TargetUpdateStatus#PENDING}.<br/>
      * B. it created completed actions.<br/>
-     * C. sets both installed and assigned DS on the target and switches the
-     * status to {@link TargetUpdateStatus#IN_SYNC} <br/>
+     * C. sets both installed and assigned DS on the target and switches the status
+     * to {@link TargetUpdateStatus#IN_SYNC} <br/>
      * D. does not send a {@link TargetAssignDistributionSetEvent}.<br/>
      *
      * @param initiatedBy
@@ -277,9 +305,9 @@ private DistributionSetAssignmentResult assignDistributionSetToTargetsWithRetry(
      *            the assignment strategy (online /offline)
      * @return the assignment result
      *
-     * @throw IncompleteDistributionSetException if mandatory
-     *        {@link SoftwareModuleType} are not assigned as define by the
-     *        {@link DistributionSetType}.
+     * @throws IncompleteDistributionSetException
+     *             if mandatory {@link SoftwareModuleType} are not assigned as
+     *             define by the {@link DistributionSetType}.
      */
     private DistributionSetAssignmentResult assignDistributionSetToTargets(final String initiatedBy, final Long dsID,
             final Collection<TargetWithActionType> targetsWithActionType, final String actionMessage,
@@ -346,9 +374,9 @@ private List<JpaAction> doAssignDistributionSetToTargets(final String initiatedB
     }
 
     /**
-     * split tIDs length into max entries in-statement because many database
-     * have constraint of max entries in in-statements e.g. Oracle with maximum
-     * 1000 elements, so we need to split the entries here and execute multiple
+     * split tIDs length into max entries in-statement because many database have
+     * constraint of max entries in in-statements e.g. Oracle with maximum 1000
+     * elements, so we need to split the entries here and execute multiple
      * statements
      */
     private static List<List<Long>> getTargetEntitiesAsChunks(final List<JpaTarget> targetEntities) {
@@ -656,8 +684,8 @@ public Page<Action> findActionsByTarget(final String rsqlParam, final String con
     }
 
     private Specification<JpaAction> createSpecificationFor(final String controllerId, final String rsqlParam) {
-        final Specification<JpaAction> spec = RSQLUtility.buildRsqlSpecification(rsqlParam, ActionFields.class, virtualPropertyReplacer,
-                database);
+        final Specification<JpaAction> spec = RSQLUtility.buildRsqlSpecification(rsqlParam, ActionFields.class,
+                virtualPropertyReplacer, database);
         return (root, query, cb) -> cb.and(spec.toPredicate(root, query, cb),
                 cb.equal(root.get(JpaAction_.target).get(JpaTarget_.controllerId), controllerId));
     }
@@ -809,10 +837,10 @@ public int deleteActionsByStatusAndLastModifiedBefore(final Set<Status> status,
             return 0;
         }
         /*
-         * We use a native query here because Spring JPA does not support to
-         * specify a LIMIT clause on a DELETE statement. However, for this
-         * specific use case (action cleanup), we must specify a row limit to
-         * reduce the overall load on the database.
+         * We use a native query here because Spring JPA does not support to specify a
+         * LIMIT clause on a DELETE statement. However, for this specific use case
+         * (action cleanup), we must specify a row limit to reduce the overall load on
+         * the database.
          */
 
         final int statusCount = status.size();
@@ -832,7 +860,7 @@ public int deleteActionsByStatusAndLastModifiedBefore(final Set<Status> status,
     }
 
     @Override
-    public boolean hasPendingCancellations(String controllerId) {
+    public boolean hasPendingCancellations(final String controllerId) {
         return actionRepository.existsByTargetControllerIdAndStatusAndActiveIsTrue(controllerId,
                 Action.Status.CANCELING);
     }

hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/JpaRolloutExecutor.java

@@ -493,7 +493,8 @@ private RolloutGroup fillRolloutGroupWithTargets(final JpaRollout rollout, final
 
         final long targetsInGroupFilter = DeploymentHelper.runInNewTransaction(txManager,
                 "countAllTargetsByTargetFilterQueryAndNotInRolloutGroups",
-                count -> targetManagement.countByRsqlAndNotInRolloutGroups(readyGroups, groupTargetFilter));
+                count -> targetManagement.countByRsqlAndNotInRolloutGroupsAndCompatible(readyGroups, groupTargetFilter,
+                        rollout.getDistributionSet().getType()));
         final long expectedInGroup = Math
                 .round((double) (group.getTargetPercentage() / 100) * (double) targetsInGroupFilter);
         final long currentlyInGroup = DeploymentHelper.runInNewTransaction(txManager,
@@ -537,8 +538,8 @@ private Long assignTargetsToGroupInNewTransaction(final JpaRollout rollout, fina
             final PageRequest pageRequest = PageRequest.of(0, Math.toIntExact(limit));
             final List<Long> readyGroups = RolloutHelper.getGroupsByStatusIncludingGroup(rollout.getRolloutGroups(),
                     RolloutGroupStatus.READY, group);
-            final Page<Target> targets = targetManagement.findByTargetFilterQueryAndNotInRolloutGroups(pageRequest,
-                    readyGroups, targetFilter);
+            final Page<Target> targets = targetManagement.findByTargetFilterQueryAndNotInRolloutGroupsAndCompatible(
+                    pageRequest, readyGroups, targetFilter, rollout.getDistributionSet().getType());
 
             createAssignmentOfTargetsToGroup(targets, group);
 
@@ -547,8 +548,8 @@ private Long assignTargetsToGroupInNewTransaction(final JpaRollout rollout, fina
     }
 
     /**
-     * Schedules a group of the rollout. Scheduled Actions are created to
-     * achieve this. The creation of those Actions is allowed to fail.
+     * Schedules a group of the rollout. Scheduled Actions are created to achieve
+     * this. The creation of those Actions is allowed to fail.
      */
     private boolean scheduleRolloutGroup(final JpaRollout rollout, final JpaRolloutGroup group) {
         final long targetsInGroup = rolloutTargetGroupRepository.countByRolloutGroup(group);
@@ -611,8 +612,8 @@ private void createAssignmentOfTargetsToGroup(final Page<Target> targets, final
 
     /**
      * Creates an action entry into the action repository. In case of existing
-     * scheduled actions the scheduled actions gets canceled. A scheduled action
-     * is created in-active.
+     * scheduled actions the scheduled actions gets canceled. A scheduled action is
+     * created in-active.
      */
     private void createScheduledAction(final Collection<Target> targets, final DistributionSet distributionSet,
             final ActionType actionType, final Long forcedTime, final Rollout rollout,