/*
|
neon - Embeddable HTTP Server based on jdk.httpserver
|
Copyright (C) 2024 Ulrich Hilger
|
|
This program is free software: you can redistribute it and/or modify
|
it under the terms of the GNU Affero General Public License as
|
published by the Free Software Foundation, either version 3 of the
|
License, or (at your option) any later version.
|
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU Affero General Public License for more details.
|
|
You should have received a copy of the GNU Affero General Public License
|
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
*/
|
package de.uhilger.neon.entity;
|
|
import com.grack.nanojson.JsonArray;
|
import com.grack.nanojson.JsonObject;
|
import com.grack.nanojson.JsonParser;
|
import com.grack.nanojson.JsonParserException;
|
import java.io.File;
|
import java.io.FileNotFoundException;
|
import java.io.FileReader;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.Objects;
|
import java.util.logging.Logger;
|
import java.util.stream.Collectors;
|
|
/**
|
* Objekte der Klasse NeonDescriptor beschreiben einen Neon-Server
|
*
|
* @author Ulrich Hilger
|
*/
|
public class NeonDescriptor {
|
|
public String contentType;
|
public String contentId;
|
public String contentDescription;
|
public String instanceName;
|
public String instanceDescription;
|
public List<String> actorPackages;
|
public AuthenticatorDescriptor authenticator;
|
public List<ServerDescriptor> server;
|
public List<WsServerDescriptor> wsserver;
|
|
/**
|
* Den NeonDescriptor aus einer in JSON abgefassten Serverbeschreibungsdatei lesen.
|
*
|
* vgl. https://uhilger.de/data/pg/neon/anleitung.adoc#srv-desc
|
*
|
* @param fileName Name und ggf. Pfad zur Serverbeschreibung
|
*/
|
public void read(String fileName) {
|
try {
|
File f = new File(fileName);
|
JsonObject serverDesc = JsonParser.object().from(new FileReader(f));
|
|
//NeonDescriptor d = new NeonDescriptor();
|
this.instanceName = serverDesc.getString("instanceName");
|
this.contentType = serverDesc.getString("contentType");
|
this.contentId = serverDesc.getString("contentId");
|
this.contentDescription = serverDesc.getString("contentDescription");
|
this.instanceDescription = serverDesc.getString("instanceDescription");
|
this.actorPackages = getArray(serverDesc, "actorPackages");
|
|
JsonObject authObj = serverDesc.getObject("authenticator");
|
if (null != authObj) {
|
this.authenticator = new AuthenticatorDescriptor();
|
this.authenticator.className = authObj.getString("className");
|
this.authenticator.attributes = getAttrMap(authObj, "attributes");
|
}
|
JsonArray serverArray = serverDesc.getArray("server");
|
this.server = new ArrayList<>();
|
Iterator serverIterator = serverArray.iterator();
|
while (serverIterator.hasNext()) {
|
Object iteratorObject = serverIterator.next();
|
if (iteratorObject instanceof JsonObject) {
|
JsonObject serverObject = (JsonObject) iteratorObject;
|
ServerDescriptor sd = new ServerDescriptor();
|
sd.name = serverObject.getString("name");
|
sd.port = serverObject.getInt("port", 0);
|
sd.contexts = new ArrayList<>();
|
JsonArray contextsArray = serverObject.getArray("contexts");
|
Iterator contextIterator = contextsArray.iterator();
|
while (contextIterator.hasNext()) {
|
Object contextObj = contextIterator.next();
|
if (contextObj instanceof JsonObject) {
|
JsonObject context = (JsonObject) contextObj;
|
ContextDescriptor cd = new ContextDescriptor();
|
cd.className = context.getString("className");
|
cd.sharedHandler = context.getBoolean("sharedHandler");
|
cd.contextPath = context.getString("contextPath");
|
if (context.containsKey("filter")) {
|
cd.filter = getArray(context, "filter");
|
}
|
cd.authenticator = context.getString("authenticator");
|
cd.attributes = getAttrMap(context, "attributes");
|
sd.contexts.add(cd);
|
}
|
}
|
this.server.add(sd);
|
}
|
}
|
//return d;
|
} catch (JsonParserException | FileNotFoundException ex) {
|
Logger.getLogger(NeonDescriptor.class.getName()).severe(ex.getMessage());
|
//return null;
|
}
|
}
|
|
/**
|
* Die Eintraege eines einfachen JSON-Array in eine String-Liste uebertragen
|
* @param src das Objekt, aus dem die Inhalte des JSON-Arrays gelesen werden
|
* @param name der Name des zu lesenden JSON-Arrays
|
* @return der Inhalt des JSON-Arrays als String-Liste
|
*/
|
private List<String> getArray(JsonObject src, String name) {
|
return src.getArray(name)
|
.stream()
|
.map((o) -> Objects.toString(o, null))
|
.collect(Collectors.toList());
|
}
|
|
/**
|
* Eine Liste von Attributen (Schluessel/Wert-Paare) aus einem JSON-Objekt
|
* in eine Map uebertragen.
|
*
|
* @param src das JSON-Objekt, aus dem die Attribute gelesen werden sollen
|
* @param name der Name des JSON-Elements, das die Attribute enthaelt
|
* @return eine Map mit den gelesenen Attributen
|
*/
|
private HashMap<String, String> getAttrMap(JsonObject src, String name) {
|
HashMap<String, String> map = new HashMap<>();
|
JsonObject attrObj = src.getObject(name);
|
Iterator attributeIterator = attrObj.keySet().iterator();
|
while (attributeIterator.hasNext()) {
|
Object keyObj = attributeIterator.next();
|
if (keyObj instanceof String) {
|
String key = (String) keyObj;
|
map.put(key, attrObj.get(key).toString());
|
}
|
}
|
return map;
|
}
|
}
|
