Clover icon

Coverage Report

  1. Project Clover database Tue Mar 10 2026 14:58:44 GMT
  2. Package jalview.workers

File AlignCalcManager2.java

 

Coverage histogram

../../img/srcFileCovDistChart0.png
0% of files have more coverage

Code metrics

60
161
40
4
535
472
82
0.51
4.03
10
2.05

Classes

Class Line # Actions
AlignCalcManager2 29 92 44
0.00%
AlignCalcManager2.WorkerManager 31 12 9
0.00%
AlignCalcManager2.SimpleWorkerManager 86 18 11
0.00%
AlignCalcManager2.PollableWorkerManager 146 39 18
0.00%
 

Contributing tests

No tests hitting this source file were found.

Source view

1    package jalview.workers;
2   
3    import java.util.HashMap;
4    import java.util.List;
5    import java.util.Map;
6    import java.util.NoSuchElementException;
7    import java.util.Objects;
8    import java.util.WeakHashMap;
9    import java.util.concurrent.CopyOnWriteArrayList;
10    import java.util.concurrent.Executors;
11    import java.util.concurrent.Future;
12    import java.util.concurrent.ScheduledExecutorService;
13    import java.util.concurrent.TimeUnit;
14   
15    import static java.lang.String.format;
16    import static java.util.Collections.synchronizedMap;
17    import static java.util.Collections.unmodifiableList;
18   
19    import java.util.ArrayList;
20   
21    import jalview.api.AlignCalcListener;
22    import jalview.api.AlignCalcManagerI2;
23    import jalview.api.AlignCalcWorkerI;
24    import jalview.api.PollableAlignCalcWorkerI;
25    import jalview.bin.Cache;
26    import jalview.bin.Console;
27    import jalview.datamodel.AlignmentAnnotation;
28   
 
29    public class AlignCalcManager2 implements AlignCalcManagerI2
30    {
 
31    private abstract class WorkerManager
32    {
33    protected volatile boolean enabled = true;
34   
35    protected AlignCalcWorkerI worker;
36   
 
37  0 toggle WorkerManager(AlignCalcWorkerI worker)
38    {
39  0 this.worker = worker;
40    }
41   
 
42  0 toggle protected AlignCalcWorkerI getWorker()
43    {
44  0 return worker;
45    }
46   
 
47  0 toggle boolean isEnabled()
48    {
49  0 return enabled;
50    }
51   
 
52  0 toggle void setEnabled(boolean enabled)
53    {
54  0 this.enabled = enabled;
55    }
56   
 
57  0 toggle synchronized void restart()
58    {
59  0 if (!isEnabled())
60    {
61  0 return;
62    }
63  0 if (!isRegistered())
64    {
65  0 setEnabled(false);
66    }
67  0 if (isWorking())
68    {
69  0 cancel();
70    }
71  0 submit();
72    }
73   
 
74  0 toggle protected boolean isRegistered()
75    {
76  0 return registered.containsKey(getWorker());
77    }
78   
79    abstract boolean isWorking();
80   
81    protected abstract void submit();
82   
83    abstract void cancel();
84    }
85   
 
86    private class SimpleWorkerManager extends WorkerManager
87    {
88    private Future<?> task = null;
89   
 
90  0 toggle SimpleWorkerManager(AlignCalcWorkerI worker)
91    {
92  0 super(worker);
93    }
94   
 
95  0 toggle @Override
96    boolean isWorking()
97    {
98  0 return task != null && !task.isDone();
99    }
100   
 
101  0 toggle @Override
102    protected void submit()
103    {
104  0 if (task != null && !(task.isDone() || task.isCancelled()))
105    {
106  0 throw new IllegalStateException(
107    "Cannot submit new task if the prevoius one is still running");
108    }
109  0 Console.debug(
110    format("Worker %s queued", getWorker()));
111  0 task = executor.submit(() -> {
112  0 try
113    {
114  0 Console.debug(format("Worker %s started", getWorker()));
115  0 getWorker().run();
116  0 Console.debug(format("Worker %s finished", getWorker()));
117    } catch (InterruptedException e)
118    {
119  0 Console.debug(format("Worker %s interrupted", getWorker()));
120    } catch (Throwable th)
121    {
122  0 Console.debug(format("Worker %s failed", getWorker()), th);
123    } finally
124    {
125  0 if (!isRegistered())
126    {
127    // delete worker reference so garbage collector can remove it
128  0 worker = null;
129    }
130    }
131    });
132    }
133   
 
134  0 toggle @Override
135    synchronized void cancel()
136    {
137  0 if (!isWorking())
138    {
139  0 return;
140    }
141  0 Console.debug(format("Cancelling worker %s", getWorker()));
142  0 task.cancel(true);
143    }
144    }
145   
 
146    private class PollableWorkerManager extends WorkerManager
147    {
148    private Future<?> task = null;
149   
 
150  0 toggle PollableWorkerManager(PollableAlignCalcWorkerI worker)
151    {
152  0 super(worker);
153    }
154   
 
155  0 toggle @Override
156    protected PollableAlignCalcWorkerI getWorker()
157    {
158  0 return (PollableAlignCalcWorkerI) super.getWorker();
159    }
160   
 
161  0 toggle @Override
162    boolean isWorking()
163    {
164  0 return task != null && !task.isDone();
165    }
166   
 
167  0 toggle protected void submit()
168    {
169  0 if (task != null && !(task.isDone() || task.isCancelled()))
170    {
171  0 throw new IllegalStateException(
172    "Cannot submit new task if the previous one is still running");
173    }
174  0 Console.debug( format("Worker %s queued", getWorker()));
175  0 final var runnable = new Runnable()
176    {
177    private boolean started = false;
178   
179    private boolean completed = false;
180   
181    Future<?> future = null;
182   
 
183  0 toggle @Override
184    public void run()
185    {
186  0 try
187    {
188  0 if (!started)
189    {
190  0 Console.debug(format("Worker %s started", getWorker()));
191  0 getWorker().startUp();
192  0 started = true;
193    }
194  0 else if (!completed)
195    {
196  0 Console.debug(format("Polling worker %s", getWorker()));
197  0 if (getWorker().poll())
198    {
199  0 Console.debug(format("Worker %s finished", getWorker()));
200  0 completed = true;
201    }
202    }
203    } catch (Throwable th)
204    {
205  0 Console.debug(format("Worker %s failed", getWorker()), th);
206  0 completed = true;
207    }
208  0 if (completed)
209    {
210  0 final var worker = getWorker();
211  0 if (!isRegistered())
212  0 PollableWorkerManager.super.worker = null;
213  0 Console.debug(format("Finalizing completed worker %s", worker));
214  0 worker.done();
215    // almost impossible, but the future may be null at this point
216    // let it throw NPE to cancel forcefully
217  0 future.cancel(false);
218    }
219    }
220    };
221  0 runnable.future = task = executor.scheduleWithFixedDelay(runnable, 10,
222    1000, TimeUnit.MILLISECONDS);
223    }
224   
 
225  0 toggle synchronized protected void cancel()
226    {
227  0 if (!isWorking())
228    {
229  0 return;
230    }
231  0 Console.debug(format("Cancelling worker %s", getWorker()));
232  0 task.cancel(false);
233  0 executor.submit(() -> {
234  0 final var worker = getWorker();
235  0 if (!isRegistered())
236  0 PollableWorkerManager.super.worker = null;
237  0 if (worker != null)
238    {
239  0 worker.cancel();
240  0 Console.debug(format("Finalizing cancelled worker %s", worker));
241  0 worker.done();
242    }
243    });
244    }
245    }
246   
247    private final ScheduledExecutorService executor = Executors
248    .newSingleThreadScheduledExecutor();
249   
250    private final Map<AlignCalcWorkerI, WorkerManager> registered = synchronizedMap(
251    new HashMap<>());
252   
253    private final Map<AlignCalcWorkerI, WorkerManager> oneshot = synchronizedMap(
254    new WeakHashMap<>());
255   
256    private final List<AlignCalcListener> listeners = new CopyOnWriteArrayList<>();
257   
 
258  0 toggle private WorkerManager createManager(AlignCalcWorkerI worker)
259    {
260  0 if (worker instanceof PollableAlignCalcWorkerI)
261    {
262  0 return new PollableWorkerManager((PollableAlignCalcWorkerI) worker);
263    }
264    else
265    {
266  0 return new SimpleWorkerManager(worker);
267    }
268    }
269   
 
270  0 toggle @Override
271    public void registerWorker(AlignCalcWorkerI worker)
272    {
273  0 Objects.requireNonNull(worker);
274  0 WorkerManager manager = createManager(worker);
275  0 registered.putIfAbsent(worker, manager);
276  0 startWorker(worker);
277    }
278   
 
279  0 toggle @Override
280    public List<AlignCalcWorkerI> getWorkers()
281    {
282  0 List<AlignCalcWorkerI> result = new ArrayList<>(registered.size());
283  0 result.addAll(registered.keySet());
284  0 return result;
285    }
286   
 
287  0 toggle @Override
288    public List<AlignCalcWorkerI> getWorkersOfClass(
289    Class<? extends AlignCalcWorkerI> cls)
290    {
291  0 List<AlignCalcWorkerI> collected = new ArrayList<>();
292  0 for (var worker : getWorkers())
293    {
294  0 if (worker.getClass().equals(cls))
295    {
296  0 collected.add(worker);
297    }
298    }
299  0 return unmodifiableList(collected);
300    }
301   
 
302  0 toggle @Override
303    public void removeWorker(AlignCalcWorkerI worker)
304    {
305  0 if (worker.isDeletable())
306    {
307  0 registered.remove(worker);
308    }
309    }
310   
 
311  0 toggle @Override
312    public void removeWorkerForAnnotation(AlignmentAnnotation annot)
313    {
314  0 synchronized (registered)
315    {
316  0 for (var worker : getWorkers())
317    {
318  0 if (worker.involves(annot))
319    {
320  0 removeWorker(worker);
321    }
322    }
323    }
324    }
325   
 
326  0 toggle @Override
327    public void removeWorkersOfClass(Class<? extends AlignCalcWorkerI> cls)
328    {
329  0 synchronized (registered)
330    {
331  0 for (var worker : getWorkers())
332    {
333  0 if (worker.getClass().equals(cls))
334    {
335  0 removeWorker(worker);
336    }
337    }
338    }
339    }
340   
 
341  0 toggle @Override
342    public void disableWorker(AlignCalcWorkerI worker)
343    {
344    // Null pointer check might be needed
345  0 registered.get(worker).setEnabled(false);
346    }
347   
 
348  0 toggle @Override
349    public void enableWorker(AlignCalcWorkerI worker)
350    {
351    // Null pointer check might be needed
352  0 registered.get(worker).setEnabled(true);
353    }
354   
 
355  0 toggle @Override
356    public boolean isDisabled(AlignCalcWorkerI worker)
357    {
358  0 if (registered.containsKey(worker))
359    {
360  0 return !registered.get(worker).isEnabled();
361    }
362    else
363    {
364  0 return false;
365    }
366    }
367   
 
368  0 toggle @Override
369    public boolean isWorking(AlignCalcWorkerI worker)
370    {
371  0 var manager = registered.get(worker);
372  0 if (manager == null)
373  0 manager = oneshot.get(worker);
374  0 if (manager == null)
375  0 return false;
376    else
377  0 return manager.isWorking();
378    }
379   
 
380  0 toggle @Override
381    public boolean isWorkingWithAnnotation(AlignmentAnnotation annot)
382    {
383  0 synchronized (registered)
384    {
385  0 for (var entry : registered.entrySet())
386  0 if (entry.getKey().involves(annot) && entry.getValue().isWorking())
387  0 return true;
388    }
389  0 synchronized (oneshot)
390    {
391  0 for (var entry : registered.entrySet())
392  0 if (entry.getKey().involves(annot) && entry.getValue().isWorking())
393  0 return true;
394    }
395  0 return false;
396    }
397   
 
398  0 toggle @Override
399    public boolean isWorking()
400    {
401  0 synchronized (registered)
402    {
403  0 for (var manager : registered.values())
404  0 if (manager.isWorking())
405  0 return true;
406    }
407  0 synchronized (oneshot)
408    {
409  0 for (var manager : oneshot.values())
410  0 if (manager.isWorking())
411  0 return true;
412    }
413  0 return false;
414    }
415   
 
416  0 toggle @Override
417    public void startWorker(AlignCalcWorkerI worker)
418    {
419  0 Objects.requireNonNull(worker);
420  0 var manager = registered.get(worker);
421  0 if (manager == null)
422    {
423  0 Console.warn("Starting unregistered worker " + worker);
424  0 manager = createManager(worker);
425  0 oneshot.put(worker, manager);
426    }
427  0 manager.restart();
428    }
429   
 
430  0 toggle @Override
431    public void restartWorkers()
432    {
433  0 synchronized (registered)
434    {
435  0 for (var manager : registered.values())
436    {
437  0 manager.restart();
438    }
439    }
440    }
441   
 
442  0 toggle @Override
443    public void cancelWorker(AlignCalcWorkerI worker)
444    {
445  0 Objects.requireNonNull(worker);
446  0 var manager = registered.get(worker);
447  0 if (manager == null)
448  0 manager = oneshot.get(worker);
449  0 if (manager == null)
450    {
451  0 throw new NoSuchElementException();
452    }
453  0 manager.cancel();
454    }
455   
 
456  0 toggle private void notifyQueued(AlignCalcWorkerI worker)
457    {
458  0 for (AlignCalcListener listener : listeners)
459    {
460  0 listener.workerQueued(worker);
461    }
462    }
463   
 
464  0 toggle private void notifyStarted(AlignCalcWorkerI worker)
465    {
466  0 for (AlignCalcListener listener : listeners)
467    {
468  0 listener.workerStarted(worker);
469    }
470    }
471   
 
472  0 toggle private void notifyCompleted(AlignCalcWorkerI worker)
473    {
474  0 for (AlignCalcListener listener : listeners)
475    {
476  0 try
477    {
478  0 listener.workerCompleted(worker);
479    } catch (RuntimeException e)
480    {
481  0 e.printStackTrace();
482    }
483    }
484    }
485   
 
486  0 toggle private void notifyCancelled(AlignCalcWorkerI worker)
487    {
488  0 for (AlignCalcListener listener : listeners)
489    {
490  0 try
491    {
492  0 listener.workerCancelled(worker);
493    } catch (RuntimeException e)
494    {
495  0 e.printStackTrace();
496    }
497    }
498    }
499   
 
500  0 toggle private void notifyExceptional(AlignCalcWorkerI worker,
501    Throwable throwable)
502    {
503  0 for (AlignCalcListener listener : listeners)
504    {
505  0 try
506    {
507  0 listener.workerExceptional(worker, throwable);
508    } catch (RuntimeException e)
509    {
510  0 e.printStackTrace();
511    }
512    }
513    }
514   
 
515  0 toggle @Override
516    public void addAlignCalcListener(AlignCalcListener listener)
517    {
518  0 listeners.add(listener);
519    }
520   
 
521  0 toggle @Override
522    public void removeAlignCalcListener(AlignCalcListener listener)
523    {
524  0 listeners.remove(listener);
525    }
526   
 
527  0 toggle @Override
528    public void shutdown()
529    {
530  0 executor.shutdownNow();
531  0 listeners.clear();
532  0 registered.clear();
533    }
534   
535    }
  • Report generated by OpenClover v 4.4.1 on Tue Mar 10 2026 14:59:17 GMT using coverage data from Thu Jan 1 1970 01:00:00 GMT.
  • OpenClover is free and open-source software.