Storing and Forwarding Messages

Store and forward messaging is used for serving traffic to back-end services that can accept request messages only at a given rate. This is also used for guaranteed delivery to ensure that request received never gets lost since they are stored in the message store and also available for future reference. 

Let's get started!

Setting up the message broker profile

The message broker profile (which is an instance of WSO2 Message Broker) is shipped with the WSO2 EI product distribution. You need to enable the following configurations to be able to store messages in the broker profile.

Open the <EI_HOME>/conf/jndi.properties file and add the following line after the queue.MyQueue = example.MyQueue line:

queue.PaymentRequestJMSMessageStore=PaymentRequestJMSMessageStore

Creating the Message Store

Now, let's create a message store artifact in WSO2 Integration Studio. 

1. Right click on SampleServices in the Project Explorer and navigate to New->Message Store.

2. Select Create a new message-store artifact and fill in the information in the following table and click Finish.

   Message Store Name	PaymentRequestMessageStore
   Message Store Type	Select WSO2 MB Message Store
   Queue Connection Factory	amqp://admin:admin@clientID/carbon?brokerlist='tcp://localhost:5675' Change the port to 5675.
   JNDI Queue Name	PaymentRequestJMSMessageStore

   

   Click Finish.

Let's look at how we update the REST API with the Store mediator.

Creating the Deployable Artifacts

Let's now update the REST API so that the messages sent to SettlePaymentEP is forwarded to the message store we created above. 

1. Drag and add a Store Mediator from the mediators palette just after the PayloadFactory mediator.
   

2. With the Store mediator selected, access the Property tab and fill in the information as in the following table:

   Field	Value
   Available Message Store	Select PaymentRequestMessageStore
   Message Store	Double click to populate the value PaymentRequestMessageStore
   Description	Payment Store

   Let's use a PayloadFactory mediator to send a customized response message to the client. 

3. Delete the Call mediator by right clicking on the mediator and selecting Delete from Model. Replace this with a PayloadFactory mediator from the Mediators palette to configure the response to be sent to the client. With the PayloadFactory mediator selected, access the Property tab and fill in the information in the following table to define a customized message to be returned to the client.

   Field	Value
   Media Type	Select json
   Payload Format	Select Inline
   Payload	{"message":" Payment request successfully submitted. Payment confirmation will be sent via email ."}

   To avoid getting an error message, first select Media Type before selecting Payload.

   You should now have a completed configuration that looks like this:
   

Creating the Response Sequence

Let's create a Sequence that uses the message in the message store to send the request to SettlePaymentEP.

1. Right click the SampleServices project in the Project Explorer and navigate to New -> Sequence. Select Create New Sequence and provide the name PaymentRequestProcessingSequence.

    
   Click Finish.

2. Drag and drop a Call mediator from the Mediators palette and add SettlePaymentEP from Defined Endpoints palette to the empty box adjoining the Call mediator. This sends the request message from the store to SettlePaymentEP.

   

3.  Drag and drop a Log mediator from the Mediators palette to log the response from SettlePaymentEP. Access the Property tab and fill in the following information:

   Field	Value
   Log Category	Select INFO
   Log Level	Select FULL

4. Add a Drop mediator from the Mediators palette.  You should now have a completed sequence configuration that looks like this:

   

5. Save the updated REST API configuration.

Creating the Message Processor

Let's create a Message Sampling Processor to dispatch the request message from the message store to the PaymentRequestProcessingSequence.

Right click the SampleServices project in the Project Explorer and navigate to  New -> Message Processor. Select create a new message-processor artifact and fill in the details as in the following table:

Click Finish.

We have now finished creating all the required artifacts.

Packaging the artifacts

Since you created a message store, sequence and a message processor,  these will need to be packaged into our existing CApp.

Package the C-App names SampleServicesCompositeApplication project with the artifacts created. Ensure the following artifact check boxes are selected in the Composite Application Project POM Editor.

• SampleServices
  • HealthcareAPI
  • ClemencyEP
  • GrandOakEP
  • PineValleyEP
  • ChannelingFeeEP
  • SettlePaymentEP
  • PaymentRequestMessageStore
  • PaymentRequestProcessingSequence
  • PaymentRequestProcessor
• SampleServicesRegistry

Starting the Message Broker runtime

Start the message broker profile as follows:

1. Open a terminal and navigate to the <EI_HOME>/wso2/broker/bin directory.

2. Start the runtime by executing the message broker startup script as shown below.

The message broker profile is now ready to receive messages from the ESB profile.

Starting the MSF4J profile

To be able to send requests to the back-end service (which is an MSF4J service deployed in the MSF4J profile), you need to first start the MSF4J runtime:

1. Open a terminal and navigate to the <EI_HOME>/wso2/msf4j/bin directory.

2. Start the runtime by executing the MSF4J startup script as shown below.

The Healthcare service is now active and you can start sending requests to the service.

Starting the ESB profile and deploying the artifacts

Assuming you have already added a server for the ESB profile in Eclipse, on the Servers tab, expand the WSO2 Carbon server, right-click SampleServicesCompositeApplication, and choose Redeploy. The Console window of the ESB profile will indicate that the CApp has been deployed successfully.

Sending requests to the ESB

1. Create a JSON file names request.json with the following request payload.

   {
   "name": "John Doe",
   "dob": "1940-03-19",
   "ssn": "234-23-525",
   "address": "California",
   "phone": "8770586755",
   "email": "johndoe@gmail.com",
   "doctor": "thomas collins",
   "hospital": "grand oak community hospital",
   "cardNo": "7844481124110331"
   }

2. Open a command line terminal and execute the following command from the location where request.json file you created is saved:

   curl -v -X POST --data @request.json http://localhost:8280/healthcare/categories/surgery/reserve --header "Content-Type:application/json"

   This is from the URI-Template defined when creating the API resource QueryDoctorAPI.

   http://<host>:<port>/categories/{category}/reserve

   You will see the response as follows:

   {"message":"Payment request successfully submitted. Payment confirmation will be sent via email."}

3. Now check the ESB server Console in Eclipse and you will see that the response from SettlePaymentEP is logged as follows:

   [2017-04-30 14:33:48,578] [EI-Core]  INFO - LogMediator message = Routing to grand oak community hospital
   
   [2017-04-30 14:33:48,598] [EI-Core]  INFO - TimeoutHandler This engine will expire all callbacks after GLOBAL_TIMEOUT: 120 seconds, irrespective of the timeout action, after the specified or optional timeout
   
   [2017-04-30 14:33:53,464] [EI-Core]  INFO - LogMediator To: http://www.w3.org/2005/08/addressing/anonymous, WSAction: , SOAPAction: , MessageID: urn:uuid:a2cf1fd2-7a89-44b6-9571-990bbdfbd289, Direction: request, Payload: {"appointmentNo":1,"doctorName":"thomas collins","patient":"John Doe","actualFee":7000.0,"discount":20,"discounted":5600.0,"paymentID":"a77038e9-3e42-46f7-ac97-11e1b3a50018","status":"Settled"}

You have now explored how the ESB profile of WSO2 EI can be used to implement store and forward messaging using Message Stores, Message Processors, and the Store mediator.