v1 Scheduled Jobs / Third Party Sync Migration

webapp/src/main/java/com/box/l10n/mojito/entity/ScheduledJob.java

@@ -0,0 +1,153 @@
+package com.box.l10n.mojito.entity;
+
+import com.box.l10n.mojito.json.ObjectMapper;
+import com.box.l10n.mojito.service.scheduledjob.ScheduledJobProperties;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.PostLoad;
+import jakarta.persistence.Table;
+import jakarta.persistence.Transient;
+import java.util.Date;
+import org.hibernate.envers.Audited;
+
+@Audited
+@Entity
+@Table(name = "scheduled_job")
+public class ScheduledJob {
+  @Id private String id;
+
+  @ManyToOne
+  @JoinColumn(name = "repository_id")
+  private Repository repository;
+
+  @ManyToOne
+  @JoinColumn(name = "job_type")
+  private ScheduledJobTypeEntity jobType;
+
+  @Column(name = "cron")
+  private String cron;
+
+  @Transient private ScheduledJobProperties properties;
+
+  @Column(name = "properties")
+  private String propertiesString;
+
+  @ManyToOne
+  @JoinColumn(name = "job_status")
+  private ScheduledJobStatusEntity jobStatus;
+
+  @Column(name = "start_date")
+  private Date startDate;
+
+  @Column(name = "end_date")
+  private Date endDate;
+
+  @Column(name = "enabled", nullable = false, columnDefinition = "TINYINT DEFAULT 1")
+  private Boolean enabled = true;
+
+  @PostLoad
+  public void deserializeProperties() {
+    ObjectMapper objectMapper = new ObjectMapper();
+    try {
+      this.properties =
+          objectMapper.readValue(propertiesString, jobType.getEnum().getPropertiesClass());
+    } catch (Exception e) {
+      throw new RuntimeException(
+          "Failed to deserialize properties '"
+              + propertiesString
+              + "' for class: "
+              + jobType.getEnum().getPropertiesClass().getName(),
+          e);
+    }
+  }
+
+  public String getId() {
+    return id;
+  }
+
+  public void setId(String id) {
+    this.id = id;
+  }
+
+  public Repository getRepository() {
+    return repository;
+  }
+
+  public void setRepository(Repository repository) {
+    this.repository = repository;
+  }
+
+  public ScheduledJobTypeEntity getJobType() {
+    return jobType;
+  }
+
+  public void setJobType(ScheduledJobTypeEntity jobType) {
+    this.jobType = jobType;
+  }
+
+  public String getCron() {
+    return cron;
+  }
+
+  public void setCron(String cron) {
+    this.cron = cron;
+  }
+
+  public ScheduledJobProperties getProperties() {
+    return properties;
+  }
+
+  public void setProperties(ScheduledJobProperties properties) {
+    this.properties = properties;
+
+    ObjectMapper objectMapper = new ObjectMapper();
+    try {
+      this.propertiesString = objectMapper.writeValueAsString(this.properties);
+    } catch (Exception e) {
+      throw new RuntimeException("Failed to serialize properties", e);
+    }
+  }
+
+  public String getPropertiesString() {
+    return propertiesString;
+  }
+
+  public void setPropertiesString(String properties) {
+    this.propertiesString = properties;
+  }
+
+  public ScheduledJobStatusEntity getJobStatus() {
+    return jobStatus;
+  }
+
+  public void setJobStatus(ScheduledJobStatusEntity jobStatus) {
+    this.jobStatus = jobStatus;
+  }
+
+  public Date getStartDate() {
+    return startDate;
+  }
+
+  public void setStartDate(Date startDate) {
+    this.startDate = startDate;
+  }
+
+  public Date getEndDate() {
+    return endDate;
+  }
+
+  public void setEndDate(Date endDate) {
+    this.endDate = endDate;
+  }
+
+  public Boolean getEnabled() {
+    return enabled;
+  }
+
+  public void setEnabled(Boolean enabled) {
+    this.enabled = enabled;
+  }
+}

webapp/src/main/java/com/box/l10n/mojito/entity/ScheduledJobStatusEntity.java

@@ -0,0 +1,36 @@
+package com.box.l10n.mojito.entity;
+
+import static org.hibernate.envers.RelationTargetAuditMode.NOT_AUDITED;
+
+import com.box.l10n.mojito.rest.View;
+import com.box.l10n.mojito.service.scheduledjob.ScheduledJobStatus;
+import com.fasterxml.jackson.annotation.JsonView;
+import jakarta.persistence.Basic;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import org.hibernate.envers.Audited;
+
+@Entity
+@Table(name = "scheduled_job_status_type")
+@Audited(targetAuditMode = NOT_AUDITED)
+public class ScheduledJobStatusEntity extends BaseEntity {
+  @Id private Long id;
+
+  @Basic(optional = false)
+  @Column(name = "name")
+  @Enumerated(EnumType.STRING)
+  @JsonView(View.Repository.class)
+  private ScheduledJobStatus jobStatus;
+
+  public ScheduledJobStatus getEnum() {
+    return jobStatus;
+  }
+
+  public void setJobStatus(ScheduledJobStatus jobStatus) {
+    this.jobStatus = jobStatus;
+  }
+}

webapp/src/main/java/com/box/l10n/mojito/entity/ScheduledJobTypeEntity.java

@@ -0,0 +1,46 @@
+package com.box.l10n.mojito.entity;
+
+import static org.hibernate.envers.RelationTargetAuditMode.NOT_AUDITED;
+
+import com.box.l10n.mojito.rest.View;
+import com.box.l10n.mojito.service.scheduledjob.ScheduledJobType;
+import com.fasterxml.jackson.annotation.JsonView;
+import jakarta.persistence.Basic;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import org.hibernate.envers.Audited;
+
+@Entity
+@Table(name = "scheduled_job_type")
+@Audited(targetAuditMode = NOT_AUDITED)
+public class ScheduledJobTypeEntity extends BaseEntity {
+  @Id private Long id;
+
+  @Basic(optional = false)
+  @Column(name = "name")
+  @Enumerated(EnumType.STRING)
+  @JsonView(View.Repository.class)
+  private ScheduledJobType jobType;
+
+  @Override
+  public Long getId() {
+    return id;
+  }
+
+  @Override
+  public void setId(Long id) {
+    this.id = id;
+  }
+
+  public ScheduledJobType getEnum() {
+    return jobType;
+  }
+
+  public void setEnum(ScheduledJobType jobType) {
+    this.jobType = jobType;
+  }
+}

webapp/src/main/java/com/box/l10n/mojito/rest/scheduledjob/ScheduledJobWS.java

@@ -0,0 +1,129 @@
+package com.box.l10n.mojito.rest.scheduledjob;
+
+import com.box.l10n.mojito.entity.ScheduledJob;
+import com.box.l10n.mojito.service.scheduledjob.ScheduledJobDTO;
+import com.box.l10n.mojito.service.scheduledjob.ScheduledJobManager;
+import com.box.l10n.mojito.service.scheduledjob.ScheduledJobRepository;
+import com.box.l10n.mojito.service.scheduledjob.ScheduledJobResponse;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobKey;
+import org.quartz.SchedulerException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.server.ResponseStatusException;
+
+/**
+ * Webservice for enabling/disabling and triggering scheduled jobs.
+ *
+ * @author mattwilshire
+ */
+@RestController
+@ConditionalOnProperty(value = "l10n.scheduledJobs.enabled", havingValue = "true")
+public class ScheduledJobWS {
+
+  static Logger logger = LoggerFactory.getLogger(ScheduledJobWS.class);
+
+  @Autowired ScheduledJobRepository scheduledJobRepository;
+  @Autowired ScheduledJobManager scheduledJobManager;
+
+  @RequestMapping(method = RequestMethod.GET, value = "/api/jobs")
+  @ResponseStatus(HttpStatus.OK)
+  public List<ScheduledJobDTO> getJobs() {
+    List<ScheduledJob> scheduledJobs = scheduledJobRepository.findAll();
+    return scheduledJobs.stream().map(ScheduledJobDTO::new).collect(Collectors.toList());
+  }
+
+  @RequestMapping(method = RequestMethod.GET, value = "/api/jobs/{id}")
+  @ResponseStatus(HttpStatus.OK)
+  public ScheduledJobDTO getJob(@PathVariable String id) {
+    return scheduledJobRepository
+        .findById(id)
+        .map(ScheduledJobDTO::new)
+        .orElseThrow(
+            () ->
+                new ResponseStatusException(HttpStatus.NOT_FOUND, "Job not found with id: " + id));
+  }
+
+  @RequestMapping(method = RequestMethod.POST, value = "/api/jobs/{id}")
+  @ResponseStatus(HttpStatus.OK)
+  public ResponseEntity<ScheduledJobResponse> triggerJob(@PathVariable String id) {
+
+    Optional<ScheduledJob> optionalScheduledJob = scheduledJobRepository.findById(id);
+    if (optionalScheduledJob.isEmpty())
+      return ResponseEntity.status(HttpStatus.NOT_FOUND)
+          .body(new ScheduledJobResponse(ScheduledJobResponse.Status.ERROR, "Job not found"));
+
+    ScheduledJob scheduledJob = optionalScheduledJob.get();
+    JobKey jobKey = scheduledJobManager.getJobKey(scheduledJob);
+
+    try {
+      if (!scheduledJobManager.getScheduler().checkExists(jobKey))
+        return ResponseEntity.status(HttpStatus.NOT_FOUND)
+            .body(new ScheduledJobResponse(ScheduledJobResponse.Status.ERROR, "Job doesn't exist"));
+
+      // Is the job currently running ?
+      // Ignore the trigger request
+      for (JobExecutionContext jobExecutionContext :
+          scheduledJobManager.getScheduler().getCurrentlyExecutingJobs()) {
+        if (jobExecutionContext.getJobDetail().getKey().equals(jobKey)) {
+          return ResponseEntity.status(HttpStatus.CONFLICT)
+              .body(
+                  new ScheduledJobResponse(
+                      ScheduledJobResponse.Status.ERROR,
+                      "Job is currently running, trigger request ignored"));
+        }
+      }
+
+      scheduledJobManager.getScheduler().triggerJob(jobKey);
+      return ResponseEntity.status(HttpStatus.OK)
+          .body(new ScheduledJobResponse(ScheduledJobResponse.Status.SUCCESS, "Job triggered"));
+    } catch (SchedulerException e) {
+      logger.error(
+          "Error triggering job manually, job: {}", jobKey.getName() + ":" + jobKey.getGroup(), e);
+      return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+          .body(new ScheduledJobResponse(ScheduledJobResponse.Status.ERROR, e.getMessage()));
+    }
+  }
+
+  @RequestMapping(method = RequestMethod.POST, value = "/api/jobs/{id}/toggle")
+  @ResponseStatus(HttpStatus.OK)
+  public ResponseEntity<ScheduledJobResponse> toggleJob(@PathVariable String id) {
+    Optional<ScheduledJob> optionalScheduledJob = scheduledJobRepository.findById(id);
+    if (optionalScheduledJob.isEmpty())
+      return ResponseEntity.status(HttpStatus.NOT_FOUND)
+          .body(new ScheduledJobResponse(ScheduledJobResponse.Status.ERROR, "Job not found"));
+
+    ScheduledJob scheduledJob = optionalScheduledJob.get();
+    JobKey jobKey = scheduledJobManager.getJobKey(scheduledJob);
+
+    try {
+      if (!scheduledJobManager.getScheduler().checkExists(jobKey))
+        return ResponseEntity.status(HttpStatus.NOT_FOUND)
+            .body(new ScheduledJobResponse(ScheduledJobResponse.Status.ERROR, "Job doesn't exist"));
+
+      scheduledJob.setEnabled(!scheduledJob.getEnabled());
+      scheduledJobRepository.save(scheduledJob);
+
+      return ResponseEntity.status(HttpStatus.OK)
+          .body(
+              new ScheduledJobResponse(
+                  ScheduledJobResponse.Status.SUCCESS,
+                  "Job " + (scheduledJob.getEnabled() ? "enabled" : "disabled")));
+    } catch (SchedulerException e) {
+      throw new ResponseStatusException(
+          HttpStatus.INTERNAL_SERVER_ERROR, "Job with id: " + id + " could not be disabled");
+    }
+  }
+}

webapp/src/main/java/com/box/l10n/mojito/retry/DeadLockLoserExceptionRetryTemplate.java

@@ -1,6 +1,7 @@
 package com.box.l10n.mojito.retry;
 
 import com.google.common.collect.ImmutableMap;
+import org.springframework.dao.CannotAcquireLockException;
 import org.springframework.dao.DeadlockLoserDataAccessException;
 import org.springframework.retry.RetryCallback;
 import org.springframework.retry.backoff.ExponentialRandomBackOffPolicy;
@@ -15,7 +16,13 @@ public class DeadLockLoserExceptionRetryTemplate {
 
   public DeadLockLoserExceptionRetryTemplate() {
     SimpleRetryPolicy retryPolicy =
-        new SimpleRetryPolicy(5, ImmutableMap.of(DeadlockLoserDataAccessException.class, true));
+        new SimpleRetryPolicy(
+            5,
+            ImmutableMap.of(
+                DeadlockLoserDataAccessException.class,
+                true,
+                CannotAcquireLockException.class,
+                true));
 
     ExponentialRandomBackOffPolicy exponentialRandomBackOffPolicy =
         new ExponentialRandomBackOffPolicy();