Unchecked warnings...

Kai Reinhard

30.15.2018 0b1981d169593525f4575746ea509460379bb540

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
package de.micromata.borgbutler.jobs;
 
import lombok.AccessLevel;
import lombok.Getter;
import lombok.Setter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
 
public abstract class AbstractJob<T> {
    private Logger logger = LoggerFactory.getLogger(AbstractJob.class);
 
    public enum Status {DONE, RUNNING, QUEUED, CANCELLED, FAILED}
 
    @Getter
    @Setter
    private boolean cancelledRequested;
 
    @Getter
    @Setter(AccessLevel.PACKAGE)
    private Status status;
    @Getter
    @Setter
    private String title;
    @Getter
    @Setter
    private String statusText;
    @Getter(AccessLevel.PACKAGE)
    @Setter(AccessLevel.PACKAGE)
 
    private Future<JobResult<T>> future;
 
    public void cancel() {
        if (this.getStatus() == Status.QUEUED) {
            this.status = Status.CANCELLED;
        }
        this.cancelledRequested = true;
        cancelRunningProcess();
    }
 
    protected void setCancelled() {
        this.status = Status.CANCELLED;
    }
 
    /**
     * Not supported if not implemented.
     */
    protected void cancelRunningProcess() {
    }
 
    /**
     * Waits for and gets the result.
     * @return
     */
    public JobResult<T> getResult() {
        try {
            return future.get();
        } catch (InterruptedException | ExecutionException ex) {
            logger.error(ex.getMessage(), ex);
        }
        return null;
    }
 
    public T getResultObject() {
        return getResult().getResultObject();
    }
 
    protected void failed() {
        if (this.status == Status.CANCELLED) {
            // do nothing. It's normal that cancelled jobs fail.
            return;
        }
        if (this.status != Status.RUNNING) {
            logger.error("Internal error, illegal state! You shouldn't set the job status to FAILED if not in status RUNNING: " + this.status);
        }
        this.status = Status.FAILED;
    }
 
    /**
     * @return true, if the job is done, stopped or failed. Otherwise false (if job is running or queued).
     */
    public boolean isFinished() {
        if (status == Status.DONE || status == Status.CANCELLED || status == Status.FAILED) {
            return true;
        }
        return false;
    }
 
    public abstract JobResult<T> execute();
 
    /**
     * A job is identified by this id. If a job with the same id is already queued (not yet finished), this job will
     * not be added twice.
     *
     * @return
     */
    public abstract Object getId();
}