How to use

jobMessage

method

in

de.otto.edison.jobs.domain.JobMessage

private void writeMessageAndStatus(final String jobId, Level messageLevel, String message, @Nullable final JobStatus jobStatus, OffsetDateTime timestamp) {
  // TODO: Refactor JobRepository so only a single update is required
  jobRepository.appendMessage(jobId, jobMessage(messageLevel, message, timestamp));
  if (jobStatus != null) {
    jobRepository.setJobStatus(jobId, jobStatus);
  }
}

public void killJob(final String jobId) {
  stopJob(jobId, DEAD);
  jobRepository.appendMessage(
      jobId,
      jobMessage(WARNING, "Job didn't receive updates for a while, considering it dead", now(clock))
  );
}

private JobMessage toJobMessage(final Document document) {
  return jobMessage(
      Level.valueOf(document.get(JobStructure.MSG_LEVEL.key()).toString()),
      getMessage(document),
      toOffsetDateTime(document.getDate(JobStructure.MSG_TS.key()))
  );
}

private JobMessage toJobMessage(final Document document) {
  return jobMessage(
      Level.valueOf(document.get(JobStructure.MSG_LEVEL.key()).toString()),
      getMessage(document),
      DateTimeConverters.toOffsetDateTime(document.getDate(JobStructure.MSG_TS.key()))
  );
}

@Test
public void shouldAppendNonErrorMessage() {
  JobMessage message = JobMessage.jobMessage(Level.INFO, "This is an interesting message", OffsetDateTime.now());
  // when
  jobService.appendMessage(JOB_ID, message);
  // then
  verify(jobRepository).appendMessage(JOB_ID, message);
  verify(jobRepository, never()).createOrUpdate(any(JobInfo.class));
}

private JobInfo someJobInfo(final String jobId) {
  return JobInfo.newJobInfo(
      jobId,
      "SOME_JOB",
      now(), now(), Optional.of(now()), OK,
      asList(
          jobMessage(Level.INFO, "foo", now()),
          jobMessage(Level.WARNING, "bar", now())),
      systemDefaultZone(),
      "localhost"
  );
}

private JobInfo jobInfo(final String jobId, final String type) {
  return JobInfo.newJobInfo(
      jobId,
      type,
      now(), now(), Optional.of(now()), OK,
      asList(
          jobMessage(Level.INFO, "foo", now()),
          jobMessage(Level.WARNING, "bar", now())),
      systemDefaultZone(),
      "localhost"
  );
}

@Test
public void shouldMarkSkipped() {
  //when
  jobService.markSkipped(JOB_ID);
  // then
  OffsetDateTime now = OffsetDateTime.now(clock);
  verify(jobRepository).appendMessage(JOB_ID, jobMessage(Level.INFO, "Skipped job ..", now));
  verify(jobRepository).setJobStatus(JOB_ID, JobInfo.JobStatus.SKIPPED);
}

  private JobInfo jobInfo(final String jobId, final String type) {
    return JobInfo.newJobInfo(
        jobId,
        type,
        now(), now(), Optional.of(now()), OK,
        asList(
            jobMessage(Level.INFO, "foo", now()),
            jobMessage(Level.WARNING, "bar", now())),
        systemDefaultZone(),
        "localhost"
    );
  }
}

@Test
public void shouldPersistFailedEvent() throws Exception {
  final StateChangeEvent event = stateChangedEvent(FAILED);
  subject.consumeStateChange(event);
  final OffsetDateTime ts = ofInstant(ofEpochMilli(event.getTimestamp()), systemDefault());
  verify(jobServiceMock).appendMessage(JOB_ID, jobMessage(ERROR, "", ts));
}

@Test
public void shouldMarkRestarted() {
  //when
  jobService.markRestarted(JOB_ID);
  // then
  OffsetDateTime now = OffsetDateTime.now(clock);
  verify(jobRepository).appendMessage(JOB_ID, jobMessage(Level.WARNING, "Restarting job ..", now));
  verify(jobRepository).setJobStatus(JOB_ID, JobInfo.JobStatus.OK);
}

@Override
protected void append(final ILoggingEvent eventObject) {
  Map<String, String> mdcMap = eventObject.getMDCPropertyMap();
  // TODO: check for JOB marker:
  if (mdcMap.containsKey("job_id") && eventObject.getMarker() != null && JobMarker.JOB.contains(eventObject.getMarker())) {
    String jobId = mdcMap.get("job_id");
    Level level = eventObject.getLevel();
    de.otto.edison.jobs.domain.Level edisonLevel = logLevelToEdisonLevel(level);
    String message = eventObject.getFormattedMessage();
    try {
      final JobMessage jobMessage = jobMessage(edisonLevel, message, OffsetDateTime.now());
      jobService.appendMessage(jobId, jobMessage);
    }
    catch(final RuntimeException e) {
      addError("Failed to persist job message (jobId=" + jobId + "): " + message, e);
    }
  }
}

@Test
public void shouldAppendMessageToJob() throws Exception {
  // given
  final String jobId = "http://localhost/baZ";
  final JobInfo jobInfo = jobInfo(jobId, "T_FOO");
  repo.createOrUpdate(jobInfo);
  // when
  final JobMessage jobMessage = jobMessage(Level.INFO, "Schön ist es auf der Welt zu sein, sagt der Igel zu dem Stachelschwein", now());
  repo.appendMessage(jobId, jobMessage);
  // then
  final JobInfo jobInfoFromDB = repo.findOne(jobId).orElse(null);
  assertThat(jobInfoFromDB.getMessages(), hasSize(3));
  assertThat(jobInfoFromDB.getMessages().get(2), is(jobMessage));
  assertThat(jobInfoFromDB.getStatus(), is(OK));
}

@Test
public void shouldAppendMessageToJobInfo() throws Exception {
  String someUri = "someUri";
  OffsetDateTime now = now();
  //Given
  JobInfo jobInfo = newJobInfo(someUri, "TEST", systemDefaultZone(), "localhost");
  repository.createOrUpdate(jobInfo);
  //When
  JobMessage igelMessage = JobMessage.jobMessage(Level.WARNING, "Der Igel ist froh.", now);
  repository.appendMessage(someUri, igelMessage);
  //Then
  JobInfo jobInfoFromRepo = repository.findOne(someUri).get();
  assertThat(jobInfoFromRepo.getMessages().size(), is(1));
  assertThat(jobInfoFromRepo.getMessages().get(0), is(igelMessage));
  assertThat(jobInfoFromRepo.getLastUpdated(), is(now.truncatedTo(ChronoUnit.MILLIS)));
}

@Test
public void shouldAppendErrorMessageAndSetErrorStatus() {
  OffsetDateTime now = OffsetDateTime.now(clock);
  OffsetDateTime earlier = now.minus(10, MINUTES);
  JobMessage message = JobMessage.jobMessage(Level.ERROR, "Error: Out of hunk", now);
  JobInfo jobInfo = defaultJobInfo()
      .setLastUpdated(earlier)
      .build();
  when(jobRepository.findOne(JOB_ID)).thenReturn(Optional.of(jobInfo));
  // when
  jobService.appendMessage(JOB_ID, message);
  // then
  verify(jobRepository).appendMessage(JOB_ID, message);
  verify(jobRepository).setJobStatus(JOB_ID, JobInfo.JobStatus.ERROR);
}

@Test
public void shouldNotChangeStatusToOKWhenOnlyAppendingAMessage() {
  OffsetDateTime now = OffsetDateTime.now(clock);
  OffsetDateTime earlier = now.minus(10, MINUTES);
  JobMessage message = JobMessage.jobMessage(Level.INFO, "Some info message", now);
  JobInfo jobInfo = defaultJobInfo()
      .setLastUpdated(earlier)
      .setStatus(JobInfo.JobStatus.SKIPPED)
      .build();
  when(jobRepository.findOne(JOB_ID)).thenReturn(Optional.of(jobInfo));
  // when
  jobService.appendMessage(JOB_ID, message);
  // then
  verify(jobRepository).appendMessage(JOB_ID, message);
  verifyNoMoreInteractions(jobRepository);
}

@Test
public void shouldUpdateJobInfo() {
  // given
  final JobInfo foo = someJobInfo("http://localhost/foo/B");
  repo.createOrUpdate(foo);
  final JobInfo writtenFoo = repo.createOrUpdate(foo.copy().addMessage(jobMessage(Level.INFO, "some message", now(foo.getClock()))).build());
  // when
  final Optional<JobInfo> jobInfo = repo.findOne("http://localhost/foo/B");
  // then
  assertThat(jobInfo.orElse(null), is(writtenFoo));
}

jobService.appendMessage(event.getJobId(), jobMessage(ERROR, event.getMessage(), ts));
break;