From 154bdaa4acb9b78d470798ee59f5673df6af58a7 Mon Sep 17 00:00:00 2001 From: SebastianEbert Date: Fri, 22 Jan 2021 10:25:03 +0100 Subject: [PATCH 01/10] integrated handler code --- .gitlab-ci.yml | 2 +- .../src/main/resources/JavaHandler.jadd | 70 +++++++++++++++++++ 2 files changed, 71 insertions(+), 1 deletion(-) create mode 100644 ragconnect.base/src/main/resources/JavaHandler.jadd diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index fb3a5cc..893df19 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -3,7 +3,7 @@ variables: stages: - build -- publish +# - publish before_script: - export GRADLE_USER_HOME=`pwd`/.gradle diff --git a/ragconnect.base/src/main/resources/JavaHandler.jadd b/ragconnect.base/src/main/resources/JavaHandler.jadd new file mode 100644 index 0000000..86a81b7 --- /dev/null +++ b/ragconnect.base/src/main/resources/JavaHandler.jadd @@ -0,0 +1,70 @@ +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.Consumer; + +aspect JavaHandler { + + /** + * Singleton class providing routing functionality for byte[] based message calls. + */ + public class CallBackRouter { + + public static org.jastadd.ragconnect.jrouter.CallBackRouter ROUTER_INSTANCE = null; + + private final org.apache.logging.log4j.Logger logger = org.apache.logging.log4j.LogManager.getLogger(org.jastadd.ragconnect.jrouter.CallBackRouter.class); + + private Map>> callbackList = new ConcurrentHashMap<>(); + + private CallBackRouter() { + + } + + public synchronized static org.jastadd.ragconnect.jrouter.CallBackRouter getInstance() { + if(ROUTER_INSTANCE == null) { + ROUTER_INSTANCE = new org.jastadd.ragconnect.jrouter.CallBackRouter(); + } + return ROUTER_INSTANCE; + } + + public void registerCallback(Consumer callback, String topic) { + + logger.debug("[ROUTER] Registering new callback."); + + List> registeredCallbacks = getAllCallbacks().get(topic); + + if(registeredCallbacks == null){ + List> newCallbackList = Collections.synchronizedList(new ArrayList<>()); + newCallbackList.add(callback); + callbackList.put(topic, newCallbackList); + } else { + registeredCallbacks.add(callback); + } + } + + public boolean push(String topic, byte[] data) { + + logger.debug("[ROUTER] Pushing a message."); + + List> callbacks = getAllCallbacks().get(topic); + + if(callbacks == null){ + logger.error("[ROUTER] Could not publish message. No callback registered for topic " + topic); + return false; + } + + for(Consumer callback : callbacks){ + logger.debug("[ROUTER] Calling callback: " + callback.toString()); + callback.accept(data); + } + + return true; + } + + public Map>> getAllCallbacks() { + return callbackList; + } + } +} \ No newline at end of file -- GitLab From 52b7b1dff340fd52a459266c26887fec04b1cffd Mon Sep 17 00:00:00 2001 From: SebastianEbert Date: Fri, 22 Jan 2021 10:27:22 +0100 Subject: [PATCH 02/10] disabled publish CI --- .gitlab-ci.yml | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 893df19..453d929 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -22,22 +22,22 @@ build: paths: - "/builds/jastadd/ragconnect/build/libs/ragconnect-*.jar" -publish: - image: openjdk:11 - stage: publish - script: - - "./gradlew publish" - only: - - master +#publish: +# image: openjdk:11 +# stage: publish +# script: +# - "./gradlew publish" +# only: +# - master -pages: - image: python:3.7-alpine - stage: publish - script: - - pip install -U sphinx sphinx-rtd-theme recommonmark sphinxemoji sphinx-markdown-tables - - sphinx-build -b html pages/ public - artifacts: - paths: - - public - only: - - master +#pages: +# image: python:3.7-alpine +# stage: publish +# script: +# - pip install -U sphinx sphinx-rtd-theme recommonmark sphinxemoji sphinx-markdown-tables +# - sphinx-build -b html pages/ public +# artifacts: +# paths: +# - public +# only: +# - master -- GitLab From 5dd8f4f6d0438a6ea479719e30a7814893df8720 Mon Sep 17 00:00:00 2001 From: SebastianEbert Date: Fri, 22 Jan 2021 16:22:15 +0100 Subject: [PATCH 03/10] integration of java backend --- .../src/main/jastadd/Configuration.jadd | 1 + .../main/jastadd/intermediate/Generation.jadd | 5 ++++ .../MustacheNodesToYAML.jrag | 6 +++++ .../jastadd/ragconnect/compiler/Compiler.java | 7 ++++- .../src/main/resources/JavaHandler.jadd | 26 +++++++++---------- .../main/resources/receiveDefinition.mustache | 3 +++ .../main/resources/sendDefinition.mustache | 16 ++++++++++++ 7 files changed, 50 insertions(+), 14 deletions(-) diff --git a/ragconnect.base/src/main/jastadd/Configuration.jadd b/ragconnect.base/src/main/jastadd/Configuration.jadd index 8d3b16c..32f13d4 100644 --- a/ragconnect.base/src/main/jastadd/Configuration.jadd +++ b/ragconnect.base/src/main/jastadd/Configuration.jadd @@ -4,4 +4,5 @@ aspect Configuration { public static TypeDecl ASTNode.rootNode; public static boolean ASTNode.usesMqtt; public static boolean ASTNode.usesRest; + public static boolean ASTNode.usesJava; } diff --git a/ragconnect.base/src/main/jastadd/intermediate/Generation.jadd b/ragconnect.base/src/main/jastadd/intermediate/Generation.jadd index 607f960..06d223e 100644 --- a/ragconnect.base/src/main/jastadd/intermediate/Generation.jadd +++ b/ragconnect.base/src/main/jastadd/intermediate/Generation.jadd @@ -15,6 +15,9 @@ aspect AttributesForMustache { syn String MRagConnect.restHandlerAttribute() = "_restHandler"; syn String MRagConnect.restHandlerField() = "_restHandler"; + syn String MRagConnect.javaHandlerAttribute() = "_javaHandler"; + syn String MRagConnect.javaHandlerField() = "_javaHandler"; + // --- MEndpointDefinition --- syn String MEndpointDefinition.preemptiveExpectedValue(); syn String MEndpointDefinition.preemptiveReturn(); @@ -141,6 +144,8 @@ aspect AttributesForMustache { result.mqttHandlerAttribute(), result.mqttHandlerField(), usesMqtt)); result.addHandler(new MHandler("RestServerHandler", "new RestServerHandler(\"RagConnectREST\")", result.restHandlerAttribute(), result.restHandlerField(), usesRest)); + result.addHandler(new MHandler("JavaHandler", "JavaHandler.getInstance()", + result.javaHandlerAttribute(), result.javaHandlerField(), usesJava)); return result; } diff --git a/ragconnect.base/src/main/jastadd/intermediate2mustache/MustacheNodesToYAML.jrag b/ragconnect.base/src/main/jastadd/intermediate2mustache/MustacheNodesToYAML.jrag index 337527d..4688e99 100644 --- a/ragconnect.base/src/main/jastadd/intermediate2mustache/MustacheNodesToYAML.jrag +++ b/ragconnect.base/src/main/jastadd/intermediate2mustache/MustacheNodesToYAML.jrag @@ -6,11 +6,17 @@ aspect MustacheNodesToYAML { root.put("closeMethod", closeMethod()); root.put("usesMqtt", usesMqtt); root.put("usesRest", usesRest); + root.put("usesJava", usesJava); + // mqtt root.put("mqttHandlerField", mqttHandlerField()); root.put("mqttHandlerAttribute", mqttHandlerAttribute()); root.put("mqttSetupWaitUntilReadyMethod", mqttSetupWaitUntilReadyMethod()); + // java + root.put("javaHandlerField", javaHandlerField()); + root.put("javaHandlerAttribute", javaHandlerAttribute()); + // rootTypeComponents ListElement rootTypeComponents = new ListElement(); for (MTypeComponent comp : getRootTypeComponentList()) { diff --git a/ragconnect.base/src/main/java/org/jastadd/ragconnect/compiler/Compiler.java b/ragconnect.base/src/main/java/org/jastadd/ragconnect/compiler/Compiler.java index 28a3f20..8c649c4 100644 --- a/ragconnect.base/src/main/java/org/jastadd/ragconnect/compiler/Compiler.java +++ b/ragconnect.base/src/main/java/org/jastadd/ragconnect/compiler/Compiler.java @@ -28,6 +28,7 @@ public class Compiler extends AbstractCompiler { private static final String OPTION_PROTOCOL_MQTT = "mqtt"; private static final String OPTION_PROTOCOL_REST = "rest"; + private static final String OPTION_PROTOCOL_JAVA = "java"; public Compiler() { super("ragconnect", true); @@ -81,6 +82,9 @@ public class Compiler extends AbstractCompiler { if (ASTNode.usesMqtt) { handlers.add("MqttHandler.jadd"); } + if (ASTNode.usesJava) { + handlers.add("JavaHandler.jadd"); + } if (ASTNode.usesRest) { handlers.add("RestHandler.jadd"); } @@ -158,8 +162,9 @@ public class Compiler extends AbstractCompiler { optionProtocols = addOption( new ValueOption("protocols", "Protocols to enable") .acceptMultipleValues(true) - .addDefaultValue(OPTION_PROTOCOL_MQTT, "Enable MQTT") + .addDefaultValue(OPTION_PROTOCOL_JAVA, "Enable Java") .addAcceptedValue(OPTION_PROTOCOL_REST, "Enable REST") + .addAcceptedValue(OPTION_PROTOCOL_MQTT, "Enable MQTT") ); optionPrintYaml = addOption( new BooleanOption("printYaml", "Print out YAML instead of generating files") diff --git a/ragconnect.base/src/main/resources/JavaHandler.jadd b/ragconnect.base/src/main/resources/JavaHandler.jadd index 86a81b7..44ac211 100644 --- a/ragconnect.base/src/main/resources/JavaHandler.jadd +++ b/ragconnect.base/src/main/resources/JavaHandler.jadd @@ -10,28 +10,28 @@ aspect JavaHandler { /** * Singleton class providing routing functionality for byte[] based message calls. */ - public class CallBackRouter { + public class JavaHandler { - public static org.jastadd.ragconnect.jrouter.CallBackRouter ROUTER_INSTANCE = null; + public static JavaHandler JAVA_HANDLER_INSTANCE = null; - private final org.apache.logging.log4j.Logger logger = org.apache.logging.log4j.LogManager.getLogger(org.jastadd.ragconnect.jrouter.CallBackRouter.class); + private final org.apache.logging.log4j.Logger logger = org.apache.logging.log4j.LogManager.getLogger(avaHandler.class); private Map>> callbackList = new ConcurrentHashMap<>(); - private CallBackRouter() { + private JavaHandler() { } - public synchronized static org.jastadd.ragconnect.jrouter.CallBackRouter getInstance() { - if(ROUTER_INSTANCE == null) { - ROUTER_INSTANCE = new org.jastadd.ragconnect.jrouter.CallBackRouter(); + public synchronized static JavaHandler getInstance() { + if(JAVA_HANDLER_INSTANCE == null) { + JAVA_HANDLER_INSTANCE = new JavaHandler(); } - return ROUTER_INSTANCE; + return JAVA_HANDLER_INSTANCE; } - public void registerCallback(Consumer callback, String topic) { + public void registerCallback(String topic, Consumer callback) { - logger.debug("[ROUTER] Registering new callback."); + logger.debug("[JAVA_HANDLER] Registering new callback."); List> registeredCallbacks = getAllCallbacks().get(topic); @@ -46,17 +46,17 @@ aspect JavaHandler { public boolean push(String topic, byte[] data) { - logger.debug("[ROUTER] Pushing a message."); + logger.debug("[JAVA_HANDLER] Pushing a message."); List> callbacks = getAllCallbacks().get(topic); if(callbacks == null){ - logger.error("[ROUTER] Could not publish message. No callback registered for topic " + topic); + logger.error("[JAVA_HANDLER] Could not publish message. No callback registered for topic " + topic); return false; } for(Consumer callback : callbacks){ - logger.debug("[ROUTER] Calling callback: " + callback.toString()); + logger.debug("[JAVA_HANDLER] Calling callback: " + callback.toString()); callback.accept(data); } diff --git a/ragconnect.base/src/main/resources/receiveDefinition.mustache b/ragconnect.base/src/main/resources/receiveDefinition.mustache index 1dd0e0d..4abe2cb 100644 --- a/ragconnect.base/src/main/resources/receiveDefinition.mustache +++ b/ragconnect.base/src/main/resources/receiveDefinition.mustache @@ -11,6 +11,9 @@ public boolean {{parentTypeName}}.{{connectMethod}}(String {{connectParameterNam {{#usesMqtt}} case "mqtt": return {{mqttHandlerAttribute}}().newConnection(uri, consumer); {{/usesMqtt}} + {{#usesJava}} + case "mqtt": return {{javaHandlerAttribute}}().registerCallback(uri, consumer); + {{/usesJava}} {{#usesRest}} case "rest": return {{restHandlerAttribute}}().newPUTConnection(uri, input -> { consumer.accept(input.getBytes()); diff --git a/ragconnect.base/src/main/resources/sendDefinition.mustache b/ragconnect.base/src/main/resources/sendDefinition.mustache index 60f5efc..56fde1d 100644 --- a/ragconnect.base/src/main/resources/sendDefinition.mustache +++ b/ragconnect.base/src/main/resources/sendDefinition.mustache @@ -20,6 +20,22 @@ public boolean {{parentTypeName}}.{{connectMethod}}(String {{connectParameterNam } break; {{/usesMqtt}} + {{#usesJava}} + case "mqtt": + final MqttHandler handler = {{javaHandlerAttribute}}().resolveHandler(uri); + final String topic = {{javaHandlerAttribute}}().extractTopic(uri); + {{sender}} = () -> { + {{#loggingEnabledForWrites}} + System.out.println("[Send] {{tokenName}} = " + get{{tokenName}}() + " -> " + {{connectParameterName}}); + {{/loggingEnabledForWrites}} + handler.publish(topic, {{lastValue}}); + }; + {{updateMethod}}(); + if (writeCurrentValue) { + {{writeMethod}}(); + } + break; + {{/usesJava}} {{#usesRest}} case "rest": {{restHandlerAttribute}}().newGETConnection(uri, () -> { -- GitLab From e4473f2702c2ce1c50bcc66310b53aae5d53c683 Mon Sep 17 00:00:00 2001 From: SebastianEbert Date: Mon, 25 Jan 2021 15:05:12 +0100 Subject: [PATCH 04/10] fixed bugs discovered in review --- ragconnect.base/src/main/resources/JavaHandler.jadd | 2 +- ragconnect.base/src/main/resources/receiveDefinition.mustache | 2 +- ragconnect.base/src/main/resources/sendDefinition.mustache | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/ragconnect.base/src/main/resources/JavaHandler.jadd b/ragconnect.base/src/main/resources/JavaHandler.jadd index 44ac211..217ae63 100644 --- a/ragconnect.base/src/main/resources/JavaHandler.jadd +++ b/ragconnect.base/src/main/resources/JavaHandler.jadd @@ -14,7 +14,7 @@ aspect JavaHandler { public static JavaHandler JAVA_HANDLER_INSTANCE = null; - private final org.apache.logging.log4j.Logger logger = org.apache.logging.log4j.LogManager.getLogger(avaHandler.class); + private final org.apache.logging.log4j.Logger logger = org.apache.logging.log4j.LogManager.getLogger(JavaHandler.class); private Map>> callbackList = new ConcurrentHashMap<>(); diff --git a/ragconnect.base/src/main/resources/receiveDefinition.mustache b/ragconnect.base/src/main/resources/receiveDefinition.mustache index 4abe2cb..86523f5 100644 --- a/ragconnect.base/src/main/resources/receiveDefinition.mustache +++ b/ragconnect.base/src/main/resources/receiveDefinition.mustache @@ -15,7 +15,7 @@ public boolean {{parentTypeName}}.{{connectMethod}}(String {{connectParameterNam case "mqtt": return {{javaHandlerAttribute}}().registerCallback(uri, consumer); {{/usesJava}} {{#usesRest}} - case "rest": return {{restHandlerAttribute}}().newPUTConnection(uri, input -> { + case "java": return {{restHandlerAttribute}}().newPUTConnection(uri, input -> { consumer.accept(input.getBytes()); }); {{/usesRest}} diff --git a/ragconnect.base/src/main/resources/sendDefinition.mustache b/ragconnect.base/src/main/resources/sendDefinition.mustache index 56fde1d..a913710 100644 --- a/ragconnect.base/src/main/resources/sendDefinition.mustache +++ b/ragconnect.base/src/main/resources/sendDefinition.mustache @@ -21,8 +21,8 @@ public boolean {{parentTypeName}}.{{connectMethod}}(String {{connectParameterNam break; {{/usesMqtt}} {{#usesJava}} - case "mqtt": - final MqttHandler handler = {{javaHandlerAttribute}}().resolveHandler(uri); + case "java": + final JavaHandler handler = {{javaHandlerAttribute}}().resolveHandler(uri); final String topic = {{javaHandlerAttribute}}().extractTopic(uri); {{sender}} = () -> { {{#loggingEnabledForWrites}} -- GitLab From 38c4a6a2b3785a7a5d7841e3f8c3229030d42e90 Mon Sep 17 00:00:00 2001 From: SebastianEbert Date: Tue, 26 Jan 2021 13:53:18 +0100 Subject: [PATCH 05/10] bugfix on java backend --- .../java/org/jastadd/ragconnect/compiler/Compiler.java | 1 + ragconnect.base/src/main/resources/JavaHandler.jadd | 6 +++++- .../src/main/resources/receiveDefinition.mustache | 4 ++-- .../src/main/resources/sendDefinition.mustache | 9 +++------ 4 files changed, 11 insertions(+), 9 deletions(-) diff --git a/ragconnect.base/src/main/java/org/jastadd/ragconnect/compiler/Compiler.java b/ragconnect.base/src/main/java/org/jastadd/ragconnect/compiler/Compiler.java index 8c649c4..0c4900d 100644 --- a/ragconnect.base/src/main/java/org/jastadd/ragconnect/compiler/Compiler.java +++ b/ragconnect.base/src/main/java/org/jastadd/ragconnect/compiler/Compiler.java @@ -227,6 +227,7 @@ public class Compiler extends AbstractCompiler { ASTNode.loggingEnabledForReads = optionLogReads.value(); ASTNode.loggingEnabledForWrites = optionLogWrites.value(); ASTNode.usesMqtt = optionProtocols.hasValue(OPTION_PROTOCOL_MQTT); + ASTNode.usesJava = optionProtocols.hasValue(OPTION_PROTOCOL_JAVA); ASTNode.usesRest = optionProtocols.hasValue(OPTION_PROTOCOL_REST); return ragConnect; } diff --git a/ragconnect.base/src/main/resources/JavaHandler.jadd b/ragconnect.base/src/main/resources/JavaHandler.jadd index 217ae63..60f43b8 100644 --- a/ragconnect.base/src/main/resources/JavaHandler.jadd +++ b/ragconnect.base/src/main/resources/JavaHandler.jadd @@ -29,7 +29,7 @@ aspect JavaHandler { return JAVA_HANDLER_INSTANCE; } - public void registerCallback(String topic, Consumer callback) { + public boolean registerCallback(String topic, Consumer callback) { logger.debug("[JAVA_HANDLER] Registering new callback."); @@ -42,8 +42,12 @@ aspect JavaHandler { } else { registeredCallbacks.add(callback); } + + return true; } + public void close(){}; + public boolean push(String topic, byte[] data) { logger.debug("[JAVA_HANDLER] Pushing a message."); diff --git a/ragconnect.base/src/main/resources/receiveDefinition.mustache b/ragconnect.base/src/main/resources/receiveDefinition.mustache index 86523f5..95340e5 100644 --- a/ragconnect.base/src/main/resources/receiveDefinition.mustache +++ b/ragconnect.base/src/main/resources/receiveDefinition.mustache @@ -12,10 +12,10 @@ public boolean {{parentTypeName}}.{{connectMethod}}(String {{connectParameterNam case "mqtt": return {{mqttHandlerAttribute}}().newConnection(uri, consumer); {{/usesMqtt}} {{#usesJava}} - case "mqtt": return {{javaHandlerAttribute}}().registerCallback(uri, consumer); + case "java": return {{javaHandlerAttribute}}().registerCallback(path, consumer); {{/usesJava}} {{#usesRest}} - case "java": return {{restHandlerAttribute}}().newPUTConnection(uri, input -> { + case "rest": return {{restHandlerAttribute}}().newPUTConnection(uri, input -> { consumer.accept(input.getBytes()); }); {{/usesRest}} diff --git a/ragconnect.base/src/main/resources/sendDefinition.mustache b/ragconnect.base/src/main/resources/sendDefinition.mustache index a913710..248ea2d 100644 --- a/ragconnect.base/src/main/resources/sendDefinition.mustache +++ b/ragconnect.base/src/main/resources/sendDefinition.mustache @@ -22,13 +22,10 @@ public boolean {{parentTypeName}}.{{connectMethod}}(String {{connectParameterNam {{/usesMqtt}} {{#usesJava}} case "java": - final JavaHandler handler = {{javaHandlerAttribute}}().resolveHandler(uri); - final String topic = {{javaHandlerAttribute}}().extractTopic(uri); + final JavaHandler handler = {{javaHandlerAttribute}}().getInstance(); + {{sender}} = () -> { - {{#loggingEnabledForWrites}} - System.out.println("[Send] {{tokenName}} = " + get{{tokenName}}() + " -> " + {{connectParameterName}}); - {{/loggingEnabledForWrites}} - handler.publish(topic, {{lastValue}}); + handler.push(path, {{lastValue}}); }; {{updateMethod}}(); if (writeCurrentValue) { -- GitLab From 9594bbdc9632c5f7fca78aa28d8a2ef100b51cb5 Mon Sep 17 00:00:00 2001 From: SebastianEbert Date: Wed, 3 Feb 2021 13:27:39 +0100 Subject: [PATCH 06/10] updated CI --- .gitlab-ci.yml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 5791891..01a6e4f 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -3,8 +3,7 @@ variables: stages: - build -# - publish -# - test + - test # - publish before_script: -- GitLab From 65f59ce4c666af8468a83f99c2f1eedc221e218e Mon Sep 17 00:00:00 2001 From: SebastianEbert Date: Wed, 3 Feb 2021 13:28:40 +0100 Subject: [PATCH 07/10] updated CI --- .gitlab-ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 01a6e4f..e5275bd 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -3,7 +3,7 @@ variables: stages: - build - - test +- test # - publish before_script: -- GitLab From 8b5fe01eae242bf607621b37733cc7b12b625050 Mon Sep 17 00:00:00 2001 From: SebastianEbert Date: Fri, 5 Feb 2021 13:54:43 +0100 Subject: [PATCH 08/10] extended impl. for disconnects, fixed bugs related to datatransfer and config and code-gen --- ragconnect.base/build.gradle | 2 + .../jastadd/ragconnect/compiler/Compiler.java | 14 +++++- .../src/main/resources/JavaHandler.jadd | 47 ++++++++++++++----- .../src/main/resources/handler.mustache | 12 +++-- .../main/resources/receiveDefinition.mustache | 11 ++++- .../main/resources/sendDefinition.mustache | 5 ++ 6 files changed, 74 insertions(+), 17 deletions(-) diff --git a/ragconnect.base/build.gradle b/ragconnect.base/build.gradle index b3e89a6..2b8fe2a 100644 --- a/ragconnect.base/build.gradle +++ b/ragconnect.base/build.gradle @@ -31,6 +31,8 @@ dependencies { implementation group: 'org.apache.logging.log4j', name: 'log4j-core', version: "${log4j_version}" implementation group: 'org.apache.logging.log4j', name: 'log4j-jul', version: "${log4j_version}" implementation group: 'com.github.spullara.mustache.java', name: 'compiler', version: "${mustache_java_version}" + // https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 + compile group: 'org.apache.commons', name: 'commons-lang3', version: '3.0' runtimeOnly group: 'org.jastadd', name: 'jastadd', version: '2.3.4' api group: 'net.sf.beaver', name: 'beaver-rt', version: '0.9.11' } diff --git a/ragconnect.base/src/main/java/org/jastadd/ragconnect/compiler/Compiler.java b/ragconnect.base/src/main/java/org/jastadd/ragconnect/compiler/Compiler.java index 8c18f32..6f8cf33 100644 --- a/ragconnect.base/src/main/java/org/jastadd/ragconnect/compiler/Compiler.java +++ b/ragconnect.base/src/main/java/org/jastadd/ragconnect/compiler/Compiler.java @@ -61,6 +61,18 @@ public class Compiler extends AbstractCompiler { RagConnect ragConnect = parseProgram(getConfiguration().getFiles()); + // lets inspect ragconnects tree + /* + for(EndpointDefinition ed : ragConnect.getEndpointDefinitionList()){ + if(ed.isReceiveTokenEndpointDefinition()){ + for(MappingDefinition md : ed.asReceiveTokenEndpointDefinition().effectiveMappings()){ + // if (!effectiveMappings().get(effectiveMappings().size() - 1).getToType().assignableTo( + // getToken().effectiveJavaTypeUse())) { + System.out.println("gtt: " + md.getToType()); + } + } + } + */ if (!ragConnect.errors().isEmpty()) { System.err.println("Errors:"); for (ErrorMessage e : ragConnect.errors()) { @@ -243,7 +255,7 @@ public class Compiler extends AbstractCompiler { grammarFile.dumpTree(System.out); } program.addGrammarFile(grammarFile); - grammarFile.treeResolveAll(); + //grammarFile.treeResolveAll(); grammarFile.setFileName(toBaseName(filename)); } catch (IOException | Parser.Exception e) { throw new CompilerException("Could not parse grammar file " + filename, e); diff --git a/ragconnect.base/src/main/resources/JavaHandler.jadd b/ragconnect.base/src/main/resources/JavaHandler.jadd index 60f43b8..9ac0c65 100644 --- a/ragconnect.base/src/main/resources/JavaHandler.jadd +++ b/ragconnect.base/src/main/resources/JavaHandler.jadd @@ -16,7 +16,7 @@ aspect JavaHandler { private final org.apache.logging.log4j.Logger logger = org.apache.logging.log4j.LogManager.getLogger(JavaHandler.class); - private Map>> callbackList = new ConcurrentHashMap<>(); + private Map>>> callbackList = new ConcurrentHashMap<>(); private JavaHandler() { @@ -29,21 +29,44 @@ aspect JavaHandler { return JAVA_HANDLER_INSTANCE; } - public boolean registerCallback(String topic, Consumer callback) { + public String registerCallback(String topic, Consumer callback) { logger.debug("[JAVA_HANDLER] Registering new callback."); - List> registeredCallbacks = getAllCallbacks().get(topic); + String callbackUUID = java.util.UUID.randomUUID().toString(); + + List>> registeredCallbacks = getAllCallbacks().get(topic); if(registeredCallbacks == null){ - List> newCallbackList = Collections.synchronizedList(new ArrayList<>()); - newCallbackList.add(callback); + List>> newCallbackList = Collections.synchronizedList(new ArrayList<>()); + newCallbackList.add(new org.apache.commons.lang3.tuple.MutablePair<>(callbackUUID, callback)); callbackList.put(topic, newCallbackList); } else { - registeredCallbacks.add(callback); + registeredCallbacks.add(new org.apache.commons.lang3.tuple.MutablePair<>(callbackUUID, callback)); } - return true; + return callbackUUID; + } + + public boolean unregisterCallback(String path, String uuid){ + + logger.debug("[JAVA_HANDLER] Unregistering callback with uuid: " + uuid + " on path: " + path); + + List>> callbacks = getAllCallbacks().get(path); + + int count = 0; + + if(callbacks != null){ + for(org.apache.commons.lang3.tuple.Pair> callbackPair : callbacks){ + if(callbackPair.getLeft().equals(uuid)){ + callbacks.remove(count); + return true; + }else{ + count++; + } + } + } + return false; } public void close(){}; @@ -52,22 +75,22 @@ aspect JavaHandler { logger.debug("[JAVA_HANDLER] Pushing a message."); - List> callbacks = getAllCallbacks().get(topic); + List>> callbacks = getAllCallbacks().get(topic); if(callbacks == null){ logger.error("[JAVA_HANDLER] Could not publish message. No callback registered for topic " + topic); return false; } - for(Consumer callback : callbacks){ - logger.debug("[JAVA_HANDLER] Calling callback: " + callback.toString()); - callback.accept(data); + for(org.apache.commons.lang3.tuple.Pair> callbackPair : callbacks){ + logger.debug("[JAVA_HANDLER] Calling callback: " + callbackPair.getLeft()); + callbackPair.getRight().accept(data); } return true; } - public Map>> getAllCallbacks() { + public Map>>> getAllCallbacks() { return callbackList; } } diff --git a/ragconnect.base/src/main/resources/handler.mustache b/ragconnect.base/src/main/resources/handler.mustache index 41e4238..896f6ac 100644 --- a/ragconnect.base/src/main/resources/handler.mustache +++ b/ragconnect.base/src/main/resources/handler.mustache @@ -1,3 +1,4 @@ + aspect RagConnectHandler { {{#Handlers}} {{#InUse}} @@ -15,14 +16,19 @@ aspect RagConnectHandler { {{/Handlers}} } class ConnectToken { - static java.util.concurrent.atomic.AtomicLong counter = new java.util.concurrent.atomic.AtomicLong(0); - final long id; + //static java.util.concurrent.atomic.AtomicLong counter = new java.util.concurrent.atomic.AtomicLong(0); + final String id; final java.net.URI uri; + public ConnectToken(java.net.URI uri) { - this.id = counter.incrementAndGet(); + this.id = java.util.UUID.randomUUID().toString(); // counter.incrementAndGet(); this.uri = uri; } + public ConnectToken(java.net.URI uri, String uuid) { + this.id = uuid; // counter.incrementAndGet(); + this.uri = uri; + } } static java.util.Map> ASTNode.connectTokens = new java.util.HashMap<>(); } diff --git a/ragconnect.base/src/main/resources/receiveDefinition.mustache b/ragconnect.base/src/main/resources/receiveDefinition.mustache index 5294f89..6acddb2 100644 --- a/ragconnect.base/src/main/resources/receiveDefinition.mustache +++ b/ragconnect.base/src/main/resources/receiveDefinition.mustache @@ -18,7 +18,13 @@ public boolean {{parentTypeName}}.{{connectMethod}}(String {{connectParameterNam break; {{/usesMqtt}} {{#usesJava}} - case "java": return {{javaHandlerAttribute}}().registerCallback(path, consumer); + case "java": + String uuid = {{javaHandlerAttribute}}().registerCallback(path, consumer); + connectToken = new ConnectToken(uri, uuid); + if (uuid == null) { + return false; + } + break; {{/usesJava}} {{#usesRest}} case "rest": @@ -45,6 +51,9 @@ public boolean {{parentTypeName}}.{{disconnectMethod}}(String {{connectParameter {{#usesMqtt}} case "mqtt": return {{mqttHandlerAttribute}}().disconnect(connectTokens.get(this).get(uri)); {{/usesMqtt}} + {{#usesJava}} + case "java": return {{javaHandlerAttribute}}().unregisterCallback(uri.getPath(), connectTokens.get(this).get(uri).id); + {{/usesJava}} {{#usesRest}} case "rest": return {{restHandlerAttribute}}().disconnect(connectTokens.get(this).get(uri)); {{/usesRest}} diff --git a/ragconnect.base/src/main/resources/sendDefinition.mustache b/ragconnect.base/src/main/resources/sendDefinition.mustache index e564ef8..5ddec00 100644 --- a/ragconnect.base/src/main/resources/sendDefinition.mustache +++ b/ragconnect.base/src/main/resources/sendDefinition.mustache @@ -62,6 +62,11 @@ public boolean {{parentTypeName}}.{{disconnectMethod}}(String {{connectParameter {{lastValue}} = null; break; {{/usesMqtt}} + {{#usesJava}} + case "java": + // nothing todo, because senders are not registered (just callbacks) + break; + {{/usesJava}} {{#usesRest}} case "rest": {{restHandlerAttribute}}().disconnect(connectTokens.get(this).get(uri)); -- GitLab From d740a6651fd956e5812711220719fcb0b6c3e4b8 Mon Sep 17 00:00:00 2001 From: SebastianEbert Date: Tue, 9 Feb 2021 10:59:00 +0100 Subject: [PATCH 09/10] updated build --- ragconnect.base/build.gradle | 2 +- ragconnect.base/src/main/resources/JavaHandler.jadd | 6 +++++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/ragconnect.base/build.gradle b/ragconnect.base/build.gradle index 2b8fe2a..5c25104 100644 --- a/ragconnect.base/build.gradle +++ b/ragconnect.base/build.gradle @@ -32,7 +32,7 @@ dependencies { implementation group: 'org.apache.logging.log4j', name: 'log4j-jul', version: "${log4j_version}" implementation group: 'com.github.spullara.mustache.java', name: 'compiler', version: "${mustache_java_version}" // https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 - compile group: 'org.apache.commons', name: 'commons-lang3', version: '3.0' + api group: 'org.apache.commons', name: 'commons-lang3', version: '3.0' runtimeOnly group: 'org.jastadd', name: 'jastadd', version: '2.3.4' api group: 'net.sf.beaver', name: 'beaver-rt', version: '0.9.11' } diff --git a/ragconnect.base/src/main/resources/JavaHandler.jadd b/ragconnect.base/src/main/resources/JavaHandler.jadd index 9ac0c65..5849b61 100644 --- a/ragconnect.base/src/main/resources/JavaHandler.jadd +++ b/ragconnect.base/src/main/resources/JavaHandler.jadd @@ -73,7 +73,11 @@ aspect JavaHandler { public boolean push(String topic, byte[] data) { - logger.debug("[JAVA_HANDLER] Pushing a message."); + logger.info("[JAVA_HANDLER] Pushing a message."); + + String dataString = new String(data); + + logger.info("[JAVA_HANDLER] Data: " + dataString); List>> callbacks = getAllCallbacks().get(topic); -- GitLab From 928649d18a998f0684adc17f21a6112785e4b491 Mon Sep 17 00:00:00 2001 From: SebastianEbert Date: Fri, 27 Aug 2021 16:09:37 +0200 Subject: [PATCH 10/10] fixed ci.yml --- .gitlab-ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 76278f6..898917d 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -8,7 +8,7 @@ stages: #- ragdoc_build #- ragdoc_view #- publish -> + before_script: - export GRADLE_USER_HOME=`pwd`/.gradle -- GitLab