X PLATFORM™
The X Platform™ is a distributed data and compute framework used to process massive amounts of big and fast data in real time. X combines big-data storage, fast-data streaming, and real-time data processing in a single holistic offering thus supercharging the data management, real-time compute and analytical capabilities of the enterprise.
X based systems, written in Java and are microservices based. Each microservice manages private in-memory state, is horizontally scalable, fault tolerant, ultra-performant and collaborates with other microservices using fire-n-forget, exactly once message passing. X applications are very easy to write, are very lightweight, operate 100% in memory, are very fast, generate zero garbage and are completely resilient to network, process, machine and data center failures. In applications written on X, the application developer focuses on business logic while X takes care of all the non-functional aspects of the application.
X is being used to implement a wide variety of enterprise systems ranging from high performance data stores, low latency stream processors, real-time analytics engines and machine learning pipelines to complex, highly collaborative microservices applications.
The X Platform™ is comprised of the following set of modules.
Talon
Talon is the core module of the X Platform. It provides the machinery to easily build, run and manage micro applications (‘micro app’). A micro app is a lightweight, stateful message processor that resides on a messaging fabric. A micro app stores state as Java objects entirely in local memory and collaborates with other micro apps using guaranteed eventing via its underlying messaging fabric.
The Talon runtime uses configuration information to connect to the messaging fabric and drive the business logic embodied in the micro app message handlers in an exactly once, fully fault tolerant manner. Application developers implement message handlers. The Talon runtime dispatches inbound messages to the appropriate handlers, the handlers execute business logic, update state and send outbound messages to downstream apps. Talon enables a developer to treat memory as durable and the underlying messaging fabric as an exactly once transport medium. What this means is that the developer can assume that state updates and outbound message sends are durable and transactional. This makes it extremely easy for the developer to author streaming, multi-agent apps that are fault tolerant, scalable and perform at memory speeds. Talon applications routinely process hundreds of thousands of transactions per second, operate at single to double digit microsecond level latencies, generate zero garbage and perform exactly once processing across failures.
Hornet
Talon adheres to the multi-agent architecture pattern. In this pattern, micro apps collaborate with each other using message passing. Any message passing framework needs to implement message routing i.e. the ability to correctly and efficiently route messages between agents. Talon supports two core abstractions related to message routing - the Channel and the Message Type. Messages in a Talon system are classified by type and channels are one-many conduits for messages to flow between micro apps. Out of the box, Talon supports the following routing mechanisms
Channel Routing
Type Routing
Channel Routing is the most flexible routing mechanism in which the user sends and receives messages through channels. In channel routing, the user controls what channels exist in the system, what the various message types are and defines what messages flow through which channels. In channel routing, the developer sends and receives messages through channels.
Type Routing is a routing mechanism in which the user works exclusively with message types. Messages are sent by type and the act of implementing a message handler of a specific type will automatically draw messages of that type. In this type of routing, channels are hidden away from the developer. (Note: Type routing is currently only available in alpha form in the product)
Although the simplicity of channel and type routing is extremely powerful, there are circumstances under which the user may want to control how messages of specific types get routed on the messaging fabric. Hornet is an extension to Talon that allows a user to perform type routing on publish-subscribe messaging fabrics but with the additional ability to control the topic on which messages of specific type would be routed by the underlying fabric. This is called Topic Routing. Hornet provides a lightweight mechanism to declaratively define the various topics that exist on the fabric, declare micro app interest in the topics and map message types to topics. In doing so, Hornet enables micro apps to use topics to drive complex inter-app routing while continuing to work exclusively with message types at the application layer. Hornet takes care of mapping messages types to the appropriate topics on the fabric so that the messages are routed appropriate to the configuration at play.
Eagle
Eagle layers on top of Talon and implements the machinery to build, run and manage micro services. Talon apps are primarily streaming apps. Eagle layers the machinery on top of Talon to enable request-reply in addition to streaming. Eagle adds a service definition facility to Talon's state and message modeling facilities. Eagle uses service interfaces to generate service handler stub implementations allowing developers to quickly focus on writing business logic. Service operations support request-only, request-reply and request-reply-event patterns that can be executed either synchronously or asynchronously using a REST or a generated Java client. Eagle is well suited to build out enterprise applications using the micro services architecture pattern.
Robin
Robin is the X Platform™ tool for DevOps. Micro app and service based application architectures can result in a plethora of agents that need to be deployed, managed and monitored as a single system. Robin implements the machinery to do so. It implements centralized deployment management (provision, deploy, configure, launch and shutdown), passive application monitoring (lifecycle, statistics and alerts) and deployment scripting (using a fluent DSL).
Since Robin is familiar with the X abstractions, it is in a position to perform rather sophisticated deployment operations such as startup and shutdown of entire micro app/service clusters in a coordinated manner, ensuring correct roles of started app/services, dynamic command and control of running apps/services and monitoring of statistics in a zero garbage manner with minimal, if any, impact to application performance.
Lumino
Lumino is the X Platform™ monitoring and management tool. It layers on top of Robin providing a visual interface to perform deployment management, passive application monitoring, deployment scripting and command and control. Users can navigate systems running across any number of environments, instantly see the status of individual components within the system and statistics about their overall health and performance.
Lumino provides out of the box dashboards for server states, execution history, CPU, memory views, application states, statistics, alerts, and lifecycles. It includes support for adding custom dashboards and external data sources. Lumino also provides a robust command and control center for executing commands to remotely control apps. Lumino works with Talon, Hornet and Eagle apps.
