adressevedligehold/tasks/Task.java

package dk.daoas.adressevedligehold.tasks;

import dk.daoas.adressevedligehold.util.TimingHelper;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;

public abstract class Task implements Runnable {
        
        private TaskLogger logger = TaskLogger.getInstance(); 
        
        public enum TaskState {
                STATE_QUEUED, STATE_RUNNING, STATE_DONE, STATE_ABORTED;
        }
        
        @SuppressFBWarnings("URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")//bliver læst via gson - og det forvirrer findbugs
        public static class TaskBean {
                public int id;
                public String description;
                public String detail;
                public String errorMessage;
                public double percentCompleted;
                public String state;
        }
        
        protected volatile boolean abort = false;//mark volatile to make sure value isn't cached by threads
        protected volatile TaskState state = TaskState.STATE_QUEUED;
        protected TaskManager manager;
        private String errorMsg;
        
        private String logMessages;
        
        private int id;
        
        public final void setManager(TaskManager manager) {
                this.manager = manager;
        }
        
        @Override
        public final void run() {
                
                TaskLogger.getInstance().reset();
                
                TimingHelper timing = new TimingHelper();
                
                
                logger.info("Starting " + this.getDescription() );
                
                this.state = TaskState.STATE_RUNNING;
                manager.setCurrentTask(this);
                
                try {
                        taskRun();
                        
                        if (this.state != TaskState.STATE_ABORTED) { //just to make sure we wasn't aborted
                                this.state = TaskState.STATE_DONE;
                        }
                        
                        
                } catch (Exception e) {
                        this.errorMsg = e.getMessage();
                        e.printStackTrace();
                        this.state = TaskState.STATE_ABORTED;
                }
                
                manager.setCurrentTask(null);
                
                logger.info("Done " + this.getDescription() + "   " + timing.getElapsed() + "ms");
                
                logMessages = TaskLogger.getInstance().getBuffer();
        }
        
        public final String getLog() {
                if (this.state == TaskState.STATE_RUNNING) {
                        return TaskLogger.getInstance().getBuffer(); //if live return current log buffer content 
                } else {
                        return logMessages;
                }
        }
        
        public final void setId(int newId) {
                this.id = newId;
        }
        
        public final int getId() {
                return this.id;
        }
        
        public final TaskState getState() {
                return this.state;
        }
        
        public boolean isAborted() {
                return this.abort;
        }
        
        public void doAbort() {
                this.abort = true;
        }
        
        public TaskBean getTaskBean() {
                TaskBean bean = new TaskBean();
                bean.id = this.getId();
                bean.description = this.getDescription();
                bean.detail = this.getDetail();
                bean.percentCompleted = this.getPercentCompleted();
                bean.state = this.state.toString();
                bean.errorMessage = this.getErrorMessage();
                
                return bean;
        }
        
        public String getErrorMessage() {
                return this.errorMsg;
        }
        
        /**
         * @throws Exception
         * 
         * Implementing classes should not catch terminating exceptions but let it propagate to Task the Task::run()
         * method.
         */
        protected abstract void taskRun() throws Exception;
        
        public abstract String getDescription();
        public abstract String getDetail();
        public abstract double getPercentCompleted();
        
}
1	package dk.daoas.adressevedligehold.tasks;
2
3	import dk.daoas.adressevedligehold.util.TimingHelper;
4	import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
5
6	public abstract class Task implements Runnable {
7
8	private TaskLogger logger = TaskLogger.getInstance();
9
10	public enum TaskState {
11	STATE_QUEUED, STATE_RUNNING, STATE_DONE, STATE_ABORTED;
12	}
13
14	@SuppressFBWarnings("URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")//bliver læst via gson - og det forvirrer findbugs
15	public static class TaskBean {
16	public int id;
17	public String description;
18	public String detail;
19	public String errorMessage;
20	public double percentCompleted;
21	public String state;
22	}
23
24	protected volatile boolean abort = false;//mark volatile to make sure value isn't cached by threads
25	protected volatile TaskState state = TaskState.STATE_QUEUED;
26	protected TaskManager manager;
27	private String errorMsg;
28
29	private String logMessages;
30
31	private int id;
32
33	public final void setManager(TaskManager manager) {
34	this.manager = manager;
35	}
36
37	@Override
38	public final void run() {
39
40	TaskLogger.getInstance().reset();
41
42	TimingHelper timing = new TimingHelper();
43
44
45	logger.info("Starting " + this.getDescription() );
46
47	this.state = TaskState.STATE_RUNNING;
48	manager.setCurrentTask(this);
49
50	try {
51	taskRun();
52
53	if (this.state != TaskState.STATE_ABORTED) { //just to make sure we wasn't aborted
54	this.state = TaskState.STATE_DONE;
55	}
56
57
58	} catch (Exception e) {
59	this.errorMsg = e.getMessage();
60	e.printStackTrace();
61	this.state = TaskState.STATE_ABORTED;
62	}
63
64	manager.setCurrentTask(null);
65
66	logger.info("Done " + this.getDescription() + " " + timing.getElapsed() + "ms");
67
68	logMessages = TaskLogger.getInstance().getBuffer();
69	}
70
71	public final String getLog() {
72	if (this.state == TaskState.STATE_RUNNING) {
73	return TaskLogger.getInstance().getBuffer(); //if live return current log buffer content
74	} else {
75	return logMessages;
76	}
77	}
78
79	public final void setId(int newId) {
80	this.id = newId;
81	}
82
83	public final int getId() {
84	return this.id;
85	}
86
87	public final TaskState getState() {
88	return this.state;
89	}
90
91	public boolean isAborted() {
92	return this.abort;
93	}
94
95	public void doAbort() {
96	this.abort = true;
97	}
98
99	public TaskBean getTaskBean() {
100	TaskBean bean = new TaskBean();
101	bean.id = this.getId();
102	bean.description = this.getDescription();
103	bean.detail = this.getDetail();
104	bean.percentCompleted = this.getPercentCompleted();
105	bean.state = this.state.toString();
106	bean.errorMessage = this.getErrorMessage();
107
108	return bean;
109	}
110
111	public String getErrorMessage() {
112	return this.errorMsg;
113	}
114
115	/**
116	* @throws Exception
117	*
118	* Implementing classes should not catch terminating exceptions but let it propagate to Task the Task::run()
119	* method.
120	*/
121	protected abstract void taskRun() throws Exception;
122
123	public abstract String getDescription();
124	public abstract String getDetail();
125	public abstract double getPercentCompleted();
126
127	}