Deploying Your Finsemble Application

In simple terms, Finsemble is set of web assets: HTML, JavaScript, CSS and JSON files (i.e., Finsemble assets). Finsemble does not interact directly with the user's desktop except in ways that you specify.

A basic analogy is that Finsemble is a “site.” However, Finsemble is not a single page app; it’s a collection of smaller web pages and native apps, from multiple sources, knit together by a framework of supporting services. Each web page represents a component or service: chart component, toolbar, microservice, config files, Finsemble API (FSBL.js), etc. These are all served from an HTTP server—just like a website. The operating layer on which Finsemble operates is the “browser” that displays the site. The thing that’s different is that this browser shows multiple pages simultaneously, and puts them directly on the desktop.

Among these Finsemble assets is an application config file (JSON) which bootstraps the application. The runtime environment is installed on the user's computers, either through group deployment or as part of a distributable installer package that your developers create. Once installed, a desktop icon and Start menu entry for your Finsemble application is created. Clicking on the icon causes the Finsemble application to launch, which starts with reading the application config from your servers, checks the version of the runtime environment (downloading it if necessary), and finally bootstrapping Finsemble from the assets hosted on your server to launch the application.

Step by step

Your components and Finsemble files will need to be deployed to a web server so they can be retrieved by your users. That web server can be internal—inside your firewall and accessible only to people on your corporate network—or external—available to anyone with internet access. A Finsemble application can be made of up assets from one or more servers. Ideally, all of the components would be hosted from the same computer because this allows for the faster Shared Worker communication, but a Finsemble application can be made up of components hosted on a mixture of internal and external servers.

Once the files have been deployed, an installer needs to be created that points to the application's configuration file. Deployment follows these steps:

  1. Ensure components have the correct URL
    • If components are built as part of Finsemble, $applicationRoot can be used as the URL base.
    • Otherwise, the component URL will need to be updated with the deployed location. These URLs are typically found in config/application/component.json.
  2. Deploy
    • Option 1: Checkout code and build on server. Project can optionally start web server.
    • Option 2: Build using a build system, then copy the finsemble folder and the contents of the dist folder to to the $moduleRoot and $applicationRoot locations, respectively.
  3. Get URL to manifest file. This is done by using the URL used in $applicationRoot and adding configs/openfin/manifest-production.json after it, e.g., http://webserver/path/to/finsemble/configs/openfin/manifest-production.json
  4. To create an installer, utilize the OpenFin Installer Generator found here: https://install.openfin.co/
    • Enter manifest URL and other information

Security overview

Finsemble does not communicate back with ChartIQ in any way, nor does ChartIQ have any access to communicate with applications built with Finsemble. Finsemble runs solely within the container on each user’s PC, with no server- or cloud-based infrastructure provided by ChartIQ.

Finsemble does not collect or report any information on usage, user behavior, preferences, or related matters back to ChartIQ or any other party. Finsemble provide your firm’s developers with the ability to connect to their own databases (to store workspaces, preferences, and other session- and component-related information) through the use of Storage Adapters.

How is Finsemble packaged?

Finsemble is provided as a package containing (1) JavaScript source code and (2) a clear source build process (gulp and Webpack). Finsemble’s dependencies are OpenFin, React, and various open source modules via an npm_modules-based dependency chain. A copy of the source code is held in escrow with NCC Group, to be released to licensees in the case of a triggering event (bankruptcy, etc.).

Installer

Deploying a Finsemble application requires doing two things: 1) getting OpenFin installed on your users’ machines, and 2) pointing OpenFin at your Finsemble “site.”

These things are accomplished by creating an OpenFin installer. The installer is an .exe that your users can download and run. It installs OpenFin, creates a launch icon for your application, and points that icon to the location of your OpenFin manifest file.

Once installed, updates are easy because of Finsemble's dynamic configuration. Each time a user launches your application, OpenFin starts up and loads your Finsemble site. Updating functionality is a simple matter of putting new components on your site. When you need to update Finsemble, replace the files at the $moduleRoot URL in the application config to point to the latest version of the Finsemble folder.

So what is deployment? It’s nothing more than copying your “dist” directory (or your own custom build output) to your production server. Of course, your systems development life cycle will have more steps, but keep in mind that it’s really a very simple thing that is happening.

Exceptions

If you choose to incorporate native components (.EXE, Java, Flash, etc.) into a Finsemble application, you must use the Windows executable assimilation.exe. ChartIQ provides this in binary and source code format. It is not necessary to manually install assimilation.exe on user’s desktops. Your firm’s developers incorporate it as an appAsset in the application config so that it is downloaded from your servers and runs dynamically. This executable acts as a bridge between native Windows events (move, minimize, maximize, etc.) and Finsemble, communicating over a WebSocket that runs on the desktop’s loopback (localhost).

Further reading

For a more thorough discussion of what Finsemble physically is and how it's structured, read the Architectural Overview.