lingwei.kong/hawkbit
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

Refactoring/Improving source: repository 3 (slf4j) (#1603)

Browse Source 
Signed-off-by: Marinov Avgustin <Avgustin.Marinov@bosch.com>
This commit is contained in:
Avgustin Marinov
2024-02-03 17:43:36 +02:00
committed by GitHub
parent ba685ef429
commit 5821c2543c
25 changed files with 147 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -20,6 +20,7 @@ import java.util.stream.StreamSupport;
import jakarta.persistence.EntityManager;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.repository.DeploymentManagement;
import org.eclipse.hawkbit.repository.QuotaManagement;
import org.eclipse.hawkbit.repository.RepositoryProperties;
@@ -60,8 +61,6 @@ import org.eclipse.hawkbit.repository.model.RolloutGroup.RolloutGroupSuccessCond
import org.eclipse.hawkbit.repository.model.Target;
import org.eclipse.hawkbit.repository.model.helper.EventPublisherHolder;
import org.eclipse.hawkbit.tenancy.TenantAware;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Slice;
import org.springframework.data.domain.Sort;
@@ -74,10 +73,9 @@ import static org.eclipse.hawkbit.repository.jpa.builder.JpaRolloutGroupCreate.a
/**
* A Jpa implementation of {@link RolloutExecutor}
*/
@Slf4j
public class JpaRolloutExecutor implements RolloutExecutor {
private static final Logger LOGGER = LoggerFactory.getLogger(JpaRolloutExecutor.class);
/**
* Max amount of targets that are handled in one transaction.
*/
@@ -148,7 +146,7 @@ public class JpaRolloutExecutor implements RolloutExecutor {
@Override
public void execute(final Rollout rollout) {
LOGGER.debug("handle rollout {}", rollout.getId());
log.debug("handle rollout {}", rollout.getId());
switch (rollout.getStatus()) {
case CREATING:
@@ -170,13 +168,13 @@ public class JpaRolloutExecutor implements RolloutExecutor {
handleStopRollout((JpaRollout) rollout);
break;
default:
LOGGER.error("Rollout in status {} not supposed to be handled!", rollout.getStatus());
log.error("Rollout in status {} not supposed to be handled!", rollout.getStatus());
break;
}
}
private void handleCreateRollout(final JpaRollout rollout) {
LOGGER.debug("handleCreateRollout called for rollout {}", rollout.getId());
log.debug("handleCreateRollout called for rollout {}", rollout.getId());
final List<RolloutGroup> rolloutGroups = rolloutGroupManagement.findByRollout(
PageRequest.of(0, quotaManagement.getMaxRolloutGroupsPerRollout(), Sort.by(Direction.ASC, "id")),
@@ -209,9 +207,9 @@ public class JpaRolloutExecutor implements RolloutExecutor {
if (!rolloutApprovalStrategy.isApprovalNeeded(rollout)) {
rollout.setStatus(RolloutStatus.READY);
LOGGER.debug("rollout {} creation done. Switch to READY.", rollout.getId());
log.debug("rollout {} creation done. Switch to READY.", rollout.getId());
} else {
LOGGER.debug("rollout {} creation done. Switch to WAITING_FOR_APPROVAL.", rollout.getId());
log.debug("rollout {} creation done. Switch to WAITING_FOR_APPROVAL.", rollout.getId());
rollout.setStatus(RolloutStatus.WAITING_FOR_APPROVAL);
rolloutApprovalStrategy.onApprovalRequired(rollout);
}
@@ -222,13 +220,13 @@ public class JpaRolloutExecutor implements RolloutExecutor {
}
private void handleDeleteRollout(final JpaRollout rollout) {
LOGGER.debug("handleDeleteRollout called for {}", rollout.getId());
log.debug("handleDeleteRollout called for {}", rollout.getId());
// check if there are actions beyond schedule
boolean hardDeleteRolloutGroups = !actionRepository.existsByRolloutIdAndStatusNotIn(rollout.getId(),
Status.SCHEDULED);
if (hardDeleteRolloutGroups) {
LOGGER.debug("Rollout {} has no actions other than scheduled -> hard delete", rollout.getId());
log.debug("Rollout {} has no actions other than scheduled -> hard delete", rollout.getId());
hardDeleteRollout(rollout);
return;
}
@@ -265,7 +263,7 @@ public class JpaRolloutExecutor implements RolloutExecutor {
}
private void handleStopRollout(final JpaRollout rollout) {
LOGGER.debug("handleStopRollout called for {}", rollout.getId());
log.debug("handleStopRollout called for {}", rollout.getId());
// clean up all scheduled actions
final Slice<JpaAction> scheduledActions = findScheduledActionsByRollout(rollout);
deleteScheduledActions(rollout, scheduledActions);
@@ -299,7 +297,7 @@ public class JpaRolloutExecutor implements RolloutExecutor {
private void handleReadyRollout(final Rollout rollout) {
if (rollout.getStartAt() != null && rollout.getStartAt() <= System.currentTimeMillis()) {
LOGGER.debug(
log.debug(
"handleReadyRollout called for rollout {} with autostart beyond define time. Switch to STARTING",
rollout.getId());
rolloutManagement.start(rollout.getId());
@@ -307,7 +305,7 @@ public class JpaRolloutExecutor implements RolloutExecutor {
}
private void handleStartingRollout(final Rollout rollout) {
LOGGER.debug("handleStartingRollout called for rollout {}", rollout.getId());
log.debug("handleStartingRollout called for rollout {}", rollout.getId());
if (ensureAllGroupsAreScheduled(rollout)) {
startFirstRolloutGroup(rollout);
@@ -315,11 +313,11 @@ public class JpaRolloutExecutor implements RolloutExecutor {
}
private void handleRunningRollout(final JpaRollout rollout) {
LOGGER.debug("handleRunningRollout called for rollout {}", rollout.getId());
log.debug("handleRunningRollout called for rollout {}", rollout.getId());
if (rollout.isDynamic()) {
if (fillDynamicRolloutGroupsWithTargets(rollout)) {
LOGGER.debug("Dynamic group created for rollout {}", rollout.getId());
log.debug("Dynamic group created for rollout {}", rollout.getId());
return;
}
}
@@ -337,12 +335,12 @@ public class JpaRolloutExecutor implements RolloutExecutor {
// to find the latest group which
executeLatestRolloutGroup(rollout);
} else {
LOGGER.debug("Rollout {} has {} running groups", rollout.getId(), rolloutGroupsRunning.size());
log.debug("Rollout {} has {} running groups", rollout.getId(), rolloutGroupsRunning.size());
executeRolloutGroups(rollout, rolloutGroupsRunning, rollout.getRolloutGroups().get(rollout.getRolloutGroups().size() - 1));
}
if (isRolloutComplete(rollout)) {
LOGGER.info("Rollout {} is finished, setting FINISHED status", rollout);
log.info("Rollout {} is finished, setting FINISHED status", rollout);
rollout.setStatus(RolloutStatus.FINISHED);
rolloutRepository.save(rollout);
}
@@ -365,7 +363,7 @@ public class JpaRolloutExecutor implements RolloutExecutor {
afterCommit.afterCommit(() -> eventPublisherHolder.getEventPublisher()
.publishEvent(new RolloutUpdatedEvent(rollout, eventPublisherHolder.getApplicationId())));
} catch (final RuntimeException e) {
LOGGER.error("Exception during deletion of actions of rollout {}", rollout, e);
log.error("Exception during deletion of actions of rollout {}", rollout, e);
}
}
}
@@ -456,7 +454,7 @@ public class JpaRolloutExecutor implements RolloutExecutor {
// rollout because of error?
final boolean isError = checkErrorState(rollout, evalProxy);
if (isError) {
LOGGER.info("Rollout {} {} has error, calling error action", rollout.getName(), rollout.getId());
log.info("Rollout {} {} has error, calling error action", rollout.getName(), rollout.getId());
callErrorAction(rollout, rolloutGroup);
} else {
// not in error so check finished state, do we need to
@@ -492,7 +490,7 @@ public class JpaRolloutExecutor implements RolloutExecutor {
try {
evaluationManager.getErrorActionEvaluator(rolloutGroup.getErrorAction()).exec(rollout, rolloutGroup);
} catch (final EvaluatorNotConfiguredException e) {
LOGGER.error("Something bad happened when accessing the error action bean {}",
log.error("Something bad happened when accessing the error action bean {}",
rolloutGroup.getErrorAction().name(), e);
}
}
@@ -518,26 +516,26 @@ public class JpaRolloutExecutor implements RolloutExecutor {
return evaluationManager.getErrorConditionEvaluator(errorCondition).eval(rollout, rolloutGroup,
rolloutGroup.getErrorConditionExp());
} catch (final EvaluatorNotConfiguredException e) {
LOGGER.error("Something bad happened when accessing the error condition bean {}", errorCondition.name(), e);
log.error("Something bad happened when accessing the error condition bean {}", errorCondition.name(), e);
return false;
}
}
private boolean checkSuccessCondition(final Rollout rollout, final RolloutGroup rolloutGroup, final RolloutGroup evalProxy,
final RolloutGroupSuccessCondition successCondition) {
LOGGER.trace("Checking finish condition {} on rolloutgroup {}", successCondition, rolloutGroup);
log.trace("Checking finish condition {} on rolloutgroup {}", successCondition, rolloutGroup);
try {
final boolean isFinished = evaluationManager.getSuccessConditionEvaluator(successCondition).eval(rollout,
evalProxy, rolloutGroup.getSuccessConditionExp());
if (isFinished) {
LOGGER.debug("Rolloutgroup {} is finished, starting next group", rolloutGroup);
log.debug("Rolloutgroup {} is finished, starting next group", rolloutGroup);
executeRolloutGroupSuccessAction(rollout, rolloutGroup);
} else {
LOGGER.debug("Rolloutgroup {} is still running", rolloutGroup);
log.debug("Rolloutgroup {} is still running", rolloutGroup);
}
return isFinished;
} catch (final EvaluatorNotConfiguredException e) {
LOGGER.error("Something bad happened when accessing the finish condition or success action bean {}",
log.error("Something bad happened when accessing the finish condition or success action bean {}",
successCondition.name(), e);
return false;
}
@@ -548,7 +546,7 @@ public class JpaRolloutExecutor implements RolloutExecutor {
}
private void startFirstRolloutGroup(final Rollout rollout) {
LOGGER.debug("startFirstRolloutGroup called for rollout {}", rollout.getId());
log.debug("startFirstRolloutGroup called for rollout {}", rollout.getId());
RolloutHelper.verifyRolloutInStatus(rollout, RolloutStatus.STARTING);
final JpaRollout jpaRollout = (JpaRollout) rollout;
@@ -643,7 +641,7 @@ public class JpaRolloutExecutor implements RolloutExecutor {
return rolloutGroupRepository.save(group);
} catch (final TransactionException e) {
LOGGER.warn("Transaction assigning Targets to RolloutGroup failed", e);
log.warn("Transaction assigning Targets to RolloutGroup failed", e);
return group;
}
}
@@ -730,7 +728,7 @@ public class JpaRolloutExecutor implements RolloutExecutor {
return true;
}
} catch (final TransactionException e) {
LOGGER.warn("Transaction assigning Targets to RolloutGroup failed", e);
log.warn("Transaction assigning Targets to RolloutGroup failed", e);
}
return false;
}
@@ -817,7 +815,7 @@ public class JpaRolloutExecutor implements RolloutExecutor {
} while (actionsCreated > 0);
} catch (final TransactionException e) {
LOGGER.warn("Transaction assigning Targets to RolloutGroup failed", e);
log.warn("Transaction assigning Targets to RolloutGroup failed", e);
return 0;
}
return totalActionsCreated;

17
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/JpaRolloutHandler.java
View File

@@ -12,22 +12,21 @@ package org.eclipse.hawkbit.repository.jpa;
import java.util.List;
import java.util.concurrent.locks.Lock;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.ContextAware;
import org.eclipse.hawkbit.repository.RolloutExecutor;
import org.eclipse.hawkbit.repository.RolloutHandler;
import org.eclipse.hawkbit.repository.RolloutManagement;
import org.eclipse.hawkbit.repository.jpa.utils.DeploymentHelper;
import org.eclipse.hawkbit.tenancy.TenantAware;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.integration.support.locks.LockRegistry;
import org.springframework.transaction.PlatformTransactionManager;
/**
* JPA implementation of {@link RolloutHandler}.
*/
@Slf4j
public class JpaRolloutHandler implements RolloutHandler {
private static final Logger LOGGER = LoggerFactory.getLogger(JpaRolloutHandler.class);
private final TenantAware tenantAware;
private final RolloutManagement rolloutManagement;
@@ -73,18 +72,18 @@ public class JpaRolloutHandler implements RolloutHandler {
final String handlerId = createRolloutLockKey(tenantAware.getCurrentTenant());
final Lock lock = lockRegistry.obtain(handlerId);
if (!lock.tryLock()) {
if (LOGGER.isTraceEnabled()) {
LOGGER.trace("Could not perform lock {}", lock);
if (log.isTraceEnabled()) {
log.trace("Could not perform lock {}", lock);
}
return;
}
try {
LOGGER.trace("Trigger handling {} rollouts.", rollouts.size());
log.trace("Trigger handling {} rollouts.", rollouts.size());
rollouts.forEach(rolloutId -> handleRolloutInNewTransaction(rolloutId, handlerId));
} finally {
if (LOGGER.isTraceEnabled()) {
LOGGER.trace("Unlock lock {}", lock);
if (log.isTraceEnabled()) {
log.trace("Unlock lock {}", lock);
}
lock.unlock();
}
@@ -114,7 +113,7 @@ public class JpaRolloutHandler implements RolloutHandler {
})
);
},
() -> LOGGER.error("Could not retrieve rollout with id {}. Will not continue with execution.",
() -> log.error("Could not retrieve rollout with id {}. Will not continue with execution.",
rolloutId));
return 0L;
});

10
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/autoassign/AbstractAutoAssignExecutor.java
View File

@@ -12,6 +12,7 @@ package org.eclipse.hawkbit.repository.jpa.autoassign;
import java.util.List;
import java.util.function.Consumer;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.ContextAware;
import org.eclipse.hawkbit.repository.DeploymentManagement;
import org.eclipse.hawkbit.repository.TargetFilterQueryManagement;
@@ -21,8 +22,6 @@ import org.eclipse.hawkbit.repository.model.Action;
import org.eclipse.hawkbit.repository.model.DeploymentRequest;
import org.eclipse.hawkbit.repository.model.TargetFilterQuery;
import org.eclipse.hawkbit.tenancy.TenantAware;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Slice;
@@ -33,10 +32,9 @@ import org.springframework.util.StringUtils;
/**
* Abstract implementation of an AutoAssignExecutor
*/
@Slf4j
public abstract class AbstractAutoAssignExecutor implements AutoAssignExecutor {
private static final Logger LOGGER = LoggerFactory.getLogger(AbstractAutoAssignExecutor.class);
/**
* The message which is added to the action status when a distribution set is
* assigned to an target. First %s is the name of the target filter.
@@ -115,10 +113,10 @@ public abstract class AbstractAutoAssignExecutor implements AutoAssignExecutor {
})
);
} catch (final RuntimeException ex) {
LOGGER.debug(
log.debug(
"Exception on forEachFilterWithAutoAssignDS execution for tenant {} with filter id {}. Continue with next filter query.",
filterQuery.getTenant(), filterQuery.getId(), ex);
LOGGER.error(
log.error(
"Exception on forEachFilterWithAutoAssignDS execution for tenant {} with filter id {} and error message [{}]. "
+ "Continue with next filter query.",
filterQuery.getTenant(), filterQuery.getId(), ex.getMessage());

11
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/autoassign/AutoAssignScheduler.java
View File

@@ -11,20 +11,19 @@ package org.eclipse.hawkbit.repository.jpa.autoassign;
import java.util.concurrent.locks.Lock;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.repository.SystemManagement;
import org.eclipse.hawkbit.repository.autoassign.AutoAssignExecutor;
import org.eclipse.hawkbit.security.SystemSecurityContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.integration.support.locks.LockRegistry;
import org.springframework.scheduling.annotation.Scheduled;
/**
* Scheduler to check target filters for auto assignment of distribution sets
*/
@Slf4j
public class AutoAssignScheduler {
private static final Logger LOGGER = LoggerFactory.getLogger(AutoAssignScheduler.class);
private static final String PROP_SCHEDULER_DELAY_PLACEHOLDER = "${hawkbit.autoassign.scheduler.fixedDelay:2000}";
private final SystemManagement systemManagement;
@@ -83,11 +82,11 @@ public class AutoAssignScheduler {
}
try {
LOGGER.debug("Auto assign scheduled execution has acquired lock and started for each tenant.");
log.debug("Auto assign scheduled execution has acquired lock and started for each tenant.");
systemManagement.forEachTenant(tenant -> autoAssignExecutor.checkAllTargets());
} finally {
lock.unlock();
LOGGER.debug("Auto assign scheduled execution has released lock and finished.");
log.debug("Auto assign scheduled execution has released lock and finished.");
}
return null;

10
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/autocleanup/AutoActionCleanup.java
View File

@@ -20,13 +20,12 @@ import java.util.EnumSet;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.repository.DeploymentManagement;
import org.eclipse.hawkbit.repository.TenantConfigurationManagement;
import org.eclipse.hawkbit.repository.model.Action;
import org.eclipse.hawkbit.repository.model.Action.Status;
import org.eclipse.hawkbit.repository.model.TenantConfigurationValue;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* A cleanup task for {@link Action} entities which can be used to delete
@@ -37,10 +36,9 @@ import org.slf4j.LoggerFactory;
* The cleanup task can be enabled /disabled and configured on a per tenant
* basis.
*/
@Slf4j
public class AutoActionCleanup implements CleanupTask {
private static final Logger LOGGER = LoggerFactory.getLogger(AutoActionCleanup.class);
private static final String ID = "action-cleanup";
private static final boolean ACTION_CLEANUP_ENABLED_DEFAULT = false;
private static final long ACTION_CLEANUP_ACTION_EXPIRY_DEFAULT = TimeUnit.DAYS.toMillis(30);
@@ -67,7 +65,7 @@ public class AutoActionCleanup implements CleanupTask {
public void run() {
if (!isEnabled()) {
LOGGER.debug("Action cleanup is disabled for this tenant...");
log.debug("Action cleanup is disabled for this tenant...");
return;
}
@@ -75,7 +73,7 @@ public class AutoActionCleanup implements CleanupTask {
if (!status.isEmpty()) {
final long lastModified = System.currentTimeMillis() - getExpiry();
final int actionsCount = deploymentMgmt.deleteActionsByStatusAndLastModifiedBefore(status, lastModified);
LOGGER.debug("Deleted {} actions in status {} which have not been modified since {} ({})", actionsCount,
log.debug("Deleted {} actions in status {} which have not been modified since {} ({})", actionsCount,
status, Instant.ofEpochMilli(lastModified), lastModified);
}
}

14
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/configuration/Constants.java
View File

@@ -9,13 +9,15 @@
*/
package org.eclipse.hawkbit.repository.jpa.configuration;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Retryable;
/**
* A constant class which holds only static constants used within the SP server.
*
*/
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public final class Constants {
/**
@@ -26,22 +28,12 @@ public final class Constants {
* number.
*/
public static final int MAX_ENTRIES_IN_STATEMENT = 999;
/**
* @see Retryable#maxAttempts()
*/
public static final int TX_RT_MAX = 10;
/**
* @see Backoff#delay()
*/
public static final long TX_RT_DELAY = 100;
/**
* Constant class only private constructor.
*/
private Constants() {
}
}

3
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/configuration/MultiTenantJpaTransactionManager.java
View File

@@ -9,6 +9,7 @@
*/
package org.eclipse.hawkbit.repository.jpa.configuration;
import java.io.Serial;
import java.util.Objects;
import jakarta.persistence.EntityManager;
@@ -30,6 +31,8 @@ import org.springframework.transaction.support.TransactionSynchronizationManager
*
*/
public class MultiTenantJpaTransactionManager extends JpaTransactionManager {
@Serial
private static final long serialVersionUID = 1L;
@Autowired

10
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/event/JpaEventEntityManager.java
View File

@@ -24,16 +24,13 @@ import org.springframework.transaction.annotation.Transactional;
public class JpaEventEntityManager implements EventEntityManager {
private final TenantAware tenantAware;
private final EntityManager entityManager;
/**
* Constructor.
*
* @param tenantAware
* the tenant aware
* @param entityManager
* the entity manager
* @param tenantAware the tenant aware
* @param entityManager the entity manager
*/
public JpaEventEntityManager(final TenantAware tenantAware, final EntityManager entityManager) {
this.tenantAware = tenantAware;
@@ -45,5 +42,4 @@ public class JpaEventEntityManager implements EventEntityManager {
final Class<E> entityType) {
return tenantAware.runAsTenant(tenant, () -> entityManager.find(entityType, id));
}
}
}

19
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/executor/AfterTransactionCommitDefaultServiceExecutor.java
View File

@@ -12,19 +12,18 @@ package org.eclipse.hawkbit.repository.jpa.executor;
import java.util.ArrayList;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.transaction.support.TransactionSynchronizationAdapter;
import org.springframework.transaction.support.TransactionSynchronizationManager;
/**
*
* A Service which calls register runnable. This runnables will executed after a
* successful spring transaction commit.The class is thread safe.
*/
@Slf4j
public class AfterTransactionCommitDefaultServiceExecutor extends TransactionSynchronizationAdapter
implements AfterTransactionCommitExecutor {
private static final Logger LOGGER = LoggerFactory.getLogger(AfterTransactionCommitDefaultServiceExecutor.class);
private static final ThreadLocal<List<Runnable>> THREAD_LOCAL_RUNNABLES = new ThreadLocal<>();
@Override
@@ -32,13 +31,13 @@ public class AfterTransactionCommitDefaultServiceExecutor extends TransactionSyn
@SuppressWarnings({ "squid:S1217" })
public void afterCommit() {
final List<Runnable> afterCommitRunnables = THREAD_LOCAL_RUNNABLES.get();
LOGGER.debug("Transaction successfully committed, executing {} runnables", afterCommitRunnables.size());
log.debug("Transaction successfully committed, executing {} runnables", afterCommitRunnables.size());
for (final Runnable afterCommitRunnable : afterCommitRunnables) {
LOGGER.debug("Executing runnable {}", afterCommitRunnable);
log.debug("Executing runnable {}", afterCommitRunnable);
try {
afterCommitRunnable.run();
} catch (final RuntimeException e) {
LOGGER.error("Failed to execute runnable " + afterCommitRunnable, e);
log.error("Failed to execute runnable " + afterCommitRunnable, e);
}
}
}
@@ -47,7 +46,7 @@ public class AfterTransactionCommitDefaultServiceExecutor extends TransactionSyn
// Exception squid:S1217 - we want to run this synchronous
@SuppressWarnings("squid:S1217")
public void afterCommit(final Runnable runnable) {
LOGGER.debug("Submitting new runnable {} to run after transaction commit", runnable);
log.debug("Submitting new runnable {} to run after transaction commit", runnable);
if (TransactionSynchronizationManager.isSynchronizationActive()) {
List<Runnable> localRunnables = THREAD_LOCAL_RUNNABLES.get();
if (localRunnables == null) {
@@ -58,7 +57,7 @@ public class AfterTransactionCommitDefaultServiceExecutor extends TransactionSyn
localRunnables.add(runnable);
return;
}
LOGGER.info("Transaction synchronization is NOT ACTIVE/ INACTIVE. Executing right now runnable {}", runnable);
log.info("Transaction synchronization is NOT ACTIVE/ INACTIVE. Executing right now runnable {}", runnable);
runnable.run();
}
@@ -67,7 +66,7 @@ public class AfterTransactionCommitDefaultServiceExecutor extends TransactionSyn
@SuppressWarnings({ "squid:S1217" })
public void afterCompletion(final int status) {
final String transactionStatus = status == STATUS_COMMITTED ? "COMMITTED" : "ROLLEDBACK";
LOGGER.debug("Transaction completed after commit with status {}", transactionStatus);
log.debug("Transaction completed after commit with status {}", transactionStatus);
THREAD_LOCAL_RUNNABLES.remove();
}

13
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/management/JpaArtifactManagement.java
View File

@@ -13,6 +13,7 @@ import java.io.IOException;
import java.io.InputStream;
import java.util.Optional;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.artifact.repository.ArtifactRepository;
import org.eclipse.hawkbit.artifact.repository.ArtifactStoreException;
import org.eclipse.hawkbit.artifact.repository.HashNotMatchException;
@@ -46,8 +47,6 @@ import org.eclipse.hawkbit.repository.model.Artifact;
import org.eclipse.hawkbit.repository.model.ArtifactUpload;
import org.eclipse.hawkbit.repository.model.SoftwareModule;
import org.eclipse.hawkbit.tenancy.TenantAware;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.ConcurrencyFailureException;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
@@ -63,14 +62,12 @@ import jakarta.persistence.EntityManager;
/**
* JPA based {@link ArtifactManagement} implementation.
*
*/
@Slf4j
@Transactional(readOnly = true)
@Validated
public class JpaArtifactManagement implements ArtifactManagement {
private static final Logger LOG = LoggerFactory.getLogger(JpaArtifactManagement.class);
private final EntityManager entityManager;
private final LocalArtifactRepository localArtifactRepository;
@@ -111,7 +108,7 @@ public class JpaArtifactManagement implements ArtifactManagement {
final Artifact existing = softwareModule.getArtifactByFilename(filename).orElse(null);
if (existing != null) {
if (artifactUpload.isOverrideExisting()) {
LOG.debug("overriding existing artifact with new filename {}", filename);
log.debug("overriding existing artifact with new filename {}", filename);
} else {
throw new EntityAlreadyExistsException("File with that name already exists in the Software Module");
}
@@ -204,7 +201,7 @@ public class JpaArtifactManagement implements ArtifactManagement {
@Override
public void afterCommit() {
try {
LOG.debug("deleting artifact from repository {}", sha1Hash);
log.debug("deleting artifact from repository {}", sha1Hash);
artifactRepository.deleteBySha1(tenantAware.getCurrentTenant(), sha1Hash);
} catch (final ArtifactStoreException e) {
throw new ArtifactDeleteFailedException(e);
@@ -319,7 +316,7 @@ public class JpaArtifactManagement implements ArtifactManagement {
artifact.setSha256Hash(result.getHashes().getSha256());
artifact.setSize(result.getSize());
LOG.debug("storing new artifact into repository {}", artifact);
log.debug("storing new artifact into repository {}", artifact);
return localArtifactRepository.save(AccessController.Operation.CREATE, artifact);
}

19
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/management/JpaDistributionSetInvalidationManagement.java
View File

@@ -13,6 +13,7 @@ import java.util.Collection;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.repository.DeploymentManagement;
import org.eclipse.hawkbit.repository.DistributionSetInvalidationManagement;
import org.eclipse.hawkbit.repository.DistributionSetManagement;
@@ -29,19 +30,15 @@ import org.eclipse.hawkbit.repository.model.DistributionSetInvalidation.Cancelat
import org.eclipse.hawkbit.repository.model.DistributionSetInvalidationCount;
import org.eclipse.hawkbit.security.SystemSecurityContext;
import org.eclipse.hawkbit.tenancy.TenantAware;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.integration.support.locks.LockRegistry;
import org.springframework.transaction.PlatformTransactionManager;
/**
* Jpa implementation for {@link DistributionSetInvalidationManagement}
*
*/
@Slf4j
public class JpaDistributionSetInvalidationManagement implements DistributionSetInvalidationManagement {
private static final Logger LOG = LoggerFactory.getLogger(JpaDistributionSetInvalidationManagement.class);
private final DistributionSetManagement distributionSetManagement;
private final RolloutManagement rolloutManagement;
private final DeploymentManagement deploymentManagement;
@@ -73,7 +70,7 @@ public class JpaDistributionSetInvalidationManagement implements DistributionSet
@Override
public void invalidateDistributionSet(final DistributionSetInvalidation distributionSetInvalidation) {
LOG.debug("Invalidate distribution sets {}", distributionSetInvalidation.getDistributionSetIds());
log.debug("Invalidate distribution sets {}", distributionSetInvalidation.getDistributionSetIds());
final String tenant = tenantAware.getCurrentTenant();
if (shouldRolloutsBeCanceled(distributionSetInvalidation.getCancelationType(),
distributionSetInvalidation.isCancelRollouts())) {
@@ -89,7 +86,7 @@ public class JpaDistributionSetInvalidationManagement implements DistributionSet
lock.unlock();
}
} catch (final InterruptedException e) {
LOG.error("InterruptedException while invalidating distribution sets {}!",
log.error("InterruptedException while invalidating distribution sets {}!",
distributionSetInvalidation.getDistributionSetIds(), e);
Thread.currentThread().interrupt();
}
@@ -113,22 +110,22 @@ public class JpaDistributionSetInvalidationManagement implements DistributionSet
final boolean cancelRollouts) {
final DistributionSet set = distributionSetManagement.getValidAndComplete(setId);
distributionSetManagement.invalidate(set);
LOG.debug("Distribution set {} marked as invalid.", setId);
log.debug("Distribution set {} marked as invalid.", setId);
// rollout cancellation should only be permitted with UPDATE_ROLLOUT permission
if (shouldRolloutsBeCanceled(cancelationType, cancelRollouts)) {
LOG.debug("Cancel rollouts after ds invalidation. ID: {}", setId);
log.debug("Cancel rollouts after ds invalidation. ID: {}", setId);
rolloutManagement.cancelRolloutsForDistributionSet(set);
}
// Do run as system to ensure all actions (even invisible) are canceled due to invalidation.
systemSecurityContext.runAsSystem(() -> {
if (cancelationType != CancelationType.NONE) {
LOG.debug("Cancel actions after ds invalidation. ID: {}", setId);
log.debug("Cancel actions after ds invalidation. ID: {}", setId);
deploymentManagement.cancelActionsForDistributionSet(cancelationType, set);
}
LOG.debug("Cancel auto assignments after ds invalidation. ID: {}", setId);
log.debug("Cancel auto assignments after ds invalidation. ID: {}", setId);
targetFilterQueryManagement.cancelAutoAssignmentForDistributionSet(setId);
return null;
});

13
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/management/JpaSystemManagement.java
View File

@@ -13,6 +13,7 @@ import java.util.function.Consumer;
import jakarta.persistence.EntityManager;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.artifact.repository.ArtifactRepository;
import org.eclipse.hawkbit.cache.TenancyCacheManager;
import org.eclipse.hawkbit.repository.RepositoryProperties;
@@ -48,8 +49,6 @@ import org.eclipse.hawkbit.repository.report.model.SystemUsageReportWithTenants;
import org.eclipse.hawkbit.security.SystemSecurityContext;
import org.eclipse.hawkbit.tenancy.TenantAware;
import org.eclipse.persistence.config.PersistenceUnitProperties;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.cache.annotation.Cacheable;
@@ -68,14 +67,12 @@ import org.springframework.validation.annotation.Validated;
/**
* JPA implementation of {@link SystemManagement}.
*
*/
@Slf4j
@Transactional(readOnly = true)
@Validated
public class JpaSystemManagement implements CurrentTenantCacheKeyGenerator, SystemManagement {
private static final Logger LOGGER = LoggerFactory.getLogger(JpaSystemManagement.class);
private static final int MAX_TENANTS_QUERY = 1000;
@Autowired
@@ -262,7 +259,7 @@ public class JpaSystemManagement implements CurrentTenantCacheKeyGenerator, Syst
final TenantMetaData metaData = tenantMetaDataRepository.findByTenantIgnoreCase(tenant);
if (metaData == null) {
if (repositoryProperties.isImplicitTenantCreateAllowed()) {
LOGGER.info("Tenant {} doesn't exist create metadata", tenant, new Exception("Thread dump"));
log.info("Tenant {} doesn't exist create metadata", tenant, new Exception("Thread dump"));
return createTenantMetadata0(tenant);
} else {
throw new EntityNotFoundException(TenantMetaData.class, tenant);
@@ -344,9 +341,9 @@ public class JpaSystemManagement implements CurrentTenantCacheKeyGenerator, Syst
try {
consumer.accept(tenant);
} catch (final RuntimeException ex) {
LOGGER.debug("Exception on forEachTenant execution for tenant {}. Continue with next tenant.",
log.debug("Exception on forEachTenant execution for tenant {}. Continue with next tenant.",
tenant, ex);
LOGGER.error("Exception on forEachTenant execution for tenant {} with error message [{}]. "
log.error("Exception on forEachTenant execution for tenant {} with error message [{}]. "
+ "Continue with next tenant.", tenant, ex.getMessage());
}
return null;

11
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/management/JpaTargetFilterQueryManagement.java
View File

@@ -16,6 +16,7 @@ import java.util.Optional;
import jakarta.validation.constraints.NotNull;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.repository.DistributionSetManagement;
import org.eclipse.hawkbit.repository.QuotaManagement;
import org.eclipse.hawkbit.repository.RepositoryProperties;
@@ -50,8 +51,6 @@ import org.eclipse.hawkbit.repository.model.TargetFilterQuery;
import org.eclipse.hawkbit.repository.rsql.VirtualPropertyReplacer;
import org.eclipse.hawkbit.security.SystemSecurityContext;
import org.eclipse.hawkbit.utils.TenantConfigHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.ConcurrencyFailureException;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
@@ -68,14 +67,12 @@ import cz.jirutka.rsql.parser.RSQLParserException;
/**
* JPA implementation of {@link TargetFilterQueryManagement}.
*
*/
@Slf4j
@Transactional(readOnly = true)
@Validated
public class JpaTargetFilterQueryManagement implements TargetFilterQueryManagement {
private static final Logger LOGGER = LoggerFactory.getLogger(JpaTargetFilterQueryManagement.class);
private final TargetFilterQueryRepository targetFilterQueryRepository;
private final TargetManagement targetManagement;
@@ -331,7 +328,7 @@ public class JpaTargetFilterQueryManagement implements TargetFilterQueryManageme
RSQLUtility.validateRsqlFor(query, TargetFields.class);
return true;
} catch (final RSQLParserException | RSQLParameterUnsupportedFieldException e) {
LOGGER.debug("The RSQL query '" + query + "' is invalid.", e);
log.debug("The RSQL query '" + query + "' is invalid.", e);
return false;
}
}
@@ -346,6 +343,6 @@ public class JpaTargetFilterQueryManagement implements TargetFilterQueryManageme
@Transactional
public void cancelAutoAssignmentForDistributionSet(final long distributionSetId) {
targetFilterQueryRepository.unsetAutoAssignDistributionSetAndActionTypeAndAccessContext(distributionSetId);
LOGGER.debug("Auto assignments for distribution sets {} deactivated", distributionSetId);
log.debug("Auto assignments for distribution sets {} deactivated", distributionSetId);
}
}

14
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/management/JpaTenantConfigurationManagement.java
View File

@@ -20,6 +20,7 @@ import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.repository.TenantConfigurationManagement;
import org.eclipse.hawkbit.repository.exception.TenantConfigurationValueChangeNotAllowedException;
import org.eclipse.hawkbit.repository.jpa.configuration.Constants;
@@ -31,8 +32,6 @@ import org.eclipse.hawkbit.repository.model.TenantConfigurationValue;
import org.eclipse.hawkbit.tenancy.configuration.TenantConfigurationProperties;
import org.eclipse.hawkbit.tenancy.configuration.TenantConfigurationProperties.TenantConfigurationKey;
import org.eclipse.hawkbit.tenancy.configuration.validator.TenantConfigurationValidatorException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
@@ -50,12 +49,11 @@ import org.springframework.validation.annotation.Validated;
/**
* Central tenant configuration management operations of the SP server.
*/
@Slf4j
@Transactional(readOnly = true)
@Validated
public class JpaTenantConfigurationManagement implements TenantConfigurationManagement {
private static final Logger LOG = LoggerFactory.getLogger(JpaTenantConfigurationManagement.class);
@Autowired
private TenantConfigurationRepository tenantConfigurationRepository;
@@ -241,7 +239,7 @@ public class JpaTenantConfigurationManagement implements TenantConfigurationMana
private void assertAutoCloseValueChange(final String key, final JpaTenantConfiguration valueChange) {
if (REPOSITORY_ACTIONS_AUTOCLOSE_ENABLED.equals(key)
&& getConfigurationValue(MULTI_ASSIGNMENTS_ENABLED, Boolean.class).getValue()) {
LOG.debug(
log.debug(
"The property '{}' must not be changed because the Multi-Assignments feature is currently enabled.",
key);
throw new TenantConfigurationValueChangeNotAllowedException();
@@ -250,13 +248,13 @@ public class JpaTenantConfigurationManagement implements TenantConfigurationMana
private void assertMultiAssignmentsValueChange(final String key, final JpaTenantConfiguration valueChange) {
if (MULTI_ASSIGNMENTS_ENABLED.equals(key) && !Boolean.parseBoolean(valueChange.getValue())) {
LOG.debug("The Multi-Assignments '{}' feature cannot be disabled.", key);
log.debug("The Multi-Assignments '{}' feature cannot be disabled.", key);
throw new TenantConfigurationValueChangeNotAllowedException();
}
if (MULTI_ASSIGNMENTS_ENABLED.equals(key) && Boolean.parseBoolean(valueChange.getValue())) {
JpaTenantConfiguration batchConfig = tenantConfigurationRepository.findByKey(BATCH_ASSIGNMENTS_ENABLED);
if (batchConfig!=null && Boolean.parseBoolean(batchConfig.getValue())) {
LOG.debug("The Multi-Assignments '{}' feature cannot be enabled as it contradicts with " +
log.debug("The Multi-Assignments '{}' feature cannot be enabled as it contradicts with " +
"The Batch-Assignments feature, which is already enabled .", key);
throw new TenantConfigurationValueChangeNotAllowedException();
}
@@ -267,7 +265,7 @@ public class JpaTenantConfigurationManagement implements TenantConfigurationMana
if (BATCH_ASSIGNMENTS_ENABLED.equals(key) && Boolean.parseBoolean(valueChange.getValue())) {
JpaTenantConfiguration multiConfig = tenantConfigurationRepository.findByKey(MULTI_ASSIGNMENTS_ENABLED);
if (multiConfig != null && Boolean.parseBoolean(multiConfig.getValue())) {
LOG.debug("The Batch-Assignments '{}' feature cannot be enabled as it contradicts with " +
log.debug("The Batch-Assignments '{}' feature cannot be enabled as it contradicts with " +
"The Multi-Assignments feature, which is already enabled .", key);
throw new TenantConfigurationValueChangeNotAllowedException();
}

11
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/model/JpaTarget.java
View File

@@ -9,6 +9,7 @@
*/
package org.eclipse.hawkbit.repository.jpa.model;
import java.io.Serial;
import java.net.URI;
import java.time.Duration;
import java.time.Instant;
@@ -45,6 +46,7 @@ import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Pattern;
import jakarta.validation.constraints.Size;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.im.authentication.SpPermission;
import org.eclipse.hawkbit.repository.event.remote.TargetDeletedEvent;
import org.eclipse.hawkbit.repository.event.remote.entity.TargetCreatedEvent;
@@ -70,12 +72,9 @@ import org.eclipse.persistence.annotations.ConversionValue;
import org.eclipse.persistence.annotations.Convert;
import org.eclipse.persistence.annotations.ObjectTypeConverter;
import org.eclipse.persistence.descriptors.DescriptorEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* JPA implementation of {@link Target}.
*
*/
@Entity
@Table(name = "sp_target", indexes = {
@@ -88,12 +87,12 @@ import org.slf4j.LoggerFactory;
// exception squid:S2160 - BaseEntity equals/hashcode is handling correctly for
// sub entities
@SuppressWarnings("squid:S2160")
@Slf4j
public class JpaTarget extends AbstractJpaNamedEntity implements Target, EventAwareEntity {
@Serial
private static final long serialVersionUID = 1L;
private static final Logger LOG = LoggerFactory.getLogger(JpaTarget.class);
private static final List<String> TARGET_UPDATE_EVENT_IGNORE_FIELDS = Arrays.asList("lastTargetQuery", "address",
"optLockRevision", "lastModifiedAt", "lastModifiedBy");
@@ -347,7 +346,7 @@ public class JpaTarget extends AbstractJpaNamedEntity implements Target, EventAw
try {
return URI.create(address);
} catch (final IllegalArgumentException e) {
LOG.warn("Invalid address provided. Cloud not be configured to URI", e);
log.warn("Invalid address provided. Cloud not be configured to URI", e);
return null;
}
}

8
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rollout/RolloutScheduler.java
View File

@@ -9,11 +9,10 @@
*/
package org.eclipse.hawkbit.repository.jpa.rollout;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.repository.RolloutHandler;
import org.eclipse.hawkbit.repository.SystemManagement;
import org.eclipse.hawkbit.security.SystemSecurityContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
/**
@@ -21,10 +20,9 @@ import org.springframework.scheduling.annotation.Scheduled;
* delay between the checks be configured using the property from
* {#PROP_SCHEDULER_DELAY_PLACEHOLDER}.
*/
@Slf4j
public class RolloutScheduler {
private static final Logger LOGGER = LoggerFactory.getLogger(RolloutScheduler.class);
private static final String PROP_SCHEDULER_DELAY_PLACEHOLDER = "${hawkbit.rollout.scheduler.fixedDelay:2000}";
private final SystemManagement systemManagement;
@@ -58,7 +56,7 @@ public class RolloutScheduler {
*/
@Scheduled(initialDelayString = PROP_SCHEDULER_DELAY_PLACEHOLDER, fixedDelayString = PROP_SCHEDULER_DELAY_PLACEHOLDER)
public void runningRolloutScheduler() {
LOGGER.debug("rollout schedule checker has been triggered.");
log.debug("rollout schedule checker has been triggered.");
// run this code in system code privileged to have the necessary
// permission to query and create entities.

13
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rollout/condition/RolloutGroupEvaluationManager.java
View File

@@ -11,9 +11,8 @@ package org.eclipse.hawkbit.repository.jpa.rollout.condition;
import java.util.List;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.repository.model.RolloutGroup;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Manager class to collect all instances of
@@ -21,10 +20,9 @@ import org.slf4j.LoggerFactory;
* {@link RolloutGroupActionEvaluator} for specific conditions and actions. The
* corresponding instance can be fetched by providing the action/condition.
*/
@Slf4j
public class RolloutGroupEvaluationManager {
private static final Logger LOGGER = LoggerFactory.getLogger(RolloutGroupEvaluationManager.class);
private final List<RolloutGroupConditionEvaluator<RolloutGroup.RolloutGroupErrorCondition>> errorConditionEvaluators;
private final List<RolloutGroupConditionEvaluator<RolloutGroup.RolloutGroupSuccessCondition>> successConditionEvaluators;
private final List<RolloutGroupActionEvaluator<RolloutGroup.RolloutGroupErrorAction>> errorActionEvaluators;
@@ -82,7 +80,7 @@ public class RolloutGroupEvaluationManager {
private static <T extends Enum<T>> RolloutGroupActionEvaluator<T> findFirstActionEvaluator(
final List<RolloutGroupActionEvaluator<T>> evaluators, final T action) {
return evaluators.stream().filter(evaluator -> evaluator.getAction() == action).findFirst().orElseThrow(() -> {
LOGGER.warn("Could not find suitable evaluator for the '{}' action.", action.name());
log.warn("Could not find suitable evaluator for the '{}' action.", action.name());
throw new EvaluatorNotConfiguredException(action.name());
});
}
@@ -91,9 +89,8 @@ public class RolloutGroupEvaluationManager {
final List<RolloutGroupConditionEvaluator<T>> evaluators, final T condition) {
return evaluators.stream().filter(evaluator -> evaluator.getCondition() == condition).findFirst()
.orElseThrow(() -> {
LOGGER.warn("Could not find suitable evaluator for the '{}' condition.", condition.name());
log.warn("Could not find suitable evaluator for the '{}' condition.", condition.name());
throw new EvaluatorNotConfiguredException(condition.name());
});
}
}
}

10
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rollout/condition/ThresholdRolloutGroupErrorCondition.java
View File

@@ -9,23 +9,19 @@
*/
package org.eclipse.hawkbit.repository.jpa.rollout.condition;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.repository.jpa.repository.ActionRepository;
import org.eclipse.hawkbit.repository.jpa.model.JpaRollout;
import org.eclipse.hawkbit.repository.jpa.model.JpaRolloutGroup;
import org.eclipse.hawkbit.repository.model.Action;
import org.eclipse.hawkbit.repository.model.Rollout;
import org.eclipse.hawkbit.repository.model.RolloutGroup;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Evaluates if the {@link RolloutGroup#getErrorConditionExp()} is reached.
*/
@Slf4j
public class ThresholdRolloutGroupErrorCondition
implements RolloutGroupConditionEvaluator<RolloutGroup.RolloutGroupErrorCondition> {
private static final Logger LOGGER = LoggerFactory.getLogger(ThresholdRolloutGroupErrorCondition.class);
private final ActionRepository actionRepository;
public ThresholdRolloutGroupErrorCondition(final ActionRepository actionRepository) {
@@ -54,7 +50,7 @@ public class ThresholdRolloutGroupErrorCondition
// calculate threshold
return ((float) error / (float) totalGroup) > ((float) threshold / 100F);
} catch (final NumberFormatException e) {
LOGGER.error("Cannot evaluate condition expression " + expression, e);
log.error("Cannot evaluate condition expression " + expression, e);
return false;
}
}

10
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rollout/condition/ThresholdRolloutGroupSuccessCondition.java
View File

@@ -9,20 +9,19 @@
*/
package org.eclipse.hawkbit.repository.jpa.rollout.condition;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.repository.jpa.repository.ActionRepository;
import org.eclipse.hawkbit.repository.model.Action;
import org.eclipse.hawkbit.repository.model.Rollout;
import org.eclipse.hawkbit.repository.model.RolloutGroup;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Threshold to calculate if the {@link RolloutGroup#getSuccessConditionExp()} is reached and the
* next rollout group can get started.
*/
@Slf4j
public class ThresholdRolloutGroupSuccessCondition
implements RolloutGroupConditionEvaluator<RolloutGroup.RolloutGroupSuccessCondition> {
private static final Logger LOGGER = LoggerFactory.getLogger(ThresholdRolloutGroupSuccessCondition.class);
private final ActionRepository actionRepository;
@@ -55,9 +54,8 @@ public class ThresholdRolloutGroupSuccessCondition
return ((float) finished / (float) totalGroup) >= ((float) threshold / 100F);
} catch (final NumberFormatException e) {
LOGGER.error("Cannot evaluate condition expression " + expression, e);
log.error("Cannot evaluate condition expression " + expression, e);
return false;
}
}
}
}

8
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rsql/AbstractFieldNameRSQLVisitor.java
View File

@@ -15,17 +15,15 @@ import java.util.stream.Collectors;
import jakarta.validation.constraints.NotNull;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.repository.FieldNameProvider;
import org.eclipse.hawkbit.repository.exception.RSQLParameterUnsupportedFieldException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import cz.jirutka.rsql.parser.ast.ComparisonNode;
@Slf4j
public abstract class AbstractFieldNameRSQLVisitor<A extends Enum<A> & FieldNameProvider> {
private static final Logger LOGGER = LoggerFactory.getLogger(AbstractFieldNameRSQLVisitor.class);
private final Class<A> fieldNameProvider;
protected AbstractFieldNameRSQLVisitor(final Class<A> fieldNameProvider) {
@@ -38,7 +36,7 @@ public abstract class AbstractFieldNameRSQLVisitor<A extends Enum<A> & FieldName
if (graph.length != 0) {
enumName = graph[0];
}
LOGGER.debug("get field identifier by name {} of enum type {}", enumName, fieldNameProvider);
log.debug("get field identifier by name {} of enum type {}", enumName, fieldNameProvider);
try {
return Enum.valueOf(fieldNameProvider, enumName.toUpperCase());
} catch (final IllegalArgumentException e) {

19
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rsql/JpaQueryRsqlVisitor.java
View File

@@ -41,14 +41,13 @@ import cz.jirutka.rsql.parser.ast.LogicalNode;
import cz.jirutka.rsql.parser.ast.Node;
import cz.jirutka.rsql.parser.ast.OrNode;
import cz.jirutka.rsql.parser.ast.RSQLVisitor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.math.NumberUtils;
import org.eclipse.hawkbit.repository.FieldNameProvider;
import org.eclipse.hawkbit.repository.FieldValueConverter;
import org.eclipse.hawkbit.repository.exception.RSQLParameterSyntaxException;
import org.eclipse.hawkbit.repository.exception.RSQLParameterUnsupportedFieldException;
import org.eclipse.hawkbit.repository.rsql.VirtualPropertyReplacer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.SimpleTypeConverter;
import org.springframework.beans.TypeMismatchException;
import org.springframework.orm.jpa.vendor.Database;
@@ -59,17 +58,13 @@ import org.springframework.util.StringUtils;
* An implementation of the {@link RSQLVisitor} to visit the parsed tokens and
* build JPA where clauses.
*
* @param <A>
* the enum for providing the field name of the entity field to
* filter on.
* @param <T>
* the entity type referenced by the root
* @param <A> the enum for providing the field name of the entity field to filter on.
* @param <T> the entity type referenced by the root
*/
@Slf4j
public class JpaQueryRsqlVisitor<A extends Enum<A> & FieldNameProvider, T> extends AbstractFieldNameRSQLVisitor<A>
implements RSQLVisitor<List<Predicate>, String> {
private static final Logger LOGGER = LoggerFactory.getLogger(JpaQueryRsqlVisitor.class);
public static final Character LIKE_WILDCARD = '*';
private static final char ESCAPE_CHAR = '\\';
private static final List<String> NO_JOINS_OPERATOR = List.of("!=", "=out=");
@@ -296,9 +291,9 @@ public class JpaQueryRsqlVisitor<A extends Enum<A> & FieldNameProvider, T> exten
} catch (final IllegalArgumentException e) {
// we could not transform the given string value into the enum
// type, so ignore it and return null and do not filter
LOGGER.info("given value {} cannot be transformed into the correct enum type {}", value.toUpperCase(),
log.info("given value {} cannot be transformed into the correct enum type {}", value.toUpperCase(),
javaType);
LOGGER.debug("value cannot be transformed to an enum", e);
log.debug("value cannot be transformed to an enum", e);
throw new RSQLParameterUnsupportedFieldException("field {" + node.getSelector()
+ "} must be one of the following values {" + Arrays.stream(tmpEnumType.getEnumConstants())
@@ -596,7 +591,7 @@ public class JpaQueryRsqlVisitor<A extends Enum<A> & FieldNameProvider, T> exten
if (!CollectionUtils.isEmpty(accept)) {
childs.addAll(accept);
} else {
LOGGER.debug("visit logical node children but could not parse it, ignoring {}", node2);
log.debug("visit logical node children but could not parse it, ignoring {}", node2);
}
}
return childs;

19
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLUtility.java
View File

@@ -17,6 +17,9 @@ import jakarta.persistence.criteria.CriteriaQuery;
import jakarta.persistence.criteria.Predicate;
import jakarta.persistence.criteria.Root;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.text.StrLookup;
import org.eclipse.hawkbit.repository.FieldNameProvider;
import org.eclipse.hawkbit.repository.exception.RSQLParameterSyntaxException;
@@ -24,8 +27,6 @@ import org.eclipse.hawkbit.repository.exception.RSQLParameterUnsupportedFieldExc
import org.eclipse.hawkbit.repository.rsql.RsqlVisitorFactoryHolder;
import org.eclipse.hawkbit.repository.rsql.VirtualPropertyReplacer;
import org.eclipse.hawkbit.repository.rsql.VirtualPropertyResolver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.orm.jpa.vendor.Database;
import org.springframework.util.CollectionUtils;
@@ -69,19 +70,11 @@ import cz.jirutka.rsql.parser.ast.RSQLVisitor;
* <em>lastControllerRequestAt=le=${OVERDUE_TS}</em><br>
* It is possible to escape a macro expression by using a second '$':
* $${OVERDUE_TS} would prevent the ${OVERDUE_TS} token from being expanded.
*
*/
@Slf4j
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public final class RSQLUtility {
private static final Logger LOGGER = LoggerFactory.getLogger(RSQLUtility.class);
/**
* private constructor due utility class.
*/
private RSQLUtility() {
}
/**
* Builds a JPA {@link Specification} which corresponds with the given RSQL
* query. The specification can be used to filter for JPA entities with the
@@ -138,7 +131,7 @@ public final class RSQLUtility {
private static Node parseRsql(final String rsql) {
try {
LOGGER.debug("Parsing rsql string {}", rsql);
log.debug("Parsing rsql string {}", rsql);
final Set<ComparisonOperator> operators = RSQLOperators.defaultOperators();
return new RSQLParser(operators).parse(rsql.toLowerCase());
} catch (final IllegalArgumentException e) {

11
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rsql/RsqlParserValidationOracle.java
View File

@@ -22,6 +22,7 @@ import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.repository.TargetFields;
import org.eclipse.hawkbit.repository.exception.RSQLParameterSyntaxException;
import org.eclipse.hawkbit.repository.exception.RSQLParameterUnsupportedFieldException;
@@ -32,8 +33,6 @@ import org.eclipse.hawkbit.repository.rsql.SuggestionContext;
import org.eclipse.hawkbit.repository.rsql.SyntaxErrorContext;
import org.eclipse.hawkbit.repository.rsql.ValidationOracleContext;
import org.eclipse.persistence.exceptions.ConversionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.orm.jpa.JpaSystemException;
import org.springframework.util.CollectionUtils;
@@ -51,12 +50,10 @@ import cz.jirutka.rsql.parser.RSQLParserException;
* There is a feature request on the GitHub project
* <a href="https://github.com/jirutka/rsql-parser/issues/22">https://github.com
* /jirutka/rsql-parser/issues/22</a>
*
*/
@Slf4j
public class RsqlParserValidationOracle implements RsqlValidationOracle {
private static final Logger LOGGER = LoggerFactory.getLogger(RsqlParserValidationOracle.class);
@Override
public ValidationOracleContext suggest(final String rsqlQuery, final int cursorPosition) {
@@ -76,10 +73,10 @@ public class RsqlParserValidationOracle implements RsqlValidationOracle {
setExceptionDetails(rsqlQuery, new Exception(ex.getCause().getCause()), expectedTokens);
errorContext.setErrorMessage(getCustomMessage(ex.getCause().getMessage(), expectedTokens));
suggestionContext.setSuggestions(expectedTokens);
LOGGER.trace("Syntax exception on parsing :", ex);
log.trace("Syntax exception on parsing :", ex);
} catch (final RSQLParameterUnsupportedFieldException | IllegalArgumentException ex) {
errorContext.setErrorMessage(getCustomMessage(ex.getMessage(), null));
LOGGER.trace("Illegal argument on parsing :", ex);
log.trace("Illegal argument on parsing :", ex);
} catch (@SuppressWarnings("squid:S1166") final ConversionException | JpaSystemException e) {
// noop
}

16
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/utils/DeploymentHelper.java
View File

@@ -14,6 +14,9 @@ import java.util.function.Supplier;
import jakarta.validation.constraints.NotNull;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.repository.jpa.model.JpaAction_;
import org.eclipse.hawkbit.repository.jpa.repository.ActionRepository;
import org.eclipse.hawkbit.repository.jpa.repository.TargetRepository;
@@ -25,8 +28,6 @@ import org.eclipse.hawkbit.repository.model.Action.Status;
import org.eclipse.hawkbit.repository.model.TargetUpdateStatus;
import org.eclipse.hawkbit.security.SecurityContextTenantAware;
import org.eclipse.hawkbit.tenancy.TenantAware;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.domain.Sort;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
@@ -38,16 +39,11 @@ import org.springframework.util.StringUtils;
/**
* Utility class for deployment related topics.
*
*/
@Slf4j
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public final class DeploymentHelper {
private static final Logger LOG = LoggerFactory.getLogger(DeploymentHelper.class);
private DeploymentHelper() {
// utility class
}
/**
* This method is called, when cancellation has been successful. It sets the
* action to canceled, resets the meta data of the target and in case there
@@ -147,7 +143,7 @@ public final class DeploymentHelper {
return;
}
final String user = username.get();
LOG.debug("Switching user context from '{}' to '{}'", currentUser, user);
log.debug("Switching user context from '{}' to '{}'", currentUser, user);
tenantAware.runAsTenantAsUser(tenantAware.getCurrentTenant(), user, () -> {
handler.run();
return null;

17
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/utils/QuotaHelper.java
View File

@@ -13,20 +13,15 @@ import java.util.function.ToLongFunction;
import jakarta.validation.constraints.NotNull;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.repository.exception.AssignmentQuotaExceededException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Helper class to check quotas.
*/
@Slf4j
public final class QuotaHelper {
/**
* Class logger
*/
private static final Logger LOG = LoggerFactory.getLogger(QuotaHelper.class);
private static final String MAX_ASSIGNMENT_QUOTA_EXCEEDED = "Quota exceeded: Cannot assign %s entities at once. The maximum is %s.";
private QuotaHelper() {
@@ -112,13 +107,13 @@ public final class QuotaHelper {
// check if the quota is unlimited
if (limit <= 0) {
LOG.debug("Quota 'Max {} entities per {}' is unlimited.", type, parentType);
log.debug("Quota 'Max {} entities per {}' is unlimited.", type, parentType);
return;
}
if (requested > limit) {
final String parentIdStr = parentId != null ? String.valueOf(parentId) : "<new>";
LOG.warn("Cannot assign {} {} entities to {} '{}' because of the configured quota limit {}.", requested,
log.warn("Cannot assign {} {} entities to {} '{}' because of the configured quota limit {}.", requested,
type, parentType, parentIdStr, limit);
throw new AssignmentQuotaExceededException(type, parentType, parentId, requested, limit);
}
@@ -126,7 +121,7 @@ public final class QuotaHelper {
if (parentId != null && countFct != null) {
final long currentCount = countFct.applyAsLong(parentId);
if (currentCount + requested > limit) {
LOG.warn(
log.warn(
"Cannot assign {} {} entities to {} '{}' because of the configured quota limit {}. Currently, there are {} {} entities assigned.",
requested, type, parentType, parentId, limit, currentCount, type);
throw new AssignmentQuotaExceededException(type, parentType, parentId, requested, limit);
@@ -146,7 +141,7 @@ public final class QuotaHelper {
public static void assertAssignmentRequestSizeQuota(final long requested, final long limit) {
if (requested > limit) {
final String message = String.format(MAX_ASSIGNMENT_QUOTA_EXCEEDED, requested, limit);
LOG.warn(message);
log.warn(message);
throw new AssignmentQuotaExceededException(message);
}
}