/** * Synonym for {@link #currentTimestamp()}. */ @Support public static Field<Timestamp> now() { return currentTimestamp(); }
/** * Get the current_timestamp() function. * <p> * This translates into any dialect */ @Support public static Field<OffsetDateTime> currentOffsetDateTime() { return currentTimestamp().cast(SQLDataType.OFFSETDATETIME); }
@Override public void performTask() { Field<Timestamp> cutoff = currentTimestamp().minus(field("interval '10 minutes'")); int n = watchdogDao.failStalled(cutoff); log.info("run -> {} command(s) are timed out", n); }
private void failStalled() { Field<Timestamp> cutOff = currentTimestamp().minus(interval(MAX_STALLED_AGE)); dao.transaction(tx -> { List<String> ids = dao.pollStalled(tx, cutOff); for(String id : ids) { dao.fail(tx, id); log.info("failStalled -> marked as failed: {}", id); } }); }
private void taskFinished(DSLContext tx, String taskId, String status) { tx.update(TASKS) .set(TASKS.FINISHED_AT, currentTimestamp()) .set(TASKS.LAST_UPDATED_AT, currentTimestamp()) .set(TASKS.TASK_STATUS, value(status)) .where(TASKS.TASK_ID.eq(taskId)) .execute(); } }
void deleteExpiredKeys() { tx(tx -> { int keys = tx.deleteFrom(API_KEYS) .where(API_KEYS.EXPIRED_AT.lessOrEqual(currentTimestamp())) .execute(); log.info("deleteExpiredKeys -> removed {} key(s)", keys); }); } }
@Override public void run() { watchdogDao.transaction(tx -> { Field<Timestamp> cutOff = currentTimestamp().minus(interval(cfg.getMaxStalledAge())); List<ProcessKey> pks = watchdogDao.pollStalled(tx, POTENTIAL_STALLED_STATUSES, cutOff, 1); for (ProcessKey pk : pks) { queueDao.updateAgentId(tx, pk, null, ProcessStatus.FAILED); logManager.warn(pk, "Process stalled, no heartbeat for more than a minute"); log.info("processStalled -> marked as failed: {}", pk); } }); } }
@Override public void run() { watchdogDao.transaction(tx -> { Field<Timestamp> cutOff = currentTimestamp().minus(interval(cfg.getMaxStartFailureAge())); List<ProcessKey> pks = watchdogDao.pollStalled(tx, FAILED_TO_START_STATUSES, cutOff, 1); for (ProcessKey pk : pks) { queueDao.updateAgentId(tx, pk, null, ProcessStatus.FAILED); logManager.warn(pk, "Process failed to start"); log.info("processStartFailures -> marked as failed: {}", pk); } }); } }
@Override public void run() { Field<Timestamp> maxAge = currentTimestamp().minus(interval(cfg.getMaxFailureHandlingAge())); for (PollEntry e : POLL_ENTRIES) { List<ProcessEntry> parents = watchdogDao.poll(e, maxAge, 1); for (ProcessEntry parent : parents) { process(e, parent); } } }
public void markAsDone(UUID checkpointId) { tx(tx -> { int i = tx.update(PROCESS_CHECKPOINT_ARCHIVE) .set(PROCESS_CHECKPOINT_ARCHIVE.STATUS, ArchivalStatus.DONE.toString()) .set(PROCESS_CHECKPOINT_ARCHIVE.LAST_UPDATED_AT, currentTimestamp()) .where(PROCESS_CHECKPOINT_ARCHIVE.CHECKPOINT_ID.eq(checkpointId)) .execute(); if (i != 1) { throw new IllegalStateException("Invalid number of rows updated: " + i + " (checkpointId: " + checkpointId + ")"); } }); } }
public void updateRunning(Set<String> runningTasks) { tx(tx -> { tx.update(TASKS) .set(TASKS.LAST_UPDATED_AT, currentTimestamp()) .where(TASKS.TASK_ID.in(runningTasks)) .execute(); }); }
public boolean touch(UUID instanceId) { return txResult(tx -> { int i = tx.update(PROCESS_QUEUE) .set(PROCESS_QUEUE.LAST_UPDATED_AT, currentTimestamp()) .where(PROCESS_QUEUE.INSTANCE_ID.eq(instanceId)) .execute(); return i == 1; }); }
public Instant now() { return txResult(tx -> tx.select(currentTimestamp().as("now")) .fetchOne(field("now", Timestamp.class)) .toInstant()); }
public void markAsDone(PartialProcessKey processKey) { tx(tx -> { int i = tx.update(PROCESS_STATE_ARCHIVE) .set(PROCESS_STATE_ARCHIVE.STATUS, ArchivalStatus.DONE.toString()) .set(PROCESS_STATE_ARCHIVE.LAST_UPDATED_AT, currentTimestamp()) .where(PROCESS_STATE_ARCHIVE.INSTANCE_ID.eq(processKey.getInstanceId())) .execute(); if (i != 1) { throw new IllegalStateException("Invalid number of rows updated: " + i + " (process key: " + processKey + ")"); } }); } }
private static Field<Timestamp> createRunningAtValue(ProcessStatus status) { return when(PROCESS_QUEUE.CURRENT_STATUS.eq(ProcessStatus.RUNNING.toString()), PROCESS_QUEUE.LAST_RUN_AT) .otherwise(when(value(status.toString()).eq(ProcessStatus.RUNNING.toString()), currentTimestamp()) .otherwise(PROCESS_QUEUE.LAST_RUN_AT)); }
public void insert(UUID commandId, String agentId, Map<String, Object> data) { tx(tx -> tx.insertInto(AGENT_COMMANDS) .columns(AGENT_COMMANDS.COMMAND_ID, AGENT_COMMANDS.AGENT_ID, AGENT_COMMANDS.COMMAND_STATUS, AGENT_COMMANDS.CREATED_AT, AGENT_COMMANDS.COMMAND_DATA) .values(value(commandId), value(agentId), value(Status.CREATED.toString()), currentTimestamp(), value(convert(data))) .execute()); }
public UUID findUserId(String key) { try (DSLContext tx = DSL.using(cfg)) { return tx.select(API_KEYS.USER_ID) .from(API_KEYS) .where(API_KEYS.API_KEY.eq(hash(key)) .and(API_KEYS.EXPIRED_AT.isNull() .or(API_KEYS.EXPIRED_AT.greaterThan(currentTimestamp())))) .fetchOne(API_KEYS.USER_ID); } }
private void updateStatus(DSLContext tx, ProcessKey processKey, ProcessStatus status, Map<String, Object> statusPayload) { UUID instanceId = processKey.getInstanceId(); tx.update(PROCESS_QUEUE) .set(PROCESS_QUEUE.CURRENT_STATUS, status.toString()) .set(PROCESS_QUEUE.LAST_RUN_AT, createRunningAtValue(status)) .set(PROCESS_QUEUE.LAST_UPDATED_AT, currentTimestamp()) .where(PROCESS_QUEUE.INSTANCE_ID.eq(instanceId)) .execute(); insertHistoryStatus(tx, processKey, status, statusPayload); }
public List<ApiKeyEntry> poll(int days) { return txResult(tx -> tx.select(API_KEYS.KEY_ID, API_KEYS.KEY_NAME, API_KEYS.EXPIRED_AT, API_KEYS.USER_ID) .from(API_KEYS) .where(API_KEYS.EXPIRED_AT.isNotNull() .and(currentTimestamp().greaterOrEqual(trunc(API_KEYS.EXPIRED_AT).minus(days)) .and(API_KEYS.LAST_NOTIFIED_AT.isNull() .or(API_KEYS.LAST_NOTIFIED_AT.lessOrEqual(API_KEYS.EXPIRED_AT.minus(days)))))) .fetch(this::toEntry)); }
public boolean updateStatus(ProcessKey processKey, ProcessStatus expected, ProcessStatus status) { UUID instanceId = processKey.getInstanceId(); return txResult(tx -> { int i = tx.update(PROCESS_QUEUE) .set(PROCESS_QUEUE.CURRENT_STATUS, status.toString()) .set(PROCESS_QUEUE.LAST_UPDATED_AT, currentTimestamp()) .set(PROCESS_QUEUE.LAST_RUN_AT, createRunningAtValue(status)) .where(PROCESS_QUEUE.INSTANCE_ID.eq(instanceId) .and(PROCESS_QUEUE.CURRENT_STATUS.eq(expected.toString()))) .execute(); insertHistoryStatus(tx, processKey, status); return i == 1; }); }