Queue API Implementation (AWS SQS)

common/src/main/java/com/genexus/ModelContext.java

@@ -43,7 +43,9 @@ public static ModelContext getModelContext()
         ModelContext context = (ModelContext)threadModelContext.get();
 		if(context == null)
 		{
-			logger.error(new Date() + " - Cannot find ModelContext for thread " + Thread.currentThread() );
+			if (logger.isDebugEnabled()) {
+				logger.debug(new Date() + " - Cannot find ModelContext for thread " + Thread.currentThread());
+			}
 		}
         return context;
     }

common/src/main/java/com/genexus/db/DynamicExecute.java

@@ -438,9 +438,7 @@ public static boolean dynamicExecute(ModelContext context, int handle, Class cal
 		}
 		catch (java.lang.reflect.InvocationTargetException e)
 		{
-			//Application.printWarning("java.lang.reflect.InvocationTargetException Can't execute dynamic call " + className + " - " + e.getTargetException().getMessage(), e);
-			//return false;
-			throw new RuntimeException("java.lang.reflect.InvocationTargetException Can't execute dynamic call " + className + " - " + e.getTargetException().getMessage());
+			throw new RuntimeException("java.lang.reflect.InvocationTargetException Can't execute dynamic call " + className + " - " + e.getTargetException().getMessage(), e);
 		}
 		catch (InstantiationException e)
 		{

common/src/main/java/com/genexus/services/ServiceConfigurationException.java

@@ -0,0 +1,7 @@
+package com.genexus.services;
+
+public class ServiceConfigurationException extends Throwable {
+	public ServiceConfigurationException(String errorMessage) {
+		super(errorMessage);
+	}
+}

common/src/main/java/com/genexus/services/ServiceSettingsReader.java

@@ -0,0 +1,91 @@
+package com.genexus.services;
+
+import com.genexus.diagnostics.core.ILogger;
+import com.genexus.diagnostics.core.LogManager;
+
+import com.genexus.util.Encryption;
+import com.genexus.util.GXService;
+
+
+public class ServiceSettingsReader {
+	private static ILogger logger = LogManager.getLogger(ServiceSettingsReader.class);
+
+	private GXService service;
+	private String name;
+	private String serviceTypeName;
+
+	public ServiceSettingsReader(String serviceType, String instanceName, GXService service) {
+		service = service;
+		name = instanceName;
+		serviceTypeName = serviceType;
+	}
+
+	public String getEncryptedPropertyValue(String propertyName, String alternativePropertyName) throws ServiceConfigurationException {
+		String value = getEncryptedPropertyValue(propertyName, alternativePropertyName, null);
+		if (value == null) {
+			String errorMessage = String.format("Service configuration error - Property name %s must be defined", resolvePropertyName(propertyName));
+			logger.fatal(errorMessage);
+			throw new ServiceConfigurationException(errorMessage);
+		}
+		return value;
+	}
+
+	public String getEncryptedPropertyValue(String propertyName, String alternativePropertyName, String defaultValue) {
+		String encryptedOrUnEncryptedValue = getPropertyValue(propertyName, alternativePropertyName, defaultValue);
+		String decryptedValue = encryptedOrUnEncryptedValue;
+		if (encryptedOrUnEncryptedValue != null && encryptedOrUnEncryptedValue.length() > 0) {
+			try {
+				String decryptedTemp = Encryption.tryDecrypt64(encryptedOrUnEncryptedValue);
+				decryptedValue = (decryptedTemp != null) ? decryptedTemp : encryptedOrUnEncryptedValue;
+			} catch (Exception e) {
+				logger.warn("Could not decrypt property name: " + resolvePropertyName(propertyName));
+			}
+		}
+		return decryptedValue;
+	}
+
+	public String getPropertyValue(String propertyName, String alternativePropertyName) throws ServiceConfigurationException {
+		String value = getPropertyValue(propertyName, alternativePropertyName, null);
+		if (value == null) {
+			String errorMessage = String.format("Service configuration error - Property name %s must be defined", resolvePropertyName(propertyName));
+			logger.fatal(errorMessage);
+			throw new ServiceConfigurationException(errorMessage);
+		}
+		return value;
+	}
+
+	public String getPropertyValue(String propertyName, String alternativePropertyName, String defaultValue) {
+		String value = readFromEnvVars(propertyName, alternativePropertyName);
+		if (value != null) {
+			return value;
+		}
+		String resolvedPtyName = resolvePropertyName(propertyName);
+		if (service != null) {
+			value = this.service.getProperties().get(resolvedPtyName);
+			if (value == null || value.length() == 0) {
+				value = this.service.getProperties().get(alternativePropertyName);
+			}
+		}
+		return value != null ? value : defaultValue;
+	}
+
+	private String readFromEnvVars(String propertyName, String alternativePropertyName) {
+		if (service != null && !service.getAllowOverrideWithEnvVarSettings()) {
+			return null;
+		}
+
+		String value = System.getenv(resolvePropertyName(propertyName));
+		if (value == null) {
+			value = System.getenv(alternativePropertyName);
+		}
+		return value;
+	}
+
+	private String resolvePropertyName(String propertyName) {
+		return String.format("%s_%s_%s", serviceTypeName, name, propertyName);
+	}
+
+	public String getName() {
+		return this.name;
+	}
+}

common/src/main/java/com/genexus/xml/GXXMLSerializable.java

@@ -9,7 +9,6 @@
 
 import java.io.Serializable;
 import java.util.Iterator;
-import java.util.Hashtable;
 import java.lang.reflect.Method;
 import java.util.concurrent.ConcurrentHashMap;
 

gxqueue/pom.xml

@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>parent</artifactId>
+        <groupId>com.genexus</groupId>
+        <version>${revision}${changelist}</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>gxqueue</artifactId>
+    <dependencies>
+        <dependency>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>gxclassR</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>gxcommon</artifactId>
+            <version>${project.version}</version>
+            <scope>compile</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>gxqueue</finalName>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>3.1.1</version>
+                <configuration>
+                    <archive>
+                        <manifest>
+                            <addClasspath>false</addClasspath>
+                        </manifest>
+                        <manifestEntries>
+                            <Build-Time>${maven.build.timestamp}</Build-Time>
+                            <Build-User>GeneXus</Build-User>
+                            <Build-Java>${java.version}</Build-Java>
+                            <Build-OS>${os.name}</Build-OS>
+                            <Build-Label>${project.version}</Build-Label>
+                            <Build-Path>${basedir}</Build-Path>
+                        </manifestEntries>
+                    </archive>
+                    <excludes>
+                        <exclude>**/com/genexusmessaging/**</exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

gxqueue/src/main/java/com/genexus/messaging/queue/Convert.java

@@ -0,0 +1,93 @@
+package com.genexus.messaging.queue;
+
+import com.genexus.GXBaseCollection;
+
+import com.genexus.messaging.queue.model.DeleteMessageResult;
+import com.genexus.messaging.queue.model.MessageQueueOptions;
+import com.genexus.messaging.queue.model.SendMessageResult;
+import com.genexus.messaging.queue.model.SimpleQueueMessage;
+import com.genexus.util.GXProperties;
+import com.genexus.util.GXProperty;
+import com.genexusmessaging.genexusmessagingqueue.simplequeue.SdtMessage;
+import com.genexusmessaging.genexusmessagingqueue.simplequeue.SdtMessageOptions;
+import com.genexusmessaging.genexusmessagingqueue.simplequeue.SdtMessageProperty;
+import com.genexusmessaging.genexusmessagingqueue.simplequeue.SdtMessageResult;
+
+import java.util.List;
+
+public class Convert {
+
+	protected static SimpleQueueMessage toSimpleQueueMessage(SdtMessage msg) {
+		return new SimpleQueueMessage() {{
+			String id = msg.getgxTv_SdtMessage_Messageid();
+			setMessageId((id.isEmpty())? java.util.UUID.randomUUID().toString() :id);
+			setMessageBody(msg.getgxTv_SdtMessage_Messagebody());
+			setMessageHandleId(msg.getgxTv_SdtMessage_Messagehandleid());
+			if (msg.getgxTv_SdtMessage_Messageattributes() != null) {
+				setMessageAttributes(toGXProperties(msg.getgxTv_SdtMessage_Messageattributes()));
+			}
+		}};
+	}
+
+	protected static MessageQueueOptions toMessageQueueOptions(SdtMessageOptions receiveOptions) {
+		MessageQueueOptions mqOptions = new MessageQueueOptions() {{
+			setMaxNumberOfMessages(receiveOptions.getgxTv_SdtMessageOptions_Maxnumberofmessages());
+			setWaitTimeout(receiveOptions.getgxTv_SdtMessageOptions_Waittimeout());
+			setTimetoLive(receiveOptions.getgxTv_SdtMessageOptions_Timetolive());
+			setDelaySeconds(receiveOptions.getgxTv_SdtMessageOptions_Delayseconds());
+			setVisibilityTimeout(receiveOptions.getgxTv_SdtMessageOptions_Visibilitytimeout());
+		}};
+		return mqOptions;
+	}
+
+
+	protected static SdtMessageResult toSdtMessageResult(SendMessageResult mResult) {
+		SdtMessageResult r = new SdtMessageResult();
+		r.setgxTv_SdtMessageResult_Messageid(mResult.getMessageId());
+		r.setgxTv_SdtMessageResult_Servermessageid(mResult.getMessageServerId());
+		r.setgxTv_SdtMessageResult_Messagestatus(mResult.getMessageSentStatus());
+		return r;
+	}
+
+	protected static GXBaseCollection<SdtMessageProperty> toSdtMessagePropertyCollection(GXProperties msgProps) {
+		GXBaseCollection<SdtMessageProperty> props = new GXBaseCollection<SdtMessageProperty>();
+		for (int i = 0; i < msgProps.count(); i++) {
+			GXProperty propertyItem = msgProps.item(i);
+			SdtMessageProperty msgProperty = new SdtMessageProperty();
+			msgProperty.setgxTv_SdtMessageProperty_Propertykey(propertyItem.getKey());
+			msgProperty.setgxTv_SdtMessageProperty_Propertyvalue(propertyItem.getValue());
+			props.add(msgProperty);
+		}
+		return props;
+	}
+
+	protected static GXProperties toGXProperties(GXBaseCollection<SdtMessageProperty> msgProps) {
+		GXProperties props = new GXProperties();
+		for (SdtMessageProperty prop : msgProps) {
+			props.add(prop.getgxTv_SdtMessageProperty_Propertykey(), prop.getgxTv_SdtMessageProperty_Propertyvalue());
+		}
+		return props;
+	}
+
+	public static SdtMessage toSdtMessage(SimpleQueueMessage simpleQueueMessage) {
+		SdtMessage msg = new SdtMessage();
+		msg.setgxTv_SdtMessage_Messageattributes(toSdtMessagePropertyCollection(simpleQueueMessage.getMessageAttributes()));
+		msg.setgxTv_SdtMessage_Messagehandleid(simpleQueueMessage.getMessageHandleId());
+		msg.setgxTv_SdtMessage_Messageid(simpleQueueMessage.getMessageId());
+		msg.setgxTv_SdtMessage_Messagebody(simpleQueueMessage.getMessageBody());
+		return msg;
+	}
+
+	public static GXBaseCollection<SdtMessageResult> toDeleteExternalMessageResultList(List<DeleteMessageResult> deletedMessages) {
+		GXBaseCollection<SdtMessageResult> externalList = new GXBaseCollection<>();
+		for (DeleteMessageResult deletedMessage : deletedMessages) {
+			SdtMessageResult sdtMessageResult = new SdtMessageResult();
+			sdtMessageResult.setgxTv_SdtMessageResult_Messageid(deletedMessage.getMessageId());
+			sdtMessageResult.setgxTv_SdtMessageResult_Servermessageid(deletedMessage.getMessageServerId());
+			sdtMessageResult.setgxTv_SdtMessageResult_Messagestatus(deletedMessage.getMessageDeleteStatus());
+			externalList.add(sdtMessageResult);
+		}
+		return externalList;
+	}
+
+}

gxqueue/src/main/java/com/genexus/messaging/queue/IQueue.java

@@ -0,0 +1,20 @@
+package com.genexus.messaging.queue;
+
+import com.genexus.messaging.queue.model.DeleteMessageResult;
+import com.genexus.messaging.queue.model.MessageQueueOptions;
+import com.genexus.messaging.queue.model.SendMessageResult;
+import com.genexus.messaging.queue.model.SimpleQueueMessage;
+
+import java.util.List;
+
+public interface IQueue {
+	Integer getQueueLength();
+	SendMessageResult sendMessage(SimpleQueueMessage simpleQueueMessage);
+	SendMessageResult sendMessage(SimpleQueueMessage simpleQueueMessage, MessageQueueOptions messageQueueOptions);
+	List<SendMessageResult> sendMessages(List<SimpleQueueMessage> simpleQueueMessages, MessageQueueOptions messageQueueOptions);
+	List<SimpleQueueMessage> getMessages(MessageQueueOptions messageQueueOptions);
+	DeleteMessageResult deleteMessage(String messageHandleId);
+
+	List<DeleteMessageResult> deleteMessages(List<String> messageHandleId);
+	boolean purge();
+}

gxqueue/src/main/java/com/genexus/messaging/queue/QueueBase.java

@@ -0,0 +1,4 @@
+package com.genexus.messaging.queue;
+
+public class QueueBase {
+}