Apache Ignite Plugin for Mule 3 - Exclusive Access

How to provide exclusive access to a resource, a processor chain in Mule, by using the Apache Ignite connector.

Watch it on youtube

{
    "type": "youtube",
    "src": "nkCArllGBxA"
}

Video transcription

Hello guys.

In this tutorial I am going to show you how to provide exclusive access to a resource, a processor chain at Mule, by using the Apache Ignite connector created by Hawkore. Specifically using the Lock Scope operation.

I am not building a realistic example, just a didactic one that you will be able to easily adapt when you find this use case.

This example, and a few others, are published at GitHub. You will find the relevant links on our webpage.

In short, we will simulate a resource by holding the Lock for 10 seconds. We will grant five seconds to acquire the lock with success. This way, we will be able to check three scenarios:

• Acquire a free Lock.
• Failure to acquire the Lock within five seconds because it is held by another process.
• Success to acquire a Lock that is holded by another process that releases it within five seconds.

So, let's start by launching Anypoint Studio.

In my case, the Apache Ignite Connector is already installed.

If you need to install the connector, you will find a tutorial at our webpage.

Create project

The first thing to do is to create a new mule project.

• Go to File menu and select New followed by Mule Project.

• Enter exclusive access as project name.
• Choose the mule runtime version to want to use, for example, 3.9 community.
• Select create a maven project and press Finish to create the project.

Once created, the "Message Flow" view of the new project's main configuration file should appear.

Add Hawkore's Maven Repository

• Some maven dependencies are only available at Hawkore's repository, so update the pom.xml file and add it.

<repository>
    <id>hawkore-releases</id>
    <name>Hawkore Releases Repository</name>
    <url>https://repository.hawkore.com/maven2/</url>
    <layout>default</layout>
</repository>

Create an Apache Ignite Spring configuration file

In order to use the connector you will need to create an Apache Ignite instance. For demo purposes we will create an embedded Apache Ignite server.

• So create a new file

• called ignite.xml.

• Enter an example configuration, store and close the file.

Remember that you can download the full example. Find the link on our webpage.

Add and configure a HTTP entry-point

• Now start building the flow by inserting a HTTP inbound endpoint that you will be able to easily test later.

• At the property dialog fill in the source configuration.
• Create a new Connector configuration.

• Accept default configuration.

• Back to the property dialog, you want to produce a JSON response so add a new header.
• Set Content Type as header name and application json as header value.

• And save the changes you've made so far.

Add and configure a Lock Scope

• Now insert a Lock Scope in order to create a processor chain that will require exclusive access.

• Fill in operation configuration at the property dialog.
• First, set the Lock name. This is important as it will identify the element that requires exclusive access, no matter the point of the application where it is used.
• Set five seconds as the timeout to acquire the lock. This means that if the lock cannot be acquired within five seconds, an exception will be thrown and flow execution will be interrupted.
• Next, create a new connection manager.

TIP: Remember the lock name because we will use it later.

• In order to keep it simple, change its name to ignite.
• Set grid one as instance name.
• And enter the name of the file that you created before and that holds the Apache Ignite configuration, ignite.xml.
• Also, you must define the Lock you are going to use, so go to the concurrency control tab

• And add a new Lock with the same name you entered at the operation definition.
• You have finished configuring connection manager, so press OK.

TIP: Remember that lock name has to be the same you entered at "Lock Scope" properties before.

• Save the changes you've made so far.

Add an exception strategy

• Add a new catch exception strategy where you will build an error response json.

• Insert a Set payload processor to set the exception cause description as the new payload.

• Modify the display name to something more meaningful.
• And as value enter the expression to extract the exception cause description (#[exception.cause.message]).

• Now add an Object to Json transformer as it is the desired response type.

Also, you want to inform about a server error by setting HTTP response status to 500.

• So add a Property processor.

• Change its display name.
• Select set property operation.
• Enter "http.status" as property name and 500 as property value.

• Save the changes you've made so far.

Add exclusive access processors chain

• Now insert an Expression processor inside the Lock Scope.

This processor's function is holding the lock for ten seconds.

• Enter a meaningful display name.
• And enter the wait sentence.
  • Use the thread sleep method to make it stop for ten seconds before continuing (java.lang.Thread.currentThread().sleep(10000)).

Once the lock is freed, you want to produce a success response.

• Insert a Set Payload processor.

• Enter a meaningful display name.
• And enter an example JSON success response. ( { "res" : "ok", "msg" : "Lock acquired during 10 seconds" } )

Again, save the changes you've made so far.

Create the Apache Ignite global configuration

The flow is already built, but a final step remains to finish the example application.

This connector supports multiple Apache Ignite versions, on this tutorials's creation date, from 2.4 to 2.6. In order to fulfill this objective you must be able to choose the libraries that are packed inside the application, so the Apache Ignite Connector does not include them. It is your responsibility to add these dependencies.

• So go to the global elements tab.
• Click the Create button.

• And add a new Apache Ignite Configuration element.

• Select the connection manager you built previously.

• And add the three dependencies required, starting by ignite core.
  • The group is org.apache.ignite.
  • The artifact is ignite-core.
  • And enter 2.6.0 as version, although we could set any supported one.

• Now continue with ignite indexing dependency.
  • Same group.
  • The artifact is ignite-indexing
  • And enter the same version you did before.

• Finally configure ignite-slf4j dependency.

• Press OK.

• And save the changes.

Run the test case

We are done with flow building. Now run the example in order to check the three scenarios I mentioned at the beginning.

• At the package explorer, right click with your mouse on the project and, at the contextual menu, select Run as and Mule Application.

• The application should start without any problem so wait until the deploy message appears on the console.

I am going to use Postman application, although you could use Soap UI, curl or just a web browser.

Let's check the first scenario.

Successfully acquire lock

We will acquire the lock while it is free, something we should always be able to do.

• Enter the inbound endpoint URl, that is http://localhost:8081, and run.

• In about ten seconds you will get a success message.
• Repeat, wait ten seconds more and you will obtain the same result.

Fail to acquire lock

• To check the second scenario duplicate the tab in order to run two queries at a time.

The first one will hold the Lock for ten seconds. If you are fast enough, the second one will fail after five seconds due to timeout to acquire the lock.

• So run the first query and quickly run the second one.

• The latter will fail after five seconds.

Successful acquire lock after waiting it to be free

Finally, in the third scenario, you will check that the flow halts and acquires the lock, even though the lock is held by another process that releases it within five seconds.

This is a little bit more difficult to test because we have to wait more than five seconds but less than ten between the first and the second requests.

• So run the first request and count to five.
• And run the second request.

• Check that the former request ends with success.
• And check that the latter also ends with success in about 15 seconds after start.

And that concludes this example.

Thanks and see you soon!