PatternFly is an open source project that promotes design commonality and improved user experience. It’s a place where open source developers and designers can collaborate, create, and share user interface (UI) components and widgets. PatternFly is based on Bootstrap, a mobile-first front-end framework for creating web sites and applications. More information on the PatternFly library, including available styles and guides for working with the framework, can be found at the official PatternFly website.

According to the official AngularJS Documentation, "AngularJS is a structural framework for dynamic web apps. It lets you use HTML as your template language and lets you extend HTML’s syntax to express your application’s components clearly and succinctly. Angular’s data binding and dependency injection eliminate much of the code you would otherwise have to write. And it all happens within the browser, making it an ideal partner with any server technology." The JavaScript framework allows for declarative decoupling of DOM logic from application logic, thereby giving a clean, straight-forward approach to utilizing controllers and services to interact with the Mortgage Dashboard’s backend Java functionality.

JBoss BPM offers a number of Client classes in the org.kie.server.client package for accessing and manipulating business processes remotely via Java. Some of the most prominent classes available follow:

Example client configuration and instantiation:

KieServicesClient client = null;
        try {

            KieServicesConfiguration conf = KieServicesFactory.newRestConfiguration(
                    Configuration.REST_BASE_URI,
                    user.username(),
                    user.password());

            conf.setMarshallingFormat(MarshallingFormat.JSON);

            client = KieServicesFactory.newKieServicesClient(conf);

        } catch (Exception e) {
            logger.error("ERROR in initializing REST client...", e);
        }
        return client;

The OpenShift Container Platform provides a command line interface (CLI) for creating applications and managing OpenShift projects from a terminal. The CLI is ideal in situations where you are working directly with project source code, scripting OpenShift operations, have restricted bandwidth resources.

The CLI is available using the oc command:

$ oc <command>

For further information, refer to the official Red Hat OpenShift Documentation for installation and setup instructions.

Containers are based on images. An image is a binary that includes all of the requirements for running a single container, as well as metadata describing its needs and capabilities. You can think of it as a packaging technology. Containers only have access to resources defined in the image, unless you give the container additional access when creating it. As alluded to previously, by deploying the same image in multiple containers across multiple hosts and load balancing between them, OpenShift can provide redundancy and horizontal scaling for a service packaged into an image.

OpenShift also supplies builders that assist with creating an image by adding your code or configuration to existing images. An image stream can be used to automatically perform an action, such as updating a deployment, when a new image, such as a new version of the base image that is used in that deployment, is created. An image stream comprises one or more Docker images identified by tags. It presents a single virtual view of related images, similar to a Docker image repository, and may contain images from any of the following: its own image repository in OpenShift’s integrated Docker Registry, other image streams, or Docker image repositories from external registries. OpenShift components such as builds and deployments can watch an image stream to receive notifications when new images are added and react by performing a build or a deployment.

Example Image Stream Object Definition:

{
  "kind": "ImageStream",
  "apiVersion": "v1",
  "metadata": {
    "name": "origin-ruby-sample",
    "namespace": "p1",
    "selfLink": "/osapi/v1/namespaces/p1/imageStreams/origin-ruby-sample",
    "uid": "480dfe73-f340-11e4-97b5-001c422dcd49",
    "resourceVersion": "293",
    "creationTimestamp": "2015-05-05T16:03:34Z",
    "labels": {
      "template": "application-template-stibuild"
    }
  },
  "spec": {},
  "status": {
    "dockerImageRepository": "172.30.30.129:5000/p1/origin-ruby-sample",
    "tags": [
      {
        "tag": "latest",
        "items": [
          {
            "created": "2015-05-05T16:05:47Z",
            "dockerImageReference": "172.30.30.129:5000/p1/origin-ruby-sample@sha256:4d3a646b58685449179a0c61ad4baa19a8df8ba668e0f0704b9ad16f5e16e642",
            "image": "sha256:4d3a646b58685449179a0c61ad4baa19a8df8ba668e0f0704b9ad16f5e16e642"
          }
        ]
      }
    ]
  }
}

Image Streams usage allows for applications to be injected into containers via source-to-image. S2I is a tool for building reproducible Docker images; the new image incorporates the base image (the builder) and built source and is ready to use with the docker run command. S2I supports incremental builds, which re-use previously downloaded dependencies, previously built artifacts, etc. In short, S2I allows us to take an EAP or Intelligent Process Server Image which establishes the base requirements for the container and inject our rules or application into the image.

A template describes a set of objects that can be parameterized and processed to produce a list of objects for creation by OpenShift. The objects to create can include anything that users have permission to create within a project, for example services, build configurations, and deployment configurations. A template may also define a set of labels to apply to every object defined in the template.

A template describes a set of related object definitions to be created together, as well as a set of parameters for those objects. For example, an application might consist of a front-end web application backed by a database; each consists of a service object and deployment configuration object, and they share a set of credentials (parameters) for the front-end to authenticate to the backend. The template can be processed, either specifying parameters or allowing them to be automatically generated (for example, a unique DB password), in order to instantiate the list of objects in the template as a cohesive application.

Example YAML Template Object Definition:

apiVersion: v1
kind: Template
metadata:
  name: redis-template
  annotations:
    description: "Description"
    iconClass: "icon-redis"
    tags: "database,nosql"
objects:
- apiVersion: v1
  kind: Pod
  metadata:
    name: redis-master
  spec:
    containers:
    - env:
      - name: REDIS_PASSWORD
        value: ${REDIS_PASSWORD}
      image: dockerfile/redis
      name: master
      ports:
      - containerPort: 6379
        protocol: TCP
parameters:
- description: Password used for Redis authentication
  from: '[A-Z0-9]{8}'
  generate: expression
  name: REDIS_PASSWORD
labels:
  redis: master

This image provides a means for executing business processes on JBoss BPMS Intelligent Process Server 6.3, which is a modular, standalone server component that can be used to instantiate and execute rules and processes. It exposes this functionality through REST, JMS and Java interfaces to client applications. There are a variety of images available based on persistence and interconnectivity needs. For the purposes of this document, the basic image is utilized, which includes a simple H2 database, although images exist for inclusion of both MySQL and PostgreSQL with either HornetQ or ActiveMQ messaging functionality.

JBoss EAP, Red Hat’s Java EE-based application server runtime, is utilized as the container for deployment of the credit check web service, PatternFly, and AngularJS-based front-end application. Various capabilities provided by the container are leveraged, such as Weld Contexts, Dependency Injection and more. It should be noted that there are significant differences in supported configurations and functionality in the JBoss EAP xPaaS image compared to the regular release of JBoss EAP. Some of these differences are as follows: