DEV Community: Hong Qiu

An Event-ful Internship at Solace

Hong Qiu — Wed, 11 Dec 2019 00:27:37 +0000

This was originally posted on Solace's blog by Rajiv Abraham Xavier, an intern in our Singapore office. If you're interested in career opportunities at Solace, please visit our Careers page.

It has been an eventful summer for me at Solace as a pre-sales intern. As an Information Systems undergraduate, majoring in Smart City Management and Technology at Singapore Management University, I heard about some of the ways Solace has been involved in making Singapore smarter and more event driven. I was excited to learn and be part of the team at Solace.

Coming into Solace, I had very little understanding as to messaging, event brokers, and events as a whole. However, thanks to the Solace development and administration courses available on Udemy, I was able to quickly pick up a basic understanding about messaging and the event-driven solutions provided by Solace. Often as an intern, you may feel apprehensive about asking others in the team for help or clarification, as you may feel like you are disturbing their work. In retrospect, this was something I did not encounter at Solace as the team was always willing to help in whatever way they could. They constantly took the time to walk us through our queries and checked in regularly to ensure that we were not lost and were still sufficiently challenged to explore on our own as well.

Creating a Central Data Exchange

One of the main tasks that was assigned to my fellow intern Giem Teck and I was to understand, scope, design, and build a smart data exchange prototype that can be used to demonstrate the concepts of the event-driven exchange of information. The main challenge in this project was to showcase the abilities of Solace to provide a central data exchange that can be utilised by other users (“agencies”) to share, monitor, and consume data.

An example use case, in the context of a smart city, is the exchange of data between different government agencies. Those agencies can share the data that they collect via the central exchange in real time (e.g., CCTV footage, sensor data) and can further utilise the data that other agencies shared with them. A machine learning or analytics application can also be subscribed to the events being published by the agencies.

Through brainstorming and whiteboarding sessions with our supervisor – Phil, and further discussions with other members of the team, we came up with a front-facing JavaScript Web application that utilises the Solace JavaScript API and various Solace Element Management Protocol (SEMP) API calls to create bridges between the central exchange broker and the agency broker.

This allows agencies to view event streams available to them from other agencies, as well as to publish events that can be accessed by other agencies. The access control of this publishing and subscribing is centrally managed via Access Control Lists on the central exchange broker.

The administrator of the central exchange broker also has the flexibility to accept or deny requests from the existing agency brokers to publish new events to the central broker. The administrator can also use registration details provided by the agencies, who wish to connect to the central brokers to establish bridges through the user interface. All this creation of new ACL topic allowance and bridge connections are executed on the backend via a SEMP API call.

What I Have Learned

As a student majoring in Smart City Technologies, I feel the idea of a central data exchange is truly eye opening. Through the use of Solace’s advanced event brokers, cities, governments, and even businesses can now share data in real time between different agencies. A central hub helps agencies to easily view the events that are available to them and also offers them the freedom to use these events in their own analytics and visualisation applications to fit their own business needs.

For example, as seen in the image above, a machine learning application can take in raw traffic camera footage from the Land Transport agency. The model can then generate description tags about the footage that can be used to trigger events, such as start of fire, which other agencies like fire and rescue departments can subscribed to.

Final thoughts

I have learned a lot in my time at Solace. As someone who came in with almost no understanding about messaging and event-driven architecture, to be able to whiteboard and come up with this prototype was no easy task. However, with the help of my friendly and talented colleagues and the start-up guides written by the Solace community, the task was made much easier. It truly has been a summer well spent at Solace getting to know the people and the technology.

The post My Event-ful Internship at Solace appeared first on Solace.

How to Build a Simple Chat App with Solace (Part 6)

Hong Qiu — Wed, 30 Oct 2019 19:08:22 +0000

This is the sixth post in a series in which I walk through the creation of a simple chat app with Solace PubSub+. In the last part, I explained how to send a REST POST request as a request/reply message. In this final part, you will learn how to create the non-exclusive queue that will receive the login request and load balance them out to the authentication server. Specifically, you will:

Create the non-exclusive queue
Add the topic subscription to the new queue
Modify the authentication server
Test the load balancing functionality

Prerequisites

Download Git to your computer
Install Apache Maven
Sign up with Solace PubSub+ Cloud
Clone a repository of the samples to your computer

Level

Beginner

Create the Non-Exclusive Queue

You need to create a queue for our PubSub+ Cloud instance to receive and save the login request for the authentication server. To create the queue, follow the steps below:

In your code editor, check out the developer-exercise-5 branch or in your command line, enter git checkout remotes/origin/bonus -f
In your code editor, open the file LoginMessageReplier.java under auth-server > server. Line 50 contains the name of the queue “LOGIN_QUEUE”.
Log in to Solace PubSub+ Cloud, select your service, and click Manage Service.
Click Queues in the left side.
Click the + Create button to create a new queue.
In the Create Queue dialog box, name the queue LOGIN_QUEUE and click Create.
In the Edit Queue Settings dialog box, change the Access Type to Non-Exclusive and click the Apply button.

Exclusive queues are for fault tolerance while non-exclusive queues are for load balancing.

Learn about queue access types.

In the Confirm dialog box, click Apply changes.

Add the Topic Subscription to the Queue

Click on the new LOGIN_QUEUE queue and click the Subscription tab.
Click the + Subscription button to open the Create Subscription dialog box.
In the Create Subscription ** dialog box, add LOGIN/MESSAGE/REQUEST as the topic subscription, press **Enter , and click Create.

Modify the Authentication Server

You are going to modify the authentication server to consume from the login request instead of receiving messages via a topic subscription.

Under the auth-server directory, open the LoginMessageReplier.java file.
Enter the following code to set the endpoint properties. (Lines 90-91).

//Add the Queue Logic Herefinal EndpointProperties endpointProps = new EndpointProperties();

Enter the following code to set the queue permissions and access type (Lines 92-94).

//Set queue permissions to ‘consume’ and access type to ‘non-exclusive’endpointProps.setPermission(EndpointProperties.PERMISSION\_CONSUME);endpointProps.setAccessType(EndpointProperties.ACCESSTYPE\_NONEXCLUSIVE);

Enter the following code to create the queue object (Lines 96- 97).

//Create the queue object locallyfinal Queue queue = JCSMPFactory.onlyInstance().createQueue(QUEUE\_NAME);

Enter the following code to provision the queue to ensure that it binds to an existing queue (Lines 98-101).

//Actually provision the queue, and do not fail if it already existssession.provision(queue, endpointProps, JCSMPSession.FLAG\_IGNORE\_ALREADY\_EXISTS);System.out.printf(“Attempting to bind to the queue ‘%s’ on the PubSub+ Broker.%n”, QUEUE\_NAME);

Enter the following code to create consumer flow properties and the flow object (Lines 102-104).

//Create a Flow be able to bind to and consume messages from the Queuefinal ConsumerFlowProperties flowProps = new ConsumerFlowProperties();flowProps.setEndpoint(queue);

The consumer flow properties define the queue that you would like to connect to.

Enter the following code to set the acknowledgment mode for the flow (Line 105-107).

//Set to ‘auto acknowledge’ where the API will ack back to Solace at the end of the//message received callbackflowProps.setAckMode(JCSMPProperties.SUPPORTED\_MESSAGE\_ACK\_AUTO);

There are two types of acknowledgment modes: AUTO and CLIENT. Learn more about acknowledgment modes.

Enter the following code to create the flow receiver and receive the messages (Lines 109-118).

final FlowReceiver cons = session.createFlow(new LoginRequestHandler(), flowProps, endpointProps, new FlowEventHandler() { @Override public void handleEvent(Object o, FlowEventArgs flowEventArgs) { System.out.println(o, toString() + “,” + flowEventArgs); } })//Start the consumercons.start();

This code snippet lets you handle events and print out the information to the console.

Test the Load Balancing Functionality

With the load balancing consumption pattern, your applications are not blocked when your replying applications cannot keep up with the number of requests.

To test the load balancing functionality of the login server, follow these steps to start multiple authentication server instances and see how they load balance the login requests. Note that there should be one web-server instance and two auth-server instances running for the final test. Also make sure that you have the right environment variables.

In your code editor, type mvn spring-boot:run under the auth-server directory to run one instance of the authentication server of the Web application.
Open a new terminal in your code editor and type mvn spring-boot:run under the auth-server directory to run the second instance of the authentication server of the Web application.
Open two Web browsers and enter localhost:8081 for each of them to access the Web application.
In one of the instances of the Web application, enter the valid username “ValidUser” and password “solace”. The login succeeds because this user is in the HashMapCredentialRepository.java file.
In the other instances of the Web application, enter the username “user” and password “user”. This time, the login fails because this user is not in the HashMapCredentialRepository.java file.

Congratulations!

You have successfully added code to bind to the login queue and respond to the request messages.

Not only that, you have reached the end of the series! To learn more about PubSub+ for developers, visit solace.dev. To share your developer experience using Solace PubSub+ or ask for help from other developers, visit the Solace Community.

Related

The post How to Build a Simple Chat App with Solace (Part 6) appeared first on Solace.

How to Build a Simple Chat App with Solace (Part 5)

Hong Qiu — Mon, 07 Oct 2019 10:00:27 +0000

This is the fifth of a series of blog posts in which I walk through the creation of a simple chat app with Solace PubSub+. In the last part, I explained how to add a simple authentication server and send a REST POST request as a Publish/Subscribe type of message. In this tutorial, you will learn how to send a REST POST request as a request/reply message. Specifically, you will learn how to:

Modify the sample code
Connect the authentication server
Change the login response message
Test the authentication and response message

Prerequisite

Download Git to your computer
Install Apache Maven
Sign up with Solace PubSub+ Cloud
Clone a repository of the samples to your computer

Level

Beginner

Modify the Sample Code

The accompanying sample code for this tutorial is for sending a REST POST request as a Publish/Subscribe message. Since you will send a REST POST request as a Request/Reply message instead this time, you need to modify the sample code.

To modify the sample code, do the following:

In your code editor, check out the developer-exercise-5 branch or in your command line, enter git checkout remotes/origin/developer-exercise-5 -f
In your code editor, open the file SolaceCloudProxy.java
Enter the following highlighted code to the section that determines a response to the Http Request to set the Solace reply wait time in milliseconds (Line 56).

//This header determines that the Http Request needs a responseset(“Solace-Reply-Wait-Time-In-ms”,”3000”);

The Solace-specific HTTP header “Solace-Reply-Wait-Time-In-ms” specifies that the message exchange pattern is Request/Reply and the Solace message broker application must wait for the specified timeout value (e.g. 3 seconds) for a reply before it stops.

Learn about Solace-Reply-Wait-Time-In-ms.

Modify the REST template POST request in the section that passes through a response code to expect a response of an authenticated object and to retrieve authenticatedObject from the call (Line 68).

//Pass through a response code based on the result of the REST-ful requestAuthenticatedObject authenticatedObject = restTemplate.postForObject(solaceRESTHost + “/LOGIN/MESSAGE/REQUEST”, request, AuthenticatedObject.class);

“AuthenticatedObject” is defined in the AuthenticatedObject.java file under solace-chat-common. It validates a client and determines whether to allow it to connect or not.

Under the above modified code line, enter the following code to define what message the client will get when their request is allowed or denied (Lines 70-73).

if (authenticatedObject.isAuthenticated()) { return new ResponseEntity(HttpStatus.OK);}else { return new ResponseEntity(HttpStatus.FORBIDDEN);}

Connect the Authentication Server

To connect the authentication server to the PubSub+ instance, you need to define the connection details.

In the auth-server directory, copy and paste the application-template.properties file under src > main > resources.
Rename the copied file to application.properties.
Log in to Solace PubSub+ Cloud and click the *Connect * tab.
Open the Solace Messaging section.
From the Connection Details on the right, copy the following:
- Username
- Password
- Message VPN
- SMF Host
Paste the connection details to the application.properties file.

Change the Login Response Message

When you receive a request to log in to the chat application, you need to authenticate the user and then send the response back to the application. To change the login response message, follow the steps below:

1. In the auth-server directory, open the LoginMessageReplier.java file.
2. Enter the following highlighted code to add the session subscription (Line 92). //Add the session subscription here session.addSubscription(JCSMPFactory.onlyInstance().createTopic( REQUEST_TOPIC), true);
3. In the createReplyMessage method, enter the following highlighted code to create a message object for the reply message and then convert the Json text in the request message to a user object type (Line 110).

private XMLMessage createReplyMessage(TextMessage request) throws JCSMPException { TextMessage replyMessage = JCSMPFactory.onlyInstance().createMessage(TextMessage.class); UserObject userObject = gson.fromJson(request.getText(), UserObject.class);}

Under the above code lines, enter the following highlighted code to validate the user and print out the message depending on the result of the validation (Lines 113 to 119).

private XMLMessage createReplyMessage(TextMessage request) throws JCSMPException { TextMessage replyMessage = JCSMPFactory.onlyInstance().createMessage(TextMessage.class); UserObject userObject = gson.fromJson(request.getText(), UserObject.class); //Validate the user boolean validUser = credentialsRepository.isValidUser(userObject.getUsername(), userObject.getPassword());if (validUser) System.out.println(“Successfully validated a user”);else System.out.println(“Authentication failed”);}

Enter the following highlighted code to create an AuthenticatedObject type, set the reply message content type, set the text, and set the delivery mode (Lines 120 to 127).

if (validUser) System.out.println(“Successfully validated a user”);else System.out.println(“Authentication failed”);AuthenticatedObject authenticatedObject = new AuthenticatedObject();authenticatedObject.setAuthenticated(validUser);replyMessage.setHTTPContentType(“application/json”);replyMessage.setText(gson.toJson(authenticatedObject));replyMessage.setApplicationMessageId(request.getApplicationMessageId());replyMessage.setDeliverToOne(true);replyMessage.setDeliveryMode(DeliveryMode.DIRECT);return replyMessage;}

Test the Authentication and Response Message

To test the authentication and login request response message, follow these steps:

In your code editor, type mvn spring-boot:run to run the Web application.
Open a new terminal window, change the directory to .\auth-server\, and type mvn spring-boot:run to run the authentication server.
In your Web browser, type localhost:8081 to view the application.
Log in with a username and a password that are preset in the HashMapCredentialRepository.java file under the server directory in auth-server (e.g. ValidUser; solace). This should bring you to the chat application page.
Refresh your browser and log in with an invalid username and an invalid password. You should see the “Login Failed” error message.

Congratulations! You now have a chat application that allows you to authenticate your user with a request/reply message pattern.

In the next part (coming soon), you will learn how to modify the Web application to load balance requests.

The post How to Build a Simple Chat App with Solace (Part 5) appeared first on Solace.

How to Build a Simple Chat App with Solace (Part 4)

Hong Qiu — Mon, 23 Sep 2019 19:00:05 +0000

This is part 4 of a series of blog posts in which I walk through the creation of a simple chat app with Solace PubSub+. In the first part, I explained how to create a simple chat app that can send and receive messages via a direct topic subscription. In the second I explained how to modify the sample code so the application consumes messages from a queue, and in part 3 I explained how to add login functionalities to send a REST POST request to Solace PubSub+.

In this tutorial, you will learn how to add a simple authentication server. The server will first receive the client login request from the web application, then authenticate the user, and finally send a REST POST response back to the application to either allow or deny the login request.

Specifically, you will

Set the connection details
Create and send the REST POST request
Test the REST POST request

Prerequisite

Download Git to your computer
Install Apache Maven
Sign up with Solace PubSub+ Cloud
Clone a repository of the samples to your computer

Level

Beginner

Set the Connection Details

The setting of the connection details tells the Web application server where to send the REST POST login request to so that the Solace instance can receive it.

To set the connection details, do the following:

In your code editor, check out the developer-exercise-4 branch or in your command line, enter git checkout remotes/origin/developer-exercise-4 -f
In your code editor, enter mvn install to run a Maven install in solace-chat-common.
Under src > main > resources, open the file application.properties.
Log in to Solace PubSub+ Cloud.
Click the Connect tab.
Open the REST section.
Copy the username, password, and REST host information from the Connection Details section and paste them to the application.properties file under src > main > java > resources.

Create and Send the REST POST Request

Now the connection details are set, you can create and send the REST POST request to the PubSub+ instance as a Publish/Subscribe message:

In your code editor, under src > main > java, open the file SolaceCloudProxy.java.
Enter the following code to create a REST template object (Line 63).

//Rest Request goes hereRestTemplate restTemplate = new RestTemplate();

RestTemplate makes HTTP REST calls and simplifies the interaction with HTTP servers.

Enter the following code below the above code to create the HTTP entity with the user object type (Line 64).

HttpEntity&lt;UserObject&gt; request = new HttpEntity&lt;UserObject&gt;(userObject,httpHeaders);

The user authentication type contains just a username and password. solace-chat-common has the reference to it.

Enter the following code to add the POST for the object to the REST template (Line 65).

restTemplate.postForObject(solaceRESTHost + “/LOGIN/MESSAGE/REQUEST”,request, String.class);

You defined solaceRESTHost at Step 7 of the “Set the Connection Details” section above.

/LOGIN/MESSAGE/REQUEST is the specific topic that you are sending the REST POST request to.

Enter the following code to return a response entity (Line 66).

return new ResponseEntity(HttpStatus.OK);

ResponseEntity creates an HTTP response.

Test the REST Request

Now you have created and sent the REST POST request, you can test whether the request is actually delivered to the Solace instance.

In your code editor, enter mvn spring-boot:run to start the web application.
In Solace PubSub+ Cloud, click the Try Me! tab.
In the Subscriber panel, click the Connect button, enter LOGIN/MESSAGE/REQUEST as the topic, and click the Subscribe button.
Open a new browser and enter localhost:8081 to bring up the web application.
Enter “user” as the username and password and click the Submit button. You should see the Try Me! tab has received the message.

Congratulations! You have successfully added an authentication server, sent a REST POST request to the server as a Publish/Subscribe message, and received a response from it. In the next part (coming soon), you will learn how to send the REST POST request as a Request/Reply message.

Related

The post How to Build a Simple Chat App with Solace (Part 4) appeared first on Solace.

How to Build a Simple Chat App with Solace (Part 3)

Hong Qiu — Tue, 03 Sep 2019 20:40:04 +0000

This is part 3 of a series of blog posts in which I walk through the creation of a simple chat app with Solace PubSub+. In the first part, I explained how to create a simple chat app that can send and receive messages via a direct topic subscription. In the second I explained how to modify the sample code so the application consumes messages from a queue. In this part, I’ll explain how to send a REST POST request from a login page to a dummy authentication service fronted by Solace PubSub+.

Specifically, you will:

Add a server URL
Complete fetch parameters

Prerequisites

Download Git to your computer
Install Apache Maven
Sign up with Solace PubSub+ Cloud
Clone a repository of the samples to your computer

Level

Beginner

Add a Server URL

By adding a server URL, you define where the REST POST request is sent to. To add a server URL, do the following:

In your code editor, check out the developer-exercise-3 branch or in your command line, enter git checkout remotes/origin/developer-exercise-3 -f
Open the solaceauth.js file under src > main > resources > static > scripts
Enter the highlighted code to add the server URL (Line 15).

//Enter serverUrl var serverUrl = ‘http://localhost:8081/solace/cloud/proxy’,

This URL sends the request through our web application server, which sends it to our Solace instance.

Complete Fetch Parameters

The fetch method defines how information is obtained from the server. Do the following to add the method and headers parameters:

Enter the highlighted code to add POST as the method (Lines 22-23).

//Complete fetch parameters; method and headers fetch(serverUrl, { method: “POST”,

Under the above code, enter the highlighted code to set the content-type of the request header (Lines 24-25).

headers: { “Content-Type”: “application/json; charset=utf-8”,

This tells the receiving server to deal with the REST message content in JSON format with the UTF-8 character encoding.

In your code editor, type mvn spring-boot:run to run the application.
In your Web browser, enter localhost:8081 to see the login page.
Type any username and password. You should get a “Login Failed” message. This is because we have just sent the REST POST request to the Solace instance and have not yet set up the login server. We will do that in the next tutorial.

Congratulations!

You have added login functionalities to the Web application to send a REST POST request to Solace PubSub+.

In Part 4 of the series (coming soon), you will learn how to add a simple authentication server.

Related Resources

The post How to Build a Simple Chat App with Solace (Part 3) appeared first on Solace.

New Resources for Spring Developers

Hong Qiu — Tue, 20 Aug 2019 23:37:24 +0000

Over the years, Solace has been working hard to help developers using the Spring Framework create Spring-based applications and event-driven microservices with Solace event brokers. We kicked off the effort by publishing a comprehensive integration guide that demonstrates how to integrate JMS with the Spring Java Framework for production and consumption of JMS messages. We’ve also released open source projects like a Spring Boot auto-config complete with a Spring Boot Starter for the Solace JMS API and an implementation of Spring’s Cloud Stream Binder for integrating with Solace PubSub+.

I’m proud to announce a few new resources we’re making available, along with a new landing page that will house all of these assets and help Spring developers understand:

What Spring Projects can be used with PubSub+
Why Spring ecosystems can benefit from Solace PubSub+
How they can can use PubSub+ with supported Spring projects

The page is at solace.com/spring — go check it out while it’s hot!

As for the new resources I mentioned above…

Spring Cloud Streams with Solace Tutorial

In addition to introducing you the fundamentals of using Spring Cloud Streams with the Solace PubSub+ Binder, this hands-on tutorial outlines a simple way to create a messaging service in Solace to quickly access Solace messaging. It shows you how to create 3 apps: a Spring Cloud Streams Source (sending app), a Spring Cloud Streams Sink (receiving app), and a Spring Cloud Streams Processor (sending & receiving app).

Check out the tutorial and the sample code in GitHub.

Spring Boot Autoconfig (JMS) Tutorial

This tutorial is all about using Spring Boot with Autoconfigure to connect an JMS client to Solace Messaging for the exchange of JMS events. It walks you through the steps to create respectively an app for receiving JMS messages and an app for sending JMS messages.

Check out the tutorial and the sample code in GitHub.

The post New Resources for Spring Developers appeared first on Solace.

How to Build a Simple Chat App with Solace (Part 2)

Hong Qiu — Fri, 02 Aug 2019 18:57:15 +0000

In an earlier blog post, I explained how to build a simple chat browser application that consumes messages via a direct topic subscription. In this follow-up to that tutorial, I’ll explain how to modify the sample code to get that application consuming messages from a queue.

Specifically, you will create a queue, add a subscription to the queue and create the queue consumer.

Prerequisites:

Level: Beginner

Create a Queue

In your code editor, check out the developer-exercise-2 branch or in your command line, enter git checkout remotes/origin/developer-exercise-2 -f
Open the scripts directory under src > main > resources > static.
Open the pubsubplusbroker.js file, comment out the direct topic subscription that was added in Part 1 and save the file.
Log in to Solace PubSub+ Cloud, open your service, and click Manage Service.
Click the Queues tab on the left.
Click the + Create button to create a queue.
In the Create Queue dialog box, give the queue a name and click the Create button.
Click Apply to use the default settings.

Add a Subscription to the Queue

Click on the queue you just created and click the Subscriptions tab.
Click the + Subscription button to open the Create Subscription dialog box.
In the Create Subscription dialog box, add the topic subscription, press Enter , and click Create.
In your code editor, type mvn spring-boot:run to run the application. Make sure you are in the web-app-server directory.
In your Web browser, type localhost:8081 to open the application if it is not already open.
Send a few messages in the application.
In the queue you created at Step 3, click Summary to see the queued messages.

Create the Queue Consumer

Now that the messages are in the queue, you need to create the consumer that consumes the messages in the queue. To create the consumer, follow the steps below:

Open the application-properties.js file under static > resources and add ‘SOLACE_CHAT’ to sReceiveQueue.
Open the pubsubplusbroker.js file, specify the queue descriptor, including the name and type of the queue, and set the acknowledge mode.
Add the following code to connect the message consumer.
In your code editor, type mvn spring-boot:run to run the application.
Refresh the chat application in your browser. You should be able to see the received messages from the broker.
In the queue that you created earlier, click Summary and then Refresh Data in the bottom right corner. You should see that the messages are no longer in the queue because of auto acknowledgement.

Congratulations! You have just created a queue, added a subscription to the queue, and created the queue consumer. In Part 3 of the series (coming soon), you will learn how to send a REST POST request from a login page to a dummy authentication service.

Related Resources

The post How to Build a Simple Chat App with Solace (Part 2) appeared first on Solace.

How to Build a Simple Chat App with Solace (Part 1)

Hong Qiu — Fri, 26 Jul 2019 19:58:37 +0000

In this tutorial, you will learn how to build a simple chat browser application. At the end of the tutorial, the application will be able to send and receive messages via a direct topic subscription. Specifically, you will learn how to build the application, connect it to Solace PubSub+ Cloud, and start publishing/receiving messages.

Prerequisites

Level

Beginner

Build the Application

On the Solace Training page, select master from the Branch drop-down menu, open the Clone or download tab, and copy the URL.
In your command line, type the following code line to clone a repository to your computer. git clone https://github.com/SolaceTraining/fundamentals-of-solace-dev.git
In your code editor, check out the developer-exercise-1 branch or in your command line, enter git checkout remotes/origin/developer-exercise-1
Under src > main > resources, duplicate the file application-template.properties and rename it to application.properties.
Download the Solace JavaScript messaging API.
Copy the lib directory of your downloaded JavaScript API to the static directory of your cloned repository under src > main > resources.
Download Maven if you have not already done so.
In your command line, enter mvn clean install to compile the application.
Type mvn spring-boot:run to run the Web server. Make sure you are in the \web-app-server directory.

Connect to the PubSub+ Cloud Service

You have created your application. However, it needs to connect to the PubSub+ Cloud service for it to work.

Under static > resources, duplicate the application-properties-template.js file and rename it to application-properties.js.
Log in to Solace PubSub+ Cloud.
Click the Create Service button to create a service.
Click the Connect tab.
Open the Solace Web Messaging section.
Copy the connection details to the application-properties.js file, add ‘solace/chat’ as the Publish and Subscribe topics, and save the file. Note: Since we need the secure WebSocket connection, make sure that you use Secured Web Messaging Host as the sBROKERURL, not Web Messaging Host.
Type mvn spring-boot:run to run the application.
In your Web browser, type localhost:8081 to view the application. You should see a message that says you are connected to your PubSub+ Cloud service.

Publish and Receive Messages

Though the application is connected to your PubSub+ Cloud service, it cannot yet publish and subscribe. In this section, you will modify the sample code to publish the messages to the Solace broker so that people who connect to it can receive them.

Under the script directory, open the pubsubplusbroker.js file.
Type the code lines as shown below to create the message, define the topic destination, and set the delivery mode and the message body. Learn about message delivery modes. Learn about topics and topic support. Learn what each of the above code lines does.
Type the code line shown below to call the broker session and send the message.
Uncomment the oResultCallback and console.debug command lines so that you can see if the message is actually published.
Run the application.
Log in to your Solace PubSub+ Cloud and click the Try Me! tab.
In the Subscriber section, click the Connect button, add the topic “solace/chat”, and click the Subscribe button.
In your Web browser, type localhost:8081 or refresh the browser if you are already there.
In the application, type “Hello World” and click the arrow. You should see that the subscriber has received the message.
In the establishing the subscription section of the pubsubplusbroker.js file, type the following code lines to create a topic, generate an event, pass in a correlation key for the event, and define the number of milliseconds it will wait before stopping to add the subscription to the connection.
Run the application.
In the application in the browser, type a message and send it out.
Open another browser at localhost:8081. You should see that the message has been received.

Congratulations!

You have just created a chat application with Solace and sent and received messages via it. In the next part (coming soon), you will learn how to modify the sample code so that the application consumes messages from a queue instead of via a direct topic subscription.

To learn more about coding for Solace PubSub+, check out the Udemy course Fundamentals of Solace Development.

The post How to Build a Simple Chat App with Solace (Part 1) appeared first on Solace.