move TcpIngestor to pdb-ui

and start it in the web application.
Also use the spring way of handling property files.

pdb-ui/src/test/java/org/lucares/performance/db/ingestor/TcpIngestorTest.java

@@ -0,0 +1,171 @@
+package org.lucares.performance.db.ingestor;
+
+import java.io.IOException;
+import java.net.ConnectException;
+import java.net.InetSocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.SocketChannel;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.time.Instant;
+import java.time.OffsetDateTime;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import org.lucares.pdb.api.Entry;
+import org.lucares.pdbui.TcpIngestor;
+import org.lucares.performance.db.FileUtils;
+import org.lucares.performance.db.PerformanceDb;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.testng.Assert;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import liquibase.exception.LiquibaseException;
+
+@Test
+public class TcpIngestorTest {
+
+	private static final Logger LOGGER = LoggerFactory.getLogger(TcpIngestorTest.class);
+
+	private Path dataDirectory;
+
+	@BeforeMethod
+	public void beforeMethod() throws IOException {
+		dataDirectory = Files.createTempDirectory("pdb");
+	}
+
+	@AfterMethod
+	public void afterMethod() throws IOException {
+		FileUtils.delete(dataDirectory);
+	}
+
+	public void testIngestDataViaTcpStream() throws LiquibaseException, Exception {
+
+		final OffsetDateTime dateA = OffsetDateTime.now();
+		final OffsetDateTime dateB = OffsetDateTime.now();
+		final String host = "someHost";
+
+		try (TcpIngestor ingestor = new TcpIngestor(dataDirectory)) {
+
+			ingestor.start();
+
+			final Map<String, Object> entryA = new HashMap<>();
+			entryA.put("duration", 1);
+			entryA.put("@timestamp", dateA.format(DateTimeFormatter.ISO_ZONED_DATE_TIME));
+			entryA.put("host", host);
+			entryA.put("tags", Collections.emptyList());
+
+			final Map<String, Object> entryB = new HashMap<>();
+			entryB.put("duration", 2);
+			entryB.put("@timestamp", dateB.format(DateTimeFormatter.ISO_ZONED_DATE_TIME));
+			entryB.put("host", host);
+			entryB.put("tags", Collections.emptyList());
+
+			send(entryA, entryB);
+		} catch (final Exception e) {
+			LOGGER.error("", e);
+			throw e;
+		}
+
+		try (PerformanceDb db = new PerformanceDb(dataDirectory)) {
+			final List<Entry> result = db.get("host=" + host).singleGroup().asList();
+			Assert.assertEquals(result.size(), 2);
+
+			Assert.assertEquals(result.get(0).getValue(), 1);
+			Assert.assertEquals(result.get(0).getDate().toInstant(), dateA.toInstant());
+
+			Assert.assertEquals(result.get(1).getValue(), 2);
+			Assert.assertEquals(result.get(1).getDate().toInstant(), dateB.toInstant());
+		}
+	}
+
+	@SafeVarargs
+	private final void send(final Map<String, Object>... entries) throws IOException {
+
+		final StringBuilder streamData = new StringBuilder();
+		final ObjectMapper mapper = new ObjectMapper();
+
+		for (final Map<String, Object> entry : entries) {
+
+			streamData.append(mapper.writeValueAsString(entry));
+			streamData.append("\n");
+		}
+
+		final SocketChannel channel = connect();
+		final ByteBuffer src = ByteBuffer.wrap(streamData.toString().getBytes(StandardCharsets.UTF_8));
+		channel.write(src);
+
+		try {
+			// ugly workaround: the channel was close too early and not all data
+			// was received
+			TimeUnit.MILLISECONDS.sleep(10);
+		} catch (final InterruptedException e) {
+			throw new IllegalStateException(e);
+		}
+		channel.close();
+		LOGGER.trace("closed sender connection");
+	}
+
+	private SocketChannel connect() throws IOException {
+
+		SocketChannel result = null;
+
+		while (true) {
+			try {
+				result = SocketChannel.open();
+				result.configureBlocking(true);
+				result.connect(new InetSocketAddress("127.0.0.1", TcpIngestor.PORT));
+				break;
+			} catch (final ConnectException e) {
+				// server socket not yet ready, it should be ready any time soon
+			}
+		}
+
+		return result;
+	}
+
+	@Test
+	public void testIngestionThreadDoesNotDieOnErrors() throws Exception {
+		final OffsetDateTime invalidDate = OffsetDateTime.ofInstant(Instant.ofEpochMilli(-1), ZoneOffset.UTC);
+		final OffsetDateTime dateB = OffsetDateTime.now();
+		final String host = "someHost";
+
+		try (TcpIngestor tcpIngestor = new TcpIngestor(dataDirectory)) {
+			tcpIngestor.start();
+
+			// this entry will be skipped, because the date is invalid
+			final Map<String, Object> entryA = new HashMap<>();
+			entryA.put("duration", 1);
+			entryA.put("@timestamp", invalidDate.format(DateTimeFormatter.ISO_ZONED_DATE_TIME));
+			entryA.put("host", host);
+			entryA.put("tags", Collections.emptyList());
+
+			final Map<String, Object> entryB = new HashMap<>();
+			entryB.put("duration", 2);
+			entryB.put("@timestamp", dateB.format(DateTimeFormatter.ISO_ZONED_DATE_TIME));
+			entryB.put("host", host);
+			entryB.put("tags", Collections.emptyList());
+
+			send(entryA, entryB);
+		}
+
+		try (PerformanceDb db = new PerformanceDb(dataDirectory)) {
+			final List<Entry> result = db.get("host=" + host).singleGroup().asList();
+			Assert.assertEquals(result.size(), 1);
+
+			Assert.assertEquals(result.get(0).getValue(), 2);
+			Assert.assertEquals(result.get(0).getDate().toInstant(), dateB.toInstant());
+		}
+	}
+}