Red Hat Data Grid on Three Clouds (the details behind the demo)

If you saw or heard about the multi-cloud demo at Red Hat Summit 2018, this article details how we ran Red Hat Data Grid in active-active-active mode across three cloud providers. This set up enabled us to show a fail over between cloud providers in real time with no loss of data. In addition to Red Hat Data Grid, we used Vert.x (reactive programming), OpenWhisk (serverless), and Red Hat Gluster Storage (software-defined storage.)

This year’s Red Hat Summit was quite an adventure for all of us. A trip to San Francisco is probably on the bucket list of IT geeks from all over the world. Also, we were able to meet many other Red Hatters, who work remotely for Red Hat as we do.  However, the best part was that we had something important to say: “we believe in the hybrid/multi cloud” and we got to prove that live on stage.

Photo credit: Bolesław Dawidowicz

 

Continue reading “Red Hat Data Grid on Three Clouds (the details behind the demo)”

Share
Eclipse Vert.x logo

When Vert.x Meets Reactive eXtensions (Part 5 of Introduction to Vert.x)

This post is the fifth post of my Introduction to Eclipse Vert.x series. In the last post, we saw how Vert.x can interact with a database. To tame the asynchronous nature of Vert.x, we used Future objects. In this post, we are going to see another way to manage asynchronous code: reactive programming. We will see how Vert.x combined with Reactive eXtensions gives you superpowers.

Let’s start by refreshing our memory with the previous posts:

  • The first post described how to build a Vert.x application with Apache Maven and execute unit tests.
  • The second post described how this application became configurable.
  • The third post introduced vertx-web, and a collection management application was developed. This application exposes a REST API used by an HTML/JavaScript front end.
  • In the fourth post, we replaced the in-memory back end with a database and introduced Future to orchestrate our asynchronous operations.

In this post, we are not going to add a new feature. Instead, we’ll explore another programming paradigm: reactive programming.

Continue reading “When Vert.x Meets Reactive eXtensions (Part 5 of Introduction to Vert.x)”

Share
Eclipse Vert.x logo

Some REST with Vert.x (Part 3 of Introduction to Vert.x)

This post is the third in a series on the Introduction to Eclipse Vert.x. So, let’s have a quick look back at the content of the previous posts. In the first post, we developed a very simple Eclipse Vert.x application and saw how this application can be tested, packaged, and executed. In the second post, we saw how this application became configurable and how we can use a random port in a test.

Well, nothing fancy… Let’s go a bit further this time and develop a CRUD-ish / REST-ish application. So an application exposing an HTML page interacting with the backend using a REST API. The level of RESTfulness of the API is not the topic of this post; I leave it you to decide as it’s a very slippery topic.

So, in other words, we are going to see:

  • Vert.x Web – a framework to let you create web applications easily using Vert.x.
  • How to expose static resources.
  • How to develop a REST API.

Continue reading “Some REST with Vert.x (Part 3 of Introduction to Vert.x)”

Share
Eclipse Vert.x logo

Eclipse Vert.x Application Configuration (Part 2 of Introduction to Vert.x)

In my previous post, Introduction to Eclipse Vert.x, we developed a very simple Vert.x application and saw how this application can be tested, packaged, and executed. That was nice, wasn’t it? Well, that was only the beginning. In this post, we are going to enhance our application to support external configuration, and learn how to deal with different configuration sources.

Continue reading “Eclipse Vert.x Application Configuration (Part 2 of Introduction to Vert.x)”

Share
Eclipse Vert.x logo

Introduction to Eclipse Vert.x – My First Vert.x Application

Let’s say, you heard someone saying that Eclipse Vert.x is awesome. Ok great, but you may want to try it yourself. The next logical question is “where do I start?”. This article is a good starting point. It shows: how to build a very simple Vert.x application (nothing fancy), how it is tested, and how it is packaged and executed. Basically everything you need to know before building your own groundbreaking application.

The code developed in this article is available on GitHub. This is part of the “Introduction to Vert.x Series”. The code for this post is located in the https://github.com/redhat-developer/introduction-to-eclipse-vertx repository in the post-1directory.

Continue reading “Introduction to Eclipse Vert.x – My First Vert.x Application”

Share
Eclipse Vert.x logo

JUnit 5 support lands in Eclipse Vert.x for testing asynchronous operations

JUnit 5 is a rewrite of the famous Java testing framework that brings new interesting features, including:

  • nested tests,
  • the ability to give a human-readable description of tests and test cases,
  • a modular extension mechanism that is more powerful than the JUnit 4 runner mechanism (@RunWith annotation),
  • conditional test execution,
  • parameterized tests, including from sources such as CSV data,
  • the support of Java 8 lambda expressions in the reworked built-in assertions API,
  • support for running tests previously written for JUnit 4.

Testing asynchronous operations is not straightforward

Continue reading “JUnit 5 support lands in Eclipse Vert.x for testing asynchronous operations”

Share

Jug Summer Camp 2017, Vert.x and collaborative DJ mix

I had the pleasure to present “Eclipse Vert.x for Dj fun and for profit!” at the latest edition of the Jug Summer Camp in La Rochelle, France.

The Jug Summer Camp is a popular developer conference organized by Serli in western France, gathering regional attendees as well as speakers and participants from other French Java user groups.

Continue reading “Jug Summer Camp 2017, Vert.x and collaborative DJ mix”

Share

Live Coding Reactive Systems w/Eclipse Vert.x and OpenShift

Do you know the battery level in your smartphone is controlled by reactive software; which is software that reacts to a set of external events, such as requests, failures, availability of services, etc? This was what I recently addressed as a slideless session consisting of pure, live coding at the Red Hat Summit this past May.

Continue reading “Live Coding Reactive Systems w/Eclipse Vert.x and OpenShift”

Share