Rose Design Goals
              Rose is a group of utilities and specifications
              which aim to provide a common way to manage the
              development and running of scientific application
              suites in both research and production environments.
              Rose was designed to allow users to follow these
              principles:
              
                - A suite and the applications it runs should be
                driven mainly by configurations that can easily be
                understood and modified by a human user as well as
                a computer.
 
                - A suite should work with no modifications when
                it is run by a different user of the same
                site.
 
                - It should require minimum efforts to port a
                suite between old and new platforms, between sites,
                and between research and production environments.
                Where possible, it should be easy to abstract away
                unportable site configurations.
 
                - Configurations for driving scientific
                applications should be portable between related
                suites.
 
                - Configurations for driving a scientific suite
                should be version controlled. The results generated
                by running such a suite should be easily
                identifiable in the archive environment.
 
                - Rose utilities should be driven by well defined
                configurations. Any site and/or application
                specific logic should be configurable.
 
                - Rose GUI utilities will provide a nice way to
                access a set of functionalities, but will not be
                the only way to access those functionalities
                (unless they are GUI specific).
 
              
              Rose Components
              Rose has the following components:
              
                - Application configuration and runner: Rose
                provides a simple and portable configuration driven
                application runner to run individual scientific
                applications in suite tasks.
 
                - Configuration editor GUI: Rose provides a
                powerful metadata driven GUI for viewing, editing,
                checking, transforming, etc. suite and application
                configurations. The behaviour of the GUI can be
                easily modified on the fly by modifying the
                metadata associated with the suite and application
                configurations.
 
                - Suite engine: Rose uses cylc as the main
                engine for running suites.
 
                - Suite installer: Rose provides a configuration
                driven installer to install and start a cylc suite.
                This can install additional files from locations
                such as version control systems and mirror the
                suite to any remote platforms where tasks are to be
                run. It can also be configured to run the suite on
                a remote platform (a resilient server for
                instance).
 
                - Common suite utilities: Rose provides various
                utilities to allow suites to be written in a common
                way. This includes a task runner which makes it
                easy to run Rose applications and utilities within
                suite tasks, a task hook to notify task failures
                and interact with the suite log viewer, plus
                utilities for file installation, housekeeping,
                archiving, etc.
 
                - Rose Bush: While a suite engine would normally
                provide its own monitoring tools to monitor a
                running suite, they do not normally cover tasks
                that are no longer current and they cannot normally
                interact with a stopped suite. Rose Bush is a
                simple service for users to browse their suite logs
                over HTTP on their intranet.
 
                - Suite storage and discovery: Rose suites are
                just files in a directory hierarchy, so they can be
                stored anywhere. To avoid chaos, however, Rose
                provides a solution to allow suites to be hosted
                centrally using a version control system. This
                allows suites to be easily identifiable, shared,
                compared and retrieved by different users. Each
                centrally hosted suite will provide an identity
                file, which the system can use to populate a
                database. Users can discover relevant suites by
                querying the database.