App42_Ruby_API 0.8.4

data/lib/message/Queue.rb

@@ -0,0 +1,50 @@
+# -----------------------------------------------------------------------
+#  Copyright © 2012 ShepHertz Technologies Pvt Ltd. All rights reserved.
+# -----------------------------------------------------------------------
+
+require 'App42_Ruby_API/App42Response'
+
+#
+#
+# This Queue object is the value object which contains the properties of Queue
+# along with the setter & getter for those properties.
+#
+#
+
+module App42
+  module Message
+    class Queue < App42Response
+      attr_accessor  :messageList,:queueName,:queueType,:description
+      @messageList = Array.new
+      @queueName
+      @queueType
+      @description
+    end
+
+    class  Message
+      attr_accessor  :correlationId,:payLoad,:messageId
+
+      #
+      # This is a constructor that takes no parameter
+      #
+      def initialize(queue)
+        queue.messageList.push(self);
+      end
+      @correlationId
+      @payLoad
+      @messageId
+
+      #
+      # Returns the Queue Response in JSON format.
+      #
+      # @return the response in JSON format.
+      #
+      #
+
+      def to_s
+        return "correlationId : #{@correlationId}" + "payLoad : #{@payLoad}" + "messageId : #{@messageId}" ;
+      end
+
+    end
+  end
+end

data/lib/message/QueueResponseBuilder.rb

@@ -0,0 +1,64 @@
+# -----------------------------------------------------------------------
+#  Copyright © 2012 ShepHertz Technologies Pvt Ltd. All rights reserved.
+# -----------------------------------------------------------------------
+
+require 'json/pure'
+require 'App42_Ruby_API/App42ResponseBuilder'
+require 'message/Queue'
+
+module App42
+  module Message
+
+    #
+    #
+    # QueueResponseBuilder class converts the JSON response retrieved from the
+    # server to the value object i.e Queue
+    #
+    #
+    class QueueResponseBuilder < App42ResponseBuilder
+
+      #
+      # Converts the response in JSON format to the value object i.e Queue
+      #
+      # @param json
+      #      - response in JSON format
+      #
+      # @return Queue object filled with json data
+      #
+      #
+      def buildResponse(json)
+        puts "testing #{json}"
+        queuesJSONObj = getServiceJSONObject("queues", json)
+        queueJSONObj =  queuesJSONObj["queue"]
+        queueObj = Queue.new()
+
+        messageList = Array.new
+        queueObj.messageList=(messageList)
+
+        queueObj.strResponse=json
+        queueObj.isResponseSuccess= isResponseSuccess(json)
+        buildObjectFromJSONTree(queueObj, queueJSONObj);
+
+        if queueJSONObj.key?("messages") == false
+          return queueObj
+        end
+        if queueJSONObj.fetch("messages").key?("message") == false
+          return queueObj
+        end
+        if queueJSONObj.fetch("messages").fetch("message").instance_of?(Hash)
+          messageObj = App42::Message::Message.new(queueObj)
+          buildObjectFromJSONTree(messageObj,queueJSONObj.fetch("messages").fetch("message"));
+        else
+          messagesJSONArray = queueJSONObj.fetch("messages").fetch("message");
+          messagesJSONArray.length.times do |i|
+            messageJSONObj = messagesJSONArray[i]
+            messageObj = App42::Message::Message.new(queueObj)
+            buildObjectFromJSONTree(messageObj, messageJSONObj);
+          end
+
+        end
+        return queueObj
+      end
+    end
+  end
+end

data/lib/message/QueueService.rb

@@ -0,0 +1,469 @@
+# -----------------------------------------------------------------------
+#  Copyright © 2012 ShepHertz Technologies Pvt Ltd. All rights reserved.
+# -----------------------------------------------------------------------
+
+require 'rubygems'
+require 'connection/RESTConnection'
+require 'util/util'
+require 'json/pure'
+require 'App42_Ruby_API/App42Response'
+require 'message/QueueResponseBuilder'
+require 'message/Queue'
+
+module App42
+  module Message
+    #
+    # Manages Asynchronous queues. Allows to create, delete, purge messages, view pending messages and
+    # get all messages
+    #
+    # @see Queue
+    #
+    class QueueService
+      #
+      # this is a constructor that takes
+      #
+      # @param apiKey
+      # @param secretKey
+      # @param baseURL
+      #
+      def initialize(api_key, secret_key, base_url)
+        puts "Message Service->initialize"
+        @api_key = api_key
+        @secret_key = secret_key
+        @base_url = base_url
+        @resource = "queue"
+        @messageResource = "message"
+        @version = "1.0"
+      end
+
+      # Creates a type Pull Queue
+      #
+      # @param queueName
+      #      - The name of the queue which has to be created
+      # @param queueDescription
+      #      - The description of the queue
+      #
+      # @return Queue object containing queue name which has been created
+      #
+      # @raise App42Exception
+      #
+
+      def create_pull_queue(queueName, queueDescription)
+        puts "Create Pull Queue Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        messageObj = nil;
+        messageObj = Queue.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(queueName, "Queue Name");
+        util.throwExceptionIfNullOrBlank(queueDescription, "Queue Description");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          body = {'app42' => {"queue"=> {
+            "name" => queueName,
+            "description" => queueDescription
+            }}}.to_json
+          puts "Body #{body}"
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+            "type"=>'pull'
+          }
+          query_params = params.clone
+          params.store("body", body)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/pull"
+          response = connection.post(signature, resource_url, query_params, body)
+          message = QueueResponseBuilder.new()
+          messageObj = message.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return messageObj
+      end
+
+      #
+      # Deletes the Pull type Queue
+      #
+      # @param queueName
+      #      - The name of the queue which has to be deleted
+      #
+      # @return App42Response if deleted successfully
+      #
+      # @raise App42Exception
+      #
+
+      def delete_pull_queue(queueName)
+        puts "Delete Pull Queue Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        responseObj = App42Response.new();
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(queueName, "Queue Name");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+            "type"=>'pull'
+          }
+          query_params = params.clone
+          params.store("queueName", queueName)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/pull/#{queueName}"
+          response = connection.delete(signature, resource_url, query_params)
+          responseObj.strResponse=(response)
+          responseObj.isResponseSuccess=(true)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return responseObj
+      end
+
+      #
+      # Purges message on the Queue. Note: once the Queue is purged the messages
+      # are removed from the Queue and wont be available for dequeueing.
+      #
+      # @param queueName
+      #      - The name of the queue which has to be purged
+      #
+      # @return Queue object containing queue name which has been purged
+      #
+      # @raise App42Exception
+      #
+
+      def purge_pull_queue(queueName)
+        puts "Purge Pull Queue Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        responseObj = App42Response.new();
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(queueName, "Queue Name");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+            "type"=>'pull'
+          }
+          query_params = params.clone
+          params.store("queueName", queueName)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/pull/purge/#{queueName}"
+          response = connection.delete(signature, resource_url, query_params)
+          responseObj.strResponse=(response)
+          responseObj.isResponseSuccess=(true)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return responseObj
+      end
+
+      #
+      # Messages which are pending to be dequeue. Note: Calling this method does not
+      # dequeue the messages in the Queue. The messages stay in the Queue till they are dequeued
+      #
+      # @param queueName
+      #      - The name of the queue from which pending messages have to be fetched
+      #
+      # @return Queue object containing pending messages in the Queue
+      #
+      # @raise App42Exception
+      #
+
+      def pending_messages(queueName)
+        puts "Pending Messages Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        messageObj = nil;
+        messageObj = Queue.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(queueName, "Queue Name");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("queueName", queueName)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/pending/#{queueName}"
+          response = connection.get(signature, resource_url, query_params)
+          message = QueueResponseBuilder.new()
+          messageObj = message.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return messageObj
+      end
+
+      #
+      # Messages are retrieved and dequeued from the Queue.
+      #
+      # @param queueName
+      #      - The name of the queue which have to be retrieved
+      # @param receiveTimeOut
+      #      - Receive time out
+      #
+      # @return Queue object containing messages in the Queue
+      #
+      # @raise App42Exception
+      #
+
+      def get_messages(queueName, receiveTimeOut)
+        puts "Get Messages Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        messageObj = nil;
+        messageObj = Queue.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(queueName, "Queue Name");
+        util.throwExceptionIfNullOrBlank(receiveTimeOut, "ReceiveTimeOut");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("queueName", queueName)
+          params.store("receiveTimeOut", (receiveTimeOut.to_i).to_s)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/messages/#{queueName}/#{(receiveTimeOut.to_i).to_s}"
+          response = connection.get(signature, resource_url, query_params)
+          message = QueueResponseBuilder.new()
+          messageObj = message.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return messageObj
+      end
+
+      #
+      # Send message on the queue with an expiry. The message will expire if it is not pulled/dequeued before the expiry
+      #
+      # @param queueName
+      #      - The name of the queue to which the message has to be sent
+      # @param msg
+      #      - Message that has to be sent
+      # @param exp
+      #      - Message expiry time
+      #
+      # @return Queue object containing message which has been sent with its message id and correlation id
+      #
+      # @raise App42Exception
+      #
+
+      def send_message(queueName, msg, exp)
+        puts "Get Messages Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        messageObj = nil;
+        messageObj = Queue.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(queueName, "Queue Name");
+        util.throwExceptionIfNullOrBlank(msg, "Message");
+        util.throwExceptionIfNullOrBlank(exp, "Exipiration");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          body = {'app42' => {"payLoad"=> {
+            "message" => msg,
+            "expiration" => exp
+            }}}.to_json
+          puts "Body #{body}"
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+            'queueName' => queueName
+          }
+          query_params = params.clone
+          params.store("body", body)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@messageResource}/#{queueName}"
+          response = connection.post(signature, resource_url, query_params, body)
+          message = QueueResponseBuilder.new()
+          messageObj = message.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return messageObj
+      end
+
+      #
+      # Pulls all the message from the queue
+      #
+      # @param queueName
+      #      - The name of the queue from which messages have to be pulled
+      # @param receiveTimeOut
+      #      - Receive time out
+      #
+      # @return Queue object containing  messages which have been pulled
+      #
+      # @raise App42Exception
+      #
+
+      def receive_message(queueName, receiveTimeOut)
+        puts "Receive Message Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        messageObj = nil;
+        messageObj = Queue.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(queueName, "Queue Name");
+        util.throwExceptionIfNullOrBlank(receiveTimeOut, "ReceiveTimeOut");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("queueName", queueName)
+          params.store("receiveTimeOut", "" + (receiveTimeOut.to_i).to_s)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@messageResource}/#{queueName}/#{(receiveTimeOut.to_i).to_s}"
+          response = connection.get(signature, resource_url, query_params)
+          message = QueueResponseBuilder.new()
+          messageObj = message.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return messageObj
+      end
+
+      #
+      # Pull message based on the correlation id
+      #
+      # @param queueName
+      #      - The name of the queue from which the message has to be pulled
+      # @param receiveTimeOut
+      #      - Receive time out
+      # @param correlationId
+      #      - Correlation Id for which message has to be pulled
+      #
+      # @return Queue containing  message which has pulled based on the correlation id
+      #
+      # @raise App42Exception
+      #
+
+      def receive_message_by_correlation_id(queueName, receiveTimeOut, correlationId)
+        puts "Receive Message Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        messageObj = nil;
+        messageObj = Queue.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(queueName, "Queue Name");
+        util.throwExceptionIfNullOrBlank(receiveTimeOut, "ReceiveTimeOut");
+        util.throwExceptionIfNullOrBlank(correlationId, "Correlation Id");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("queueName", queueName)
+          params.store("receiveTimeOut", "" + (receiveTimeOut.to_i).to_s)
+          params.store("correlationId", "" + correlationId)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@messageResource}/#{queueName}/#{(receiveTimeOut.to_i).to_s}/#{correlationId}"
+          response = connection.get(signature, resource_url, query_params)
+          message = QueueResponseBuilder.new()
+          messageObj = message.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return messageObj
+      end
+
+      #
+      # Remove message from the queue based on the message id. Note: Once the message is removed it cannot be pulled
+      #
+      # @param queueName
+      #      - The name of the queue from which the message has to be removed
+      # @param messageId
+      #      - The message id of the message which has to be removed.
+      #
+      # @return App42Response if removed successfully
+      #
+      # @raise App42Exception
+      #
+
+      def remove_message(queueName, messageId)
+        puts "Remove Message Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        responseObj = App42Response.new();
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(queueName, "Queue Name");
+        util.throwExceptionIfNullOrBlank(messageId, "messageId");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("queueName", queueName)
+          params.store("messageId", messageId)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@messageResource}/#{queueName}/#{messageId}"
+          response = connection.delete(signature, resource_url, query_params)
+          responseObj.strResponse=(response)
+          responseObj.isResponseSuccess=(true)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return responseObj
+      end
+
+    end
+  end
+end