diff --git a/common/src/main/java/com/genexus/ModelContext.java b/common/src/main/java/com/genexus/ModelContext.java index 0a014aca6..f194af131 100644 --- a/common/src/main/java/com/genexus/ModelContext.java +++ b/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; } diff --git a/common/src/main/java/com/genexus/db/DynamicExecute.java b/common/src/main/java/com/genexus/db/DynamicExecute.java index 3e09e97ad..cd0c4dda3 100644 --- a/common/src/main/java/com/genexus/db/DynamicExecute.java +++ b/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) { diff --git a/common/src/main/java/com/genexus/services/ServiceConfigurationException.java b/common/src/main/java/com/genexus/services/ServiceConfigurationException.java new file mode 100644 index 000000000..b70298a7d --- /dev/null +++ b/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); + } +} diff --git a/common/src/main/java/com/genexus/services/ServiceSettingsReader.java b/common/src/main/java/com/genexus/services/ServiceSettingsReader.java new file mode 100644 index 000000000..d7b62a78c --- /dev/null +++ b/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; + } +} diff --git a/common/src/main/java/com/genexus/xml/GXXMLSerializable.java b/common/src/main/java/com/genexus/xml/GXXMLSerializable.java index 4ef504414..d4a72cf1a 100644 --- a/common/src/main/java/com/genexus/xml/GXXMLSerializable.java +++ b/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; diff --git a/gxqueue/pom.xml b/gxqueue/pom.xml new file mode 100644 index 000000000..628235710 --- /dev/null +++ b/gxqueue/pom.xml @@ -0,0 +1,56 @@ + + + + parent + com.genexus + ${revision}${changelist} + + 4.0.0 + + gxqueue + + + ${project.groupId} + gxclassR + ${project.version} + + + ${project.groupId} + gxcommon + ${project.version} + compile + + + + + gxqueue + + + org.apache.maven.plugins + maven-jar-plugin + 3.1.1 + + + + false + + + ${maven.build.timestamp} + GeneXus + ${java.version} + ${os.name} + ${project.version} + ${basedir} + + + + **/com/genexusmessaging/** + + + + + + + \ No newline at end of file diff --git a/gxqueue/src/main/java/com/genexus/messaging/queue/Convert.java b/gxqueue/src/main/java/com/genexus/messaging/queue/Convert.java new file mode 100644 index 000000000..2bc5bcc5d --- /dev/null +++ b/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 toSdtMessagePropertyCollection(GXProperties msgProps) { + GXBaseCollection props = new GXBaseCollection(); + 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 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 toDeleteExternalMessageResultList(List deletedMessages) { + GXBaseCollection 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; + } + +} diff --git a/gxqueue/src/main/java/com/genexus/messaging/queue/IQueue.java b/gxqueue/src/main/java/com/genexus/messaging/queue/IQueue.java new file mode 100644 index 000000000..a4164d4bf --- /dev/null +++ b/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 sendMessages(List simpleQueueMessages, MessageQueueOptions messageQueueOptions); + List getMessages(MessageQueueOptions messageQueueOptions); + DeleteMessageResult deleteMessage(String messageHandleId); + + List deleteMessages(List messageHandleId); + boolean purge(); +} diff --git a/gxqueue/src/main/java/com/genexus/messaging/queue/QueueBase.java b/gxqueue/src/main/java/com/genexus/messaging/queue/QueueBase.java new file mode 100644 index 000000000..c14bf3827 --- /dev/null +++ b/gxqueue/src/main/java/com/genexus/messaging/queue/QueueBase.java @@ -0,0 +1,4 @@ +package com.genexus.messaging.queue; + +public class QueueBase { +} diff --git a/gxqueue/src/main/java/com/genexus/messaging/queue/SimpleMessageQueue.java b/gxqueue/src/main/java/com/genexus/messaging/queue/SimpleMessageQueue.java new file mode 100644 index 000000000..43377bcef --- /dev/null +++ b/gxqueue/src/main/java/com/genexus/messaging/queue/SimpleMessageQueue.java @@ -0,0 +1,174 @@ +package com.genexus.messaging.queue; + +import com.genexus.*; +import com.genexus.diagnostics.core.ILogger; +import com.genexus.diagnostics.core.LogManager; +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.genexusmessaging.genexusmessagingqueue.simplequeue.SdtMessage; +import com.genexusmessaging.genexusmessagingqueue.simplequeue.SdtMessageOptions; +import com.genexusmessaging.genexusmessagingqueue.simplequeue.SdtMessageResult; + +import java.util.ArrayList; +import java.util.List; + +public class SimpleMessageQueue { + private IQueue queue; + private static ILogger logger = LogManager.getLogger(SimpleMessageQueue.class); + + public SimpleMessageQueue() { + + } + + public SimpleMessageQueue(IQueue queueProvider) { + queue = queueProvider; + } + + void validQueue() throws Exception { + if (queue == null) { + logger.error("Queue was not instantiated."); + throw new Exception("Queue was not instantiated."); + } + } + + public void clear(GXBaseCollection[] errorMessagesArr, boolean[] success) { + GXBaseCollection errorMessages = errorMessagesArr[0]; + errorMessages.clear(); + try { + validQueue(); + success[0] = queue.purge(); + } catch (Exception ex) { + queueErrorMessagesSetup(ex, errorMessages); + logger.error("Could not clear queue", ex); + } + success[0] = false; + } + + public short getQueueLength(GXBaseCollection[] errorMessagesArr, boolean[] success) { + GXBaseCollection errorMessages = errorMessagesArr[0]; + errorMessages.clear(); + short queueLength = 0; + try { + validQueue(); + queueLength = queue.getQueueLength().shortValue(); + } catch (Exception ex) { + queueErrorMessagesSetup(ex, errorMessages); + logger.error("Could not getQueueLength", ex); + } + return queueLength; + } + + public SdtMessageResult sendMessage(SdtMessage sdtMessage, GXBaseCollection[] errorMessagesArr, boolean[] success) { + GXBaseCollection messages = new GXBaseCollection<>(); + messages.add(sdtMessage); + GXBaseCollection result = sendMessages(messages, new SdtMessageOptions(), errorMessagesArr, success); + return ((result.size() == 1) ? result.item(1) : Convert.toSdtMessageResult(new SendMessageResult())); + } + + public GXBaseCollection sendMessages(GXBaseCollection sdtMessages, SdtMessageOptions msgOptions, GXBaseCollection[] errorMessagesArr, boolean[] success) { + GXBaseCollection errorMessages = errorMessagesArr[0]; + List msgList = new ArrayList<>(); + GXBaseCollection listReturn = new GXBaseCollection<>(); + errorMessages.clear(); + + for (SdtMessage m : sdtMessages) { + msgList.add(Convert.toSimpleQueueMessage(m)); + } + + try { + validQueue(); + List sendMessageResult = queue.sendMessages(msgList, Convert.toMessageQueueOptions(msgOptions)); + success[0] = true; + for (SendMessageResult msgResult : sendMessageResult) { + listReturn.add(Convert.toSdtMessageResult(msgResult)); + } + } catch (Exception ex) { + queueErrorMessagesSetup(ex, errorMessages); + logger.error("Could not send queue message", ex); + } + + return listReturn; + } + + public GXBaseCollection getMessages(GXBaseCollection[] errorMessagesArr, boolean[] success) { + return getMessages(null, errorMessagesArr, success); + } + + public GXBaseCollection getMessages(SdtMessageOptions receiveOptions, GXBaseCollection[] errorMessagesArr, boolean[] success) { + GXBaseCollection errorMessages = errorMessagesArr[0]; + + MessageQueueOptions mqOptions = (receiveOptions != null) ? Convert.toMessageQueueOptions(receiveOptions) : new MessageQueueOptions(); + List receivedMessages = queue.getMessages(mqOptions); + GXBaseCollection receivedMessagesResult = new GXBaseCollection<>(); + try { + validQueue(); + for (SimpleQueueMessage m : receivedMessages) { + receivedMessagesResult.add(Convert.toSdtMessage(m)); + } + success[0] = true; + } catch (Exception ex) { + queueErrorMessagesSetup(ex, errorMessages); + logger.error(String.format("Could not get Messages from Queue"), ex); + } + return receivedMessagesResult; + } + + public SdtMessageResult deleteMessage(SdtMessage msg, GXBaseCollection[] errorMessagesArr, boolean[] success) { + GXBaseCollection errorMessages = errorMessagesArr[0]; + errorMessages.clear(); + SdtMessageResult sdtDelete = new SdtMessageResult(); + if (msg == null || msg.getgxTv_SdtMessage_Messagehandleid().isEmpty()) { + sdtDelete.setgxTv_SdtMessageResult_Messagestatus(DeleteMessageResult.FAILED); + appendErrorMessage(errorMessages, 1, "Message HandledId property cannot be empty"); + return sdtDelete; + } + + try { + validQueue(); + DeleteMessageResult deletedMessage = queue.deleteMessage(msg.getgxTv_SdtMessage_Messagehandleid()); + sdtDelete.setgxTv_SdtMessageResult_Messageid(deletedMessage.getMessageId()); + sdtDelete.setgxTv_SdtMessageResult_Servermessageid(deletedMessage.getMessageServerId()); + sdtDelete.setgxTv_SdtMessageResult_Messagestatus(deletedMessage.getMessageDeleteStatus()); + success[0] = true; + } catch (Exception ex) { + queueErrorMessagesSetup(ex, errorMessages); + logger.error(String.format("Could not delete Message '%s' from Queue", msg.getgxTv_SdtMessage_Messagehandleid()), ex); + } + return sdtDelete; + } + + public GXBaseCollection deleteMessages(GXBaseCollection msgHandlesToDelete, GXBaseCollection[] errorMessagesArr, boolean[] success) { + GXBaseCollection errorMessages = errorMessagesArr[0]; + errorMessages.clear(); + try { + validQueue(); + List handles = new ArrayList<>(); + for (SdtMessage msg : msgHandlesToDelete) { + handles.add(msg.getgxTv_SdtMessage_Messagehandleid()); + } + List deletedMessage = queue.deleteMessages(handles); + success[0] = true; + return Convert.toDeleteExternalMessageResultList(deletedMessage); + } catch (Exception ex) { + queueErrorMessagesSetup(ex, errorMessages); + logger.error(String.format("Could not delete Messages from Queue "), ex); + } + return new GXBaseCollection(); + } + + protected void queueErrorMessagesSetup(Exception ex, GXBaseCollection messages) { + if (messages != null && ex != null) { + appendErrorMessage(messages, 1, ex.getMessage()); + } + } + + private void appendErrorMessage(GXBaseCollection messages, int errorType, String errMessage) { + SdtMessages_Message struct = new SdtMessages_Message(); + struct.setgxTv_SdtMessages_Message_Type((byte) errorType); + struct.setgxTv_SdtMessages_Message_Description(errMessage); + messages.add(struct); + } + +} diff --git a/gxqueue/src/main/java/com/genexus/messaging/queue/exceptions/GeneralQueueException.java b/gxqueue/src/main/java/com/genexus/messaging/queue/exceptions/GeneralQueueException.java new file mode 100644 index 000000000..9d564d4bb --- /dev/null +++ b/gxqueue/src/main/java/com/genexus/messaging/queue/exceptions/GeneralQueueException.java @@ -0,0 +1,5 @@ +package com.genexus.messaging.queue.exceptions; + +public class GeneralQueueException extends Throwable { + +} diff --git a/gxqueue/src/main/java/com/genexus/messaging/queue/model/DeleteMessageResult.java b/gxqueue/src/main/java/com/genexus/messaging/queue/model/DeleteMessageResult.java new file mode 100644 index 000000000..0c5c8cf88 --- /dev/null +++ b/gxqueue/src/main/java/com/genexus/messaging/queue/model/DeleteMessageResult.java @@ -0,0 +1,15 @@ +package com.genexus.messaging.queue.model; + +public class DeleteMessageResult extends MessageId { + public static String DELETED = "Deleted"; + + private String messageDeleteStatus = UNKNOWN; + + public String getMessageDeleteStatus() { + return messageDeleteStatus; + } + + public void setMessageDeleteStatus(String messageDeleteStatus) { + this.messageDeleteStatus = messageDeleteStatus; + } +} diff --git a/gxqueue/src/main/java/com/genexus/messaging/queue/model/MessageId.java b/gxqueue/src/main/java/com/genexus/messaging/queue/model/MessageId.java new file mode 100644 index 000000000..701276b93 --- /dev/null +++ b/gxqueue/src/main/java/com/genexus/messaging/queue/model/MessageId.java @@ -0,0 +1,26 @@ +package com.genexus.messaging.queue.model; + +public abstract class MessageId { + public static String FAILED = "Failed"; + public static String UNKNOWN = "Unknown"; + + private String messageId; + private String messageServerId; + + public String getMessageId() { + return messageId; + } + + public void setMessageId(String messageId) { + this.messageId = messageId; + } + + public String getMessageServerId() { + return messageServerId; + } + + public void setMessageServerId(String messageServerId) { + this.messageServerId = messageServerId; + } + +} diff --git a/gxqueue/src/main/java/com/genexus/messaging/queue/model/MessageQueueOptions.java b/gxqueue/src/main/java/com/genexus/messaging/queue/model/MessageQueueOptions.java new file mode 100644 index 000000000..4e99485c8 --- /dev/null +++ b/gxqueue/src/main/java/com/genexus/messaging/queue/model/MessageQueueOptions.java @@ -0,0 +1,76 @@ +package com.genexus.messaging.queue.model; + +public class MessageQueueOptions { + private int maxNumberOfMessages; + private boolean deleteConsumedMessages; + private int waitTimeout; + private int visibilityTimeout; + private int timetoLive; + private int delaySeconds; + private String receiveRequestAttemptId = ""; + private boolean receiveMessageAttributes; + + public int getMaxNumberOfMessages() { + return maxNumberOfMessages; + } + + public void setMaxNumberOfMessages(int maxNumberOfMessages) { + this.maxNumberOfMessages = maxNumberOfMessages; + } + + public boolean isDeleteConsumedMessages() { + return deleteConsumedMessages; + } + + public void setDeleteConsumedMessages(boolean deleteConsumedMessages) { + this.deleteConsumedMessages = deleteConsumedMessages; + } + + public int getWaitTimeout() { + return waitTimeout; + } + + public void setWaitTimeout(int waitTimeout) { + this.waitTimeout = waitTimeout; + } + + public int getVisibilityTimeout() { + return visibilityTimeout; + } + + public void setVisibilityTimeout(int visibilityTimeout) { + this.visibilityTimeout = visibilityTimeout; + } + + public int getTimetoLive() { + return timetoLive; + } + + public void setTimetoLive(int timetoLive) { + this.timetoLive = timetoLive; + } + + public int getDelaySeconds() { + return delaySeconds; + } + + public void setDelaySeconds(int delaySeconds) { + this.delaySeconds = delaySeconds; + } + + public String getReceiveRequestAttemptId() { + return receiveRequestAttemptId; + } + + public void setReceiveRequestAttemptId(String receiveRequestAttemptId) { + this.receiveRequestAttemptId = receiveRequestAttemptId; + } + + public boolean isReceiveMessageAttributes() { + return receiveMessageAttributes; + } + + public void setReceiveMessageAttributes(boolean receiveMessageAttributes) { + this.receiveMessageAttributes = receiveMessageAttributes; + } +} diff --git a/gxqueue/src/main/java/com/genexus/messaging/queue/model/SendMessageResult.java b/gxqueue/src/main/java/com/genexus/messaging/queue/model/SendMessageResult.java new file mode 100644 index 000000000..de889c169 --- /dev/null +++ b/gxqueue/src/main/java/com/genexus/messaging/queue/model/SendMessageResult.java @@ -0,0 +1,16 @@ +package com.genexus.messaging.queue.model; + +public class SendMessageResult extends MessageId { + public static String SENT = "Sent"; + + + private String messageSentStatus = UNKNOWN; + + public String getMessageSentStatus() { + return messageSentStatus; + } + + public void setMessageSentStatus(String messageSentStatus) { + this.messageSentStatus = messageSentStatus; + } +} diff --git a/gxqueue/src/main/java/com/genexus/messaging/queue/model/SimpleQueueMessage.java b/gxqueue/src/main/java/com/genexus/messaging/queue/model/SimpleQueueMessage.java new file mode 100644 index 000000000..e07336cf3 --- /dev/null +++ b/gxqueue/src/main/java/com/genexus/messaging/queue/model/SimpleQueueMessage.java @@ -0,0 +1,42 @@ +package com.genexus.messaging.queue.model; + +import com.genexus.util.GXProperties; + +public class SimpleQueueMessage { + private String messageId; + private String messageBody; + private GXProperties messageAttributes = new GXProperties(); + private String messageHandleId; + + public String getMessageId() { + return messageId; + } + + public void setMessageId(String messageId) { + this.messageId = messageId; + } + + public String getMessageBody() { + return messageBody; + } + + public void setMessageBody(String messageBody) { + this.messageBody = messageBody; + } + + public GXProperties getMessageAttributes() { + return messageAttributes; + } + + public void setMessageAttributes(GXProperties messageAttributes) { + this.messageAttributes = messageAttributes; + } + + public String getMessageHandleId() { + return messageHandleId; + } + + public void setMessageHandleId(String messageHandleId) { + this.messageHandleId = messageHandleId; + } +} diff --git a/gxqueue/src/main/java/com/genexusmessaging/genexusmessagingqueue/simplequeue/SdtMessage.java b/gxqueue/src/main/java/com/genexusmessaging/genexusmessagingqueue/simplequeue/SdtMessage.java new file mode 100644 index 000000000..d4c7c874e --- /dev/null +++ b/gxqueue/src/main/java/com/genexusmessaging/genexusmessagingqueue/simplequeue/SdtMessage.java @@ -0,0 +1,83 @@ +package com.genexusmessaging.genexusmessagingqueue.simplequeue; + +import com.genexus.*; + +public final class SdtMessage extends GxUserType { + protected byte gxTv_SdtMessage_N; + protected byte gxTv_SdtMessage_Messageattributes_N; + protected String sTagName; + protected String gxTv_SdtMessage_Messagebody; + protected String gxTv_SdtMessage_Messageid; + protected String gxTv_SdtMessage_Messagehandleid; + protected GXBaseCollection gxTv_SdtMessage_Messageattributes_aux; + protected GXBaseCollection gxTv_SdtMessage_Messageattributes = null; + + + public SdtMessage( ) + { + this( new ModelContext(SdtMessage.class)); + } + + public SdtMessage( ModelContext context ) + { + super( context, "SdtMessage"); + } + + public String getgxTv_SdtMessage_Messageid() { + return gxTv_SdtMessage_Messageid; + } + + public void setgxTv_SdtMessage_Messageid(String value) { + gxTv_SdtMessage_N = (byte) (0); + gxTv_SdtMessage_Messageid = value; + } + + public String getgxTv_SdtMessage_Messagebody() { + return gxTv_SdtMessage_Messagebody; + } + + public void setgxTv_SdtMessage_Messagebody(String value) { + gxTv_SdtMessage_N = (byte) (0); + gxTv_SdtMessage_Messagebody = value; + } + + public String getgxTv_SdtMessage_Messagehandleid() { + return gxTv_SdtMessage_Messagehandleid; + } + + public void setgxTv_SdtMessage_Messagehandleid(String value) { + gxTv_SdtMessage_N = (byte) (0); + gxTv_SdtMessage_Messagehandleid = value; + } + + public GXBaseCollection getgxTv_SdtMessage_Messageattributes() { + if (gxTv_SdtMessage_Messageattributes == null) { + gxTv_SdtMessage_Messageattributes = new GXBaseCollection(com.genexusmessaging.genexusmessagingqueue.simplequeue.SdtMessageProperty.class, "MessageProperty", "GeneXusMessaging", remoteHandle); + } + gxTv_SdtMessage_Messageattributes_N = (byte) (0); + gxTv_SdtMessage_N = (byte) (0); + return gxTv_SdtMessage_Messageattributes; + } + + public void setgxTv_SdtMessage_Messageattributes(GXBaseCollection value) { + gxTv_SdtMessage_Messageattributes_N = (byte) (0); + gxTv_SdtMessage_N = (byte) (0); + gxTv_SdtMessage_Messageattributes = value; + } + + + public void initialize() { + gxTv_SdtMessage_Messageid = ""; + gxTv_SdtMessage_N = (byte) (1); + gxTv_SdtMessage_Messagebody = ""; + gxTv_SdtMessage_Messagehandleid = ""; + gxTv_SdtMessage_Messageattributes_N = (byte) (1); + sTagName = ""; + } + + @Override + public String getJsonMap(String value) { + return null; + } +} + diff --git a/gxqueue/src/main/java/com/genexusmessaging/genexusmessagingqueue/simplequeue/SdtMessageOptions.java b/gxqueue/src/main/java/com/genexusmessaging/genexusmessagingqueue/simplequeue/SdtMessageOptions.java new file mode 100644 index 000000000..7809a5665 --- /dev/null +++ b/gxqueue/src/main/java/com/genexusmessaging/genexusmessagingqueue/simplequeue/SdtMessageOptions.java @@ -0,0 +1,108 @@ +package com.genexusmessaging.genexusmessagingqueue.simplequeue; + +import com.genexus.*; + +public final class SdtMessageOptions extends GxUserType { + protected byte gxTv_SdtMessageOptions_N; + protected short gxTv_SdtMessageOptions_Maxnumberofmessages; + protected int gxTv_SdtMessageOptions_Waittimeout; + protected int gxTv_SdtMessageOptions_Visibilitytimeout; + protected int gxTv_SdtMessageOptions_Timetolive; + protected int gxTv_SdtMessageOptions_Delayseconds; + + protected boolean gxTv_SdtMessageOptions_Deleteconsumedmessages; + protected boolean gxTv_SdtMessageOptions_Receivemessageattributes; + protected String gxTv_SdtMessageOptions_Receiverequestattemptid; + + public SdtMessageOptions( ) + { + this( new ModelContext(SdtMessageOptions.class)); + } + + public SdtMessageOptions( ModelContext context ) + { + super( context, "SdtMessageOptions"); + } + + public short getgxTv_SdtMessageOptions_Maxnumberofmessages() { + return gxTv_SdtMessageOptions_Maxnumberofmessages; + } + + public void setgxTv_SdtMessageOptions_Maxnumberofmessages(short value) { + gxTv_SdtMessageOptions_N = (byte) (0); + gxTv_SdtMessageOptions_Maxnumberofmessages = value; + } + + public boolean getgxTv_SdtMessageOptions_Deleteconsumedmessages() { + return gxTv_SdtMessageOptions_Deleteconsumedmessages; + } + + public void setgxTv_SdtMessageOptions_Deleteconsumedmessages(boolean value) { + gxTv_SdtMessageOptions_N = (byte) (0); + gxTv_SdtMessageOptions_Deleteconsumedmessages = value; + } + + public int getgxTv_SdtMessageOptions_Waittimeout() { + return gxTv_SdtMessageOptions_Waittimeout; + } + + public void setgxTv_SdtMessageOptions_Waittimeout(int value) { + gxTv_SdtMessageOptions_N = (byte) (0); + gxTv_SdtMessageOptions_Waittimeout = value; + } + + public int getgxTv_SdtMessageOptions_Visibilitytimeout() { + return gxTv_SdtMessageOptions_Visibilitytimeout; + } + + public void setgxTv_SdtMessageOptions_Visibilitytimeout(int value) { + gxTv_SdtMessageOptions_N = (byte) (0); + gxTv_SdtMessageOptions_Visibilitytimeout = value; + } + + public int getgxTv_SdtMessageOptions_Timetolive() { + return gxTv_SdtMessageOptions_Timetolive; + } + + public void setgxTv_SdtMessageOptions_Timetolive(int value) { + gxTv_SdtMessageOptions_N = (byte) (0); + gxTv_SdtMessageOptions_Timetolive = value; + } + + public int getgxTv_SdtMessageOptions_Delayseconds() { + return gxTv_SdtMessageOptions_Delayseconds; + } + + public void setgxTv_SdtMessageOptions_Delayseconds(int value) { + gxTv_SdtMessageOptions_N = (byte) (0); + gxTv_SdtMessageOptions_Delayseconds = value; + } + + public String getgxTv_SdtMessageOptions_Receiverequestattemptid() { + return gxTv_SdtMessageOptions_Receiverequestattemptid; + } + + public void setgxTv_SdtMessageOptions_Receiverequestattemptid(String value) { + gxTv_SdtMessageOptions_N = (byte) (0); + gxTv_SdtMessageOptions_Receiverequestattemptid = value; + } + + public boolean getgxTv_SdtMessageOptions_Receivemessageattributes() { + return gxTv_SdtMessageOptions_Receivemessageattributes; + } + + public void setgxTv_SdtMessageOptions_Receivemessageattributes(boolean value) { + gxTv_SdtMessageOptions_N = (byte) (0); + gxTv_SdtMessageOptions_Receivemessageattributes = value; + } + + public void initialize() { + gxTv_SdtMessageOptions_N = (byte) (1); + gxTv_SdtMessageOptions_Receiverequestattemptid = ""; + } + @Override + public String getJsonMap(String value) { + return null; + } +} + diff --git a/gxqueue/src/main/java/com/genexusmessaging/genexusmessagingqueue/simplequeue/SdtMessageProperty.java b/gxqueue/src/main/java/com/genexusmessaging/genexusmessagingqueue/simplequeue/SdtMessageProperty.java new file mode 100644 index 000000000..d8fe7e3a3 --- /dev/null +++ b/gxqueue/src/main/java/com/genexusmessaging/genexusmessagingqueue/simplequeue/SdtMessageProperty.java @@ -0,0 +1,53 @@ +package com.genexusmessaging.genexusmessagingqueue.simplequeue; + +import com.genexus.*; + +public final class SdtMessageProperty extends GxUserType { + protected byte gxTv_SdtMessageProperty_N; + protected String gxTv_SdtMessageProperty_Propertykey; + protected String gxTv_SdtMessageProperty_Propertyvalue; + + public SdtMessageProperty( ) + { + this( new ModelContext(SdtMessageOptions.class)); + } + + public SdtMessageProperty( ModelContext context ) + { + super( context, "SdtMessageOptions"); + } + + public String getgxTv_SdtMessageProperty_Propertykey() { + return gxTv_SdtMessageProperty_Propertykey; + } + + public void setgxTv_SdtMessageProperty_Propertykey(String value) { + gxTv_SdtMessageProperty_N = (byte) (0); + gxTv_SdtMessageProperty_Propertykey = value; + } + + public String getgxTv_SdtMessageProperty_Propertyvalue() { + return gxTv_SdtMessageProperty_Propertyvalue; + } + + public void setgxTv_SdtMessageProperty_Propertyvalue(String value) { + gxTv_SdtMessageProperty_N = (byte) (0); + gxTv_SdtMessageProperty_Propertyvalue = value; + } + + public void initialize(int remoteHandle) { + initialize(); + } + + public void initialize() { + gxTv_SdtMessageProperty_Propertykey = ""; + gxTv_SdtMessageProperty_N = (byte) (1); + gxTv_SdtMessageProperty_Propertyvalue = ""; + } + + @Override + public String getJsonMap(String value) { + return null; + } +} + diff --git a/gxqueue/src/main/java/com/genexusmessaging/genexusmessagingqueue/simplequeue/SdtMessageResult.java b/gxqueue/src/main/java/com/genexusmessaging/genexusmessagingqueue/simplequeue/SdtMessageResult.java new file mode 100644 index 000000000..9a5a69cac --- /dev/null +++ b/gxqueue/src/main/java/com/genexusmessaging/genexusmessagingqueue/simplequeue/SdtMessageResult.java @@ -0,0 +1,86 @@ +package com.genexusmessaging.genexusmessagingqueue.simplequeue; + +import com.genexus.*; + +public final class SdtMessageResult extends GxUserType { + protected byte gxTv_SdtMessageResult_N; + protected byte gxTv_SdtMessageResult_Messageattributes_N; + protected String gxTv_SdtMessageResult_Messageid; + protected String gxTv_SdtMessageResult_Servermessageid; + protected String gxTv_SdtMessageResult_Messagehandleid; + protected String gxTv_SdtMessageResult_Messagestatus; + protected GXBaseCollection gxTv_SdtMessageResult_Messageattributes_aux; + protected GXBaseCollection gxTv_SdtMessageResult_Messageattributes = null; + + public SdtMessageResult( ) + { + this( new ModelContext(SdtMessageResult.class)); + } + + public SdtMessageResult( ModelContext context ) + { + super( context, "SdtMessageResult"); + } + + public String getgxTv_SdtMessageResult_Messageid() { + return gxTv_SdtMessageResult_Messageid; + } + + public void setgxTv_SdtMessageResult_Messageid(String value) { + gxTv_SdtMessageResult_N = (byte) (0); + gxTv_SdtMessageResult_Messageid = value; + } + + public String getgxTv_SdtMessageResult_Servermessageid() { + return gxTv_SdtMessageResult_Servermessageid; + } + + public void setgxTv_SdtMessageResult_Servermessageid(String value) { + gxTv_SdtMessageResult_N = (byte) (0); + gxTv_SdtMessageResult_Servermessageid = value; + } + + public String getgxTv_SdtMessageResult_Messagehandleid() { + return gxTv_SdtMessageResult_Messagehandleid; + } + + public void setgxTv_SdtMessageResult_Messagehandleid(String value) { + gxTv_SdtMessageResult_N = (byte) (0); + gxTv_SdtMessageResult_Messagehandleid = value; + } + + public String getgxTv_SdtMessageResult_Messagestatus() { + return gxTv_SdtMessageResult_Messagestatus; + } + + public void setgxTv_SdtMessageResult_Messagestatus(String value) { + gxTv_SdtMessageResult_N = (byte) (0); + gxTv_SdtMessageResult_Messagestatus = value; + } + + public GXBaseCollection getgxTv_SdtMessageResult_Messageattributes() { + if (gxTv_SdtMessageResult_Messageattributes == null) { + gxTv_SdtMessageResult_Messageattributes = new GXBaseCollection(com.genexusmessaging.genexusmessagingqueue.simplequeue.SdtMessageProperty.class, "MessageProperty", "GeneXusMessaging", remoteHandle); + } + gxTv_SdtMessageResult_Messageattributes_N = (byte) (0); + gxTv_SdtMessageResult_N = (byte) (0); + return gxTv_SdtMessageResult_Messageattributes; + } + + public void setgxTv_SdtMessageResult_Messageattributes(GXBaseCollection value) { + gxTv_SdtMessageResult_Messageattributes_N = (byte) (0); + gxTv_SdtMessageResult_N = (byte) (0); + gxTv_SdtMessageResult_Messageattributes = value; + } + + @Override + public void initialize() { + + } + + @Override + public String getJsonMap(String value) { + return null; + } +} + diff --git a/gxqueueawssqs/pom.xml b/gxqueueawssqs/pom.xml new file mode 100644 index 000000000..f2ad2f07e --- /dev/null +++ b/gxqueueawssqs/pom.xml @@ -0,0 +1,69 @@ + + + + parent + com.genexus + ${revision}${changelist} + + 4.0.0 + + gxqueueawssqs + + + ${project.groupId} + gxclassR + ${project.version} + + + ${project.groupId} + gxcommon + ${project.version} + + + ${project.groupId} + gxqueue + ${project.version} + + + software.amazon.awssdk + sqs + ${software.awssdk.version} + + + software.amazon.awssdk + apache-client + ${software.awssdk.version} + + + + + gxqueue-awssqs + + + org.apache.maven.plugins + maven-jar-plugin + 3.1.1 + + + + false + + + ${maven.build.timestamp} + GeneXus + ${java.version} + ${os.name} + ${project.version} + ${basedir} + + + + **/com/genexusmessaging/** + + + + + + \ No newline at end of file diff --git a/gxqueueawssqs/src/main/java/com/genexus/messaging/queue/aws/AWSBasicCredentials.java b/gxqueueawssqs/src/main/java/com/genexus/messaging/queue/aws/AWSBasicCredentials.java new file mode 100644 index 000000000..f2a0af299 --- /dev/null +++ b/gxqueueawssqs/src/main/java/com/genexus/messaging/queue/aws/AWSBasicCredentials.java @@ -0,0 +1,31 @@ +package com.genexus.messaging.queue.aws; + +public class AWSBasicCredentials extends AWSCredentials { + private String accessKeyId; + private String secretKey; + private String region; + + public String getAccessKeyId() { + return accessKeyId; + } + + public void setAccessKeyId(String accessKeyId) { + this.accessKeyId = accessKeyId; + } + + public String getSecretKey() { + return secretKey; + } + + public void setSecretKey(String secretKey) { + this.secretKey = secretKey; + } + + public String getRegion() { + return region; + } + + public void setRegion(String region) { + this.region = region; + } +} diff --git a/gxqueueawssqs/src/main/java/com/genexus/messaging/queue/aws/AWSCredentials.java b/gxqueueawssqs/src/main/java/com/genexus/messaging/queue/aws/AWSCredentials.java new file mode 100644 index 000000000..c09c308c5 --- /dev/null +++ b/gxqueueawssqs/src/main/java/com/genexus/messaging/queue/aws/AWSCredentials.java @@ -0,0 +1,4 @@ +package com.genexus.messaging.queue.aws; + +public abstract class AWSCredentials { +} diff --git a/gxqueueawssqs/src/main/java/com/genexus/messaging/queue/aws/AWSQueue.java b/gxqueueawssqs/src/main/java/com/genexus/messaging/queue/aws/AWSQueue.java new file mode 100644 index 000000000..adb15f448 --- /dev/null +++ b/gxqueueawssqs/src/main/java/com/genexus/messaging/queue/aws/AWSQueue.java @@ -0,0 +1,279 @@ +package com.genexus.messaging.queue.aws; + +import com.genexus.messaging.queue.IQueue; +import com.genexus.messaging.queue.model.SimpleQueueMessage; +import com.genexus.messaging.queue.model.DeleteMessageResult; +import com.genexus.messaging.queue.model.MessageQueueOptions; +import com.genexus.messaging.queue.model.SendMessageResult; + +import com.genexus.services.ServiceConfigurationException; +import com.genexus.util.GXProperties; +import com.genexus.util.GXProperty; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; +import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider; +import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; +import software.amazon.awssdk.regions.Region; +import software.amazon.awssdk.services.sqs.SqsClient; +import software.amazon.awssdk.services.sqs.model.*; + +import java.util.*; + +public class AWSQueue implements IQueue { + private static Logger logger = LogManager.getLogger(AWSQueue.class); + + public static String Name = "AWSSQS"; + + private SqsClient sqsClient; + + private String accessKey; + private String secret; + private String awsRegion; + private String queueURL; + private boolean isFIFO; + + private static String MESSSAGE_GROUP_ID = "MessageGroupId"; + private static String MESSSAGE_DEDUPLICATION_ID = "MessageDeduplicationId"; + + public AWSQueue(String queueUrl) throws ServiceConfigurationException { + initialize(null, queueURL); + } + + public AWSQueue(AWSBasicCredentials credentials, String queueUrl) throws ServiceConfigurationException { + initialize(credentials, queueUrl); + } + + private void initialize(AWSBasicCredentials credentials, String queueUrl) throws ServiceConfigurationException { + queueURL = queueUrl; + + boolean bUseIAM = credentials == null; + if (!bUseIAM) { + accessKey = credentials.getAccessKeyId(); + secret = credentials.getSecretKey(); + awsRegion = credentials.getRegion(); + isFIFO = queueURL.endsWith(".fifo"); + } + + if (bUseIAM) { + sqsClient = SqsClient.builder() + .region(Region.of(awsRegion)) + .credentialsProvider(ProfileCredentialsProvider.create()) + .build(); + } else { + AwsBasicCredentials awsCreds = AwsBasicCredentials.create( + accessKey, + secret); + sqsClient = SqsClient.builder() + .region(Region.of(awsRegion)) + .credentialsProvider(StaticCredentialsProvider.create(awsCreds)) + .build(); + } + } + + @Override + public Integer getQueueLength() { + String attName = "ApproximateNumberOfMessages"; + GetQueueAttributesRequest request = GetQueueAttributesRequest.builder() + .queueUrl(queueURL) + .attributeNamesWithStrings(attName) + .build(); + GetQueueAttributesResponse response = sqsClient.getQueueAttributes(request); + String queueLengthS = response.attributesAsStrings().getOrDefault(attName, "0"); + return Integer.parseInt(queueLengthS); + } + + @Override + public SendMessageResult sendMessage(SimpleQueueMessage simpleQueueMessage) { + return sendMessage(simpleQueueMessage, new MessageQueueOptions()); + } + + @Override + public SendMessageResult sendMessage(SimpleQueueMessage simpleQueueMessage, MessageQueueOptions messageQueueOptions) { + List result = sendMessagesImpl(Arrays.asList(simpleQueueMessage), messageQueueOptions); + return result.get(0); + } + + @Override + public List sendMessages(List simpleQueueMessages, MessageQueueOptions messageQueueOptions) { + return sendMessagesImpl(simpleQueueMessages, messageQueueOptions); + } + + private List sendMessagesImpl(List simpleQueueMessages, MessageQueueOptions messageQueueOptions) { + List sendMessageResultList = new ArrayList<>(); + List entryList = new ArrayList<>(); + + if (simpleQueueMessages.size() == 0) + return sendMessageResultList; + + for (SimpleQueueMessage msg : simpleQueueMessages) { + Map msgProps = new HashMap<>(); + for (int i = 0; i < msg.getMessageAttributes().count(); i++) { + GXProperty prop = msg.getMessageAttributes().item(i); + MessageAttributeValue msgAtt = MessageAttributeValue.builder() + .stringValue(prop.getValue()) + .dataType("String") + .build(); + msgProps.put(prop.getKey(), msgAtt); + } + + SendMessageBatchRequestEntry.Builder entry = SendMessageBatchRequestEntry.builder() + .messageBody(msg.getMessageBody()) + .id(msg.getMessageId()) + .messageAttributes(msgProps); + + if (isFIFO) { + String msgDeduplicationId = msg.getMessageAttributes().get(MESSSAGE_DEDUPLICATION_ID); + String msgGroupId = msg.getMessageAttributes().get(MESSSAGE_GROUP_ID); + if (msgDeduplicationId != null) { + entry.messageDeduplicationId(msgDeduplicationId); + } + if (msgGroupId != null) { + entry.messageGroupId(msgGroupId); + } + } + if (messageQueueOptions.getDelaySeconds() > 0) { + entry.delaySeconds(messageQueueOptions.getDelaySeconds()); + } + entryList.add(entry.build()); + } + + SendMessageBatchResponse responseBatch = sqsClient.sendMessageBatch(SendMessageBatchRequest.builder() + .queueUrl(queueURL) + .entries(entryList) + .build()); + + for (SendMessageBatchResultEntry msg : responseBatch.successful()) { + sendMessageResultList.add(new SendMessageResult() {{ + setMessageId(msg.id()); + setMessageServerId(msg.messageId()); + setMessageSentStatus(SendMessageResult.SENT); + }}); + } + for (BatchResultErrorEntry msg : responseBatch.failed()) { + logger.error(String.format("SendMessage '%s' was rejected by AWS SQS server. Message: %s", msg.id(), msg.message())); + sendMessageResultList.add(new SendMessageResult() {{ + setMessageId(msg.id()); + setMessageSentStatus(SendMessageResult.FAILED); + }}); + } + + return sendMessageResultList; + } + + @Override + public List getMessages(MessageQueueOptions messageQueueOptions) { + List receivedSimpleQueueMessages = new ArrayList<>(); + + ReceiveMessageRequest.Builder receiveMessageRequest = ReceiveMessageRequest.builder().queueUrl(queueURL); + + if (messageQueueOptions.getMaxNumberOfMessages() > 0) { + receiveMessageRequest.maxNumberOfMessages((int) messageQueueOptions.getMaxNumberOfMessages()); + } + if (messageQueueOptions.getVisibilityTimeout() > 0) { + receiveMessageRequest.visibilityTimeout(messageQueueOptions.getVisibilityTimeout()); + } + if (messageQueueOptions.getWaitTimeout() > 0) { + receiveMessageRequest.waitTimeSeconds(messageQueueOptions.getWaitTimeout()); + } + if (messageQueueOptions.getReceiveRequestAttemptId().length() > 0) { + receiveMessageRequest.receiveRequestAttemptId(messageQueueOptions.getReceiveRequestAttemptId()); + } + if (messageQueueOptions.isReceiveMessageAttributes()) { + receiveMessageRequest.messageAttributeNames("All"); + receiveMessageRequest.attributeNamesWithStrings("All"); + + } + + ReceiveMessageResponse receiveMessageResponse = sqsClient.receiveMessage(receiveMessageRequest.build()); + + if (receiveMessageResponse.hasMessages()) { + for (Message m : receiveMessageResponse.messages()) { + receivedSimpleQueueMessages.add(setupSimpleQueueMessage(m)); + } + } + return receivedSimpleQueueMessages; + } + + private SimpleQueueMessage setupSimpleQueueMessage(Message response) { + SimpleQueueMessage simpleQueueMessage = new SimpleQueueMessage() {{ + setMessageId(response.messageId()); + setMessageHandleId(response.receiptHandle()); + setMessageBody(response.body()); + }}; + GXProperties messageAtts = simpleQueueMessage.getMessageAttributes(); + + messageAtts.add("MD5OfMessageAttributes", response.md5OfMessageAttributes()); + messageAtts.add("MD5OfBody", response.md5OfBody()); + + for (Map.Entry entry : response.attributesAsStrings().entrySet()) { + messageAtts.add(entry.getKey(), entry.getValue()); + } + + for (Map.Entry entry : response.messageAttributes().entrySet()) { + messageAtts.add(entry.getKey(), entry.getValue().stringValue()); + } + + return simpleQueueMessage; + } + + @Override + public DeleteMessageResult deleteMessage(String messageHandleId) { + if (messageHandleId.length() == 0) + return new DeleteMessageResult(); + return deleteMessagesImpl(Arrays.asList(messageHandleId)).get(0); + } + + @Override + public List deleteMessages(List messageHandleIds) { + return deleteMessagesImpl(messageHandleIds); + } + + private List deleteMessagesImpl(List messageHandleIds) { + if (messageHandleIds.size() == 0) + return new ArrayList<>(); + + List deleteMessageResults = new ArrayList<>(); + + List deleteMessageEntries = new ArrayList<>(); + for (String msgId: messageHandleIds) { + deleteMessageEntries.add(DeleteMessageBatchRequestEntry.builder() + .id(java.util.UUID.randomUUID().toString()) + .receiptHandle(msgId) + .build()); + } + DeleteMessageBatchRequest.Builder deleteMessageRequest = DeleteMessageBatchRequest.builder() + .queueUrl(queueURL) + .entries(deleteMessageEntries); + + DeleteMessageBatchResponse deleteMessageBatchResponse = sqsClient.deleteMessageBatch(deleteMessageRequest.build()); + + for (DeleteMessageBatchResultEntry msg:deleteMessageBatchResponse.successful()) { + deleteMessageResults.add(new DeleteMessageResult() {{ + setMessageId(msg.id()); + setMessageDeleteStatus(DeleteMessageResult.DELETED); + }}); + } + + for (BatchResultErrorEntry msg:deleteMessageBatchResponse.failed()) { + logger.error(String.format("DeleteMessage '%s' was rejected by AWS SQS server: Message: %s", msg.id(), msg.message())); + deleteMessageResults.add(new DeleteMessageResult() {{ + setMessageId(msg.id()); + setMessageDeleteStatus(DeleteMessageResult.FAILED); + }}); + } + return deleteMessageResults; + } + + @Override + public boolean purge() { + PurgeQueueRequest purgeQueueRequest = PurgeQueueRequest.builder().queueUrl(queueURL).build(); + try { + sqsClient.purgeQueue(purgeQueueRequest); + return true; + } catch (PurgeQueueInProgressException e) { + logger.info("Failed to purge queue because a purge queue operation is in progress", e); + } + return false; + } +} diff --git a/gxqueueawssqs/src/main/java/com/genexus/messaging/queue/aws/AWSQueueFactory.java b/gxqueueawssqs/src/main/java/com/genexus/messaging/queue/aws/AWSQueueFactory.java new file mode 100644 index 000000000..6074f3b86 --- /dev/null +++ b/gxqueueawssqs/src/main/java/com/genexus/messaging/queue/aws/AWSQueueFactory.java @@ -0,0 +1,60 @@ +package com.genexus.messaging.queue.aws; + +import com.genexus.GXBaseCollection; +import com.genexus.GxUserType; +import com.genexus.SdtMessages_Message; +import com.genexus.diagnostics.core.ILogger; +import com.genexus.diagnostics.core.LogManager; +import com.genexus.messaging.queue.IQueue; +import com.genexus.messaging.queue.SimpleMessageQueue; +import com.genexus.services.ServiceConfigurationException; +import com.genexusmessaging.awscore.SdtAWSBasicCredentials; + + +public class AWSQueueFactory { + private static ILogger logger = LogManager.getLogger(AWSQueueFactory.class); + + public SimpleMessageQueue connect(GxUserType awsBasicCredentials, String queueURL, GXBaseCollection[] errorMessagesArr, boolean[] success) { + GXBaseCollection errMessages = errorMessagesArr[0]; + AWSBasicCredentials credentials = new AWSBasicCredentials() {{ + setAccessKeyId(((SdtAWSBasicCredentials) awsBasicCredentials).getgxTv_SdtAWSBasicCredentials_Accesskey()); + setSecretKey(((SdtAWSBasicCredentials) awsBasicCredentials).getgxTv_SdtAWSBasicCredentials_Secretkey()); + setRegion(((SdtAWSBasicCredentials) awsBasicCredentials).getgxTv_SdtAWSBasicCredentials_Region()); + }}; + + try { + IQueue queueImpl = new AWSQueue(credentials, queueURL); + errMessages.clear(); + success[0] = queueURL.length() > 0; + return new SimpleMessageQueue(queueImpl); + + } catch (ServiceConfigurationException e) { + handleConnectionError(errMessages, e); + } + return null; + } + + public SimpleMessageQueue connect(String queueURL, GXBaseCollection[] errorMessagesArr, boolean[] success) { + GXBaseCollection errMessages = errorMessagesArr[0]; + + try { + IQueue queueImpl = new AWSQueue(queueURL); + errMessages.clear(); + success[0] = queueURL.length() > 0; + return new SimpleMessageQueue(queueImpl); + + } catch (ServiceConfigurationException e) { + handleConnectionError(errMessages, e); + } + return null; + } + + private static void handleConnectionError(GXBaseCollection errMessages, ServiceConfigurationException e) { + logger.error("Failed to connect to AWS SQS Queue", e); + SdtMessages_Message msg = new SdtMessages_Message(); + msg.setgxTv_SdtMessages_Message_Description(e.getMessage()); + msg.setgxTv_SdtMessages_Message_Type((byte) 1); + errMessages.add(msg); + } + +} diff --git a/gxqueueawssqs/src/main/java/com/genexusmessaging/awscore/SdtAWSBasicCredentials.java b/gxqueueawssqs/src/main/java/com/genexusmessaging/awscore/SdtAWSBasicCredentials.java new file mode 100644 index 000000000..423847095 --- /dev/null +++ b/gxqueueawssqs/src/main/java/com/genexusmessaging/awscore/SdtAWSBasicCredentials.java @@ -0,0 +1,78 @@ +package com.genexusmessaging.awscore; + +import com.genexus.*; + +public final class SdtAWSBasicCredentials extends GxUserType { + protected byte gxTv_SdtAWSBasicCredentials_N; + protected String sTagName; + protected String gxTv_SdtAWSBasicCredentials_Accesskey; + protected String gxTv_SdtAWSBasicCredentials_Secretkey; + protected String gxTv_SdtAWSBasicCredentials_Region; + + public SdtAWSBasicCredentials() { + this(new ModelContext(SdtAWSBasicCredentials.class)); + } + + public SdtAWSBasicCredentials(ModelContext context) { + super(context, "SdtAWSBasicCredentials"); + } + + public SdtAWSBasicCredentials(int remoteHandle, + ModelContext context) { + super(remoteHandle, context, "SdtAWSBasicCredentials"); + } + + public String getgxTv_SdtAWSBasicCredentials_Accesskey() { + return gxTv_SdtAWSBasicCredentials_Accesskey; + } + + public void setgxTv_SdtAWSBasicCredentials_Accesskey(String value) { + gxTv_SdtAWSBasicCredentials_N = (byte) (0); + gxTv_SdtAWSBasicCredentials_Accesskey = value; + } + + public String getgxTv_SdtAWSBasicCredentials_Secretkey() { + return gxTv_SdtAWSBasicCredentials_Secretkey; + } + + public void setgxTv_SdtAWSBasicCredentials_Secretkey(String value) { + gxTv_SdtAWSBasicCredentials_N = (byte) (0); + gxTv_SdtAWSBasicCredentials_Secretkey = value; + } + + public String getgxTv_SdtAWSBasicCredentials_Region() { + return gxTv_SdtAWSBasicCredentials_Region; + } + + public void setgxTv_SdtAWSBasicCredentials_Region(String value) { + gxTv_SdtAWSBasicCredentials_N = (byte) (0); + gxTv_SdtAWSBasicCredentials_Region = value; + } + + public void initialize(int remoteHandle) { + initialize(); + } + + public void initialize() { + gxTv_SdtAWSBasicCredentials_Accesskey = ""; + gxTv_SdtAWSBasicCredentials_N = (byte) (1); + gxTv_SdtAWSBasicCredentials_Secretkey = ""; + gxTv_SdtAWSBasicCredentials_Region = ""; + sTagName = ""; + } + + public byte isNull() { + return gxTv_SdtAWSBasicCredentials_N; + } + + public SdtAWSBasicCredentials Clone() { + return (SdtAWSBasicCredentials) (clone()); + } + + + @Override + public String getJsonMap(String value) { + return null; + } +} + diff --git a/gxqueueawssqs/src/test/java/com/genexus/messaging/queue/aws/TestAWSQueue.java b/gxqueueawssqs/src/test/java/com/genexus/messaging/queue/aws/TestAWSQueue.java new file mode 100644 index 000000000..8675d8fcd --- /dev/null +++ b/gxqueueawssqs/src/test/java/com/genexus/messaging/queue/aws/TestAWSQueue.java @@ -0,0 +1,57 @@ +package com.genexus.messaging.queue.aws; + +import com.genexus.GXBaseCollection; +import com.genexus.SdtMessages_Message; +import com.genexus.messaging.queue.IQueue; +import com.genexus.messaging.queue.SimpleMessageQueue; +import com.genexus.services.ServiceConfigurationException; +import com.genexus.services.ServiceSettingsReader; +import com.genexus.util.GXService; +import com.genexusmessaging.awscore.SdtAWSBasicCredentials; + +public class TestAWSQueue extends TestQueueBase { + + public static String ACCESS_KEY = "ACCESS_KEY"; + public static String SECRET_ACCESS_KEY = "SECRET_KEY"; + public static String REGION = "REGION"; + public static String QUEUE_URL = "QUEUE_URL"; + + + @Override + public String getProviderName() { + return AWSQueue.Name; + } + + @Override + public IQueue getQueue() throws ServiceConfigurationException { + + ServiceSettingsReader serviceSettings = new ServiceSettingsReader("QUEUE", AWSQueue.Name, new GXService()); + String queueURL = serviceSettings.getEncryptedPropertyValue(QUEUE_URL, ""); + + AWSBasicCredentials credentials = new AWSBasicCredentials() {{ + setAccessKeyId(serviceSettings.getEncryptedPropertyValue(ACCESS_KEY, "")); + setSecretKey(serviceSettings.getEncryptedPropertyValue(SECRET_ACCESS_KEY, "")); + setRegion(serviceSettings.getEncryptedPropertyValue(REGION, "")); + }}; + + return new AWSQueue(credentials, queueURL); + } + + @Override + public SimpleMessageQueue getQueueWrapper() throws ServiceConfigurationException { + + ServiceSettingsReader serviceSettings = new ServiceSettingsReader("QUEUE", AWSQueue.Name, new GXService()); + String queueURL = serviceSettings.getEncryptedPropertyValue(QUEUE_URL, ""); + + SdtAWSBasicCredentials credentials = new SdtAWSBasicCredentials(); + credentials.setgxTv_SdtAWSBasicCredentials_Accesskey(serviceSettings.getEncryptedPropertyValue(ACCESS_KEY, "")); + credentials.setgxTv_SdtAWSBasicCredentials_Secretkey(serviceSettings.getEncryptedPropertyValue(SECRET_ACCESS_KEY, "")); + credentials.setgxTv_SdtAWSBasicCredentials_Region(serviceSettings.getEncryptedPropertyValue(REGION, "")); + + GXBaseCollection[] errArray = new GXBaseCollection[1]; + boolean[] success = new boolean[1]; + + return new AWSQueueFactory().connect(credentials, queueURL, errArray, success); + + } +} diff --git a/gxqueueawssqs/src/test/java/com/genexus/messaging/queue/aws/TestQueueBase.java b/gxqueueawssqs/src/test/java/com/genexus/messaging/queue/aws/TestQueueBase.java new file mode 100644 index 000000000..eeb0a2b70 --- /dev/null +++ b/gxqueueawssqs/src/test/java/com/genexus/messaging/queue/aws/TestQueueBase.java @@ -0,0 +1,258 @@ +package com.genexus.messaging.queue.aws; + +import com.genexus.messaging.queue.IQueue; +import com.genexus.messaging.queue.SimpleMessageQueue; +import com.genexus.messaging.queue.model.DeleteMessageResult; +import com.genexus.messaging.queue.model.MessageQueueOptions; +import com.genexus.messaging.queue.model.SimpleQueueMessage; +import com.genexus.messaging.queue.model.SendMessageResult; +import com.genexus.services.ServiceConfigurationException; +import com.genexus.specific.java.Connect; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.List; + +import static org.junit.Assert.assertTrue; +import static org.junit.Assume.assumeTrue; + +public abstract class TestQueueBase { + protected IQueue queue; + + public abstract String getProviderName(); + + public abstract IQueue getQueue() throws ServiceConfigurationException; + public abstract SimpleMessageQueue getQueueWrapper() throws ServiceConfigurationException; + + @Before + public void beforeEachTestMethod() { + Connect.init(); + boolean testEnabled = false; + try { + testEnabled = System.getenv(getProviderName() + "_TEST_ENABLED") != null; + } catch (Exception e) { + + } + + assumeTrue(testEnabled); + + try { + queue = getQueue(); + } catch (ServiceConfigurationException e) { + e.printStackTrace(); + } + assertTrue(queue != null); + } + + @Test + public void purgue() { + boolean purged = ensurePurged(); + Assert.assertTrue("Queue was not purged", purged); + } + + private boolean ensurePurged() { + boolean purged = queue.purge(); + int retry = 30; + int sleepMs = 1000 * 5; + while (!purged && retry > 0) { + sleep(sleepMs); + purged = queue.purge() || queue.getQueueLength() == 0; + retry--; + } + return purged; + } + + private void sleep(int sleepMs) { + try { + Thread.sleep(sleepMs); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + @Test + public void getQueueLength() { + boolean purged = ensurePurged(); + Assert.assertTrue("Queue was not purged", purged); + int retry = 60; + while (queue.getQueueLength() != 0 && retry-- > 0) { + sleep(500); + } + int queueLength = queue.getQueueLength(); + Assert.assertEquals(0, queueLength); + } + + @Test + public void sendMessage() { + SendMessageResult sendResult = sendQueueMessage(); + Assert.assertNotNull(sendResult); + Assert.assertEquals(SendMessageResult.SENT, sendResult.getMessageSentStatus()); + Assert.assertNotEquals("", sendResult.getMessageId()); + Assert.assertNotEquals("", sendResult.getMessageServerId()); + } + + @Test + public void sendMessageWithNoId() { + SimpleQueueMessage msg = createMessage(); + msg.setMessageId(""); + SendMessageResult sendResult = queue.sendMessage(msg); + Assert.assertNotNull(sendResult); + Assert.assertEquals(SendMessageResult.SENT, sendResult.getMessageSentStatus()); + Assert.assertNotEquals("", sendResult.getMessageId()); + Assert.assertNotEquals("", sendResult.getMessageServerId()); + } + + /*@Test + public void sendMessageWithFactoryQueue() { + try { + SimpleMessageQueue simpleQueue = getQueueWrapper(); + simpleQueue.sendMessage(createMessage()); + + } catch (ServiceConfigurationException e) { + e.printStackTrace(); + } + + SendMessageResult sendResult = sendQueueMessage(); + Assert.assertNotNull(sendResult); + Assert.assertEquals(SendMessageResult.SENT, sendResult.getMessageSentStatus()); + Assert.assertNotEquals("", sendResult.getMessageId()); + Assert.assertNotEquals("", sendResult.getMessageServerId()); + }*/ + + @Test + public void sendMessageError() { + List sendResult = queue.sendMessages(new ArrayList(), new MessageQueueOptions()); + Assert.assertNotNull(sendResult); + Assert.assertTrue(sendResult.size() == 0); + } + + @Test + public void receiveMessages() { + SendMessageResult sendResult = sendQueueMessage(); + Assert.assertNotNull(sendResult); + Assert.assertEquals(SendMessageResult.SENT, sendResult.getMessageSentStatus()); + Assert.assertNotEquals("", sendResult.getMessageId()); + + List msgs = queue.getMessages(new MessageQueueOptions()); + Assert.assertTrue(msgs.size() > 0); + SimpleQueueMessage msg = msgs.get(0); + Assert.assertTrue(msg.getMessageBody().length() > 0); + Assert.assertTrue(msg.getMessageId().length() > 0); + Assert.assertTrue(msg.getMessageHandleId().length() > 0); + + } + + @Test + public void receiveMessagesMaxNumberOfMessages() { + for (int i = 0; i < 20; i++) { + SendMessageResult sendResult = sendQueueMessage(); + Assert.assertNotNull(sendResult); + Assert.assertEquals(SendMessageResult.SENT, sendResult.getMessageSentStatus()); + Assert.assertNotEquals("", sendResult.getMessageId()); + } + sleep(1000); + List msgs = queue.getMessages(new MessageQueueOptions(){{ + setMaxNumberOfMessages(2); + }}); + Assert.assertTrue(msgs.size() <= 2); + SimpleQueueMessage msg = msgs.get(0); + Assert.assertTrue(msg.getMessageBody().length() > 0); + Assert.assertTrue(msg.getMessageId().length() > 0); + Assert.assertTrue(msg.getMessageHandleId().length() > 0); + ensurePurged(); + } + + @Test + public void receiveMultipleMessages() { + for (int i = 0; i < 20; i++) { + SendMessageResult sendResult = sendQueueMessage(); + Assert.assertNotNull(sendResult); + Assert.assertEquals(SendMessageResult.SENT, sendResult.getMessageSentStatus()); + Assert.assertNotEquals("", sendResult.getMessageId()); + } + sleep(1000); + List msgs = queue.getMessages(new MessageQueueOptions(){{ + setWaitTimeout(10); + setMaxNumberOfMessages(10); + }}); + Assert.assertTrue(msgs.size() >= 5); // fewer messages might be returned) + SimpleQueueMessage msg = msgs.get(0); + Assert.assertTrue(msg.getMessageBody().length() > 0); + Assert.assertTrue(msg.getMessageId().length() > 0); + Assert.assertTrue(msg.getMessageHandleId().length() > 0); + } + + @Test + public void receiveMessagesWithAtributes() { + SendMessageResult sendResult = sendQueueMessage(); + Assert.assertNotNull(sendResult); + Assert.assertEquals(SendMessageResult.SENT, sendResult.getMessageSentStatus()); + Assert.assertNotEquals("", sendResult.getMessageId()); + + List msgs = queue.getMessages(new MessageQueueOptions()); + Assert.assertTrue(msgs.size() > 0); + SimpleQueueMessage msg = msgs.get(0); + Assert.assertTrue(msg.getMessageBody().length() > 0); + Assert.assertTrue(msg.getMessageId().length() > 0); + Assert.assertTrue(msg.getMessageHandleId().length() > 0); + Assert.assertTrue(msg.getMessageAttributes().count() > 1); + Assert.assertTrue(msg.getMessageAttributes().count() < 5); + + MessageQueueOptions opts = new MessageQueueOptions() {{ + setReceiveMessageAttributes(true); + setMaxNumberOfMessages(5); + setDelaySeconds(2); + setTimetoLive(2); + setWaitTimeout(3); + }}; + + sendQueueMessage(); + + msgs = queue.getMessages(opts); + Assert.assertTrue(msgs.size() > 0); + msg = msgs.get(0); + Assert.assertTrue(msg.getMessageBody().length() > 0); + Assert.assertTrue(msg.getMessageId().length() > 0); + Assert.assertTrue(msg.getMessageHandleId().length() > 0); + Assert.assertTrue(msg.getMessageAttributes().count() > 6); + } + + @Test + public void deleteMessage() { + SendMessageResult sendResult = sendQueueMessage(); + Assert.assertNotNull(sendResult); + Assert.assertEquals(SendMessageResult.SENT, sendResult.getMessageSentStatus()); + Assert.assertNotEquals("", sendResult.getMessageId()); + Assert.assertNotEquals("", sendResult.getMessageServerId()); + + sleep(5000); + + List msgs = queue.getMessages(new MessageQueueOptions()); + Assert.assertTrue(msgs.size() > 0); + DeleteMessageResult deleteMessageResult = queue.deleteMessage(msgs.get(0).getMessageHandleId()); + Assert.assertNotNull(deleteMessageResult); + Assert.assertTrue(deleteMessageResult.getMessageId().length() > 0); + Assert.assertEquals(DeleteMessageResult.DELETED, deleteMessageResult.getMessageDeleteStatus()); + + } + + private SendMessageResult sendQueueMessage() { + SimpleQueueMessage msg = createMessage(); + return queue.sendMessage(msg); + } + + private SimpleQueueMessage createMessage() { + SimpleQueueMessage msg = new SimpleQueueMessage() {{ + setMessageId("gx_" + java.util.UUID.randomUUID().toString()); + setMessageBody("messageBody test"); + getMessageAttributes().set("att1", "test1"); + getMessageAttributes().set("att2", "test2"); + getMessageAttributes().set("att3", "test3"); + getMessageAttributes().set("att4", "test4"); + getMessageAttributes().set("att5", "test5"); + }}; + return msg; + } +} diff --git a/gxqueueazure/pom.xml b/gxqueueazure/pom.xml new file mode 100644 index 000000000..30d5d1250 --- /dev/null +++ b/gxqueueazure/pom.xml @@ -0,0 +1,56 @@ + + + + parent + com.genexus + ${revision}${changelist} + + 4.0.0 + + gxqueueazure + + + ${project.groupId} + gxcommon + ${project.version} + compile + + + ${project.groupId} + gxqueue + ${project.version} + compile + + + + + gxqueue-azure + + + org.apache.maven.plugins + maven-jar-plugin + 3.1.1 + + + + false + + + ${maven.build.timestamp} + GeneXus + ${java.version} + ${os.name} + ${project.version} + ${basedir} + + + + **/com/genexusmessaging/** + + + + + + \ No newline at end of file diff --git a/gxqueueazure/src/main/java/com/genexus/messaging/queue/azure/AzureQueueFactory.java b/gxqueueazure/src/main/java/com/genexus/messaging/queue/azure/AzureQueueFactory.java new file mode 100644 index 000000000..20afd9f73 --- /dev/null +++ b/gxqueueazure/src/main/java/com/genexus/messaging/queue/azure/AzureQueueFactory.java @@ -0,0 +1,28 @@ +package com.genexus.messaging.queue.azure; + +import com.genexus.GXBaseCollection; +import com.genexus.SdtMessages_Message; +import com.genexus.diagnostics.core.ILogger; +import com.genexus.diagnostics.core.LogManager; +import com.genexus.messaging.queue.SimpleMessageQueue; +import com.genexus.services.ServiceConfigurationException; +import org.apache.commons.lang.NotImplementedException; + + +public class AzureQueueFactory { + private static ILogger logger = LogManager.getLogger(AzureQueueFactory.class); + + + public SimpleMessageQueue connect(String queueName, String queueUrl, GXBaseCollection[] errorMessagesArr, boolean[] success) { + throw new NotImplementedException(); + } + + private static void handleConnectionError(GXBaseCollection errMessages, ServiceConfigurationException e) { + logger.error("Failed to connect to AWS SQS Queue", e); + SdtMessages_Message msg = new SdtMessages_Message(); + msg.setgxTv_SdtMessages_Message_Description(e.getMessage()); + msg.setgxTv_SdtMessages_Message_Type((byte) 1); + errMessages.add(msg); + } + +} diff --git a/pom.xml b/pom.xml index 5c55d62dd..5b88c8aa0 100644 --- a/pom.xml +++ b/pom.xml @@ -13,20 +13,20 @@ Core classes for the runtime used by Java and Android apps generated with GeneXus https://github.com/genexuslabs/JavaClasses - - 2.8 - -SNAPSHOT - + + 2.8 + -SNAPSHOT + - UTF-8 - - 2.34 - 3.0.3 - 5.2.2 - 2.13.2 - 4.13.2 - 2.17.213 - + UTF-8 + + 2.34 + 3.0.3 + 5.2.2 + 2.13.2 + 4.13.2 + 2.17.213 + GeneXus S.A. @@ -84,6 +84,9 @@ gxwebsocketjakarta gxawsserverless androidreports + gxqueue + gxqueueawssqs + gxqueueazure diff --git a/wrappercommon/src/main/java/com/genexus/diagnostics/core/provider/Log4J2Logger.java b/wrappercommon/src/main/java/com/genexus/diagnostics/core/provider/Log4J2Logger.java index eb824c849..9db36cb9a 100644 --- a/wrappercommon/src/main/java/com/genexus/diagnostics/core/provider/Log4J2Logger.java +++ b/wrappercommon/src/main/java/com/genexus/diagnostics/core/provider/Log4J2Logger.java @@ -3,30 +3,23 @@ import com.genexus.diagnostics.core.ILogger; public class Log4J2Logger implements ILogger { - - //Java implementation - public Log4J2Logger (final Class clazz) { + private org.apache.logging.log4j.Logger log; + + public Log4J2Logger(final Class clazz) { log = org.apache.logging.log4j.LogManager.getLogger(clazz); } - - public Log4J2Logger (String clazz) { + + public Log4J2Logger(String clazz) { log = org.apache.logging.log4j.LogManager.getLogger(clazz); } - - org.apache.logging.log4j.Logger log = null; - - + @Override public void fatal(String msg) { - if (log.isFatalEnabled()) { - log.fatal(msg); - } + log.fatal(msg); } - + public void fatal(String msg, Throwable ex) { - if (log.isFatalEnabled()) { - log.fatal(msg, ex); - } + log.fatal(msg, ex); } public void fatal(String msg1, String msg2, Throwable ex) { @@ -44,15 +37,11 @@ public void fatal(Throwable ex, String[] list) { } public void fatal(String[] list) { - if (log.isFatalEnabled()) { - fatal(null, list); - } + fatal(null, list); } - + public void error(String msg, Throwable ex) { - if (log.isErrorEnabled()) { - log.error(msg, ex); - } + log.error(msg, ex); } public void error(String msg1, String msg2, Throwable ex) { @@ -72,11 +61,9 @@ public void error(Throwable ex, String[] list) { public void error(String[] list) { error(null, list); } - + public void error(String msg) { - if (log.isErrorEnabled()) { - log.error(msg); - } + log.error(msg); } public void warn(Throwable ex, String[] list) { @@ -97,18 +84,14 @@ public void warn(String[] list) { } public void warn(String msg, Throwable ex) { - if (log.isWarnEnabled()) { - log.warn(msg, ex); - } + log.warn(msg, ex); } public void debug(String msg) { - if (log.isDebugEnabled()) { - log.debug(msg); - } + log.debug(msg); } - - + + public void debug(Throwable ex, String[] list) { if (log.isDebugEnabled()) { StringBuilder msg = new StringBuilder(); @@ -123,9 +106,7 @@ public void debug(Throwable ex, String[] list) { } public void debug(String[] list) { - if (log.isDebugEnabled()) { - debug(null, list); - } + debug(null, list); } // Lambda Functions not supported JAVA 7. Only Java 8. @@ -142,9 +123,7 @@ public void debug(String msg1, String msg2, Throwable ex) { } public void debug(String msg, Throwable ex) { - if (log.isDebugEnabled()) { - log.debug(msg, ex); - } + log.debug(msg, ex); } public void info(String[] list) { @@ -156,28 +135,19 @@ public void info(String[] list) { log.info(msg); } } - + public void info(String msg) { - if (log.isInfoEnabled()) { - log.info(msg); - } + log.info(msg); } - + public void warn(String msg) { - if (log.isWarnEnabled()) { - log.warn(msg); - } + log.warn(msg); } - - public void trace(String msg) { - if (log.isTraceEnabled()) { - log.trace(msg); - } + log.trace(msg); } - public void trace(Throwable ex, String[] list) { if (log.isTraceEnabled()) { StringBuilder msg = new StringBuilder(); @@ -192,9 +162,7 @@ public void trace(Throwable ex, String[] list) { } public void trace(String[] list) { - if (log.isTraceEnabled()) { - trace(null, list); - } + trace(null, list); } // Lambda Functions not supported JAVA 7. Only Java 8. @@ -211,11 +179,9 @@ public void trace(String msg1, String msg2, Throwable ex) { } public void trace(String msg, Throwable ex) { - if (log.isTraceEnabled()) { - log.trace(msg, ex); - } + log.trace(msg, ex); } - + public boolean isDebugEnabled() { return log.isDebugEnabled(); } @@ -223,5 +189,5 @@ public boolean isDebugEnabled() { public boolean isErrorEnabled() { return log.isErrorEnabled(); } - + }