Corus

• Overview
• Features
• Architecture
• Purpose
• More Details

Overview

Corus is a framework allowing centralized control of distributed application processes. Concretely, Corus allows distributing applications on different nodes (grouped by domain or cluster) and executing/terminating processes corresponding to these applications. As of now, Corus supports clustered execution and termination of Java virtual machines.

Features

At a glance, Corus presents the following features

• non-intrusive distribution of plain-vanilla Java apps built with your lightweight framework of choice (distributed apps without an app server);
• clustered application deployment on distributed Corus nodes (hosts);
• clustered execution of distributed processes;
• clustered administration of Corus nodes;
• clustered JNDI naming service and RMI-like distributed computing (based on Sapia's Ubik), supporting transparent fail-over, load-balancing and client-side discovery;
• monitoring of executing processes and auto-restart of crashed ones;
• command-line administration client emulating Unix commands, used to administrate applications and running processes;
• port management;
• process scheduling.

Architecture

Corus consists of a lightweight daemon implemented in Java. A Corus server is installed on a given host, and executes/monitors processes on that host.

Multiple Corus daemons are grouped by domain, which allows performing clustered application deployment and process execution. A command-line client is provided in order to control multiple Corus daemons remotely, in a centralized manner.

A typical Corus topology is illustrated below:

Purpose

The main goal behind Corus is to allow distribution of plain-vanilla Java apps (with a simple main() method as an entry point) on a large-scale without the intrusion of an app server and compliance with a heavy-weight programming model.

The rationale behind Corus is that one should not need to rely on application servers (and the bloat that comes with them) to distribute applications on a large scale. How about just taking your plain Java app and deploy multiple instances of it in a cluster, making its services available on the network to other applications?

In theory, that could be done by simply writing a shell script for your app and deploy that script and your application's resources on the required hosts. But in theory, that is hardly practicable in enterprise contexts, where application instances can be numerous and manual startup/shutdown of processes through shell scripts quickly becomes overwhelming. That is why application servers generally rely on remote management and clustered deployment for distributing applications. But application servers impose a strict programming model, and the ones with enterprise-grade clustering features usually come with quite a price tag.

Corus allows avoiding the app server programming model. With Corus, you can stick to the basic, lightweight Java application. For example:

• you can build your app with your lightweight framework of choice.
• you can test your app locally withouth thinking about a distributed container contract.
• you can eventually deploy and execute your application on multiple nodes, in a centralized manner.
• you can use Corus' built-in distributed computing capabilities and/or other communication means of your choice (JMS, JavaSpace, etc.) to enable network links between your distributed applications.

More Details

Corus complements the lightweight philosophy very well, by not imposing a specific type of container in order to distribute your apps, and by keeping as close as possible to "normal", standalone, plain application execution. For exhaustive documentation, download the Corus Guide.