ATEST-122

src/main/java/ch/psi/daq/queryrest/response/JsonStreamSerializer.java

@@ -0,0 +1,24 @@
+package ch.psi.daq.queryrest.response;
+
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.stream.Stream;
+
+import com.fasterxml.jackson.core.JsonGenerationException;
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import com.fasterxml.jackson.databind.ser.std.StdSerializer;
+
+public class JsonStreamSerializer extends StdSerializer<Stream<?>>{
+   private static final long serialVersionUID = 4695859735299703478L;
+   
+   public JsonStreamSerializer() {
+      super(Stream.class, true);
+   }
+
+   @Override
+   public void serialize(Stream<?> stream, JsonGenerator jgen, SerializerProvider provider) throws IOException,
+         JsonGenerationException {
+      provider.findValueSerializer(Iterator.class, null).serialize(stream.iterator(), jgen, provider);
+   }
+}

src/main/java/ch/psi/daq/queryrest/response/ResponseStreamWriter.java

@@ -21,9 +21,8 @@ import com.fasterxml.jackson.databind.ObjectWriter;
 import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
 import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
 
-import ch.psi.daq.domain.cassandra.DataEvent;
 import ch.psi.daq.query.model.AbstractQuery;
-import ch.psi.daq.query.model.AggregationEnum;
+import ch.psi.daq.query.model.Aggregation;
 import ch.psi.daq.query.model.QueryField;
 
 /**
@@ -44,16 +43,16 @@ public class ResponseStreamWriter {
     * Responding with the the contents of the stream by writing into the output stream of the
     * {@link ServletResponse}.
     * 
-    * @param stream {@link Stream} instance of {@link DataEvent}s
+    * @param stream Mapping from channel name to data
     * @param query concrete instance of {@link AbstractQuery}
     * @param response {@link ServletResponse} instance given by the current HTTP request
     * @throws IOException thrown if writing to the output stream fails
     */
-   public void respond(Stream<Entry<String, Stream<? extends DataEvent>>> stream, AbstractQuery query,
+   public void respond(Stream<Entry<String, ?>> stream, AbstractQuery query,
          ServletResponse response) throws IOException {
 
       Set<QueryField> queryFields = query.getFields();
-      List<AggregationEnum> aggregations = query.getAggregations();
+      List<Aggregation> aggregations = query.getAggregations();
 
       Set<String> includedFields =
             new LinkedHashSet<String>(queryFields.size() + (aggregations != null ? aggregations.size() : 0));
@@ -62,7 +61,7 @@ public class ResponseStreamWriter {
          includedFields.add(field.name());
       }
       if (aggregations != null) {
-         for (AggregationEnum aggregation : query.getAggregations()) {
+         for (Aggregation aggregation : query.getAggregations()) {
             includedFields.add(aggregation.name());
          }
       }
@@ -88,43 +87,33 @@ public class ResponseStreamWriter {
       ObjectWriter writer = mapper.writer(propertyFilter);
       return writer;
    }
-
+   
    /**
-    * Writes the Java stream into the output stream.
+    * Writes the outer Java stream into the output stream.
     * 
-    * @param stream {@link Stream} instance of {@link DataEvent}s
+    * @param stream Mapping from channel name to data
     * @param response {@link ServletResponse} instance given by the current HTTP request
     * @param writer configured writer that includes the fields the end user wants to see
     * @throws IOException thrown if writing to the output stream fails
     */
-   private void respondInternal(Stream<Entry<String, Stream<? extends DataEvent>>> stream, ServletResponse response,
+   private void respondInternal(Stream<Entry<String, ?>> stream, ServletResponse response,
          ObjectWriter writer)
          throws IOException {
 
       JsonGenerator generator = jsonFactory.createGenerator(response.getOutputStream(), JsonEncoding.UTF8);
       generator.writeStartArray();
       stream
-            /* ensure elements are sequentially written to the stream */
+            /* ensure elements are sequentially written */
             .sequential()
             .forEach(
                   entry -> {
                      try {
                         generator.writeStartObject();
                         generator.writeStringField(QueryField.channel.name(), entry.getKey());
-                        generator.writeArrayFieldStart("data");
-                        entry.getValue()
-                              /* ensure elements are sequentially written to the stream */
-                              .sequential()
-                              .forEach(
-                                    dataEvent -> {
-                                       try {
-                                          writer.writeValue(generator, dataEvent);
-                                       } catch (Exception e) {
-                                          logger.error("Could not write event with pulse-id '{}' of channel '{}'",
-                                                dataEvent.getPulseId(), entry.getKey(), e);
-                                       }
-                                    });
-                        generator.writeEndArray();
+
+                        generator.writeFieldName("data");
+                        writer.writeValue(generator, entry.getValue());
+                        
                         generator.writeEndObject();
                      } catch (Exception e) {
                         logger.error("Could not write channel name of channel '{}'", entry.getKey(), e);