Stratus is a Spring Boot packaging of Geoserver (currently targeting 2.16) that is designed for Enterprise/Cloud deployments. Due to the magic of Spring and Maven, Stratus doesn't actually change any of the core code of the GeoServer community project. It instead declares (some) of those modules as dependencies and rewires parts of the runtime configuration to use custom pieces.

Stratus has the following main differences from community GeoServer:

• The web administration interface has been removed from all Stratus instances in the cluster. A single instance with the web UI will be deployed for times when the administrative tasks need to be performed with the UI.
• The standard XML file based catalog and resource stores are replaced with a Redis based ones. They intentionally do not cache any resources but instead fetch configuration from the catalog on each request. Ideally this renders Stratus stateless and scalable.
• Stratus uses an embedded Tomcat 8 rather than building a WAR file (however it is still possible to build one)

• Building Stratus
• Running Stratus locally
• Releasing Stratus
• Testing
• Deployment
• Upgrade Procedures

• Maven 3
• Java 8+
• Docker

Build Stratus jar using:

cd src
mvn clean install -DskipTests

If you wish to enable GDAL support in Stratus, build using:

cd src
mvn clean install -Dgdal

Build Stratus docker image using:

cd src/stratus-application
mvn docker:build

To enable GDAL support while running Strats in docker, you must first build the custom docker base image which includes the GDAL binaries:

cd build/docker/amazonlinux-gdal-py-java11
docker build -t amazonlinux-gdal-py-java11 .

The GDAL-enabled Stratus docker image can then be built using:

cd src/stratus-application
mvn docker:build -Dgdal

For more details on building and developing Stratus, refer to the stratus-application submodule.

Stratus makes extensive use of Lombok, download from https://projectlombok.org/download and run java -jar lombok.jar to launch the installer. Restart eclipse and run Project/clean/clean all projects.

Requires: Java 8, Local Redis instance

The Stratus jar can be executed with the command java -jar stratus.jar.

Alternatively, you can run Stratus from source from the stratus-application subfolder using mvn spring-boot:run.

Redis is the only dependency required for Stratus to run. By default, it will attempt to connect to a Redis server at localhost:6379.

The deploy/standalone directory contains several useful scripts to start various supporting services, including Redis, PostGIS, and Stratus itself.

By default, Stratus will start with a configuration that excludes all web components and backup/restore dependencies. To enable the web admin UI, be sure to set the property stratus.admin-enabled or environment variable STRATUS_ADMIN_ENABLED to true.

By default, Stratus will start using the redis-manual profile which will attempt to connect to a single Redis host.
The following profiles are available:

By default, running Stratus with no parameters will attempt to connect to a single Redis host on localhost:6379. The following configuration properties can be specified as command line parameters or environment variables.

Passing in custom properties depends on how you are running Stratus. Below are examples using java and maven from the command line:

Set the active profile:

• java: java -jar -Dspring.profiles.active=redis-sentinel stratus.jar
• maven: mvn spring-boot:run -Dspring-boot.run.profiles=lettuce-sentinel

Set the server port:

• java: java -jar -Dserver.port=8081 stratus.jar
• maven: mvn spring-boot:run -Dserver.port=8081

In addition, properties can be set via environment variables. The variable names should follow the following rules:

• Strictly use all uppercase
• Replace all periods in the property path with underscores
• Separate camelcase variables with underscore where the case changes

Example:

Before performing a release, update the CHANGELOG and whatsnew.rst with details of the release.

1. Add a new heading for the version being released.

2. If you are performing a major or minor release:

   i. Add a Summary subsection with the highlights of the release. Any migration notes should also be included in this section. ii. Add a Changes subsections to list individual changes (git log --oneline $PREVIOUS_RELEASE_TAG..HEAD should provide a good basis for the list). Further seperate this list into Version Updates, New Features, and Bugfixes.

3. If you are performing a patch release, instead just list the changes, without any subsections. This should be pretty short, or else you probably shouldn't be doing a patch release.

4. Update build.properties and banner.txt with the version of the new release.

5. Push the updated files to master.

Stratus is released using Jenkins, via the stratus-release job. When run, this job will:

• Run all tests.
• Remove -SNAPSHOT from the project version
• Commit and Tag in git with v${version}.
• Increment the patch version by one, and add -SNAPSHOT back onto the version.
• Commit.
• Push commits and tag to the gsstratus/stratus repository.
• Trigger a new run of stratus-deploy-all against the released tag, which will create Docker images and push them to Docker Hub.

Jenkins configuration is managed in deploy/jenkins.

Requires:

• Git
• Maven
• Docker
• Commit access to https://github.com/gsstratus/stratus/releases
• A Docker Hub account, with access to https://docker.io/repository/gsstratus/stratus
• You must be logged into Docker Hub locally in docker

To run the release process locally, you can use the command:

mvn release:prepare --batch-mode -Dtag=$GIT_TAG -DreleaseVersion=$RELEASE_VERSION -DdevelopmentVersion=$DEVELOPMENT_VERSION

Where:

• $GIT_TAG - The tag for the release, to be pushed to git. Usually of the form v1.2.0
• $RELEASE_VERSION - The maven version for the release, usualy of the form 1.2.0
• $DEVELOPMENT_VERSION - The maven version to update master to, usually of the form 1.2.1-SNAPSHOT.

(For more information on tagging and version guidlines, refer to tagging.md)

This will do everything the stratus-release job does except for building and deploying the docker images. To deploy the release, checkout the newly created release tag, cd to the stratus-application submodule and follow the instructions for deploying with docker.

After running the release job:

1. Verify the new git tag is listed at https://github.com/planetlabs/stratus/releases.

2. Still on GitHub, click Draft a new release, selecting the tag you just pushed, and fill in details for this release (Only do this for final releases, not RCs).

3. Verify the new docker tag is listed at https://docker.io/repository/gsstratus/stratus?tab=tags

You can test the release artifacts locally using single-host-deploy.sh in stratus:

1. Update DOCKER_TAG to the tag you just pushed to docker.io, and ensure that DOCKER_REPO=docker.io

2. Run single-host-deploy.sh.

3. Navigate to http://localhost:8080/geoserver/web and verify the UI shows up.

4. Navigate to http://localhost:8080/geoserver/rest/manage/info and verify that the git commit id matches that of the release tag in git.

For integration testing, refer to the test/ directory.

This includes a number of integration and performance tests, and an upgrade test.

Stratus deployments can be found under deploy/.

This includes:

• Jenkins pipelines for CI.
• Scripts for standalone deployments for demos and testing.
• Kubernetes deployments, both manual and using helm.
• Terraform Deployments.

Any custom Docker images used by these deployments can be found in build/docker.

• Ensure the methods in CommunityRestConfiguration are up to date with the current RestConfiguration class found in community GeoServer (note: community extends WebMvcConfigurationSupport and Stratus should extend WebMvcConfigurerAdapter)

• Ensure all of the context XML files in the stratus-gwc are updated with any changes made in the corresponding GeoServer GWC context files. Note there are exceptions for context files that contain important custom configurations. These
  files are:

  • applicationContext.xml
  • geowebcache-rest-context.xml
  • geowebcache-wmtsservice-context.xml