← Back to branch summary

~jstys-z/helioviewer.org/timeline

« back to all changes in this revision

Viewing changes to timeline/Highstock-1.3.10/exporting-server/java/highcharts-export/highcharts-export-convert/src/main/java/com/highcharts/export/pool/AbstractPool.java

  • Committer: Jeff Stys
  • Date: 2014-04-21 12:46:26 UTC
  • Revision ID: jstys@sesda3.com-20140421124626-2332pb2dyjc33jxi
Proof-of-concept version of Data Coverage Timeline using Highchart/Highstock javascript library.  Changes to getDataCoverage API in order to feed the necessary data to the Timeline

Show diffs side-by-side

added added

removed removed

Lines of Context:
timeline/Highstock-1.3.10/exporting-server/java/highcharts-export/highcharts-export-convert/src/main/java/com/highcharts/export/pool/AbstractPool.java
 
1
package com.highcharts.export.pool;
 
2
 
 
3
import com.highcharts.export.util.TempDir;
 
4
import java.io.File;
 
5
import java.io.IOException;
 
6
import java.nio.file.Files;
 
7
import java.nio.file.Path;
 
8
import java.nio.file.Paths;
 
9
import java.nio.file.attribute.BasicFileAttributes;
 
10
import java.util.Collection;
 
11
import java.util.Date;
 
12
import java.util.Queue;
 
13
import java.util.concurrent.atomic.AtomicInteger;
 
14
import org.apache.commons.io.FileUtils;
 
15
import org.apache.commons.io.filefilter.IOFileFilter;
 
16
 
 
17
import org.apache.log4j.Logger;
 
18
import org.springframework.scheduling.annotation.Scheduled;
 
19
 
 
20
public abstract class AbstractPool<T> implements ObjectPool<T> {
 
21
 
 
22
        final ObjectFactory<T> objectFactory;
 
23
        Queue<T> queue;
 
24
        final AtomicInteger poolSize = new AtomicInteger(0);
 
25
        int maxWait;
 
26
        final int capacity;
 
27
        final long retentionTime;
 
28
        protected static Logger logger = Logger.getLogger("pool");
 
29
 
 
30
        public AbstractPool(ObjectFactory<T> objectFactory, int number, int maxWait, Long retentionTime) throws PoolException {
 
31
                this.objectFactory = objectFactory;
 
32
                this.capacity = number;
 
33
                this.maxWait = maxWait;
 
34
                this.retentionTime = retentionTime;
 
35
        }
 
36
 
 
37
        @Override
 
38
        public void createObject() {
 
39
                T object = objectFactory.create();
 
40
                queue.add(object);
 
41
                poolSize.getAndIncrement();
 
42
        }
 
43
 
 
44
        @Override
 
45
        public void destroyObject(T object) {
 
46
                objectFactory.destroy(object);
 
47
        }
 
48
 
 
49
        @Override
 
50
        @Scheduled(initialDelay = 10000, fixedRate = 60000)
 
51
        public void poolCleaner() throws InterruptedException, PoolException {
 
52
 
 
53
                logger.debug("HC: queue size: " + queue.size() + " poolSize " + poolSize.get());
 
54
 
 
55
                int size = poolSize.get();
 
56
                // remove invalid objects
 
57
                for (int i = 0; i < size; i++) {
 
58
                        T object = borrowObject();
 
59
                        if (object == null) {
 
60
                                logger.debug("HC: object is null");
 
61
                                continue;
 
62
                        } else {
 
63
                                logger.debug("HC: validating " + object.toString());
 
64
                                if (!objectFactory.validate(object)) {
 
65
                                        logger.debug("HC: destroying " + object.toString());
 
66
                                        destroyObject(object);
 
67
                                } else {
 
68
                                        returnObject(object, false);
 
69
                                }
 
70
                        }
 
71
                }
 
72
 
 
73
                int number = poolSize.get() - capacity;
 
74
                logger.debug("in cleanpool, the surplus or shortage is: " + number);
 
75
                synchronized (this) {
 
76
                                int iterations = Math.abs(number);
 
77
                                for (int i = 0; i < iterations; i++) {
 
78
                                        if (number < 1) {
 
79
                                                this.createObject();
 
80
                                        } else {
 
81
                                                T object = borrowObject();
 
82
                                                this.destroyObject(object);
 
83
                                        }
 
84
                                }
 
85
                }
 
86
        }
 
87
 
 
88
        @Override
 
89
        @Scheduled(initialDelay = 15000, fixedRate = 60000)
 
90
        public void tempDirCleaner() {
 
91
                IOFileFilter filter = new IOFileFilter() {
 
92
 
 
93
                        @Override
 
94
                        public boolean accept(File file) {
 
95
                                try {
 
96
                                        Long now = new Date().getTime();
 
97
                                        Path path = Paths.get(file.getAbsolutePath());
 
98
                                        BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
 
99
                                        Long inBetween = now - attrs.lastAccessTime().toMillis();
 
100
 
 
101
                                        if (inBetween > retentionTime) {
 
102
                                                return true;
 
103
                                        }
 
104
 
 
105
                                } catch (IOException ioex) {
 
106
                                        logger.error("Error: while selection files for deletion: "  + ioex.getMessage());
 
107
                                }
 
108
                                return false;
 
109
                        }
 
110
 
 
111
                        @Override
 
112
                        public boolean accept(File file, String string) {
 
113
                                throw new UnsupportedOperationException("Not supported yet."); 
 
114
                        }
 
115
                };
 
116
 
 
117
                Collection<File> oldFiles = FileUtils.listFiles(TempDir.outputDir.toFile(),filter, null);
 
118
                for (File file : oldFiles) {
 
119
                        file.delete();
 
120
                }
 
121
        }
 
122
 
 
123
 
 
124
        /*Getter and Setters*/
 
125
        public int getMaxWait() {
 
126
                return maxWait;
 
127
        }
 
128
 
 
129
        public void setMaxWait(int maxWait) {
 
130
                this.maxWait = maxWait;
 
131
        }
 
132
}