--- /dev/null
+package org.simantics.history.rest;
+
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.core.CacheControl;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+
+import org.simantics.db.exception.DatabaseException;
+import org.simantics.history.HistoryException;
+import org.simantics.history.HistorySampler;
+import org.simantics.history.HistorySamplerItem;
+import org.simantics.history.HistorySamplerItem2;
+import org.simantics.history.csv.ExportInterpolation;
+import org.simantics.history.util.HistoryExportUtil;
+import org.simantics.history.util.StreamIterator;
+import org.simantics.history.util.ValueBand;
+
+import gnu.trove.list.array.TDoubleArrayList;
+
+@Path("history")
+@Produces(MediaType.APPLICATION_JSON)
+public class HistoryRestApi {
+
+ private static gnu.trove.map.TLongObjectMap<HistoryCache> historyCaches = new gnu.trove.map.hash.TLongObjectHashMap<>();
+
+ private static CacheControl cacheControl;
+
+ static {
+ cacheControl = new CacheControl();
+ cacheControl.setNoCache(true);
+ cacheControl.setNoStore(true);
+ }
+
+ @Path("/register")
+ @POST
+ public static synchronized Response register(@QueryParam("runId") long run) {
+ if (historyCaches.containsKey(run))
+ return Response.ok().build();
+ try {
+ HistoryCache cache = new HistoryCache(run);
+ historyCaches.put(run, cache);
+ return Response.ok().cacheControl(cacheControl).build();
+ } catch (DatabaseException e) {
+ return Response.status(Status.NOT_FOUND).build();
+ }
+ }
+
+ @Path("/unregister")
+ @POST
+ public static synchronized Response unregister(@QueryParam("runId") long run) {
+ HistoryCache cache = historyCaches.remove(run);
+ if (cache != null) {
+ cache.dispose();
+ }
+ return Response.ok().cacheControl(cacheControl).build();
+ }
+
+ @Path("/values")
+ @GET
+ public static Response activeHistoryValuesAndTimesWithTimeStep(@QueryParam("runId") long run,@QueryParam("itemId") long item,@QueryParam("startTime") double startTime,@QueryParam("endTime") double endTime,@QueryParam("timeWindow") double timeWindow, @QueryParam("timeStep")double timeStep) {
+ try {
+ HistoryCache cache = getOrCreateCache(run);
+ TDoubleArrayList doubles;
+ synchronized (cache) {
+ HistorySamplerItem hi = cache.getSamplerItem(item);
+ doubles= HistorySampler.sample(hi, startTime, endTime, timeWindow, timeStep, true);
+ }
+ return Response.ok(buildJSONResponse("values",doubles.toArray())).cacheControl(cacheControl).build();
+ } catch (HistoryException | IOException | DatabaseException e) {
+ return Response.serverError().build();
+ }
+
+ }
+ @Path("/lvalues")
+ @GET
+ public static Response sampleHistory(@QueryParam("runId")long run,@QueryParam("itemId") long item,@QueryParam("endTime") double endTime, @QueryParam("timeWindow") double timeWindow,@QueryParam("maxSamples") int maxSamples,@QueryParam("resample") boolean resample) {
+ try {
+ HistoryCache cache = getOrCreateCache(run);
+ TDoubleArrayList doubles = null;
+ synchronized (cache) {
+ HistorySamplerItem2 hi = cache.getSamplerItem2(item);
+ doubles = HistorySampler.sample(hi, endTime, timeWindow, maxSamples, resample);
+ }
+ return Response.ok(buildJSONResponse("values",doubles.toArray())).cacheControl(cacheControl).build();
+ } catch (HistoryException | IOException | DatabaseException e) {
+ return Response.serverError().build();
+ }
+ }
+
+ @Path("/samples")
+ @GET
+ public static Response sampleHistory(@QueryParam("runId")long run,@QueryParam("itemId") long item,@QueryParam("startTime") double startTime, @QueryParam("endTime") double endTime, @QueryParam("maxSamples") int maxSamples) {
+
+ if (maxSamples <= 0)
+ return Response.status(Status.BAD_REQUEST).build();
+ try {
+ HistoryCache cache = getOrCreateCache(run);
+ Map<String, Object> result = null;
+ synchronized (cache) {
+ result = _sampleHistory(cache, item, startTime, endTime, maxSamples);
+ }
+ return Response.ok(result).cacheControl(cacheControl).build();
+ } catch (HistoryException | DatabaseException e) {
+ return Response.serverError().build();
+ }
+ }
+
+ @Path("/multisamples")
+ @GET
+ public static Response sampleHistories(@QueryParam("runId")long run,@QueryParam("itemId") final List<Long> items,@QueryParam("startTime") double startTime, @QueryParam("endTime") double endTime, @QueryParam("maxSamples") int maxSamples) {
+
+ if (maxSamples <= 0)
+ return Response.status(Status.BAD_REQUEST).build();
+ try {
+ HistoryCache cache = getOrCreateCache(run);
+ Map<String, Object> combined = new HashMap<>();
+ synchronized (cache) {
+ for (long item : items) {
+ Map<String, Object> result = _sampleHistory(cache, item, startTime, endTime, maxSamples);
+ combined.put(Long.toString(item), result);
+ }
+ }
+ return Response.ok(combined).cacheControl(cacheControl).build();
+ } catch (HistoryException | DatabaseException e) {
+ return Response.serverError().build();
+ }
+ }
+
+ @Path("/ranges")
+ @GET
+ public static Response ranges(@QueryParam("runId")long run,@QueryParam("itemId") final List<Long> items) {
+
+ try {
+ HistoryCache cache = getOrCreateCache(run);
+ Map<String, Object> combined = new HashMap<>();
+ synchronized (cache) {
+ for (long item : items) {
+ HistorySamplerItem2 hi = null;
+ try {
+ hi= cache.getSamplerItem2(item);
+ hi.open();
+ double first = hi.iter.getFirstTime();
+ double last = hi.iter.getLastTime();
+ combined.put(Long.toString(item), buildJSONResponse("start",first,"end",last));
+
+ } finally {
+ hi.close();
+ }
+
+ }
+ }
+ return Response.ok(combined).cacheControl(cacheControl).build();
+
+ } catch (HistoryException | DatabaseException e) {
+ return Response.serverError().build();
+ }
+ }
+ private static synchronized HistoryCache getOrCreateCache(long run) throws DatabaseException {
+ HistoryCache cache = historyCaches.get(run);
+ if (cache == null || cache.isDisposed()) {
+ cache = new HistoryCache(run);
+ historyCaches.put(run, cache);
+ }
+ return cache;
+ }
+
+
+
+ private static Map<String,Object> _sampleHistory(HistoryCache cache, long item, double startTime, double endTime, int maxSamples) throws DatabaseException, HistoryException {
+ HistorySamplerItem2 hi = null;
+ try {
+ hi = cache.getSamplerItem2(item);
+
+ double timeWindow = endTime - startTime;
+ //double timeStep = 0.0;
+ double timeStep = timeWindow / maxSamples;
+ double secondsPerPixel = timeWindow / (double) maxSamples;
+ hi.flush();
+ if (hi.iter == null)
+ hi.open(secondsPerPixel);
+ StreamIterator iter = hi.iter;
+ if (iter.isEmpty()) {
+ buildJSONResponse("time",new double[0],"value",new double[0]);
+ }
+ double dataFrom = iter.getFirstTime();
+ double dataEnd = iter.getLastTime();
+ boolean hasAnyValues = dataFrom != Double.MAX_VALUE && dataEnd != -Double.MAX_VALUE;
+ if (!hasAnyValues) {
+ return buildJSONResponse("time",new double[0],"value",new double[0]);
+ }
+ double from = Math.max(startTime, dataFrom);
+ double end = Math.min(endTime, dataEnd);
+ iter.gotoTime(startTime);
+
+ double time = from;
+
+ BigDecimal bigTime = new BigDecimal(String.valueOf(time));
+ BigDecimal bigTimeStep = new BigDecimal(String.valueOf(timeStep));
+
+ TDoubleArrayList times = new TDoubleArrayList();
+ TDoubleArrayList values = new TDoubleArrayList();
+ TDoubleArrayList min = new TDoubleArrayList();
+ TDoubleArrayList max = new TDoubleArrayList();
+ TDoubleArrayList avg = new TDoubleArrayList();
+ if (!iter.gotoTime(time)) {
+ return buildJSONResponse("time",new double[0],"value",new double[0]);
+ }
+
+
+ ExportInterpolation interpolation = ExportInterpolation.LINEAR_INTERPOLATION;
+ do {
+ //System.out.println("process " + time + " " + iter.getValueBand() + " (ignore = " + ignore + ")");
+
+ // Check for valid value
+ if ( iter.hasValidValue() ) {
+
+ // Write time
+ times.add(time);
+ // Write value
+ Object value = iter.getValueBand().getValue();
+ //System.out.print("Add value : " + value);
+ if (value instanceof Number) {
+ if (value instanceof Float || value instanceof Double) {
+ switch (interpolation) {
+ case PREVIOUS_SAMPLE:
+ values.add(((Number) value).doubleValue());
+ break;
+
+ case LINEAR_INTERPOLATION:
+ if (time != iter.getValueBand().getTimeDouble() && iter.hasNext()) {
+ // Interpolate
+ int currentIndex = iter.getIndex();
+ ValueBand band = iter.getValueBand();
+ //double t1 = band.getTimeDouble();
+ Number v1 = (Number) value;
+ double t12 = band.getEndTimeDouble();
+ iter.next();
+ double t2 = iter.getValueBand().getTimeDouble();
+ Number v2 = (Number) iter.getValueBand().getValue();
+ iter.gotoIndex(currentIndex);
+
+ double vs = v1.doubleValue();
+ if (time > t12)
+ vs = HistoryExportUtil.biglerp(t12, v1.doubleValue(), t2, v2.doubleValue(), time);
+
+ values.add(vs);
+
+ } else {
+ // Exact timestamp match, or last sample.
+ // Don't interpolate nor extrapolate.
+ values.add(((Number) value).doubleValue());
+ }
+ break;
+
+ default:
+ throw new UnsupportedOperationException("Unsupported interpolation: " + interpolation);
+ }
+ if (iter.getValueBand().hasMax())
+ max.add(((Number) iter.getValueBand().getMax()).doubleValue());
+ else
+ max.add(Double.NaN);
+ if (iter.getValueBand().hasMin())
+ min.add(((Number) iter.getValueBand().getMin()).doubleValue());
+ else
+ min.add(Double.NaN);
+ if (iter.getValueBand().hasAvg())
+ avg.add(((Number) iter.getValueBand().getAvg()).doubleValue());
+ else
+ avg.add(Double.NaN);
+ } else {
+ throw new IllegalStateException("Value is not a number " + value);
+ }
+ } else if (value instanceof Boolean) {
+ values.add( (Boolean)value ? 1.0: 0.0);
+ } else {
+ throw new IllegalStateException("Value is not a number " + value);
+ }
+
+ }
+
+
+ // Read next values, and the following times
+ if ( timeStep>0.0 ) {
+ bigTime = bigTime.add(bigTimeStep);
+ time = bigTime.doubleValue();
+ } else {
+ // Get smallest end time that is larger than current time
+ Double nextTime = null;
+ //System.out.println(" time = "+time);
+ if(!iter.hasNext()) {
+ duplicateLastDataPoint(values);
+ times.add(end);
+ break;
+ }
+ Double itemNextTime = iter.getNextTime( time );
+ //System.out.println(" "+iter.toString()+" nextTime="+itemNextTime);
+ if ( nextTime == null || ( nextTime > itemNextTime && !itemNextTime.equals( time ) ) ) nextTime = itemNextTime;
+ if ( nextTime == null || nextTime.equals( time ) ) break;
+ time = nextTime;
+ }
+
+ boolean hasMore = false;
+
+ iter.proceedToTime(time);
+ if (HistoryExportUtil.contains(iter, time)) hasMore = true;
+
+ if (!hasMore) {
+ if (time <= end) {
+ duplicateLastDataPoint(values);
+ times.add(end);
+ }
+ break;
+ }
+
+ } while (time <= end);
+
+ return buildJSONResponse("time", times.toArray(),"value",values.toArray(), "min", min.toArray(), "max", max.toArray(),"avg", avg.toArray());
+ } finally {
+ if (hi != null) {
+ try {
+ hi.close();
+ } catch (Throwable err) {
+ }
+ }
+ }
+ }
+
+ private static void duplicateLastDataPoint(TDoubleArrayList data) {
+ double lastValue = data.get(data.size() - 1);
+ //System.out.println("Duplicating last sample value " + lastValue + " @ " + timestamp);
+ data.add(lastValue);
+ }
+
+ private static Map<String, Object> buildJSONResponse(Object... keyValues) {
+ if ((keyValues.length % 2) != 0)
+ throw new IllegalArgumentException("Invalid amount of arguments! " + Arrays.toString(keyValues));
+ Map<String, Object> results = new HashMap<>(keyValues.length / 2);
+ for (int i = 0; i < keyValues.length; i += 2) {
+ Object key = keyValues[i];
+ Object value = keyValues[i + 1];
+ if (!(key instanceof String))
+ throw new IllegalArgumentException("Key with index " + i + " is not String");
+ results.put((String) key, value);
+ }
+ return results;
+ }
+
+}
Code Review / simantics / platform.git / blobdiff