This overview provides details on how a Finsemble application is composed.
As a starting point, consider four Finsemble windows on a monitor: a stock-chart and three chat windows. For this example, these four windows make up a Finsemble application.
A corresponding representation of these windows is shown below: a set of HTML5 windows connected through underlying microservices. By connecting and coordinating with Finsemble microservices, the windows form a Finsemble application.
Below is a complete architectural breakdown of a Finsemble application: a set of cooperating Finsemble components and microservices. All components access the microservices though the client APIs contained in the Finsemble Library. All communication between windows and microservices takes place through the Finsemble Router, which is itself a microservice.
The core of Finsemble is packaged as a NPM module to simplify updates. The most common scenario for Finsemble users (i.e., developers) is to build new components on top of the core module. Developers can connect their components, our prebuilt components, and third-party components to the Finsemble core to form a single application. For advanced users, Finsemble also supports adding new microservices and corresponding client APIs. The aim is full extensibility though new components, services, and client APIs.
As mentioned earlier, the Finsemble Library is a set of client APIs connecting to one or more microservices. For example, the Launcher Client connects to the Launcher microservice. Likewise, the Router Client connects to the Router microservice. The Router microservice (via the Router Client) acts as an inter-window event hub, providing communication between all components and microservices.
Also shown in the diagram at the application level are our sample UI components, which are kept in the Finsemble seed project repo. This sample UI is built on the core as well as a separate Finsemble UI control module. Although the sample UI and the controls are production quality, we keep them outside the core because most customers will customize the UI for their own UI needs.
Here's a summary of key ideas about the Finsemble architecture reflected in the above diagram.
Components are "pluggable" in the sense they can be mixed and matched to form an application. ChartIQ has a set of starting fintech components, which can be further customized by developers building their own application. Developers can also create their own components or use third-party components built for Finsemble.
A special class of components, called presentation components, are provided as samples to provide common UI functionality to end users. An example is the toolbar component that end users can use to launch or control other components. The presentation components are distinct in their purpose. However, each is built like every other Finsemble component: by using the Finsemble Library's client APIs.
Similar to components, microservices are "pluggable"—one might think of a microservice as a kind of "invisible component" delivering centralized functionality. Microservices are less likely to change (or be interchanged) than components since they provide a basic building block functionality. Nevertheless, developers can create their own microservices with corresponding client APIs, essentially extending the Finsemble Library. Third-party microservices built for Finsemble can also be used as they become available.
A special class of microservices, called connector microservices, communicate externally to public or private servers (e.g., datafeeds, databases, or cloud-based microservices).
Each individual component and microservice is independently threaded in its own Chromium window that sits on top of OpenFin's secure operating layer.
New microservices and components will be added by the Finsemble development team to the core modules. Advanced components and sample components will also be made available as they are created.
|Finsemble Application||A desktop application built on Finsemble and composed of Finsemble components. Depending on context, this term might refer to a specific application instance running on a specific computer.|
|Finsemble Framework||Also known as just Finsemble. The Finsemble framework is a cooperating set of software components and microservices used to build HTML5 desktop applications on top of the OpenFin operating layer.|
|Finsemble Library||A set of client APIs that have been packaged together for easy component access. Only Finsemble components use the library; microservices directly access the client APIs to use other microservices.|
|Finsemble Router||A microservice that is the center point for all Finsemble communication. The Finsemble Router sends and receives messages between windows, enabling communication between all Finsemble components and services through three types of messaging: Listen/Transmit, Query/Response, and SubPub.|
|Finsemble Window||A Chromium container, sitting on top of OpenFin's secure operating layer, injected with Finsemble capabilities. These Finsemble capabilities allow the window to plug into the overall Finsemble application, cooperating with other Finsemble components and microservices. A Finsemble window always contains an instance of a Finsemble component.|
|OpenFin Operating Layer||OpenFin offers a secure run-time container that executes on a operating system (e.g., Windows, OSX). The OpenFin operating layer enables the Chromium browser to run locally, essentially enabling HTML5 web pages to load and execute within an operating system, (optionally) decoupled from the internet.|
|User-Defined Components||User-defined components are HTML5 web pages that users integrate into a Finsemble window. If the HTML5 web page has no special customization or knowledge of Finsemble, its integration into the Finsemble application is limited.|
For more about the basic set up and configuration of Finsemble, proceed onward to Configuration.
To learn more about the Finsemble Router, check out the Router documentation.