Architecture/Robust

From LookingGlass

Jump to: navigation, search
Home < Architecture < Robust

Robust Exploration

This is a walk through of the Robust system in OpenSimulator as of September 12, 2010. The goal is to explain the component and grid service system by digging down in some example services.

The term "Robust" is used for two things:

  • a modular system of connectors enabling flexible configurations of grid services; and
  • a container for running back-end grid services

We'll start with the first and work up to the second.

The Robust connector architecture links together request APIs to service providers with a set of modules that are loaded and configured at simulator start up time.

Standalone

Let's work through an example for a standalone grid.

In Standalone.ini, there is

   [Modules]
       AssetServices = "LocalAssetServicesConnector"
Standalone.jpg
LocalAssetServicesConnector's code is in

OpenSim.Region.CoreModules.ServiceConnectorsOut.Asset. This module is a shared region module that registers itself with the region to present an IAssetService interface. It provides that functionality by looking up a local service module in Standalone.ini. LocalAssetServicesConnector finds in Standalone.ini:

   [AssetService]
       LocalServiceModule = "OpenSim.Services.AssetService.dll:AssetService"

LocalAssetServicesConnector loads the asset service (see note below) which implements local database access for assets.

Grid

Now let's look at Grid mode. The entry in Grid.ini is

   [Modules]
       AssetService = "RemoteAssetServicesConnector"

RemoteAssetServicesConnector's code is in OpenSim.Region.CoreModules.ServiceConnectorOut.Asset and is also a region module that registers its IAssetService with the region. This module also inherits the AssetServicesConnector class. This module uses the URI specified in the [AssetService] section to connect to the remote grid service.

For the grid configuration, each region in the simulator is connected to a RemoteAssetServicesConnector which implements the IAssetService interface by making network requests.

This is where the Robust grid service container comes in.

GridMode.jpg
To implement the receiver of the asset requests

and access the database a container is needed which reads configuration and assembles all the connectors. The application Robust.exe reads Robust.ini and starts up all the services specified in ServiceConnectors.

Continuing with the asset service example, the parameter is "8003/OpenSim.Server.Handlers.dll:AssetServiceConnector. This connector looks up the asset service in Robust.ini:

   [AssetService]
       LocalServiceModule = "OpenSim.Services.AssetService.dll:AssetService"

Well look at that! This is exactly the same asset service code loaded by the standalone configuration. So, what one ends up with is a network connector in the region which can talk to a network connection receiver in Robust.exe which is running the exact same code as the standalone asset service.

MultipleGrid.jpg
This connector architecture is used for all the services and

each region service can be individually configured for remote or local connections and code can be shared between the standalone setup and the grid services setup.

Since everything is parametrized, there is no reason that there be only one grid service -- there can be many Robust.exe's each configured to run some of the grid services. Similarly, some services could be local while others remote. Why you'd do that I don't know, but it's possible.

HyperGrid

Other Notes

Loaders

As a side note, the connectors specified in the [Modules] section are loaded at simulator start time via OpenSim.ApplicationPlugins.RegionModulesController.RegionModulesControllerPlugin which loads all the modules with the C# language extension "/OpenSim/RegionModules". This extension is specified either in the source of the module or in one of the XML resource files (like "CoreModulePlugin.addin.xml"). Later connectors are usually loaded by the Robust plugin loader (OpenSim.Server.Base.ServerUtils.LoadPlugin). This latter loader takes the parameter "DLLName:PackageID" which is what you will find elsewhere in the configuration files.

Simian

There has been some confusion about the different available grid backends (Robust and Simian).

The Robust backend uses C# code to implement the grid service (asset, inventory, ...) and the code is modularized in such a way that the same code can be used for standalone and grid simulator configurations. The Simian backend, on the other hand, is an implementation of the grid services using REST/PHP/etc. So, Robust and Simian both use the Robust connector architecture but use different protocols and data storage systems on the backend.

Personal tools