leeonky / test-charm-java / 117

Committed 26 Feb 2025 03:01AM UTC coverage: 74.16% (+0.9%) from 73.251%

Build # 117

Build Type

push

circleci

Committed by

leeonky

Commit Message

Update version

Run Details

7838 of 10569 relevant lines covered (74.16%)

0.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.0

/DAL-extension-inspector/src/main/java/com/github/leeonky/dal/extensions/inspector/Inspector.java

package com.github.leeonky.dal.extensions.inspector;

import com.github.leeonky.dal.DAL;
import com.github.leeonky.dal.runtime.RuntimeContextBuilder;
import com.github.leeonky.interpreter.InterpreterException;
import com.github.leeonky.util.Suppressor;
import de.neuland.pug4j.PugConfiguration;
import de.neuland.pug4j.template.TemplateLoader;
import io.javalin.Javalin;
import io.javalin.http.staticfiles.Location;
import io.javalin.plugin.rendering.JavalinRenderer;
import io.javalin.websocket.WsContext;

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.function.Supplier;
import java.util.stream.Collectors;

import static com.github.leeonky.util.function.Extension.getFirstPresent;
import static java.lang.Thread.currentThread;
import static java.util.Objects.requireNonNull;
import static java.util.Optional.ofNullable;

public class Inspector {
    private static Inspector inspector = null;
    private static Mode mode = null;
    private final Javalin javalin;
    private final CountDownLatch serverReadyLatch;
    private final Set<DAL> instances = new LinkedHashSet<>();
    //   TODO refactor
    private final Map<String, WsContext> clientConnections = new ConcurrentHashMap<>();
    private final Map<String, Set<String>> clientMonitors = new ConcurrentHashMap<>();
    private final Map<String, DalInstance> dalInstances = new ConcurrentHashMap<>();
    private static Supplier<Object> defaultInput = () -> null;

    public Inspector() {
        dalInstances.put("Try It!", new DalInstance(() -> defaultInput.get(), DAL.create(InspectorExtension.class), ""));

        PugConfiguration pugConfiguration = new PugConfiguration();
        pugConfiguration.setTemplateLoader(new TemplateLoader() {
            @Override
            public long getLastModified(String name) throws IOException {
                return -1;
            }

            @Override
            public Reader getReader(String name) throws IOException {
                return new InputStreamReader(requireNonNull(currentThread().getContextClassLoader().getResourceAsStream(name)),
                        StandardCharsets.UTF_8);
            }

            @Override
            public String getExtension() {
                return "pug";
            }

            @Override
            public String getBase() {
                return "";
            }
        });

        JavalinRenderer.register((filePath, model, context) ->
                pugConfiguration.renderTemplate(pugConfiguration.getTemplate("public/" + filePath), model), ".pug", ".PNG", ".Png");

        serverReadyLatch = new CountDownLatch(1);
        javalin = Javalin.create(config -> config.addStaticFiles("/public", Location.CLASSPATH))
                .events(event -> event.serverStarted(serverReadyLatch::countDown));
        requireNonNull(javalin.jettyServer()).setServerPort(10081);
        javalin.get("/", ctx -> ctx.render("/index.pug", Collections.emptyMap()));
        javalin.post("/api/execute", ctx -> ctx.html(execute(ctx.queryParam("name"), ctx.body())));
        javalin.post("/api/exchange", ctx -> exchange(ctx.queryParam("session"), ctx.body()));
        javalin.post("/api/release", ctx -> release(ctx.queryParam("name")));
        javalin.post("/api/release-all", ctx -> releaseAll());
        javalin.get("/api/request", ctx -> ctx.html(request(ctx.queryParam("name"))));
        javalin.ws("/ws/exchange", ws -> {
            ws.onConnect(ctx -> {
                clientConnections.put(ctx.getSessionId(), ctx);
                sendInstances(ctx);
            });
            ws.onClose(ctx -> clientConnections.remove(ctx.getSessionId()));
        });
        javalin.start();
        Suppressor.run(serverReadyLatch::await);
    }

    private void releaseAll() {
        for (String instanceName : new ArrayList<>(dalInstances.keySet()))
            release(instanceName);
    }

    private void release(String name) {
        DalInstance remove = dalInstances.remove(name);
        if (remove != null)
            remove.release();
    }

    public static void setDefaultMode(Mode mode) {
        Inspector.mode = mode;
    }

    private void exchange(String session, String body) {
        if (clientConnections.containsKey(session)) {
            clientMonitors.put(session, Arrays.stream(body.trim().split("\\n")).map(String::trim).filter(s -> !s.isEmpty()).collect(Collectors.toSet()));
        }
    }

    public static class DalInstance {
        private final Supplier<Object> input;
        private boolean running = true;
        private final DAL dal;
        private final String code;

        public DalInstance(Supplier<Object> input, DAL dal, String code) {
            this.input = input;
            this.dal = dal;
            this.code = code;
        }

        public String execute(String code) {
            Map<String, String> response = new HashMap<>();
            Object inputObject = input.get();
            RuntimeContextBuilder.DALRuntimeContext runtimeContext = dal.getRuntimeContextBuilder().build(inputObject);
            try {
                response.put("root", runtimeContext.wrap(inputObject).dumpAll());
                response.put("inspect", dal.compileSingle(code, runtimeContext).inspect());
                response.put("result", runtimeContext.wrap(dal.evaluate(inputObject, code)).dumpAll());
            } catch (InterpreterException e) {
                response.put("error", e.show(code) + "\n\n" + e.getMessage());
            }
            return ObjectWriter.serialize(response);
        }

        public void hold() {
//            TODO use logger
            System.err.println("Waiting for inspector response");
            //        TODO use sempahore to wait for the result
            while (running)
                Suppressor.run(() -> Thread.sleep(20));
//            TODO use logger
            System.err.println("inspector released");
        }

        public void release() {
            running = false;
        }
    }

    public void inspectInner(DAL dal, Object input, String code) {
        if (isRecursive())
            return;
//        lock inspect by name
//        check mode
        if (currentMode() == Mode.FORCED) {
            DalInstance dalInstance = new DalInstance(() -> input, dal, code);
            dalInstances.put(dal.getName(), dalInstance);

            List<WsContext> monitored = clientMonitors.entrySet().stream().filter(e -> e.getValue().contains(dal.getName()))
                    .map(o -> clientConnections.get(o.getKey()))
                    .collect(Collectors.toList());
            for (WsContext wsContext : monitored) {
                wsContext.send(ObjectWriter.serialize(new HashMap<String, String>() {{
                    put("request", dal.getName());
                }}));
            }

            dalInstance.hold();

        } else {
//        TODO refactor
            List<WsContext> monitored = clientMonitors.entrySet().stream().filter(e -> e.getValue().contains(dal.getName()))
                    .map(o -> clientConnections.get(o.getKey()))
                    .collect(Collectors.toList());
            if (!monitored.isEmpty()) {
                DalInstance dalInstance = new DalInstance(() -> input, dal, code);
                dalInstances.put(dal.getName(), dalInstance);
                for (WsContext wsContext : monitored) {
                    wsContext.send(ObjectWriter.serialize(new HashMap<String, String>() {{
                        put("request", dal.getName());
                    }}));
                }

                dalInstance.hold();
            }
        }
    }

    public static void inspect(DAL dal, Object input, String code) {
        if (currentMode() != Mode.DISABLED)
            inspector.inspectInner(dal, input, code);
    }

    private String request(String name) {
//       TODO reject other request
        return dalInstances.get(name).code;
    }

    private String execute(String name, String code) {
        return dalInstances.get(name).execute(code);
    }

    public static void register(DAL dal) {
        inspector.addInstance(dal);
    }

    private void addInstance(DAL dal) {
        instances.add(dal);
        for (WsContext ctx : clientConnections.values()) {
            sendInstances(ctx);
        }
    }

    private void sendInstances(WsContext ctx) {
        ctx.send(ObjectWriter.serialize(new HashMap<String, Object>() {{
            put("instances", instances.stream().map(DAL::getName).collect(Collectors.toSet()));
            put("session", ctx.getSessionId());
        }}));
    }

    private void stop() {
        javalin.close();
    }

    public static void launch() {
        if (inspector == null) {
            inspector = new Inspector();
        }
    }

    public static void shutdown() {
        if (inspector != null) {
            inspector.stop();
            inspector = null;
        }
    }

    public static void setDefaultInput(Supplier<Object> supplier) {
        defaultInput = supplier;
    }

    public static Mode currentMode() {
        return getFirstPresent(() -> ofNullable(mode),
                () -> ofNullable(System.getenv("DAL_INSPECTOR_MODE")).map(Mode::valueOf),
                () -> ofNullable(System.getProperty("dal.inspector.mode")).map(Mode::valueOf))
                .orElse(Mode.DISABLED);
    }

    public enum Mode {
        DISABLED, FORCED, AUTO
    }

    private boolean isRecursive() {
        for (StackTraceElement stack : Thread.currentThread().getStackTrace())
            if (DalInstance.class.getName().equals(stack.getClassName()))
                return true;
        return false;
    }

    public static void main(String[] args) {
        launch();
    }
}

1	package com.github.leeonky.dal.extensions.inspector;
2
3	import com.github.leeonky.dal.DAL;
4	import com.github.leeonky.dal.runtime.RuntimeContextBuilder;
5	import com.github.leeonky.interpreter.InterpreterException;
6	import com.github.leeonky.util.Suppressor;
7	import de.neuland.pug4j.PugConfiguration;
8	import de.neuland.pug4j.template.TemplateLoader;
9	import io.javalin.Javalin;
10	import io.javalin.http.staticfiles.Location;
11	import io.javalin.plugin.rendering.JavalinRenderer;
12	import io.javalin.websocket.WsContext;
13
14	import java.io.IOException;
15	import java.io.InputStreamReader;
16	import java.io.Reader;
17	import java.nio.charset.StandardCharsets;
18	import java.util.*;
19	import java.util.concurrent.ConcurrentHashMap;
20	import java.util.concurrent.CountDownLatch;
21	import java.util.function.Supplier;
22	import java.util.stream.Collectors;
23
24	import static com.github.leeonky.util.function.Extension.getFirstPresent;
25	import static java.lang.Thread.currentThread;
26	import static java.util.Objects.requireNonNull;
27	import static java.util.Optional.ofNullable;
28
29	public class Inspector {
30	private static Inspector inspector = null;	1✔
31	private static Mode mode = null;	1✔
32	private final Javalin javalin;
33	private final CountDownLatch serverReadyLatch;
34	private final Set<DAL> instances = new LinkedHashSet<>();	1✔
35	// TODO refactor
36	private final Map<String, WsContext> clientConnections = new ConcurrentHashMap<>();	1✔
37	private final Map<String, Set<String>> clientMonitors = new ConcurrentHashMap<>();	1✔
38	private final Map<String, DalInstance> dalInstances = new ConcurrentHashMap<>();	1✔
39	private static Supplier<Object> defaultInput = () -> null;	1✔
40
41	public Inspector() {	1✔
42	dalInstances.put("Try It!", new DalInstance(() -> defaultInput.get(), DAL.create(InspectorExtension.class), ""));	1✔
43
44	PugConfiguration pugConfiguration = new PugConfiguration();	1✔
45	pugConfiguration.setTemplateLoader(new TemplateLoader() {	1✔
46	@Override
47	public long getLastModified(String name) throws IOException {
48	return -1;	1✔
49	}
50
51	@Override
52	public Reader getReader(String name) throws IOException {
53	return new InputStreamReader(requireNonNull(currentThread().getContextClassLoader().getResourceAsStream(name)),	1✔
54	StandardCharsets.UTF_8);
55	}
56
57	@Override
58	public String getExtension() {
59	return "pug";	×
60	}
61
62	@Override
63	public String getBase() {
64	return "";	×
65	}
66	});
67
68	JavalinRenderer.register((filePath, model, context) ->	1✔
69	pugConfiguration.renderTemplate(pugConfiguration.getTemplate("public/" + filePath), model), ".pug", ".PNG", ".Png");	1✔
70
71	serverReadyLatch = new CountDownLatch(1);	1✔
72	javalin = Javalin.create(config -> config.addStaticFiles("/public", Location.CLASSPATH))	1✔
73	.events(event -> event.serverStarted(serverReadyLatch::countDown));	1✔
74	requireNonNull(javalin.jettyServer()).setServerPort(10081);	1✔
75	javalin.get("/", ctx -> ctx.render("/index.pug", Collections.emptyMap()));	1✔
76	javalin.post("/api/execute", ctx -> ctx.html(execute(ctx.queryParam("name"), ctx.body())));	1✔
77	javalin.post("/api/exchange", ctx -> exchange(ctx.queryParam("session"), ctx.body()));	1✔
78	javalin.post("/api/release", ctx -> release(ctx.queryParam("name")));	1✔
79	javalin.post("/api/release-all", ctx -> releaseAll());	1✔
80	javalin.get("/api/request", ctx -> ctx.html(request(ctx.queryParam("name"))));	1✔
81	javalin.ws("/ws/exchange", ws -> {	1✔
82	ws.onConnect(ctx -> {	1✔
83	clientConnections.put(ctx.getSessionId(), ctx);	1✔
84	sendInstances(ctx);	1✔
85	});	1✔
86	ws.onClose(ctx -> clientConnections.remove(ctx.getSessionId()));	1✔
87	});	1✔
88	javalin.start();	1✔
89	Suppressor.run(serverReadyLatch::await);	1✔
90	}	1✔
91
92	private void releaseAll() {
93	for (String instanceName : new ArrayList<>(dalInstances.keySet()))	1✔
94	release(instanceName);	1✔
95	}	1✔
96
97	private void release(String name) {
98	DalInstance remove = dalInstances.remove(name);	1✔
99	if (remove != null)	1✔
100	remove.release();	1✔
101	}	1✔
102
103	public static void setDefaultMode(Mode mode) {
104	Inspector.mode = mode;	1✔
105	}	1✔
106
107	private void exchange(String session, String body) {
108	if (clientConnections.containsKey(session)) {	1✔
109	clientMonitors.put(session, Arrays.stream(body.trim().split("\\n")).map(String::trim).filter(s -> !s.isEmpty()).collect(Collectors.toSet()));	1✔
110	}
111	}	1✔
112
113	public static class DalInstance {
114	private final Supplier<Object> input;
115	private boolean running = true;	1✔
116	private final DAL dal;
117	private final String code;
118
119	public DalInstance(Supplier<Object> input, DAL dal, String code) {	1✔
120	this.input = input;	1✔
121	this.dal = dal;	1✔
122	this.code = code;	1✔
123	}	1✔
124
125	public String execute(String code) {
126	Map<String, String> response = new HashMap<>();	1✔
127	Object inputObject = input.get();	1✔
128	RuntimeContextBuilder.DALRuntimeContext runtimeContext = dal.getRuntimeContextBuilder().build(inputObject);	1✔
129	try {
130	response.put("root", runtimeContext.wrap(inputObject).dumpAll());	1✔
131	response.put("inspect", dal.compileSingle(code, runtimeContext).inspect());	1✔
132	response.put("result", runtimeContext.wrap(dal.evaluate(inputObject, code)).dumpAll());	1✔
133	} catch (InterpreterException e) {	1✔
134	response.put("error", e.show(code) + "\n\n" + e.getMessage());	1✔
135	}	1✔
136	return ObjectWriter.serialize(response);	1✔
137	}
138
139	public void hold() {
140	// TODO use logger
141	System.err.println("Waiting for inspector response");	1✔
142	// TODO use sempahore to wait for the result
143	while (running)	1✔
144	Suppressor.run(() -> Thread.sleep(20));	1✔
145	// TODO use logger
146	System.err.println("inspector released");	1✔
147	}	1✔
148
149	public void release() {
150	running = false;	1✔
151	}	1✔
152	}
153
154	public void inspectInner(DAL dal, Object input, String code) {
155	if (isRecursive())	1✔
156	return;	1✔
157	// lock inspect by name
158	// check mode
159	if (currentMode() == Mode.FORCED) {	1✔
160	DalInstance dalInstance = new DalInstance(() -> input, dal, code);	1✔
161	dalInstances.put(dal.getName(), dalInstance);	1✔
162
163	List<WsContext> monitored = clientMonitors.entrySet().stream().filter(e -> e.getValue().contains(dal.getName()))	1✔
164	.map(o -> clientConnections.get(o.getKey()))	1✔
165	.collect(Collectors.toList());	1✔
166	for (WsContext wsContext : monitored) {	1✔
167	wsContext.send(ObjectWriter.serialize(new HashMap<String, String>() {{	1✔
168	put("request", dal.getName());	1✔
169	}}));	1✔
170	}	1✔
171
172	dalInstance.hold();	1✔
173
174	} else {	1✔
175	// TODO refactor
176	List<WsContext> monitored = clientMonitors.entrySet().stream().filter(e -> e.getValue().contains(dal.getName()))	1✔
177	.map(o -> clientConnections.get(o.getKey()))	1✔
178	.collect(Collectors.toList());	1✔
179	if (!monitored.isEmpty()) {	1✔
180	DalInstance dalInstance = new DalInstance(() -> input, dal, code);	1✔
181	dalInstances.put(dal.getName(), dalInstance);	1✔
182	for (WsContext wsContext : monitored) {	1✔
183	wsContext.send(ObjectWriter.serialize(new HashMap<String, String>() {{	1✔
184	put("request", dal.getName());	1✔
185	}}));	1✔
186	}	1✔
187
188	dalInstance.hold();	×
189	}
190	}
191	}	1✔
192
193	public static void inspect(DAL dal, Object input, String code) {
194	if (currentMode() != Mode.DISABLED)	1✔
195	inspector.inspectInner(dal, input, code);	1✔
196	}	1✔
197
198	private String request(String name) {
199	// TODO reject other request
200	return dalInstances.get(name).code;	1✔
201	}
202
203	private String execute(String name, String code) {
204	return dalInstances.get(name).execute(code);	1✔
205	}
206
207	public static void register(DAL dal) {
208	inspector.addInstance(dal);	1✔
209	}	1✔
210
211	private void addInstance(DAL dal) {
212	instances.add(dal);	1✔
213	for (WsContext ctx : clientConnections.values()) {	1✔
214	sendInstances(ctx);	1✔
215	}	1✔
216	}	1✔
217
218	private void sendInstances(WsContext ctx) {
219	ctx.send(ObjectWriter.serialize(new HashMap<String, Object>() {{	1✔
220	put("instances", instances.stream().map(DAL::getName).collect(Collectors.toSet()));	1✔
221	put("session", ctx.getSessionId());	1✔
222	}}));	1✔
223	}	1✔
224
225	private void stop() {
226	javalin.close();	1✔
227	}	1✔
228
229	public static void launch() {
230	if (inspector == null) {	1✔
231	inspector = new Inspector();	1✔
232	}
233	}	1✔
234
235	public static void shutdown() {
236	if (inspector != null) {	1✔
237	inspector.stop();	1✔
238	inspector = null;	1✔
239	}
240	}	1✔
241
242	public static void setDefaultInput(Supplier<Object> supplier) {
243	defaultInput = supplier;	1✔
244	}	1✔
245
246	public static Mode currentMode() {
247	return getFirstPresent(() -> ofNullable(mode),	1✔
248	() -> ofNullable(System.getenv("DAL_INSPECTOR_MODE")).map(Mode::valueOf),	×
249	() -> ofNullable(System.getProperty("dal.inspector.mode")).map(Mode::valueOf))	×
250	.orElse(Mode.DISABLED);	1✔
251	}
252
253	public enum Mode {	1✔
254	DISABLED, FORCED, AUTO	1✔
255	}
256
257	private boolean isRecursive() {
258	for (StackTraceElement stack : Thread.currentThread().getStackTrace())	1✔
259	if (DalInstance.class.getName().equals(stack.getClassName()))	1✔
260	return true;	1✔
261	return false;	1✔
262	}
263
264	public static void main(String[] args) {
265	launch();	×
266	}	×
267	}

leeonky / test-charm-java / 117

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous