@Override public String buildRefDesc(final Task task) { return taskUtilsFactory.getInstance(task).getType().name() + " " + "Task " + task.getKey() + " " + (task instanceof SchedTask ? SchedTask.class.cast(task).getName() : task instanceof PropagationTask ? PropagationTask.class.cast(task).getConnObjectKey() : StringUtils.EMPTY); }
@Override public TaskExec storeExec(final TaskExec execution) { NotificationTask task = taskDAO.find(execution.getTask().getKey()); task.add(execution); task.setExecuted(true); taskDAO.save(task); return execution; }
@Override public long countExecutionsWithStatus(final String taskKey, final String status) { NotificationTask task = taskDAO.find(taskKey); long count = 0; for (TaskExec taskExec : task.getExecs()) { if (status == null) { if (taskExec.getStatus() == null) { count++; } } else if (status.equals(taskExec.getStatus())) { count++; } } return count; }
@Override public ExecTO getExecTO(final TaskExec execution) { ExecTO execTO = new ExecTO(); execTO.setKey(execution.getKey()); execTO.setStatus(execution.getStatus()); execTO.setMessage(execution.getMessage()); execTO.setStart(execution.getStart()); execTO.setEnd(execution.getEnd()); if (execution.getTask() != null && execution.getTask().getKey() != null) { execTO.setJobType(JobType.TASK); execTO.setRefKey(execution.getTask().getKey()); execTO.setRefDesc(buildRefDesc(execution.getTask())); } return execTO; }
@PreAuthorize("hasRole('" + StandardEntitlement.TASK_CREATE + "')") public <T extends SchedTaskTO> T createSchedTask(final TaskType type, final T taskTO) { TaskUtils taskUtils = taskUtilsFactory.getInstance(taskTO); if (taskUtils.getType() != type) { SyncopeClientException sce = SyncopeClientException.build(ClientExceptionType.InvalidRequest); sce.getElements().add("Found " + type + ", expected " + taskUtils.getType()); throw sce; } SchedTask task = binder.createSchedTask(taskTO, taskUtils); task = taskDAO.save(task); try { jobManager.register( task, task.getStartAt(), confDAO.find("tasks.interruptMaxRetries", 1L)); } catch (Exception e) { LOG.error("While registering quartz job for task " + task.getKey(), e); SyncopeClientException sce = SyncopeClientException.build(ClientExceptionType.Scheduling); sce.getElements().add(e.getMessage()); throw sce; } return binder.getTaskTO(task, taskUtils, false); }
@Override public void updateSchedTask(final SchedTask task, final SchedTaskTO taskTO, final TaskUtils taskUtils) { Class<? extends TaskTO> taskTOClass = taskUtils.taskTOClass(); if (taskTOClass == null || !taskTOClass.equals(taskTO.getClass())) { throw new IllegalArgumentException(String.format("Expected %s, found %s", taskTOClass, taskTO.getClass())); } if (StringUtils.isBlank(taskTO.getName())) { SyncopeClientException sce = SyncopeClientException.build(ClientExceptionType.RequiredValuesMissing); sce.getElements().add("name"); throw sce; } task.setName(taskTO.getName()); task.setDescription(taskTO.getDescription()); task.setCronExpression(taskTO.getCronExpression()); task.setActive(taskTO.isActive()); if (task instanceof ProvisioningTask) { fill((ProvisioningTask) task, (ProvisioningTaskTO) taskTO); } }
/** * Check whether an execution has to be stored, for a given task. * * @param task propagation task * @param execution to be decide whether to store or not * @return true if execution has to be store, false otherwise */ protected boolean hasToBeregistered(final PropagationTask task, final TaskExec execution) { boolean result; boolean failed = ExecStatus.valueOf(execution.getStatus()) != ExecStatus.SUCCESS; switch (task.getOperation()) { case CREATE: result = (failed && task.getResource().getCreateTraceLevel().ordinal() >= TraceLevel.FAILURES.ordinal()) || task.getResource().getCreateTraceLevel() == TraceLevel.ALL; break; case UPDATE: result = (failed && task.getResource().getUpdateTraceLevel().ordinal() >= TraceLevel.FAILURES.ordinal()) || task.getResource().getUpdateTraceLevel() == TraceLevel.ALL; break; case DELETE: result = (failed && task.getResource().getDeleteTraceLevel().ordinal() >= TraceLevel.FAILURES.ordinal()) || task.getResource().getDeleteTraceLevel() == TraceLevel.ALL; break; default: result = false; } return result; }
private boolean hasToBeRegistered(final TaskExec execution) { NotificationTask task = (NotificationTask) execution.getTask(); // True if either failed and failures have to be registered, or if ALL // has to be registered. return (NotificationJob.Status.valueOf(execution.getStatus()) == NotificationJob.Status.NOT_SENT && task.getTraceLevel().ordinal() >= TraceLevel.FAILURES.ordinal()) || task.getTraceLevel() == TraceLevel.ALL; }
@PreAuthorize("hasRole('" + StandardEntitlement.TASK_READ + "')") @Transactional(readOnly = true) public <T extends TaskTO> T read(final TaskType type, final String key, final boolean details) { Task task = taskDAO.find(key); if (task == null) { throw new NotFoundException("Task " + key); } TaskUtils taskUtils = taskUtilsFactory.getInstance(task); if (type != null && taskUtils.getType() != type) { SyncopeClientException sce = SyncopeClientException.build(ClientExceptionType.InvalidRequest); sce.getElements().add("Found " + type + ", expected " + taskUtils.getType()); throw sce; } return binder.getTaskTO(task, taskUtilsFactory.getInstance(task), details); }
@Override protected boolean hasToBeRegistered(final TaskExec execution) { final ProvisioningTask provTask = (ProvisioningTask) task; // True if either failed and failures have to be registered, or if ALL has to be registered. return (TaskJob.Status.valueOf(execution.getStatus()) == TaskJob.Status.FAILURE && provTask.getResource().getProvisioningTraceLevel().ordinal() >= TraceLevel.FAILURES.ordinal()) || provTask.getResource().getProvisioningTraceLevel().ordinal() >= TraceLevel.SUMMARY.ordinal(); }
public static JobKey getJobKey(final Task task) { return new JobKey("taskJob" + task.getKey(), Scheduler.DEFAULT_GROUP); }
@Transactional @Override public void before(final PropagationTask task, final ConnectorObject beforeObj) { if (task.getOperation() == ResourceOperation.DELETE || task.getOperation() == ResourceOperation.NONE) { return; } switch (task.getAnyTypeKind()) { case USER: setName(task); break; case GROUP: setName(task); break; default: LOG.debug("Not about user or group: not doing anything"); } }
@Override public void setTaskExecuted(final String taskKey, final boolean executed) { NotificationTask task = taskDAO.find(taskKey); task.setExecuted(executed); taskDAO.save(task); }
@Override @Transactional(rollbackFor = { Throwable.class }) public void saveAndAdd(final String taskKey, final TaskExec execution) { Task task = taskDAO.find(taskKey); task.add(execution); taskDAO.save(task); }
@Override protected AnyPatch doUpdate( final AnyTO before, final AnyPatch anyPatch, final SyncDelta delta, final ProvisioningReport result) { AnyObjectPatch anyObjectPatch = AnyObjectPatch.class.cast(anyPatch); Pair<AnyObjectPatch, List<PropagationStatus>> updated = anyObjectProvisioningManager.update( anyObjectPatch, Collections.singleton(profile.getTask().getResource().getKey()), true); return anyPatch; } }
public Boolean readEnabled(final ConnectorObject connectorObject, final ProvisioningTask task) { Boolean enabled = null; if (task.isSyncStatus()) { Attribute status = AttributeUtil.find(OperationalAttributes.ENABLE_NAME, connectorObject.getAttributes()); if (status != null && status.getValue() != null && !status.getValue().isEmpty()) { enabled = (Boolean) status.getValue().get(0); } } return enabled; } }
private void link(final Realm realm, final boolean unlink, final ProvisioningReport result) { RealmTO realmTO = binder.getRealmTO(realm, true); if (unlink) { realmTO.getResources().remove(profile.getTask().getResource().getKey()); } else { realmTO.getResources().add(profile.getTask().getResource().getKey()); } update(realmTO, null, result); }
@PreAuthorize("hasRole('" + StandardEntitlement.TASK_DELETE + "')") public <T extends TaskTO> T delete(final TaskType type, final String key) { Task task = taskDAO.find(key); if (task == null) { throw new NotFoundException("Task " + key); } TaskUtils taskUtils = taskUtilsFactory.getInstance(task); if (type != null && taskUtils.getType() != type) { SyncopeClientException sce = SyncopeClientException.build(ClientExceptionType.InvalidRequest); sce.getElements().add("Found " + type + ", expected " + taskUtils.getType()); throw sce; } T taskToDelete = binder.getTaskTO(task, taskUtils, true); if (TaskType.SCHEDULED == taskUtils.getType() || TaskType.PULL == taskUtils.getType() || TaskType.PUSH == taskUtils.getType()) { jobManager.unregister(task); } taskDAO.delete(task); return taskToDelete; }
public static JobKey getJobKey(final Task task) { return new JobKey("taskJob" + task.getKey(), Scheduler.DEFAULT_GROUP); }