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() {
                
                if (this.state == TaskState.STATE_ABORTED) {//if this task as cancelled while still in queue  
                        return;
                }
                
                
                
                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) {
                        logger.warning("Error during taskrun", e);
                        this.errorMsg = e.getMessage();
                        this.state = TaskState.STATE_ABORTED;
                }
                
                manager.setCurrentTask(null);
                
                logger.info("Done " + this.getDescription() + "   " + timing.getElapsed() + "ms");
                
                logMessages = TaskLogger.getInstance().getBuffer();
                
                
                // Make some delay between tasks to make sure that the VM settles and other contexts can perform their tasks as well
                try {
                        Thread.sleep(60*1000);
                } catch (InterruptedException e) {
                        e.printStackTrace();
                }
                
        }
        
        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 void doAbort(Exception e) {
                this.abort = true;
                this.errorMsg = e.getMessage();
        }
        
        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;
        }
        
        @Override
        public int hashCode() {
                return this.id;
        }
        
        @Override
        public boolean equals(Object o) {
                if (! (o instanceof Task))
                        return false;
                
                Task otherTask = (Task) o;
                
                return this.getId() == otherTask.getId();
        }
        
        /**
         * @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	torben	2838	package dk.daoas.adressevedligehold.tasks;
2
3			import dk.daoas.adressevedligehold.util.TimingHelper;
4	torben	2864	import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
5
6	torben	2838	public abstract class Task implements Runnable {
7
8	torben	2903	private TaskLogger logger = TaskLogger.getInstance();
9
10	torben	2838	public enum TaskState {
11			STATE_QUEUED, STATE_RUNNING, STATE_DONE, STATE_ABORTED;
12			}
13
14	torben	2864	@SuppressFBWarnings("URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")//bliver læst via gson - og det forvirrer findbugs
15	torben	2838	public static class TaskBean {
16	torben	2903	public int id;
17	torben	2838	public String description;
18			public String detail;
19	torben	2844	public String errorMessage;
20	torben	2838	public double percentCompleted;
21			public String state;
22			}
23
24	torben	2913	protected volatile boolean abort = false;//mark volatile to make sure value isn't cached by threads
25	torben	2915	protected volatile TaskState state = TaskState.STATE_QUEUED;
26	torben	2838	protected TaskManager manager;
27	torben	2844	private String errorMsg;
28	torben	2838
29	torben	2903	private String logMessages;
30
31			private int id;
32
33			public final void setManager(TaskManager manager) {
34	torben	2838	this.manager = manager;
35			}
36
37			@Override
38			public final void run() {
39	torben	2903
40	torben	2928	if (this.state == TaskState.STATE_ABORTED) {//if this task as cancelled while still in queue
41			return;
42			}
43
44
45
46	torben	2903	TaskLogger.getInstance().reset();
47
48	torben	2838	TimingHelper timing = new TimingHelper();
49
50	torben	2903
51			logger.info("Starting " + this.getDescription() );
52
53	torben	2838	this.state = TaskState.STATE_RUNNING;
54			manager.setCurrentTask(this);
55
56			try {
57			taskRun();
58	torben	2915
59			if (this.state != TaskState.STATE_ABORTED) { //just to make sure we wasn't aborted
60			this.state = TaskState.STATE_DONE;
61			}
62
63
64	torben	2838	} catch (Exception e) {
65	torben	2926	logger.warning("Error during taskrun", e);
66	torben	2844	this.errorMsg = e.getMessage();
67	torben	2838	this.state = TaskState.STATE_ABORTED;
68			}
69
70			manager.setCurrentTask(null);
71
72	torben	2903	logger.info("Done " + this.getDescription() + " " + timing.getElapsed() + "ms");
73
74			logMessages = TaskLogger.getInstance().getBuffer();
75	torben	2992
76
77			// Make some delay between tasks to make sure that the VM settles and other contexts can perform their tasks as well
78			try {
79			Thread.sleep(60*1000);
80			} catch (InterruptedException e) {
81			e.printStackTrace();
82			}
83
84	torben	2838	}
85
86	torben	2903	public final String getLog() {
87			if (this.state == TaskState.STATE_RUNNING) {
88			return TaskLogger.getInstance().getBuffer(); //if live return current log buffer content
89			} else {
90			return logMessages;
91			}
92			}
93	torben	2838
94	torben	2903	public final void setId(int newId) {
95			this.id = newId;
96			}
97
98			public final int getId() {
99			return this.id;
100			}
101
102			public final TaskState getState() {
103	torben	2838	return this.state;
104			}
105
106	torben	2878	public boolean isAborted() {
107			return this.abort;
108			}
109
110	torben	2838	public void doAbort() {
111			this.abort = true;
112			}
113
114	torben	2916	public void doAbort(Exception e) {
115			this.abort = true;
116			this.errorMsg = e.getMessage();
117			}
118
119	torben	2838	public TaskBean getTaskBean() {
120			TaskBean bean = new TaskBean();
121	torben	2903	bean.id = this.getId();
122	torben	2838	bean.description = this.getDescription();
123			bean.detail = this.getDetail();
124			bean.percentCompleted = this.getPercentCompleted();
125			bean.state = this.state.toString();
126	torben	2844	bean.errorMessage = this.getErrorMessage();
127	torben	2838
128			return bean;
129			}
130
131	torben	2844	public String getErrorMessage() {
132			return this.errorMsg;
133			}
134	torben	2838
135	torben	2918	@Override
136	torben	2921	public int hashCode() {
137			return this.id;
138			}
139
140			@Override
141			public boolean equals(Object o) {
142			if (! (o instanceof Task))
143			return false;
144
145	torben	2918	Task otherTask = (Task) o;
146
147			return this.getId() == otherTask.getId();
148			}
149
150	torben	2844	/**
151			* @throws Exception
152			*
153			* Implementing classes should not catch terminating exceptions but let it propagate to Task the Task::run()
154			* method.
155			*/
156			protected abstract void taskRun() throws Exception;
157
158	torben	2838	public abstract String getDescription();
159			public abstract String getDetail();
160	torben	2891	public abstract double getPercentCompleted();
161	torben	2838
162			}