 -----
 Kalumet Console Environment JEE Applications
 -----
 -----
 -----

~~ Licensed to the Apache Software Foundation (ASF) under one
~~ or more contributor license agreements.  See the NOTICE file
~~ distributed with this work for additional information
~~ regarding copyright ownership.  The ASF licenses this file
~~ to you under the Apache License, Version 2.0 (the
~~ "License"); you may not use this file except in compliance
~~ with the License.  You may obtain a copy of the License at
~~
~~   http://www.apache.org/licenses/LICENSE-2.0
~~
~~ Unless required by applicable law or agreed to in writing,
~~ software distributed under the License is distributed on an
~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~~ KIND, either express or implied.  See the License for the
~~ specific language governing permissions and limitations
~~ under the License.

~~ NOTE: For help with the syntax of this file, see:
~~ http://maven.apache.org/doxia/references/apt-format.html

Apache Kalumet Console JEE Applications

  The JEE applications tab allows you to manage the applications deployed in the JEE application server given by the "scope" checkbox.

[/images/env_apps.png]

  On each JEE application, you can:

  * copy the JEE application to be pasted into another application

  * enable (light on) or disable (light off) the JEE application. If disabled, the JEE application won't be part of the update process.

  * set update blocker (green puzzle piece) or not update blocker (grey puzzle piece)

  * change the JEE application order (using up arrow and down arrow icons)

  * launch the JEE application update

  * validate a change on the JEE application URI

  * delete the JEE application

  At the right of the URI, the "world icon" allows you to check if the URI is valid.

  Clicking on the JEE application name, or on "Add JEE Application" button, you will have a JEE application window.

[/images/env_app_general.png]

  The "General" tab allows you to define the general information about the JEE application:

  * Name: it's the JEE application name.

  * Active: if "true", the JEE application is active and will be part of the update process. If "false", the JEE application is disabled and the application won't be updated by the whole update process.

  * Update blocker: if "true", the JEE application is an update blocker. It means that if the JEE application update fails, the whole update process will fail and stop. If "false", the JEE application is not an update blocker. So, if the JEE application updated fails, the whole update process will just log a warning and the process will continue.

  * URI: it's an optional URI. It's a base URI. All relative URIs inside JEE application (like in archive, configuration file, etc) will be based on this master one.

  * Agent: if empty, the agent used will be the environment one. However, you can delegate the JEE application update to a specific agent.
