`) and of a context (the context's
+ JNDI environment) exposes its JNDI entries โ `resource`,
+ `resourceLink` (context only; not part of the global environment),
+ `resourceEnvRef`, `environment`, `ejb`, `localEjb` and `serviceRef` โ
+ each keyed by its JNDI name. The `namingResources` node itself is
+ required and cannot be removed (400 `REQUIRED_COMPONENT`); the
+ entries are added/removed and the node's `global` flag drives the
+ client (a server node offers no `resourceLink`). Adding an entry
+ registers and binds it in the live JNDI environment at once (the
+ `NamingContextListener` reacts to the add); removing one unbinds it.
+ An entry's attributes are edited through the property list. Every
+ entry type extends `ResourceBase`, which carries a generic map of
+ string parameters (the RefAddr keys the JNDI factories consume at
+ lookup time); those parameters are shown in the entry detail for
+ **all** the entry types and can be added (an "Add parameter" form),
+ edited, or removed (cleared) from the property list. For a
+ `resource` the closed option set (RefAddr keys) of its effective
+ first-party factory is additionally rendered as typed fields โ the
+ four shipped factories (`BasicDataSourceFactory`,
+ `MemoryUserDatabaseFactory`, `DataSourceUserDatabaseFactory`, and the
+ `PerUserPool`/`SharedPool` data sources) render their options as
+ typed fields, while any other factory (or an extra key) is a
+ free-form parameter. Editing an attribute or a `param` re-binds the
+ entry by removing and re-adding it (so the change is visible to the
+ live JNDI environment without a restart); renaming a JNDI name is a
+ risky change (type-to-confirm).
+ - *Remove* asks for typing the component's display name and is
+ disabled for the self component. Server-side guards additionally
+ reject: the last service (`LAST_SERVICE`), the service/engine/host/
+ context hosting this webapp (`SELF_COMPONENT`), the basic (first)
+ valve of a pipeline (`BASIC_COMPONENT`), an engine that still
+ contains hosts (`NOT_EMPTY`), a directly attached realm whose
+ container would be left without a realm (`LAST_REALM`), a context's
+ `manager`/`resources`/`loader`/`cookieProcessor` or a manager's
+ `sessionIdGenerator` (`REQUIRED_COMPONENT` โ required, replace
+ instead), the default
+ SSL host configuration of a running, TLS enabled connector while
+ other configurations remain (`SSL_DEFAULT`) and the last
+ certificate of a running, TLS enabled connector (`SSL_LAST_CERTIFICATE`).
+ - *Save to server.xml* fetches the preview (the resulting `server.xml`
+ plus the external context files that would be rewritten, shown in a
+ wide modal) and, on confirmation (typing `server.xml`), persists the
+ live state: a timestamped backup of the previous `server.xml` is
+ kept. Contexts keep their current storage location, mirroring regular
+ StoreConfig behaviour โ a context backed by its own file
+ (`META-INF/context.xml` or `conf/Catalina/.../context.xml`) is written
+ back to that file, a context defined inline stays inline in
+ `server.xml`. The preview is read-only (external files are captured in
+ memory, never written). A context restarts when its own file is
+ written, so a save that rewrites this webapp's own file restarts the
+ manager and resets the admin session; the dialog warns about this when
+ it applies (`restartsManager` in the preview response).
+
+**Users**
+- Manages the users, groups and roles of the `UserDatabase` JNDI resources
+ configured for the server (the default `server.xml` configures the file
+ based `MemoryUserDatabase` that backs `conf/tomcat-users.xml`). Databases
+ are discovered through the server's global JNDI naming context; when more
+ than one is configured a selector in the header chooses which to operate
+ on (all API calls accept a `name` field/parameter).
+- Header card: database type, `read-only` / `not writable` / `writable`
+ badge, and the JNDI name (plus id).
+- When the database is read-only a warning banner explains that
+ `readonly="false"` must be set on its `Resource` in `server.xml`, and all
+ mutation controls are disabled.
+- Users table: user name (+ full name), roles (badges; roles inherited
+ through groups shown dimmed with a `+`), groups, row actions *Roles* /
+ *Password* / *Remove* (remove asks for typing the user name). "Add user"
+ modal: user name, password, full name, roles (comma separated with
+ suggestions).
+- Groups table: group name, roles, members, row actions *Members* / *Roles* /
+ *Remove*. "Add group" modal: group name, description, roles.
+- Roles table: role name, description, the users and groups that hold the
+ role, row action *Remove* (removal asks for typing the role name and
+ detaches the role from all users and groups). "Add role" modal: role name,
+ description. Roles can also still be created implicitly when assigned to a
+ user or group; removing the last user or group that uses a role leaves the
+ (now unused) role defined, matching `UserDatabase` semantics.
+- Security notes: passwords are stored exactly as provided (same semantics as
+ the `password` attribute of `tomcat-users.xml`) and are never returned by
+ the API; the signed-in account cannot remove itself, nor a role it holds
+ (directly or through a group); group members must
+ exist; name values are restricted to a safe character set because they are
+ persisted in comma separated lists and used as URL path segments. Every
+ mutation is followed by `save()` so the change is persisted to the storage
+ of the database.
+
+**Monitoring**
+- CPU and memory status cards (5 s cadence): an instant snapshot from
+ `GET /api/status/system`, not a chart. The CPU card shows the system and
+ JVM process CPU load as percentage bars, plus cores, 1-minute load
+ average and live/daemon/peak thread counts; the memory card shows
+ physical memory and swap usage, the JVM heap (used / max bar, committed)
+ and non-heap usage as bars and facts, and a per-memory-pool table
+ (used, committed, max). Values the platform does not expose (CPU loads
+ before the first monitoring interval, the load average on Windows,
+ physical/swap memory on a JVM without the HotSpot management MBean)
+ render as "-".
+- Live workers table (5 s cadence): stage, processing time, bytes
+ sent/received, remote address (forwarded + actual), virtual host,
+ request line. Only *active* workers are listed โ stages P (parsing,
+ blue), S (service, green) and F (finishing, amber), each with its own
+ bullet colour; R (ready), K (keep-alive) and unknown stages are idle
+ one way or another and are left out so the table stays short; the
+ header badge reports "N active ยท X idle".
+- Connector detail cards with the same data as the Dashboard, plus
+ max-processing-time history chart.
+
+**Diagnostics**
+- SSL: ciphers / certs / trusted certs tables per connector; "reload SSL
+ host configs" (all, or single `tlsHostName`).
+- Memory leaks: "check now" button, list of suspect contexts.
+- JNDI resources: type filter, tree.
+- VM: VM info, thread dump (monospace viewer, download as .txt).
+
+**Logs**
+- File selector over the JULI server log files (`catalina`, `localhost`,
+ `manager`, `host-manager`, `catalina.out`), max-lines selector (500-5000),
+ refresh and download buttons (the download saves the full, unfiltered raw
+ file of the current selection).
+- Filters: severity (the levels actually present in the file) and free-text
+ search.
+- Table: time, level (coloured badge), thread, source, message. Row click
+ opens a drawer with the full record, including the stack trace.
+- Both the plain one-line format and the JSON log format
+ (`org.apache.juli.JsonFormatter`) are handled; the format is detected per
+ file from the first line.
+
+**Access log**
+- File selector over the access log files, max-lines selector, refresh and
+ download buttons (the download saves the full, unfiltered raw file of the
+ current selection).
+- Filters that are shown depend on the fields the configured format
+ provides: method, status (class `1xx`-`5xx` or exact code), user, session
+ ID and free-text search. A filter is only offered when its field is part
+ of the configured format (e.g. no session-ID filter when the pattern has
+ no `%S`).
+- The pattern based format is parsed with the pattern of the configured
+ `AccessLogValve` (falling back to the common and combined patterns when no
+ valve is configured), and the JSON format
+ (`org.apache.catalina.valves.JsonAccessLogValve`) as one JSON object per
+ line. Both formats expose the same field names, and the method / path /
+ query / protocol are derived from the request line when only `%r` is
+ logged.
+- Table: host, user, time, the method / path / query / protocol columns
+ (derived from `%r` when the format logs only the request line), status
+ (coloured badge), size, session ID (when logged). The raw request line
+ is not a column โ it repeats the derived columns and is by far the
+ widest; it stays available in the record drawer, which a row click
+ opens with the full record.
+
+### 5.3 Design system
+
+- Plain CSS with custom properties (no framework); light + dark themes
+ (system preference default, manual toggle, persisted in
+ `localStorage`).
+- System font stack; 12-column grid; 8 px spacing scale; single accent
+ colour; states (success/warning/danger) with colour + icon (never colour
+ alone). The accent is otherwise neutral: per-tab hues are reserved for
+ the active navigation item (see ยง5.1) so the current section is
+ recognisable at a glance, and are never used for content.
+- Responsive. Phone mode below 900 px (bottom tab bar, management tables
+ (applications,
+ hosts, users, sessions, connectors, servlets, โฆ) convert to stacked
+ cards, each cell labelled with its column header; kebab menus, full-width
+ forms and modals) โ 900 px rather than the classic 768 px so iPad
+ portrait and small tablets get it too. Independently, high-volume tables
+ (server logs, access log, active workers) get the scrollable treatment โ
+ size to content so columns are never squeezed or wrapped, first column
+ pinned while the table scrolls horizontally โ up to 1150 px, because
+ below that even the thirteen access-log columns do not fit without
+ squeezing and a horizontal scroll is the better trade; above it the
+ ordinary desktop tables take over (which also keeps ordinary desktop
+ windows, however short, on the desktop treatment). The log pages never
+ pin their first column at any width in that range โ the pinned Time
+ column would dominate the viewport and leave a sliver for the scrolling
+ content, so the whole log table scrolls.
+ The log pages' long text columns (messages) are given most of
+ the viewport (90vw portrait, 100vw landscape) because with
+ `table-layout:auto` any extra table width flows into the only wrapping
+ column, keeping rows to one or two lines for information density.
+ Charts re-flow to a single column; row actions move into an overflow
+ (kebab) menu; form fields and modals go full width.
+- The side navigation is an icons-only 60 px rail at all widths where it
+ is shown; in landscape viewports it pops out at full width and label on
+ hover/focus as a fixed flyout that never resizes the view (see ยง5.1).
+- Accessibility (WCAG 2.1 AA): semantic landmarks, visible focus states,
+ keyboard-operable modals/drawers (focus trap, `Esc` closes),
+ `aria-live="polite"` toasts, live chart updates announced at reduced
+ frequency, contrast โฅ 4.5:1.
+
+## 6. Live updating
+
+- **Default transport: HTTP polling.** Dashboard 2 s, Monitoring 5 s,
+ Applications list 10 s; all polling pauses when `document.hidden` and
+ resumes on focus. Intervals are servlet init-params
+ (`pollIntervalStatus`, โฆ) and client-configurable.
+- **Why not WebSockets/SSE first:** polling is proxy/LoadBalancer-safe,
+ stateless, and the payload is tiny; the MBean attribute reads done per
+ poll are the same ones the legacy status page did per full page load.
+ A `GET /api/stream` (Server-Sent Events) endpoint is specified as an
+ optional future extension behind an init-param.
+- **Charting:** hand-written canvas module (`js/charts.js`): rolling
+ ring-buffer per series, auto-scaling y-axis, 1 s/5 s/15 min window
+ switcher, hover readout, optional log scale for byte counters. Line
+ charts, area charts and gauges only โ no external chart library.
+- **Data integrity:** every snapshot carries `ts`; the client discards
+ out-of-order duplicates and renders a gap marker if a poll is missed.
+ Counter deltas that go backwards (JVM/connector restart) reset the rate
+ calculation instead of producing negative rates.
+
+## 7. Security
+
+### 7.1 Authentication โ HTTP FORM
+
+`WEB-INF/web.xml` (replacing the legacy `BASIC` login-config):
+
+```xml
+
+ FORM
+ Tomcat Manager2 Application
+
+ /login
+ /login?error=1
+
+
+```
+
+- Works with any configured Realm (default file realm, JDBC, LDAP, โฆ);
+ credentials are sent once over the session, not in every request header.
+- The login page is rendered by `LoginServlet` (not served as a static
+ resource) for three reasons:
+ - it injects a `` element, because the page can be displayed at
+ arbitrary URLs (the browser keeps the URL of the request that triggered
+ the forward) and the relative CSS link would otherwise break;
+ - it normalizes the FORM-authentication *saved request* so the
+ post-login redirect lands inside the application instead of at the
+ last unauthenticated request, which for a single-page application is
+ frequently a CSS or JS file or a JSON API call. Concretely: when the
+ login page is being rendered for an SPA route (the deep-link gate in
+ `HomeServlet` forwards with the route URI still on the request), the
+ saved request is pointed at that route, so the user returns to exactly
+ the page they were on; any other saved request (an API call, an asset,
+ ...) is replaced with a GET of the context root (`/`). The root URL
+ (not `/index.html`) keeps the SPA router on its dashboard route;
+ `HomeServlet` serves the shell there.
+ - it creates the session (and records its ID, mirroring what the
+ authenticator does when it changes the session ID) so the login form
+ submission is tied to a session even when the browser arrived at the
+ login page without one.
+- `LoginServlet` also sets the `FormAuthenticator` landing page to the
+ context root (`/`) as a safety net for logins without a saved request.
+- The session cookie (`JSESSIONID`) is `HttpOnly`; deployments are
+ expected to serve manager2 over TLS so the cookie is `Secure`. The
+ context uses the RFC 6265 cookie processor with `sameSiteCookies="strict"`
+ (see ยง8).
+
+### 7.2 Authorization โ per-endpoint roles
+
+Same role names as the legacy webapps (no new roles to document; a
+`manager2-*` naming scheme is an open question, ยง12):
+
+```xml
+
+
+ Read-only status
+ /api/status
+ /api/status/*
+ /api/info
+ /api/csrf
+
+
+ manager-gui
+ manager-status
+
+
+
+
+
+ Manager API
+ /api/*
+
+
+ manager-gui
+
+
+```
+
+`manager-status` users get read-only monitoring; `manager-gui` users get
+everything.
+
+The SPA shell and its static assets (`/`, `/index.html`, `/css/*`, `/js/*`,
+`/img/*`, the login and error pages) are **not** protected with a security
+constraint. A constraint with the URL pattern `/` matches *every* request in
+the context (not just the context root), so protecting the shell with `/`
+would also catch the login page's own CSS and JS: they would be sent through
+FORM authentication (leaving the login page unstyled) and would poison the
+saved request (sending the browser to a CSS file after login). Instead:
+
+- `HomeServlet` gates the SPA entry point (`/`) and the SPA deep-link routes
+ (`/apps`, `/hosts`, `/configuration`, `/users`, `/monitoring`,
+ `/diagnostics`, `/logs`, `/access-log`, `/apps/*`): it forwards
+ unauthenticated visitors to the login page and authenticated users get the
+ shell rendered from `index.html` as a template, preserving the requested
+ URL so deep links survive a reload. The template rendering (rather than a
+ plain forward to the static file) injects a `` element (the
+ `` placeholder, see `Html`): a *multi-segment* deep
+ link such as `/apps/localhost/myapp` would otherwise make the browser
+ resolve the shell's relative asset URLs (`js/main.js`, `css/manager2.css`)
+ against the deep path (`/apps/localhost/js/main.js`), which the server
+ answers with the shell HTML and the browser then refuses as a script.
+- The context root *without* a trailing slash (e.g. `/manager2`) is
+ redirected (302) to the trailing-slash form by `HomeServlet`. Without the
+ redirect the browser would resolve the page's relative URLs (`css/*`,
+ `js/*`, `images/*`) against the server root instead of the context,
+ breaking the page. The mapper's own context-root redirect
+ (`Context#setMapperContextRootRedirectEnabled`, on by default) cannot do
+ this here: it only applies when *no* servlet is mapped to the context
+ root, but `HomeServlet` is (via the empty URL pattern, which the mapper
+ registers as the exact match `/`), so the mapper always finds a wrapper
+ before that redirect branch is reached.
+- The JSON API is the only place where data lives and the only place that is
+ constraint-protected. The SPA itself reacts to an unauthenticated API
+ response (the container forwards the XHR to the login page) by performing a
+ full navigation to the *current* URL (not the application root): the server
+ then gates that page to the login page at the same URL, and a successful
+ login returns the user to the page they were on. A short guard suppresses a
+ second bounce within a few seconds (falling back to the root) so a bad
+ credential cannot spin a reload loop. Note that error responses (4xx/5xx,
+ including the container's HTML error page) are surfaced to the page and are
+ *not* treated as an unauthenticated condition.
+
+ This matters when the session is lost while the user is mid-application
+ (e.g. the webapp is redeployed, which destroys all in-memory sessions): the
+ user is re-prompted for credentials at the page they were on rather than
+ being dropped at the root.
+
+### 7.3 CSRF protection
+
+Synchronizer-token pattern, implemented in a small `CsrfFilter`
+(`org.apache.tomcat.manager2.CsrfFilter`) mapped to `/api/*`:
+
+1. On first API access (or after login) the filter generates a 128-bit
+ `SecureRandom` token (32-char hex) and stores it in the `HttpSession`.
+2. The token is delivered to the SPA in the **`X-CSRF-Token` response
+ header of every API response** (so it is always fresh after a session
+ change) and also via `GET /api/csrf`. It is never placed in URLs or
+ query strings.
+3. Every non-safe request (`POST`, `PUT`, `DELETE`, `PATCH`) must carry the
+ token in an `X-CSRF-Token` request header. The SPA's `api.js` wrapper
+ reads the header from the last response and attaches it automatically;
+ missing or mismatched token โ `403` with `error: "CSRF"` and an audit
+ log entry.
+4. Defence in depth: all mutation endpoints require
+ `Content-Type: application/json` (except the multipart upload) and the
+ webapp sets no `Access-Control-Allow-Origin` headers, so a cross-origin
+ page cannot make a simple cross-site request succeed โ the browser
+ preflight is rejected. The token covers the cases browsers do not
+ (e.g. same-site subdomain hosting, non-browser clients that should be
+ rejected).
+5. The filter additionally requires an authenticated session for unsafe
+ methods (redundant with the security constraints, but it gives a clean
+ 403/401 split and a single audit point).
+
+This is functionally equivalent to the `CsrfPreventionFilter` the legacy
+webapp already applies to `/html/*`, but adapted to a header-based JSON
+client instead of a hidden form field.
+
+### 7.4 Security headers
+
+`HttpHeaderSecurityFilter` mapped to `/*`, with the new default
+`hstsEnabled=true` (overridable, like the legacy app but safer by
+default) plus an explicit CSP:
+
+```
+Content-Security-Policy: default-src 'self'; script-src 'self';
+ style-src 'self'; img-src 'self' data:; connect-src 'self';
+ frame-ancestors 'none'; base-uri 'self'; form-action 'self'
+X-Frame-Options: DENY
+X-Content-Type-Options: nosniff
+```
+
+No inline scripts/styles exist, so no `'unsafe-inline'` is needed.
+Note: `style-src 'self'` also makes the browser **drop style attributes
+set through `setAttribute('style', ...)`** (they count as inline style
+and are blocked, with a console violation) โ while the CSS object model
+(`el.style.cssText = ...`) is unaffected. The `el()` helper therefore
+applies a `style` attribute through `node.style.cssText`; any new code
+must keep doing so or the style is silently ignored.
+
+### 7.5 Request-safety invariants (inherited from the legacy servlets)
+
+- WAR upload: 50 MiB `multipart-config` cap, `.war` suffix validation,
+ submitted file name reduced to its base name, destination confined to
+ the host's `appBase` via canonical-path containment check, update path
+ writes `*.war.tmp` first to avoid auto-deploy races, per-context
+ `tryAddServiced` guard against concurrent deployments.
+- Server-side deploy: WAR/config paths are confined to `appBase` /
+ `conf` via the same containment checks.
+- Context name validation (leading `/`, no `..`, version syntax) as in
+ `ManagerServlet.validateContextName`.
+- The servlet refuses to undeploy/reload the context it runs in; the host
+ it runs in cannot be stopped or removed. manager2 must therefore be
+ deployed in its own context (default: `/manager2`) โ documented.
+- All output is JSON produced by the API layer; there is no HTML
+ rendering of user/server data, so no escaping surface. The thread-dump
+ and VM-info endpoints return plain text in a JSON string, rendered in a
+ read-only `` (never `innerHTML`-ed from data).
+
+### 7.6 Audit logging
+
+Every mutation is logged at INFO by the API layer, including: timestamp,
+authenticated principal, remote address, action, target (host/context),
+parameters that are not secrets, and outcome (ok/error code). This is
+strictly more auditable than the legacy `debug`-level logging and is the
+single place to hook external audit sinks later.
+
+### 7.7 Known limitation
+
+Tomcat does not change the session id at successful FORM login by default,
+so session-fixation protection relies on the login happening in a fresh
+anonymous session. The howto will recommend serving manager2 over TLS with
+`SameSite=Lax` session cookies; a session-id-change valve is listed as a
+possible follow-up rather than a requirement.
+
+## 8. Packaging and build
+
+**Design decision (implemented):** everything lives in a standalone module
+at `modules/manager2` with its own Ant build and packaging, instead of being
+merged into the main tree's `catalina.jar` + `webapps/` copy. The module is
+fully decoupled: it compiles against the main build's jars, produces its own
+`manager2.jar` + `manager2.war`, and its `deploy` target drops the WAR into
+the main build's `webapps/` directory.
+
+Module layout:
+
+```
+modules/manager2/
+ build.xml standalone Ant build (jar, war, deploy, test)
+ build.properties.default version + main-build location
+ resources/MANIFEST.MF jar manifest
+ src/main/java/org/apache/tomcat/manager2/
+ AppsApiServlet.java extends HTMLManagerServlet
+ HostsApiServlet.java extends HostManagerServlet
+ StatusApiServlet.java status endpoints
+ StatusSnapshot.java MBean collection โ JSON model
+ LogsApiServlet.java /api/logs + /api/access-log (list, tail, filters, raw download)
+ LogParser.java JULI text/JSON log lines, access log patternโregex
+ AccessLogSupport.java access log field names, normalization
+ UsersApiServlet.java /api/users + /api/groups + /api/roles
+ (UserDatabase JNDI discovery,
+ user/group/role management, save)
+ CsrfFilter.java CSRF token issue/verify
+ HeadersFilter.java CSP / Referrer-Policy
+ Strings.java StringManager creation that finds the web app's
+ LocalStrings bundle regardless of the initializing
+ thread's context class loader; binds the request
+ locale (LocaleFilter) to the current thread
+ LocaleFilter.java Maps Accept-Language to the StringManager locale
+ for the duration of the request
+ I18nServlet.java GET /i18n โ serves the manager2.ui.* bundle keys
+ as JSON for the client
+ Api.java, Json.java, Constants.java
+ LocalStrings.properties
+ src/test/java/org/apache/tomcat/manager2/
+ TestManager2Webapp.java
+ TestManager2Config.java
+ webapp/ SPA shell, login, css, js, WEB-INF/web.xml,
+ META-INF/context.xml (privileged context)
+```
+
+Notes:
+
+1. The package is `org.apache.tomcat.manager2`, not
+ `org.apache.catalina.manager2`: `DefaultInstanceManager` always loads
+ `org.apache.catalina*` classes with the container class loader, which
+ would make the web app's own jar unreachable.
+2. The WAR is self-contained (`WEB-INF/lib/manager2.jar`), following the
+ convention of the other `modules/` web apps.
+3. No main-tree build changes at all; no new Ant dependencies, no new jars,
+ no license/NOTICE changes (zero third-party code).
+
+`conf/` changes: none required to *use* the webapp; existing role names
+(`manager-gui`, `manager-status`) are reused. To make the Users page
+*persist* changes, the `UserDatabase` resource must be writable: the file
+based database defaults to read-only, so `readonly="false"` has to be added
+to its `` definition in `server.xml` (and the server restarted).
+Until then the page still shows the current users, groups and roles, the
+mutation controls are disabled, and a banner explains what to configure.
+
+## 9. Testing
+
+New `modules/manager2/src/test/java/org/apache/tomcat/manager2/
+TestManager2Webapp.java` (`TomcatBaseTest`, run by the module's `ant test`),
+modelled on the existing `TestManagerWebapp` but exercising the new flows:
+
+1. **FORM auth flow** with `SimpleHttpClient`: unauthenticated `GET
+ /manager2/api/apps` โ redirect to `login.html`; `POST
+ j_security_check` with the session cookie โ 302 back; authenticated
+ call โ 200. The context root without a trailing slash (`/manager2`)
+ is a 302 redirect to `/manager2/` (see ยง7.2).
+2. **CSRF flow**: `POST /api/hosts` (or any mutation) without token โ 403
+ `CSRF`; with the `X-CSRF-Token` header โ 200. Re-login invalidates the
+ old token.
+3. **Authorization**: user with only `manager-status` can `GET
+ /api/status` but gets 403 on `/api/apps` and all mutations;
+ unassigned user gets 401/redirect on everything.
+4. **Functional parity** (same test WARs as `TestManagerWebapp`): list,
+ deploy (server-side + upload), start/stop/reload/undeploy, session
+ list/sort/detail/invalidate/attribute-removal, expire idle, global JNDI
+ resources (asserts the classic manager's human readable status header is
+ stripped from the `name:class` lines).
+5. **Hosts**: add (all parameters), list (asserts the running default host
+ is reported `started: true`, not matched on the raw state name), stop,
+ start, remove, persist.
+6. **Status**: `GET /api/status`, `/api/status/workers`,
+ `/api/status/apps/{path}` โ assert the JSON contract (key presence,
+ types, connector names) rather than exact values; counters
+ monotonically increase across two polls.
+ 7. **Headers**: `X-Frame-Options: DENY`, CSP, `X-CSRF-Token` presence on
+ responses, `Cache-Control: no-store` on API responses.
+ 8. **Users**: with no `UserDatabase` JNDI resource configured, `GET
+ /api/users` and mutations return 404 `USER_DATABASE_MISSING`. With a
+ file based `MemoryUserDatabase` registered on the global naming context
+ (via `Tomcat.enableNaming()` + `ContextResource`): list (users, groups,
+ roles, `readonly`/`writable` flags), create user with roles, change
+ password, replace roles, create group, set members, replace group
+ roles, create role with description, remove role (detaching it from
+ the users that hold it), remove group/user โ each verified against the
+ persisted XML file; duplicate names โ 409, unknown members โ 400
+ `UNKNOWN_GROUP_MEMBER`, unknown user/group/role โ 404, self removal โ
+ 400 `SELF_REMOVAL`, self role removal (a role held by the signed-in
+ account) โ 400 `SELF_ROLE_REMOVAL`; a read-only database
+ (`readonly` attribute not set) rejects all mutations with 400
+ `USER_DATABASE_READONLY`; `manager-status` gets 403 on the users API.
+ 9. **Logs**: list (JULI + access log files, detected format), tail with
+ level / method / status / user / session / free-text filters (text and
+ JSON formats, pattern driven access log fields), the raw download
+ (`/api/logs/download`, `/api/access-log/download`) returns the full
+ unfiltered file and rejects path traversal, and the returned
+ records are asserted to be the most recent matching lines ordered from
+ most recent to least recent. `manager-status` gets 403.
+10. **Deploy wizard (browser E2E)**: the modal opens with only the
+ *Upload* pane visible; *From server* shows only its pane; switching
+ back to *Upload* shows the complete upload form again (regression for
+ the "truncated form" report, which had two causes: the server pane
+ lacked an initial `display:none`, and the CSP blocked `style`
+ attributes set via `setAttribute` โ see ยง7.4).
+11. **Configuration** (`TestManager2Config`): tree shape (the service,
+ engine and host are resolved from the returned tree by type โ their
+ names depend on how the test instance was created); node details
+ (id/type/className/properties, the `self` flag on the self context,
+ 404 for unknown nodes); attribute round-trip (read, update, read
+ back, restore) plus guards (non-writable attribute โ 400 `READ_ONLY`,
+ unknown attribute โ 404 `ATTRIBUTE_NOT_FOUND`, value that does not
+ convert to the attribute type โ 400 `INVALID_VALUE`, the self
+ context's `path` โ 403 `SELF_COMPONENT` with or without a confirm);
+ add + remove of all eight structural child types (service,
+ connector, executor, host, alias, context, wrapper, valve) with the
+ whole branch visible in the tree in between, and the guards
+ (unsupported type โ 400 `UNSUPPORTED_TYPE`, wrong parent โ 400
+ `BAD_PARENT`, duplicate service name โ 409 `DUPLICATE`, invalid
+ connector port โ 400 `INVALID_VALUE`, executor
+ `minSpareThreads > maxThreads` โ 400 `INVALID_VALUE`, last service โ
+ 400 `LAST_SERVICE`, self service/host/context โ 403
+ `SELF_COMPONENT`, basic valve โ 400 `BASIC_COMPONENT`); add +
+ remove of a `listener` on a `Lifecycle` parent (visible in the tree,
+ node detail resolves, non-listener or unknown class โ 400
+ `INVALID_CLASS`, alias parent โ 400 `BAD_PARENT`); `store/preview`
+ returns the XML without writing
+ anything; `store` writes `conf/server.xml` containing the live state
+ (including a just-added alias) and keeps a timestamped backup.
+ Unauthenticated tree request โ the login page; `manager-status` โ
+ 403; a mutation without a CSRF token โ 403. The root context (empty
+ path) is addressed by a bare `+` segment and displayed as `/`: its
+ node detail and its child components (a wrapper added through the API)
+ both resolve. TLS on a dedicated service (so it never is the connector
+ of this webapp): guards (wrong parent โ 400 `BAD_PARENT`, no
+ certificate โ 400 `INVALID_VALUE`, unloadable keystore โ 400
+ `ADD_FAILED` + rollback, unknown certificate type โ 400
+ `INVALID_NAME`, certificate outside an SSL host configuration โ
+ 400 `BAD_PARENT`); add an SSL host configuration with its
+ certificate (the connector serves real TLS, verified with a TLS
+ handshake, and reports `sslEnabled`), node details of the host
+ configuration and the certificate (including the `protocols`
+ property, compared order-independently), attribute update
+ (`protocols`) and read-only protection (`type`, `hostName`),
+ adding and removing a second certificate, the
+ `SSL_LAST_CERTIFICATE` guard, the TLS branch in the stored
+ `server.xml` (including the keystore path), the duplicate host
+ name guard (409 `DUPLICATE`), and removal (the connector serves
+ plain HTTP again, verified with a plain request). Realms: the
+ engine realm is shown and an inherited realm is not; node detail
+ (modeler properties, `acceptsSubRealm` false for a plain realm);
+ add a realm to a host (unknown class โ 400 `INVALID_CLASS`, a
+ second one โ 409 `DUPLICATE`), attribute update (`allRolesMode`,
+ invalid value โ 400 `SET_FAILED`), a `LockOutRealm` on a context
+ with sub realms (`acceptsSubRealm` true, adding two, both shown,
+ node detail of a sub realm, the combined realm and its sub realms
+ in the stored `server.xml`), removing a sub realm and the
+ combined realm, the `LAST_REALM` guard on the engine realm, and
+ removing the host realm (falling back to the engine realm).
+ Context sub components on a dedicated context: the manager (with
+ its session id generator), resources, loader and cookie processor
+ are shown; node detail (the manager and resources through their
+ modeler descriptor, the loader, cookie processor and session id
+ generator through the explicit attribute list); attribute updates
+ (`maxActive`, `allowLinking`, `delegate`, `sameSiteCookies`,
+ `sessionIdLength`, invalid value โ 400 `SET_FAILED`); replace via
+ add (a fresh instance with the defaults is in place, the
+ manager/loader keep their `STARTED` state, the session id
+ generator is re-created), wrong class โ 400 `INVALID_CLASS`,
+ wrong parent โ 400 `BAD_PARENT`, replacing the self context's
+ manager or loader โ 403 `SELF_COMPONENT`, replacing the
+ resources of a running context โ 400 `CONTEXT_RUNNING` and on a
+ stopped context โ 200 (started again afterwards), and the
+ `REQUIRED_COMPONENT` guard on removal of all five types.
+ JNDI naming resources (with naming enabled via `Tomcat.enableNaming()`):
+ the server's global `namingResources` node (`global: true`) and a
+ context's (`global: false`); add a global `UserDatabase` with a
+ first-party factory (the closed factory options are shown as `param`
+ properties with their values, a not-set option is listed with a null
+ value) and verify it is bound in the live global naming context (and
+ loaded its users); add an `environment`, `ejb`, `localEjb` and
+ `serviceRef` (all shown in the tree); the generic string parameters
+ of the `environment`, `ejb` and `serviceRef` entries (the
+ `ResourceBase` property map) are shown as `param` properties and can
+ be added, edited and removed (cleared); the guards (duplicate JNDI name
+ โ 409 `DUPLICATE`, missing `jndiType` โ 400 `MISSING_FIELD`,
+ `resourceLink` at the server level โ 400 `BAD_PARENT`, unloadable
+ factory โ 400 `INVALID_CLASS`, removing the node โ 400
+ `REQUIRED_COMPONENT`); a parameter update re-binds the entry (the new
+ value is reported and the live lookup still resolves); renaming a JNDI
+ name requires a confirm and re-binds it (the old name is unbound, the
+ new name is bound); a free-form parameter is added and then cleared
+ (empty value removes it); the global entries round-trip to
+ `` in the store preview (including the
+ ``); and a context-level `resourceLink` (shown with its
+ `global`) and a `resource` whose type dispatches to the default
+ data-source factory (bound in the context's live environment, its
+ factory options editable as parameters, the pool size update re-binds
+ it, duplicate โ 409, removal unbinds it).
+
+ The browser E2E for this page (login, tree, property edit, add/remove
+ with confirm, save preview, no console errors) is driven over CDP and
+ is not part of `ant test`.
+
+Test-environment notes (discovered while implementing):
+
+- The programmatic test instance has no global `conf/web.xml` and
+ `setAddDefaultWebXmlToWebapp(false)` is set, so the test webapps must
+ declare their own `default`/`jsp` servlets and welcome files in
+ `web.xml`; `StandardContext.stop()` resets all wrappers and only
+ re-creates them from `web.xml` on start, which is what makes
+ stop/start/undeploy testable at all.
+- The test instance's default host has no `HostConfig`, so the
+ `Catalina:type=Deployer,host=...` MBean (the `Deployer` the deploy API
+ uses) is absent; the test attaches one as a host lifecycle listener.
+- `SimpleHttpClient` request parts must keep their CRLF terminators and the
+ client must re-`connect()` before every request (`Connection: Close`).
+- JNDI naming is disabled by default in the programmatic `Tomcat`, so the
+ users tests call `Tomcat.enableNaming()` before start; the test then
+ registers a `MemoryUserDatabase` on the server's global naming resources
+ exactly like the `` of the default `server.xml` does.
+- The `StringManager` cache is JVM-wide and the first creation for a
+ package wins; a class initialized by a non-request thread (e.g. the
+ filter initialization during context start) would otherwise cache a
+ manager that cannot see the web app's `LocalStrings` bundle. `Strings`
+ creates the manager with the web app's own class loader as the context
+ class loader, so the first creation always finds the bundle.
+- The programmatic `Tomcat` API installs a private internal realm
+ (`Tomcat$SimpleRealm`) on the engine that `storeconfig` cannot
+ serialise (`StoreAppender` instantiates the realm class via its public
+ no-arg constructor), and names the default service *and* engine
+ `Tomcat` rather than `Catalina`. `TestManager2Config` therefore swaps
+ in a `MemoryRealm` โ the same type the production `server.xml` uses โ
+ loaded from a minimal `conf/tomcat-users.xml` written into the test's
+ temporary `catalina.base` (a bare `MemoryRealm`, such as the one
+ `addService` creates for new services, requires that file to exist to
+ start), and resolves every node path from the returned tree instead of
+ hard-coding service/engine names.
+- `SimpleHttpClient` cannot read chunked responses: a response larger
+ than the connector's 8 KB buffer that has no content length is
+ committed mid-write and sent with `Transfer-Encoding: chunked`, which
+ the client then reads as raw framing. The manager2 API therefore
+ always sets the content length on its JSON responses (the body is
+ already built in memory), which the node-details test exercises
+ (the context node detail is well over 8 KB).
+- `org.apache.tomcat.util.json.JSONParser` (the shared request-body
+ parser) recognised the JSON escape sequences of a string token but
+ never resolved them, so any parsed string kept its backslashes
+ (`"a\"b"` parsed as `a\"b`). This was fixed in the parser (both the
+ generated class and the `.jjt` grammar): the string body is now
+ unescaped (`\"`, `\\`, `\/`, `\b`, `\f`, `\n`, `\r`, `\t`). The
+ configuration store-preview test is the first assertion that parses
+ a response whose value contains quotes (the stored `server.xml`),
+ and it failed until the fix.
+ - `storeconfig` parsed a `` (a JNDI `serviceRef` entry) but
+ could not store it back: `NamingResourcesSF` did not write the services
+ and the registry had no `` description. A two-line core
+ change (a `ServiceRef` registry description for `ContextService`, and
+ storing `findServices()` in `NamingResourcesSF.storeChildren`) closes
+ the round-trip, so a `serviceRef` added through the Configuration page
+ is written to `server.xml` like the other JNDI entries. The other six
+ entry types already round-tripped.
+
+Frontend: a manual smoke-test checklist in the docs (login, each page,
+deploy upload, live chart behaviour, mobile widths); the JS is small
+enough that a lint pass (`--check` via a CI node step, optional) plus the
+integration tests above gives adequate coverage without a JS test
+harness.
+
+Mobile checklist (portrait 360/390/414/820 px and landscape 667/812/932 px,
+both themes, plus mid-width windows at 901/1024 px): no page-level
+horizontal overflow; below 900 px management tables render
+as labelled stacked cards and row actions collapse into the kebab menu
+(kebab opens, closes on outside tap and `Esc`, disabled actions stay
+disabled); high-volume tables (logs, access log, workers) scroll
+horizontally with the first column pinned (log pages: never pinned, the
+whole table scrolls) and single-line rows below 1150 px, not squeezed; tabs scroll when crowded; page-head, log and diagnostics
+controls go full width; modals show stacked full-width buttons; toasts
+appear above the bottom nav; the bottom nav keeps all nine items as icons
+only (labels as `aria-label`, active item in its per-tab hue); inputs are
+16 px at โค480 px (no iOS
+focus zoom); the Configuration detail scrolls into view after a tree
+selection; a multi-segment deep link (e.g. an application detail) reloads
+to the correct page (the base-element fix above).
diff --git a/modules/manager2/resources/MANIFEST.MF b/modules/manager2/resources/MANIFEST.MF
new file mode 100644
index 000000000000..6dc136355c36
--- /dev/null
+++ b/modules/manager2/resources/MANIFEST.MF
@@ -0,0 +1,6 @@
+Manifest-Version: 1.0
+Bundle-Vendor: Apache Software Foundation
+Bundle-Version: @VERSION@
+Bundle-Name: Apache Tomcat Manager2
+Bundle-ManifestVersion: 2
+Bundle-SymbolicName: org.apache.tomcat.manager2
diff --git a/modules/manager2/src/main/java/org/apache/tomcat/manager2/AccessLogSupport.java b/modules/manager2/src/main/java/org/apache/tomcat/manager2/AccessLogSupport.java
new file mode 100644
index 000000000000..f0e4c82984f7
--- /dev/null
+++ b/modules/manager2/src/main/java/org/apache/tomcat/manager2/AccessLogSupport.java
@@ -0,0 +1,221 @@
+/*
+ * 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.
+ */
+package org.apache.tomcat.manager2;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+
+/**
+ * Shared helpers for access log records, independent of the format that produced them. The field names are the
+ * attribute names of {@code org.apache.catalina.valves.JsonAccessLogValve}, so that the pattern based and the JSON
+ * access log format expose the same fields.
+ */
+final class AccessLogSupport {
+
+
+ /**
+ * The directive to regular expression and field name mapping. The regular expressions are capturing groups; the
+ * character values that the valve writes for "not available" ({@code -}) are accepted by the numeric ones.
+ */
+ private static final Map DIRECTIVES;
+ static {
+ Map map = new HashMap<>();
+ map.put('a', new String[] { "(\\S+)", "remoteAddr" });
+ map.put('A', new String[] { "(\\S+)", "localAddr" });
+ map.put('b', new String[] { "(-?\\d+|-)", "size" });
+ map.put('B', new String[] { "(-?\\d+|-)", "byteSentNC" });
+ map.put('D', new String[] { "(\\d+)", "elapsedTime" });
+ map.put('F', new String[] { "(\\d+)", "firstByteTime" });
+ map.put('h', new String[] { "(\\S+)", "host" });
+ map.put('H', new String[] { "(\\S+)", "protocol" });
+ map.put('I', new String[] { "(\\S+)", "threadName" });
+ map.put('l', new String[] { "(\\S+)", "logicalUserName" });
+ map.put('m', new String[] { "(\\S+)", "method" });
+ map.put('p', new String[] { "(\\d+)", "port" });
+ map.put('q', new String[] { "(\\S*)", "query" });
+ map.put('r', new String[] { "([^\\\"]*)", "request" });
+ map.put('s', new String[] { "(\\d{3}|-)", "statusCode" });
+ map.put('S', new String[] { "(\\S+)", "sessionId" });
+ map.put('t', new String[] { "(\\[[^\\]]*\\])", "time" });
+ map.put('T', new String[] { "(\\d+(?:\\.\\d+)?)", "elapsedTimeS" });
+ map.put('u', new String[] { "(\\S+)", "user" });
+ map.put('U', new String[] { "(\\S+)", "path" });
+ map.put('v', new String[] { "(\\S+)", "localServerName" });
+ map.put('X', new String[] { "(\\S+)", "connectionStatus" });
+ DIRECTIVES = Collections.unmodifiableMap(map);
+ }
+
+
+ /**
+ * The field name prefix of the keyed directives ({@code %{name}x}).
+ */
+ private static final Map KEYED_PREFIXES;
+ static {
+ Map map = new HashMap<>();
+ map.put('a', "remoteAddr");
+ map.put('c', "cookie");
+ map.put('i', "header");
+ map.put('L', "identifier");
+ map.put('o', "responseHeader");
+ map.put('p', "port");
+ map.put('r', "requestAttribute");
+ map.put('s', "sessionAttribute");
+ map.put('t', "time");
+ KEYED_PREFIXES = Collections.unmodifiableMap(map);
+ }
+
+
+ private AccessLogSupport() {
+ // Utility class, do not instantiate
+ }
+
+
+ static Map directives() {
+ return DIRECTIVES;
+ }
+
+
+ /**
+ * The field name of a keyed directive or {@code null} if the directive is not supported.
+ */
+ static String keyedField(char directive, String key) {
+ String prefix = KEYED_PREFIXES.get(directive);
+ if (prefix == null) {
+ return null;
+ }
+ return prefix + "-" + key;
+ }
+
+
+ /**
+ * The ordered list of all field names a record can have: the fields of the capture groups plus, when the request
+ * line is logged but not the method, path, query or protocol individually, the fields derived from it (inserted
+ * directly after the request).
+ */
+ static List displayFields(List groupFields) {
+ List fields = new ArrayList<>(groupFields);
+ if (fields.contains("request")) {
+ boolean missing = !fields.contains("method") || !fields.contains("path") || !fields.contains("query") ||
+ !fields.contains("protocol");
+ if (missing) {
+ int at = fields.indexOf("request") + 1;
+ List derived = new ArrayList<>();
+ for (String name : new String[] { "method", "path", "query", "protocol" }) {
+ if (!fields.contains(name)) {
+ derived.add(name);
+ }
+ }
+ fields.addAll(at, derived);
+ }
+ }
+ return fields;
+ }
+
+
+ /**
+ * Normalize a parsed record: convert the common {@code -} marker to {@code null}, remove the square brackets of the
+ * time and convert the numeric fields to numbers.
+ */
+ static void normalize(Map record) {
+ Object time = record.get("time");
+ if (time instanceof String t && t.startsWith("[") && t.endsWith("]")) {
+ record.put("time", t.substring(1, t.length() - 1));
+ }
+ for (Map.Entry entry : record.entrySet()) {
+ if (entry.getValue() instanceof String s) {
+ if ("-".equals(s)) {
+ entry.setValue(null);
+ } else {
+ entry.setValue(numberOf(entry.getKey(), s));
+ }
+ }
+ }
+ }
+
+
+ /**
+ * Split the request line of a record into method, path, query and protocol when those fields are not present
+ * individually.
+ */
+ static void deriveFromRequest(Map record) {
+ if (!(record.get("request") instanceof String request) || record.containsKey("method")) {
+ return;
+ }
+ int i1 = request.indexOf(' ');
+ if (i1 <= 0) {
+ return;
+ }
+ String method = request.substring(0, i1);
+ int i2 = request.indexOf(' ', i1 + 1);
+ String target = i2 >= 0 ? request.substring(i1 + 1, i2) : request.substring(i1 + 1);
+ String protocol = i2 >= 0 && i2 + 1 < request.length() ? request.substring(i2 + 1) : null;
+ record.putIfAbsent("method", method);
+ int q = target.indexOf('?');
+ if (q >= 0) {
+ record.putIfAbsent("path", target.substring(0, q));
+ record.putIfAbsent("query", target.substring(q + 1));
+ } else {
+ record.putIfAbsent("path", target);
+ }
+ if (protocol != null) {
+ record.putIfAbsent("protocol", protocol);
+ }
+ }
+
+
+ private static Object numberOf(String key, String value) {
+ switch (key) {
+ case "statusCode": {
+ try {
+ return Integer.valueOf(value);
+ } catch (NumberFormatException e) {
+ return value;
+ }
+ }
+ case "port":
+ case "elapsedTime":
+ case "firstByteTime": {
+ try {
+ return Long.valueOf(value);
+ } catch (NumberFormatException e) {
+ return value;
+ }
+ }
+ case "size":
+ case "byteSentNC": {
+ try {
+ return Long.valueOf(value);
+ } catch (NumberFormatException e) {
+ return value;
+ }
+ }
+ case "elapsedTimeS": {
+ try {
+ return Double.valueOf(value);
+ } catch (NumberFormatException e) {
+ return value;
+ }
+ }
+ default:
+ return value;
+ }
+ }
+}
diff --git a/modules/manager2/src/main/java/org/apache/tomcat/manager2/Api.java b/modules/manager2/src/main/java/org/apache/tomcat/manager2/Api.java
new file mode 100644
index 000000000000..ff963ab3ce59
--- /dev/null
+++ b/modules/manager2/src/main/java/org/apache/tomcat/manager2/Api.java
@@ -0,0 +1,114 @@
+/*
+ * 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.
+ */
+package org.apache.tomcat.manager2;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import jakarta.servlet.http.HttpServletResponse;
+
+
+/**
+ * Shared helpers for writing the JSON responses of the Manager2 API.
+ */
+public final class Api {
+
+
+ /**
+ * Write an arbitrary JSON payload (a {@code Map} produced by the API layer).
+ *
+ * @param response the servlet response
+ * @param payload the JSON payload
+ *
+ * @throws IOException if a write error occurs
+ */
+ public static void json(HttpServletResponse response, Object payload) throws IOException {
+ response.setStatus(HttpServletResponse.SC_OK);
+ headers(response);
+ String body = Json.write(payload);
+ // Set the content length so that the response is never sent with
+ // chunked transfer encoding, which breaks simple HTTP clients.
+ response.setContentLength(body.getBytes(StandardCharsets.UTF_8).length);
+ response.getWriter().print(body);
+ }
+
+
+ /**
+ * Write a successful mutation result envelope.
+ *
+ * @param response the servlet response
+ * @param message the (localized) result message
+ *
+ * @throws IOException if a write error occurs
+ */
+ public static void ok(HttpServletResponse response, String message) throws IOException {
+ Map payload = new LinkedHashMap<>();
+ payload.put("ok", Boolean.TRUE);
+ payload.put("message", message);
+ json(response, payload);
+ }
+
+
+ /**
+ * Write an error envelope.
+ *
+ * @param response the servlet response
+ * @param status the HTTP status code
+ * @param code the machine readable error code
+ * @param message the (localized) error message
+ *
+ * @throws IOException if a write error occurs
+ */
+ public static void error(HttpServletResponse response, int status, String code, String message) throws IOException {
+ response.setStatus(status);
+ headers(response);
+ Map payload = new LinkedHashMap<>();
+ payload.put("ok", Boolean.FALSE);
+ payload.put("error", code);
+ payload.put("message", message);
+ String body = Json.write(payload);
+ response.setContentLength(body.getBytes(StandardCharsets.UTF_8).length);
+ response.getWriter().print(body);
+ }
+
+
+ /**
+ * Write a 404 error envelope.
+ *
+ * @param response the servlet response
+ *
+ * @throws IOException if a write error occurs
+ */
+ public static void notFound(HttpServletResponse response) throws IOException {
+ error(response, HttpServletResponse.SC_NOT_FOUND, "NOT_FOUND",
+ Strings.sm().getString("manager2.notFound"));
+ }
+
+
+ private static void headers(HttpServletResponse response) {
+ response.setContentType("application/json; charset=" + Constants.CHARSET);
+ response.setCharacterEncoding(Constants.CHARSET);
+ response.setHeader("Cache-Control", "no-store");
+ }
+
+
+ private Api() {
+ // Utility class, do not instantiate
+ }
+}
diff --git a/modules/manager2/src/main/java/org/apache/tomcat/manager2/AppsApiServlet.java b/modules/manager2/src/main/java/org/apache/tomcat/manager2/AppsApiServlet.java
new file mode 100644
index 000000000000..f41cd6f2917a
--- /dev/null
+++ b/modules/manager2/src/main/java/org/apache/tomcat/manager2/AppsApiServlet.java
@@ -0,0 +1,758 @@
+/*
+ * 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.
+ */
+package org.apache.tomcat.manager2;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.io.Serial;
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.servlet.http.HttpSession;
+import jakarta.servlet.http.Part;
+
+import org.apache.catalina.Context;
+import org.apache.catalina.Container;
+import org.apache.catalina.Session;
+import org.apache.catalina.manager.HTMLManagerServlet;
+import org.apache.catalina.manager.JspHelper;
+import org.apache.catalina.util.ContextName;
+import org.apache.tomcat.util.json.JSONParser;
+import org.apache.tomcat.util.res.StringManager;
+
+
+/**
+ * The Manager2 web application API. Delegates the actual operations to the inherited implementation from
+ * {@link HTMLManagerServlet} and {@link org.apache.catalina.manager.ManagerServlet}, and exposes them as a JSON API.
+ */
+public class AppsApiServlet extends HTMLManagerServlet {
+
+
+ @Serial
+ private static final long serialVersionUID = 1L;
+
+
+ @Override
+ public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
+ try {
+ doGetInternal(request, response);
+ } catch (IllegalArgumentException e) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH", e.getMessage());
+ }
+ }
+
+
+ private void doGetInternal(HttpServletRequest request, HttpServletResponse response) throws IOException {
+
+ String path = path(request);
+
+ if (path.equals("/api/apps")) {
+ Map payload = new LinkedHashMap<>();
+ payload.put("apps", apps());
+ Api.json(response, payload);
+ } else if (path.matches("/api/apps/.+/sessions")) {
+ handleSessionsList(request, response, contextName(request));
+ } else if (path.matches("/api/apps/.+/sessions/[^/]+")) {
+ handleSessionDetail(request, response, contextName(request));
+ } else if (path.equals("/api/ssl/ciphers")) {
+ Api.json(response, getConnectorCiphers(legacySm(request)));
+ } else if (path.equals("/api/ssl/certs")) {
+ Api.json(response, getConnectorCerts(legacySm(request)));
+ } else if (path.equals("/api/ssl/trusted")) {
+ Api.json(response, getConnectorTrustedCerts(legacySm(request)));
+ } else if (path.equals("/api/leaks")) {
+ StringWriter writer = new StringWriter();
+ try (PrintWriter pw = new PrintWriter(writer)) {
+ super.findleaks(false, pw, legacySm(request));
+ }
+ List leaks = new ArrayList<>();
+ for (String line : writer.toString().split("\\R")) {
+ if (!line.isEmpty()) {
+ leaks.add(line);
+ }
+ }
+ Map payload = new LinkedHashMap<>();
+ payload.put("leaks", leaks);
+ Api.json(response, payload);
+ } else if (path.equals("/api/resources")) {
+ StringWriter writer = new StringWriter();
+ try (PrintWriter pw = new PrintWriter(writer)) {
+ super.resources(pw, request.getParameter("type"), legacySm(request));
+ }
+ Map payload = new LinkedHashMap<>();
+ // The legacy resources() method writes a human readable status
+ // message as its first line (for example "OK - Listed global
+ // resources of all types") before the resource entries. That
+ // line is a presentation artifact of the classic manager's HTML
+ // page, not a resource, so it is dropped from the payload.
+ payload.put("resources", dropFirstLine(writer.toString()));
+ Api.json(response, payload);
+ } else if (path.equals("/api/diagnostics/vminfo")) {
+ StringWriter writer = new StringWriter();
+ try (PrintWriter pw = new PrintWriter(writer)) {
+ super.vmInfo(pw, legacySm(request), request.getLocales());
+ }
+ Map payload = new LinkedHashMap<>();
+ payload.put("info", writer.toString());
+ Api.json(response, payload);
+ } else if (path.equals("/api/diagnostics/threaddump")) {
+ StringWriter writer = new StringWriter();
+ try (PrintWriter pw = new PrintWriter(writer)) {
+ super.threadDump(pw, legacySm(request), request.getLocales());
+ }
+ Map payload = new LinkedHashMap<>();
+ payload.put("dump", writer.toString());
+ Api.json(response, payload);
+ } else {
+ Api.notFound(response);
+ }
+ }
+
+
+ @Override
+ public void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException {
+ try {
+ doPostInternal(request, response);
+ } catch (IllegalArgumentException e) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH", e.getMessage());
+ }
+ }
+
+
+ private void doPostInternal(HttpServletRequest request, HttpServletResponse response) throws IOException {
+
+ String path = path(request);
+
+ if (path.equals("/api/apps/deploy")) {
+ handleDeploy(request, response);
+ } else if (path.equals("/api/apps/upload")) {
+ handleUpload(request, response);
+ } else if (path.matches("/api/apps/.+/start")) {
+ handleLifecycle(request, response, contextName(request), "start");
+ } else if (path.matches("/api/apps/.+/stop")) {
+ handleLifecycle(request, response, contextName(request), "stop");
+ } else if (path.matches("/api/apps/.+/reload")) {
+ handleLifecycle(request, response, contextName(request), "reload");
+ } else if (path.matches("/api/apps/.+/expire")) {
+ handleExpire(request, response, contextName(request));
+ } else if (path.matches("/api/apps/.+/sessions/invalidate")) {
+ handleInvalidate(request, response, contextName(request));
+ } else if (path.equals("/api/ssl/reload")) {
+ handleSslReload(request, response);
+ } else {
+ Api.notFound(response);
+ }
+ }
+
+
+ @Override
+ public void doDelete(HttpServletRequest request, HttpServletResponse response) throws IOException {
+ try {
+ doDeleteInternal(request, response);
+ } catch (IllegalArgumentException e) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH", e.getMessage());
+ }
+ }
+
+
+ private void doDeleteInternal(HttpServletRequest request, HttpServletResponse response) throws IOException {
+
+ String path = path(request);
+
+ if (path.matches("/api/apps/.+/sessions/[^/]+/attributes/[^/]+")) {
+ handleRemoveAttribute(request, response, contextName(request));
+ } else if (path.matches("/api/apps/.+")) {
+ handleUndeploy(request, response, contextName(request));
+ } else {
+ Api.notFound(response);
+ }
+ }
+
+
+ // -------------------------------------------------------------- Actions
+
+
+ private List> apps() {
+ List> result = new ArrayList<>();
+ Container[] children = host.findChildren();
+ for (Container child : children) {
+ Context context = (Context) child;
+ Map app = new LinkedHashMap<>();
+ app.put("host", host.getName());
+ app.put("path", context.getPath());
+ app.put("displayName", context.getDisplayName());
+ app.put("version", context.getWebappVersion());
+ app.put("docBase", context.getDocBase());
+ app.put("available", Boolean.valueOf(context.getState().isAvailable()));
+ org.apache.catalina.Manager manager = context.getManager();
+ if (manager != null) {
+ app.put("sessions", Integer.valueOf(manager.getActiveSessions()));
+ app.put("sessionTimeout", Integer.valueOf(context.getSessionTimeout()));
+ } else {
+ app.put("sessions", 0);
+ app.put("sessionTimeout", null);
+ }
+ try {
+ app.put("deployed", Boolean.valueOf(isDeployed(context.getName())));
+ } catch (Exception e) {
+ app.put("deployed", Boolean.FALSE);
+ }
+ app.put("self", Boolean.valueOf(context.getName().equals(this.context.getName())));
+ result.add(app);
+ }
+ result.sort((a, b) -> String.valueOf(a.get("path")).compareTo(String.valueOf(b.get("path"))));
+ return result;
+ }
+
+
+ private void handleLifecycle(HttpServletRequest request, HttpServletResponse response, ContextName cn,
+ String action) throws IOException {
+ try {
+ if (cn == null) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH",
+ Strings.sm().getString("manager2.missingPath"));
+ return;
+ }
+ String message = invoke(pw -> {
+ switch (action) {
+ case "start" -> super.start(pw, cn, legacySm(request));
+ case "stop" -> super.stop(pw, cn, legacySm(request));
+ case "reload" -> super.reload(pw, cn, legacySm(request));
+ default -> {
+ }
+ }
+ });
+ sendResult(response, message);
+ } catch (IllegalArgumentException e) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH", e.getMessage());
+ }
+ }
+
+
+ private void handleUndeploy(HttpServletRequest request, HttpServletResponse response, ContextName cn)
+ throws IOException {
+ try {
+ if (cn == null) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH",
+ Strings.sm().getString("manager2.missingPath"));
+ return;
+ }
+ String message = invoke(pw -> super.undeploy(pw, cn, legacySm(request)));
+ sendResult(response, message);
+ } catch (IllegalArgumentException e) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH", e.getMessage());
+ }
+ }
+
+
+ private void handleExpire(HttpServletRequest request, HttpServletResponse response, ContextName cn)
+ throws IOException {
+ try {
+ if (cn == null) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH",
+ Strings.sm().getString("manager2.missingPath"));
+ return;
+ }
+ Map body = readJson(request);
+ int idle = -1;
+ Object idleValue = body.get("idle");
+ if (idleValue instanceof Number n) {
+ idle = n.intValue();
+ }
+ int idleFinal = idle;
+ String message = invoke(pw -> super.sessions(pw, cn, idleFinal, legacySm(request)));
+ sendResult(response, message);
+ } catch (IllegalArgumentException e) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH", e.getMessage());
+ }
+ }
+
+
+ private void handleDeploy(HttpServletRequest request, HttpServletResponse response) throws IOException {
+ try {
+ Map body = readJson(request);
+ StringManager smClient = legacySm(request);
+
+ String config = string(body.get("config"));
+ String war = string(body.get("war"));
+ boolean replace = booleanValue(body.get("replace"), false);
+
+ ContextName cn;
+ String pathValue = string(body.get("path"));
+ if (pathValue != null && !pathValue.isEmpty()) {
+ cn = new ContextName(decode(pathValue), string(body.get("version")));
+ } else if (config != null && !config.isEmpty()) {
+ cn = ContextName.extractFromPath(config);
+ } else if (war != null && !war.isEmpty()) {
+ cn = ContextName.extractFromPath(war);
+ } else {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH",
+ Strings.sm().getString("manager2.missingPath"));
+ return;
+ }
+
+ String message = invoke(pw -> super.deploy(pw, config, cn, war, replace, smClient));
+ sendResult(response, message);
+ } catch (IllegalArgumentException e) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_JSON", e.getMessage());
+ }
+ }
+
+
+ private void handleUpload(HttpServletRequest request, HttpServletResponse response) throws IOException {
+ StringManager smClient = legacySm(request);
+
+ try {
+ Part warPart = request.getPart("war");
+ if (warPart == null) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "UPLOAD_NO_FILE",
+ Strings.sm().getString("manager2.uploadNoFile"));
+ return;
+ }
+ String filename = warPart.getSubmittedFileName();
+ if (filename == null || !filename.toLowerCase(Locale.ENGLISH).endsWith(".war")) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "UPLOAD_NOT_WAR",
+ Strings.sm().getString("manager2.uploadNotWar", filename));
+ return;
+ }
+ int slash = Math.max(filename.lastIndexOf('/'), filename.lastIndexOf('\\'));
+ if (slash >= 0) {
+ filename = filename.substring(slash + 1);
+ }
+
+ String pathParam = request.getParameter("path");
+ ContextName cn;
+ if (pathParam != null && !pathParam.isEmpty()) {
+ cn = new ContextName(decode(pathParam), request.getParameter("version"));
+ } else {
+ cn = new ContextName(filename, true);
+ }
+
+ StringWriter validation = new StringWriter();
+ try (PrintWriter pw = new PrintWriter(validation)) {
+ if (!validateContextName(cn, pw, smClient)) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH",
+ validation.toString().trim());
+ return;
+ }
+ }
+
+ String name = cn.getName();
+ boolean replace = "true".equals(request.getParameter("replace"));
+ Context existing = (Context) host.findChild(name);
+ if (existing != null && !replace) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "ALREADY_DEPLOYED",
+ Strings.sm().getString("manager2.alreadyDeployed", cn.getDisplayName()));
+ return;
+ }
+
+ File appBase = host.getAppBaseFile();
+ File deployedWar = new File(appBase, cn.getBaseName() + ".war");
+ if (!pathCheck(deployedWar, appBase, response)) {
+ return;
+ }
+ File target = replace ? new File(deployedWar.getAbsolutePath() + ".tmp") : deployedWar;
+ if (!replace && target.exists()) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "WAR_EXISTS",
+ Strings.sm().getString("manager2.uploadWarExists", filename));
+ return;
+ }
+
+ if (tryAddServiced(name)) {
+ try {
+ warPart.write(target.getAbsolutePath());
+ if (replace) {
+ if (deployedWar.exists() && !deployedWar.delete()) {
+ Api.error(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "DELETE_FAILED",
+ Strings.sm().getString("manager2.uploadDeleteFailed", deployedWar));
+ return;
+ }
+ if (!target.renameTo(deployedWar)) {
+ Api.error(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "RENAME_FAILED",
+ Strings.sm().getString("manager2.uploadRenameFailed", target, deployedWar));
+ return;
+ }
+ }
+ } finally {
+ removeServiced(name);
+ }
+ check(name);
+ } else {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "IN_SERVICE",
+ Strings.sm().getString("manager2.contextInService", cn.getDisplayName()));
+ return;
+ }
+
+ Context deployed = (Context) host.findChild(name);
+ String message;
+ if (deployed != null && deployed.getConfigured() && deployed.getState().isAvailable()) {
+ message = Strings.sm().getString("manager2.deployed", cn.getDisplayName());
+ } else if (deployed != null && !deployed.getState().isAvailable()) {
+ message = Strings.sm().getString("manager2.deployedNotStarted", cn.getDisplayName());
+ } else {
+ message = Strings.sm().getString("manager2.deployFailed", cn.getDisplayName());
+ }
+ Api.ok(response, message);
+ } catch (IllegalArgumentException e) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_JSON", e.getMessage());
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.upload"), e);
+ Api.error(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "UPLOAD_FAILED",
+ Strings.sm().getString("manager2.uploadFailed", e.getMessage()));
+ }
+ }
+
+
+ private void handleSessionsList(HttpServletRequest request, HttpServletResponse response, ContextName cn)
+ throws IOException {
+ try {
+ if (cn == null) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH",
+ Strings.sm().getString("manager2.missingPath"));
+ return;
+ }
+ StringManager smClient = legacySm(request);
+ List sessions = getSessionsForName(cn, smClient);
+
+ String sortBy = request.getParameter("sort");
+ String orderBy = null;
+ if (sortBy != null && !sortBy.trim().isEmpty()) {
+ Comparator comparator = getComparator(sortBy);
+ if (comparator != null) {
+ boolean asc = !"DESC".equalsIgnoreCase(request.getParameter("order"));
+ if (!asc) {
+ comparator = Collections.reverseOrder(comparator);
+ }
+ try {
+ sessions.sort(comparator);
+ } catch (IllegalStateException ise) {
+ // At least one session was invalidated while sorting
+ }
+ orderBy = asc ? "ASC" : "DESC";
+ }
+ }
+
+ List> result = new ArrayList<>();
+ for (Session session : sessions) {
+ result.add(sessionToJson(session));
+ }
+ Map payload = new LinkedHashMap<>();
+ payload.put("path", cn.getPath());
+ payload.put("sort", sortBy);
+ payload.put("order", orderBy);
+ payload.put("sessions", result);
+ Api.json(response, payload);
+ } catch (IllegalArgumentException e) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH", e.getMessage());
+ }
+ }
+
+
+ private void handleSessionDetail(HttpServletRequest request, HttpServletResponse response, ContextName cn)
+ throws IOException {
+ try {
+ if (cn == null) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH",
+ Strings.sm().getString("manager2.missingPath"));
+ return;
+ }
+ String path = path(request);
+ int index = path.lastIndexOf("/sessions/");
+ if (index < 0) {
+ Api.notFound(response);
+ return;
+ }
+ String sessionId = path.substring(index + "/sessions/".length());
+
+ Session session = getSessionForNameAndId(cn, sessionId, legacySm(request));
+ if (session == null) {
+ Api.error(response, HttpServletResponse.SC_NOT_FOUND, "SESSION_NOT_FOUND",
+ Strings.sm().getString("manager2.sessionNotFound", sessionId));
+ return;
+ }
+ Map payload = sessionToJson(session);
+ payload.put("attributes", attributesToJson(session));
+ Api.json(response, payload);
+ } catch (IllegalArgumentException e) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH", e.getMessage());
+ }
+ }
+
+
+ private void handleInvalidate(HttpServletRequest request, HttpServletResponse response, ContextName cn)
+ throws IOException {
+ try {
+ if (cn == null) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH",
+ Strings.sm().getString("manager2.missingPath"));
+ return;
+ }
+ Map body = readJson(request);
+ List ids = new ArrayList<>();
+ if (body.get("ids") instanceof List list) {
+ for (Object item : list) {
+ ids.add(String.valueOf(item));
+ }
+ }
+ int count = invalidateSessions(cn, ids.toArray(new String[0]), legacySm(request));
+ Map payload = new LinkedHashMap<>();
+ payload.put("ok", Boolean.TRUE);
+ payload.put("count", Integer.valueOf(count));
+ payload.put("message", Strings.sm().getString("manager2.sessionsInvalidated", Integer.valueOf(count)));
+ Api.json(response, payload);
+ } catch (IllegalArgumentException e) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH", e.getMessage());
+ }
+ }
+
+
+ private void handleRemoveAttribute(HttpServletRequest request, HttpServletResponse response, ContextName cn)
+ throws IOException {
+ try {
+ if (cn == null) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH",
+ Strings.sm().getString("manager2.missingPath"));
+ return;
+ }
+ String path = path(request);
+ String attributesPrefix = "/attributes/";
+ int index = path.lastIndexOf(attributesPrefix);
+ if (index < 0) {
+ Api.notFound(response);
+ return;
+ }
+ String before = path.substring(0, index);
+ String sessionId = before.substring(before.lastIndexOf('/') + 1);
+ String attributeName = decode(path.substring(index + attributesPrefix.length()));
+
+ boolean removed = removeSessionAttribute(cn, sessionId, attributeName, legacySm(request));
+ if (removed) {
+ Api.ok(response, Strings.sm().getString("manager2.attributeRemoved", attributeName));
+ } else {
+ Api.error(response, HttpServletResponse.SC_NOT_FOUND, "ATTRIBUTE_NOT_FOUND",
+ Strings.sm().getString("manager2.attributeNotFound", attributeName));
+ }
+ } catch (IllegalArgumentException e) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH", e.getMessage());
+ }
+ }
+
+
+ private void handleSslReload(HttpServletRequest request, HttpServletResponse response) throws IOException {
+ try {
+ Map body = readJson(request);
+ String tlsHostName = string(body.get("tlsHostName"));
+ String message = invoke(pw -> super.sslReload(pw, tlsHostName, legacySm(request)));
+ sendResult(response, message);
+ } catch (IllegalArgumentException e) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_JSON", e.getMessage());
+ }
+ }
+
+
+ // ------------------------------------------------------------- Helpers
+
+
+ private Map sessionToJson(Session session) {
+ Map result = new LinkedHashMap<>();
+ result.put("id", session.getId());
+ result.put("creationTime", Long.valueOf(session.getCreationTime()));
+ result.put("lastAccessedTime", Long.valueOf(session.getLastAccessedTime()));
+ result.put("maxInactiveInterval", Integer.valueOf(session.getMaxInactiveInterval()));
+ HttpSession httpSession = session.getSession();
+ result.put("active", Boolean.valueOf(httpSession != null));
+ result.put("isNew", Boolean.valueOf(httpSession != null && httpSession.isNew()));
+ result.put("locale", JspHelper.guessDisplayLocaleFromSession(session));
+ result.put("user", JspHelper.guessDisplayUserFromSession(session));
+ return result;
+ }
+
+
+ private List> attributesToJson(Session session) {
+ List> result = new ArrayList<>();
+ HttpSession httpSession = session.getSession();
+ if (httpSession == null) {
+ return result;
+ }
+ for (String name : Collections.list(httpSession.getAttributeNames())) {
+ Object value = httpSession.getAttribute(name);
+ Map attribute = new LinkedHashMap<>();
+ attribute.put("name", name);
+ attribute.put("class", value != null ? value.getClass().getName() : null);
+ String text = value == null ? null : String.valueOf(value);
+ if (text != null && text.length() > 500) {
+ text = text.substring(0, 500) + "...";
+ }
+ attribute.put("value", text);
+ result.add(attribute);
+ }
+ result.sort((a, b) -> String.valueOf(a.get("name")).compareTo(String.valueOf(b.get("name"))));
+ return result;
+ }
+
+
+ private static String path(HttpServletRequest request) {
+ String path = request.getServletPath();
+ String info = request.getPathInfo();
+ if (info != null && !info.isEmpty()) {
+ path = path + info;
+ }
+ return path;
+ }
+
+
+ /**
+ * Decode the context from the request. The context path is taken from the {@code path} query parameter when present
+ * (which also supports context paths containing slashes), otherwise from the first path segment after
+ * {@code /api/apps}. Returns {@code null} when no path is present.
+ */
+ private ContextName contextName(HttpServletRequest request) {
+ String version = request.getParameter("version");
+ // The client always sends the (possibly empty) context path as the
+ // "path" query parameter. Note that getParameter() returns "" when
+ // the parameter is present with an empty value (ROOT context) and
+ // null when it is absent.
+ String pathParam = request.getParameter("path");
+ if (pathParam != null) {
+ return new ContextName(decode(pathParam), version);
+ }
+ String path = path(request);
+ String prefix = "/api/apps/";
+ if (!path.startsWith(prefix)) {
+ return null;
+ }
+ String rest = path.substring(prefix.length());
+ int slash = rest.indexOf('/');
+ String encoded = slash >= 0 ? rest.substring(0, slash) : rest;
+ if (encoded.isEmpty()) {
+ return null;
+ }
+ String decoded = decode(encoded);
+ if (decoded.equals("root")) {
+ // URL segment convention for the ROOT context
+ decoded = "";
+ }
+ return new ContextName(decoded, version);
+ }
+
+
+ private static String decode(String value) {
+ return URLDecoder.decode(value, StandardCharsets.UTF_8);
+ }
+
+
+ /**
+ * Everything after the first line of the given text (or an empty string when the text has at most one line).
+ */
+ private static String dropFirstLine(String text) {
+ int index = text.indexOf('\n');
+ return index < 0 ? "" : text.substring(index + 1);
+ }
+
+
+ private static String string(Object value) {
+ return value == null ? null : String.valueOf(value);
+ }
+
+
+ private static boolean booleanValue(Object value, boolean defaultValue) {
+ if (value instanceof Boolean b) {
+ return b;
+ }
+ if (value instanceof String s) {
+ return Boolean.parseBoolean(s);
+ }
+ return defaultValue;
+ }
+
+
+ private static Map readJson(HttpServletRequest request) throws IOException {
+ String body = new String(request.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
+ if (body.isBlank()) {
+ return new LinkedHashMap<>();
+ }
+ try {
+ return new JSONParser(body).parseObject();
+ } catch (Exception e) {
+ throw new IllegalArgumentException(Strings.sm().getString("manager2.invalidJson", e.getMessage()), e);
+ }
+ }
+
+
+ private String invoke(Operation operation) {
+ StringWriter stringWriter = new StringWriter();
+ try (PrintWriter writer = new PrintWriter(stringWriter)) {
+ operation.run(writer);
+ }
+ return stringWriter.toString().trim();
+ }
+
+
+ /**
+ * A StringManager for the legacy manager message bundle. All the inherited operations report their results using
+ * the {@code org.apache.catalina.manager} strings, so that bundle has to be used for localized output.
+ */
+ private static StringManager legacySm(HttpServletRequest request) {
+ return StringManager.getManager("org.apache.catalina.manager", request.getLocales());
+ }
+
+
+ /**
+ * Ensure the file is contained in the expected directory (canonical path containment, same check as the legacy
+ * manager servlets).
+ */
+ private static boolean pathCheck(File input, File expected, HttpServletResponse response) throws IOException {
+ try {
+ if (!input.getCanonicalFile().toPath().startsWith(expected.getCanonicalFile().toPath())) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "PATH_CHECK_FAILED",
+ Strings.sm().getString("manager2.pathCheckFail", input, expected));
+ return false;
+ }
+ } catch (IOException ioe) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "PATH_CHECK_ERROR",
+ Strings.sm().getString("manager2.pathCheckError", input, expected, ioe.getMessage()));
+ return false;
+ }
+ return true;
+ }
+
+
+ private void sendResult(HttpServletResponse response, String message) throws IOException {
+ if (message.startsWith("FAIL -")) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "OPERATION_FAILED", message);
+ } else {
+ Api.ok(response, message);
+ }
+ }
+
+
+ @FunctionalInterface
+ private interface Operation {
+ void run(PrintWriter writer);
+ }
+}
diff --git a/modules/manager2/src/main/java/org/apache/tomcat/manager2/ConfigApiServlet.java b/modules/manager2/src/main/java/org/apache/tomcat/manager2/ConfigApiServlet.java
new file mode 100644
index 000000000000..02628579216d
--- /dev/null
+++ b/modules/manager2/src/main/java/org/apache/tomcat/manager2/ConfigApiServlet.java
@@ -0,0 +1,5353 @@
+/*
+ * 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. See the License for the specific language governing
+ * permissions and limitations under the License.
+ *
+ * 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.
+ */
+package org.apache.tomcat.manager2;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.Serial;
+import java.io.StringWriter;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServlet;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+
+import org.apache.catalina.Cluster;
+import org.apache.catalina.Container;
+import org.apache.catalina.ContainerServlet;
+import org.apache.catalina.Context;
+import org.apache.catalina.Engine;
+import org.apache.catalina.Executor;
+import org.apache.catalina.Host;
+import org.apache.catalina.Lifecycle;
+import org.apache.catalina.LifecycleListener;
+import org.apache.catalina.Loader;
+import org.apache.catalina.Manager;
+import org.apache.catalina.Pipeline;
+import org.apache.catalina.Realm;
+import org.apache.catalina.Server;
+import org.apache.catalina.Service;
+import org.apache.catalina.SessionIdGenerator;
+import org.apache.catalina.Valve;
+import org.apache.catalina.WebResourceRoot;
+import org.apache.catalina.Wrapper;
+import org.apache.catalina.connector.Connector;
+import org.apache.catalina.core.StandardContext;
+import org.apache.catalina.core.StandardEngine;
+import org.apache.catalina.core.StandardHost;
+import org.apache.catalina.core.StandardServer;
+import org.apache.catalina.core.StandardService;
+import org.apache.catalina.core.StandardThreadExecutor;
+import org.apache.catalina.core.StandardWrapper;
+import org.apache.catalina.deploy.NamingResourcesImpl;
+import org.apache.catalina.ha.CatalinaCluster;
+import org.apache.catalina.ha.ClusterDeployer;
+import org.apache.catalina.ha.ClusterListener;
+import org.apache.catalina.ha.ClusterManager;
+import org.apache.catalina.ha.ClusterValve;
+import org.apache.catalina.ha.tcp.SimpleTcpCluster;
+import org.apache.catalina.loader.WebappLoader;
+import org.apache.catalina.realm.CombinedRealm;
+import org.apache.catalina.realm.MemoryRealm;
+import org.apache.catalina.realm.RealmBase;
+import org.apache.catalina.session.ManagerBase;
+import org.apache.catalina.startup.Bootstrap;
+import org.apache.catalina.startup.ContextConfig;
+import org.apache.catalina.startup.HostConfig;
+import org.apache.catalina.storeconfig.IStoreFactory;
+import org.apache.catalina.storeconfig.StandardContextSF;
+import org.apache.catalina.storeconfig.StoreConfig;
+import org.apache.catalina.storeconfig.StoreDescription;
+import org.apache.catalina.storeconfig.StoreFileMover;
+import org.apache.catalina.storeconfig.StoreLoader;
+import org.apache.catalina.storeconfig.XMLFormatPreserver;
+import org.apache.catalina.tribes.Channel;
+import org.apache.catalina.tribes.ChannelInterceptor;
+import org.apache.catalina.tribes.ChannelReceiver;
+import org.apache.catalina.tribes.ChannelSender;
+import org.apache.catalina.tribes.ManagedChannel;
+import org.apache.catalina.tribes.Member;
+import org.apache.catalina.tribes.MembershipService;
+import org.apache.catalina.tribes.group.GroupChannel;
+import org.apache.catalina.tribes.group.interceptors.MessageDispatchInterceptor;
+import org.apache.catalina.tribes.group.interceptors.StaticMembershipInterceptor;
+import org.apache.catalina.tribes.group.interceptors.TcpFailureDetector;
+import org.apache.catalina.tribes.membership.McastService;
+import org.apache.catalina.tribes.membership.StaticMember;
+import org.apache.catalina.tribes.membership.StaticMembershipService;
+import org.apache.catalina.tribes.transport.AbstractSender;
+import org.apache.catalina.tribes.transport.MultiPointSender;
+import org.apache.catalina.tribes.transport.ReceiverBase;
+import org.apache.catalina.tribes.transport.ReplicationTransmitter;
+import org.apache.catalina.util.ContextName;
+import org.apache.catalina.util.LifecycleBase;
+import org.apache.catalina.util.SessionIdGeneratorBase;
+import org.apache.coyote.AbstractProtocol;
+import org.apache.coyote.UpgradeProtocol;
+import org.apache.coyote.http11.AbstractHttp11Protocol;
+import org.apache.coyote.http2.Http2Protocol;
+import org.apache.tomcat.util.descriptor.web.ContextEjb;
+import org.apache.tomcat.util.descriptor.web.ContextEnvironment;
+import org.apache.tomcat.util.descriptor.web.ContextLocalEjb;
+import org.apache.tomcat.util.descriptor.web.ContextResource;
+import org.apache.tomcat.util.descriptor.web.ContextResourceEnvRef;
+import org.apache.tomcat.util.descriptor.web.ContextResourceLink;
+import org.apache.tomcat.util.descriptor.web.ContextService;
+import org.apache.tomcat.util.descriptor.web.ResourceBase;
+import org.apache.tomcat.util.http.CookieProcessor;
+import org.apache.tomcat.util.http.CookieProcessorBase;
+import org.apache.tomcat.util.json.JSONParser;
+import org.apache.tomcat.util.modeler.AttributeInfo;
+import org.apache.tomcat.util.modeler.ManagedBean;
+import org.apache.tomcat.util.modeler.Registry;
+import org.apache.tomcat.util.net.AbstractEndpoint;
+import org.apache.tomcat.util.net.SSLHostConfig;
+import org.apache.tomcat.util.net.SSLHostConfigCertificate;
+
+
+/**
+ * The Manager2 configuration API. Exposes the complete component tree of the Catalina {@code Server} (services,
+ * engines, hosts, contexts, wrappers, valves, connectors, executors, listeners, host aliases, realms, TLS host
+ * configurations, the upgrade protocols of a connector, the context sub components manager, session id generator,
+ * resources, loader and cookie processor, and the JNDI naming resources of the server and of the contexts), allows
+ * reading and updating the descriptor defined attributes of any component, adding and removing child components,
+ * starting, stopping and restarting any component that implements {@code Lifecycle}, and persisting the live state to
+ * {@code conf/server.xml} through the storeconfig mechanism.
+ *
+ * Changes are applied to the running server immediately. Persisting (store) rewrites {@code conf/server.xml} from the
+ * live state and keeps a timestamped backup of the previous file.
+ *
+ * Lifecycle operations. Not every change takes effect until the affected component is restarted (which
+ * attributes apply live is not documented), so the API offers explicit lifecycle operations: {@code start}, {@code
+ * stop} and {@code restart} (a stop followed by a start) for every component that implements {@code Lifecycle}. A
+ * {@code start} or {@code stop} of a component that would interrupt access to this web application (the server itself,
+ * the service, engine, host or context that route it, the connector that serves it and the wrappers of the context it
+ * runs in) is refused (403 {@code SELF_COMPONENT}): the request would lose its way back. A {@code restart} of such a
+ * component is still allowed: the client's connection may be interrupted during the operation, but the component is
+ * running again at the end and the client reconnects (re-logging in when the admin session was reset by the restart).
+ *
+ * Contexts keep their storage location when the configuration is persisted, mirroring regular StoreConfig
+ * behavior: a context that is backed by its own configuration file (its {@code META-INF/context.xml} or
+ * {@code conf/Catalina/.../context.xml}) is written back to that file, and a context defined inline in
+ * {@code server.xml} stays inline. A context restarts when its own file is (re)written, so a save that rewrites the
+ * file of this web application restarts the manager and resets the admin session; the UI warns about this before the
+ * save. The store preview is read-only: it reports the resulting {@code server.xml} and the external context files that
+ * would be rewritten, without touching the configuration on disk.
+ *
+ * Node addressing. Every node of the tree carries a path based {@code id} made of named segments (URL encoded,
+ * where a {@code /} inside a value - e.g. in a context path - is written as {@code +}) and, for components that have no
+ * name (valves, connectors, listeners), a positional index:
+ *
+ *
+ * server
+ * server/service/{name}
+ * server/service/{s}/engine/{name}
+ * server/service/{s}/engine/{e}/host/{name}
+ * server/service/{s}/engine/{e}/host/{h}/alias/{alias}
+ * server/service/{s}/engine/{e}/host/{h}/context/{path}
+ * server/service/{s}/engine/{e}/host/{h}/context/{p}/wrapper/{name}
+ * server/service/{s}/engine/{e}/host/{h}/context/{p}/valve/{index}
+ * server/service/{s}/engine/{e}/host/{h}/context/{p}/manager/0
+ * server/service/{s}/engine/{e}/host/{h}/context/{p}/manager/0/sessionIdGenerator/0
+ * server/service/{s}/engine/{e}/host/{h}/context/{p}/resources/0
+ * server/service/{s}/engine/{e}/host/{h}/context/{p}/loader/0
+ * server/service/{s}/engine/{e}/host/{h}/context/{p}/cookieProcessor/0
+ * server/service/{s}/engine/{e}/host/{h}/context/{p}/namingResources/0
+ * server/namingResources/0
+ * server/namingResources/0/resource/{name}
+ * server/namingResources/0/resourceLink/{name}
+ * server/namingResources/0/resourceEnvRef/{name}
+ * server/namingResources/0/environment/{name}
+ * server/namingResources/0/ejb/{name}
+ * server/namingResources/0/localEjb/{name}
+ * server/namingResources/0/serviceRef/{name}
+ * server/service/{s}/engine/{e}/host/{h}/context/{p}/namingResources/0/resource/{name}
+ * ...
+ * server/service/{s}/engine/{e}/host/{h}/valve/{index}
+ * server/service/{s}/engine/{e}/valve/{index}
+ * server/service/{s}/engine/{e}/listener/{index}
+ * server/service/{s}/connector/{index}
+ * server/service/{s}/connector/{i}/sslHostConfig/{hostName}
+ * server/service/{s}/connector/{i}/sslHostConfig/{h}/certificate/{index}
+ * server/service/{s}/connector/{i}/upgradeProtocol/{index}
+ * server/service/{s}/executor/{name}
+ * server/service/{s}/valve/{index}
+ * server/service/{s}/listener/{index}
+ * server/valve/{index}
+ * server/listener/{index}
+ *
+ *
+ * The tree endpoint generates these ids; clients only echo them back.
+ *
+ * Attributes. The property list of a node is derived from the modeler MBean descriptor of the component's class
+ * (the same contract that defines the {@code Catalina:*} MBeans). The TLS components ({@code SSLHostConfig} and
+ * {@code SSLHostConfigCertificate}), the context sub components ({@code WebappLoader}, {@code CookieProcessorBase}
+ * subclasses and {@code SessionIdGeneratorBase} subclasses), the HTTP/2 upgrade protocol
+ * ({@code org.apache.coyote.http2.Http2Protocol}) and the JNDI entry nodes have no (complete) modeler descriptor; their
+ * editable attribute list is defined explicitly by this servlet. Only attributes that map to a simple UI type (boolean,
+ * integral, string, string array) are editable; everything else is reported read-only.
+ *
+ * Context sub components. A running context always has exactly one manager, one resource root, one loader and
+ * one cookie processor (the defaults are created at context start). Adding one of these to a context therefore replaces
+ * the current instance with a new instance of the given class; the current instance is stopped first (where it has a
+ * lifecycle). These components are required by the context and cannot be removed - only replaced. Replacing the
+ * resources of a running context is refused (the context must be stopped first). The manager's session id generator is
+ * replaced the same way.
+ *
+ * TLS. Adding an {@code sslHostConfig} to a connector enables TLS on that connector. The TLS state of a running
+ * connector only takes effect when the connector is restarted, so the operations that change it (add or remove an
+ * {@code sslHostConfig}, add or remove a {@code certificate}) restart the affected connector and roll back the change
+ * if the restart fails (for example because the keystore does not exist or the password is wrong). The connector that
+ * hosts this web application itself is never touched.
+ *
+ * Upgrade protocols. A connector whose protocol handler is the HTTP/1.1 variant can carry upgrade protocols (the
+ * {@code UpgradeProtocol} interface; the only implementation shipped with Tomcat is the HTTP/2 one,
+ * {@code org.apache.coyote.http2.Http2Protocol}). An upgrade protocol is only referenced when the connector is
+ * initialised, so adding one does not change a running connector: it becomes active the next time the connector is
+ * (re)started (see the lifecycle operations). No live activation is attempted.
+ *
+ * JNDI naming resources. The server and every context have a {@code namingResources} node (a
+ * {@code NamingResourcesImpl}) that holds the JNDI entries: {@code resource}, {@code resourceLink},
+ * {@code resourceEnvRef}, {@code environment}, {@code ejb}, {@code localEjb} and {@code service}. A server level node
+ * does not accept {@code resourceLink} entries (they only exist in the context JNDI environment and are not parsed from
+ * {@code }). Adding and removing an entry updates the live JNDI environment of the server (the
+ * global context) or of the context ({@code java:comp/env}) immediately; the container's {@code NamingContextListener}
+ * performs the JNDI bind/unbind on the property change event. Updating an attribute of an existing entry does not fire
+ * such an event, so the update is implemented as a remove plus re-add of the entry (the change is rolled back if the
+ * re-add fails). The factory specific options of a {@code resource} (e.g. {@code url}, {@code driverClassName},
+ * {@code maxTotal}) are free form string parameters; for the first party JNDI {@code ObjectFactory} implementations
+ * shipped with Tomcat ({@code BasicDataSourceFactory}, {@code MemoryUserDatabaseFactory},
+ * {@code DataSourceUserDatabaseFactory} and the per user / shared pool data source factories) the parameters they
+ * actually consume are listed in the node's property set, with validation.
+ *
+ * Like the rest of the mutable API, this API requires the {@code manager-gui} role and, for the mutating methods, a
+ * valid CSRF token.
+ */
+public class ConfigApiServlet extends HttpServlet implements ContainerServlet {
+
+
+ @Serial
+ private static final long serialVersionUID = 1L;
+
+
+ /**
+ * A component name that may be used for new hosts, wrappers, executors and services (and that is accepted for
+ * engines).
+ */
+ private static final Pattern SAFE_NAME = Pattern.compile("[A-Za-z0-9._-]+");
+
+ /**
+ * The attribute types that can be edited through the API.
+ */
+ private static final Set EDITABLE_TYPES = Set.of("boolean", "int", "long", "short", "byte", "float",
+ "double", "java.lang.String", "[Ljava.lang.String;");
+
+ /**
+ * Attribute names whose update requires a type to confirm (renames and the like).
+ */
+ private static final Set RISKY_ATTRIBUTES = Set.of("name", "path", "defaultHost");
+
+ /**
+ * The cluster sub component types. They are excluded from the generic "accepts a lifecycle listener" flag: only the
+ * cluster itself (not its channel, manager, ...) accepts a {@code } in the cluster model, even when the
+ * sub component is itself a lifecycle.
+ */
+ private static final Set CLUSTER_SUB_TYPES = Set.of("channel", "membership", "sender", "receiver",
+ "transport", "interceptor", "deployer", "clusterManager", "clusterValve", "clusterListener", "member");
+
+ /**
+ * The maximum number of nested Realm levels, the same bound the XML parser applies to Realm elements
+ * (org.apache.catalina.startup.RealmRuleSet).
+ */
+ private static final int MAX_NESTED_REALM_LEVELS = 3;
+
+
+ private transient Wrapper wrapper = null;
+
+ private transient Context selfContext = null;
+
+ private transient Host selfHost = null;
+
+ private transient Server server = null;
+
+
+ // ------------------------------------------------ ContainerServlet API
+
+
+ @Override
+ public Wrapper getWrapper() {
+ return wrapper;
+ }
+
+
+ @Override
+ public void setWrapper(Wrapper wrapper) {
+ this.wrapper = wrapper;
+ if (wrapper == null) {
+ selfContext = null;
+ selfHost = null;
+ server = null;
+ } else {
+ selfContext = (Context) wrapper.getParent();
+ selfHost = (Host) selfContext.getParent();
+ Engine engine = (Engine) selfHost.getParent();
+ Service service = engine.getService();
+ server = (service != null) ? service.getServer() : null;
+ }
+ }
+
+
+ // ------------------------------------------------------------ Request API
+
+
+ @Override
+ protected void doGet(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ String path = path(request);
+
+ try {
+ requireServer();
+ if ("/api/config/tree".equals(path)) {
+ Map payload = new LinkedHashMap<>();
+ payload.put("tree", build(server, "server", "server"));
+ Api.json(response, payload);
+ } else if (path.startsWith("/api/config/node/")) {
+ NodeRef ref = resolve(path.substring("/api/config/node/".length()));
+ Api.json(response, node(ref));
+ } else if ("/api/config/store/preview".equals(path)) {
+ preview(response);
+ } else {
+ Api.notFound(response);
+ }
+ } catch (ConfigException e) {
+ Api.error(response, e.status, e.code, e.getMessage());
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.config"), e);
+ throw new ServletException(e);
+ }
+ }
+
+
+ @Override
+ protected void doPost(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ String path = path(request);
+ Map body = readJson(request);
+
+ try {
+ requireServer();
+ if ("/api/config/attribute".equals(path)) {
+ updateAttribute(response, body);
+ } else if ("/api/config/child".equals(path)) {
+ addChild(response, body);
+ } else if ("/api/config/store".equals(path)) {
+ store(response);
+ } else if ("/api/config/lifecycle".equals(path)) {
+ lifecycle(response, body);
+ } else {
+ Api.notFound(response);
+ }
+ } catch (ConfigException e) {
+ Api.error(response, e.status, e.code, e.getMessage());
+ } catch (IllegalArgumentException e) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_JSON", e.getMessage());
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.config"), e);
+ throw new ServletException(e);
+ }
+ }
+
+
+ @Override
+ protected void doDelete(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ String path = path(request);
+
+ try {
+ requireServer();
+ if ("/api/config/child".equals(path)) {
+ Map body = readJson(request);
+ removeChild(response, body);
+ } else {
+ Api.notFound(response);
+ }
+ } catch (ConfigException e) {
+ Api.error(response, e.status, e.code, e.getMessage());
+ } catch (IllegalArgumentException e) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_JSON", e.getMessage());
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.config"), e);
+ throw new ServletException(e);
+ }
+ }
+
+
+ // ------------------------------------------------------- Tree building
+
+
+ /**
+ * Build the tree entry of one component, including its children.
+ */
+ private Map build(Object component, String id, String type) {
+
+ Map node = new LinkedHashMap<>();
+ node.put("id", id);
+ node.put("type", type);
+ node.put("className", component.getClass().getName());
+ node.put("name", displayName(component, type));
+ if (component instanceof Lifecycle lifecycle) {
+ node.put("state", lifecycle.getState().toString());
+ }
+ if ("context".equals(type) && component == selfContext) {
+ node.put("self", Boolean.TRUE);
+ }
+ if ("namingResources".equals(type) && component instanceof NamingResourcesImpl namingResources) {
+ // The server level node (container is the Server) does not
+ // accept resourceLink entries; the client filters them out.
+ node.put("global", Boolean.valueOf(namingResources.getContainer() instanceof Server));
+ }
+
+ List> children = new ArrayList<>();
+ if (component instanceof StandardServer s) {
+ children.add(build(s.getGlobalNamingResources(), id + "/namingResources/0", "namingResources"));
+ for (Service service : s.findServices()) {
+ children.add(build(service, id + "/service/" + enc(service.getName()), "service"));
+ }
+ children.addAll(childrenOfListeners(s, id));
+ } else if (component instanceof StandardService service) {
+ Engine engine = service.getContainer();
+ if (engine != null) {
+ children.add(build(engine, id + "/engine/" + enc(engine.getName()), "engine"));
+ }
+ children.addAll(childrenOfConnectors(service, id));
+ children.addAll(childrenOfExecutors(service, id));
+ children.addAll(childrenOfListeners(service, id));
+ } else if (component instanceof StandardEngine engine) {
+ for (Container host : engine.findChildren()) {
+ if (host instanceof Host) {
+ children.add(build(host, id + "/host/" + enc(host.getName()), "host"));
+ }
+ }
+ children.addAll(childrenOfRealm(engine, id));
+ children.addAll(childrenOfCluster(engine, id));
+ children.addAll(childrenOfValves(engine, id));
+ children.addAll(childrenOfListeners(engine, id));
+ } else if (component instanceof Host host) {
+ for (String alias : host.findAliases()) {
+ Map entry = new LinkedHashMap<>();
+ entry.put("id", id + "/alias/" + enc(alias));
+ entry.put("type", "alias");
+ entry.put("className", String.class.getName());
+ entry.put("name", alias);
+ entry.put("children", new ArrayList>());
+ children.add(entry);
+ }
+ for (Container child : host.findChildren()) {
+ if (child instanceof Context context) {
+ children.add(build(context, id + "/context/" + encContextPath(context.getPath()), "context"));
+ }
+ }
+ children.addAll(childrenOfRealm(host, id));
+ children.addAll(childrenOfCluster(host, id));
+ children.addAll(childrenOfValves(host, id));
+ children.addAll(childrenOfListeners((LifecycleBase) host, id));
+ } else if (component instanceof Context context) {
+ for (Container child : context.findChildren()) {
+ if (child instanceof Wrapper wrapper) {
+ children.add(build(wrapper, id + "/wrapper/" + enc(wrapper.getName()), "wrapper"));
+ }
+ }
+ children.addAll(childrenOfRealm(context, id));
+ children.addAll(childrenOfCluster(context, id));
+ children.addAll(childrenOfContextComponents(context, id));
+ children.add(build(context.getNamingResources(), id + "/namingResources/0", "namingResources"));
+ children.addAll(childrenOfValves(context, id));
+ children.addAll(childrenOfListeners((LifecycleBase) context, id));
+ } else if (component instanceof Connector connector) {
+ children.addAll(sslHostConfigChildren(connector, id));
+ children.addAll(upgradeProtocolChildren(connector, id));
+ } else if (component instanceof SSLHostConfig sslHostConfig) {
+ children.addAll(certificateChildren(sslHostConfig, id));
+ } else if (component instanceof CatalinaCluster cluster) {
+ children.addAll(clusterChildren(cluster, id));
+ } else if (component instanceof Channel channel) {
+ if (channel instanceof ManagedChannel managed) {
+ children.addAll(channelChildren(managed, id));
+ }
+ } else if (component instanceof ChannelSender sender) {
+ children.addAll(senderChildren(sender, id));
+ } else if (component instanceof MembershipService membership) {
+ children.addAll(membershipChildren(membership, id));
+ } else if (component instanceof StaticMembershipInterceptor interceptor) {
+ children.addAll(interceptorChildren(interceptor, id));
+ } else if (component instanceof Realm realm) {
+ children.addAll(childrenOfSubRealms(realm, id));
+ } else if (component instanceof Manager manager) {
+ children.addAll(sessionIdGeneratorChildren(manager, id));
+ } else if (component instanceof NamingResourcesImpl namingResources) {
+ children.addAll(childrenOfNamingResources(namingResources, id));
+ }
+ node.put("children", children);
+ return node;
+ }
+
+
+ /**
+ * The tree entries of the TLS (SSL) host configurations of a connector, each with its certificate children.
+ */
+ private List> sslHostConfigChildren(Connector connector, String parentId) {
+ List> result = new ArrayList<>();
+ SSLHostConfig[] hostConfigs = connector.findSslHostConfigs();
+ if (hostConfigs == null || hostConfigs.length == 0) {
+ return result;
+ }
+ // The configurations are held in a hash map; sort them by host
+ // name so that the tree (and the order in which they are
+ // displayed) is stable across requests and restarts.
+ SSLHostConfig[] sorted = hostConfigs.clone();
+ Arrays.sort(sorted, (a, b) -> a.getHostName().compareTo(b.getHostName()));
+ for (SSLHostConfig hostConfig : sorted) {
+ Map entry = new LinkedHashMap<>();
+ String id = parentId + "/sslHostConfig/" + enc(hostConfig.getHostName());
+ entry.put("id", id);
+ entry.put("type", "sslHostConfig");
+ entry.put("className", hostConfig.getClass().getName());
+ entry.put("name", hostConfig.getHostName());
+ entry.put("children", certificateChildren(hostConfig, id));
+ result.add(entry);
+ }
+ return result;
+ }
+
+
+ /**
+ * The tree entries of the certificates of an SSL host configuration.
+ */
+ private List> certificateChildren(SSLHostConfig hostConfig, String parentId) {
+ List> result = new ArrayList<>();
+ SSLHostConfigCertificate[] certificates = hostConfig.getCertificates().toArray(new SSLHostConfigCertificate[0]);
+ for (int i = 0; i < certificates.length; i++) {
+ SSLHostConfigCertificate certificate = certificates[i];
+ Map entry = new LinkedHashMap<>();
+ entry.put("id", parentId + "/certificate/" + i);
+ entry.put("type", "certificate");
+ entry.put("className", certificate.getClass().getName());
+ entry.put("name", certificateLabel(certificate));
+ entry.put("children", new ArrayList>());
+ result.add(entry);
+ }
+ return result;
+ }
+
+
+ /**
+ * A human readable name for a certificate configuration: the certificate type, with the (typeless) default
+ * certificate shown as "default".
+ */
+ private static String certificateLabel(SSLHostConfigCertificate certificate) {
+ if (certificate.getType() == SSLHostConfigCertificate.Type.UNDEFINED) {
+ return "default";
+ }
+ return certificate.getType().name();
+ }
+
+
+ /**
+ * The tree entries of the upgrade protocols of a connector, addressed by a positional index in the order they were
+ * added.
+ */
+ private List> upgradeProtocolChildren(Connector connector, String parentId) {
+ List> result = new ArrayList<>();
+ UpgradeProtocol[] upgradeProtocols = connector.findUpgradeProtocols();
+ for (int i = 0; i < upgradeProtocols.length; i++) {
+ UpgradeProtocol upgradeProtocol = upgradeProtocols[i];
+ Map entry = new LinkedHashMap<>();
+ entry.put("id", parentId + "/upgradeProtocol/" + i);
+ entry.put("type", "upgradeProtocol");
+ entry.put("className", upgradeProtocol.getClass().getName());
+ entry.put("name", upgradeProtocolLabel(upgradeProtocol));
+ entry.put("children", new ArrayList>());
+ result.add(entry);
+ }
+ return result;
+ }
+
+
+ /**
+ * A human readable name for an upgrade protocol: the ALPN name (e.g. h2), then the HTTP upgrade name (e.g. h2c),
+ * then the simple name of the class.
+ */
+ private static String upgradeProtocolLabel(UpgradeProtocol upgradeProtocol) {
+ String label = upgradeProtocol.getAlpnName();
+ if (label == null || label.isEmpty()) {
+ label = upgradeProtocol.getHttpUpgradeName(false);
+ }
+ if (label == null || label.isEmpty()) {
+ label = upgradeProtocol.getHttpUpgradeName(true);
+ }
+ if (label == null || label.isEmpty()) {
+ label = upgradeProtocol.getClass().getSimpleName();
+ }
+ return label;
+ }
+
+
+ private List> childrenOfConnectors(StandardService service, String parentId) {
+ List> result = new ArrayList<>();
+ Connector[] connectors = service.findConnectors();
+ for (int i = 0; i < connectors.length; i++) {
+ Connector connector = connectors[i];
+ String id = parentId + "/connector/" + i;
+ Map entry = new LinkedHashMap<>();
+ entry.put("id", id);
+ entry.put("type", "connector");
+ entry.put("className", connector.getClass().getName());
+ entry.put("name", connectorLabel(connector));
+ entry.put("state", connector.getState().toString());
+ List> connectorChildren = sslHostConfigChildren(connector, id);
+ connectorChildren.addAll(upgradeProtocolChildren(connector, id));
+ entry.put("children", connectorChildren);
+ result.add(entry);
+ }
+ return result;
+ }
+
+
+ /**
+ * A human readable name for a connector: the configured protocol when known, otherwise the simple name of the
+ * protocol handler class.
+ */
+ private static String connectorLabel(Connector connector) {
+ String protocol = connector.getProtocol();
+ if (protocol == null || protocol.isEmpty()) {
+ String handler = connector.getProtocolHandlerClassName();
+ int separator = handler != null ? handler.lastIndexOf('.') : -1;
+ protocol = (separator >= 0) ? handler.substring(separator + 1) : "connector";
+ }
+ return protocol + " (port " + connector.getPort() + ")";
+ }
+
+
+ private List> childrenOfExecutors(StandardService service, String parentId) {
+ List> result = new ArrayList<>();
+ for (Executor executor : service.findExecutors()) {
+ Map entry = new LinkedHashMap<>();
+ entry.put("id", parentId + "/executor/" + enc(executor.getName()));
+ entry.put("type", "executor");
+ entry.put("className", executor.getClass().getName());
+ entry.put("name", executor.getName());
+ entry.put("state", executor.getState().toString());
+ entry.put("children", new ArrayList>());
+ result.add(entry);
+ }
+ return result;
+ }
+
+
+ private List> childrenOfValves(Container container, String parentId) {
+ List> result = new ArrayList<>();
+ Valve[] valves = container.getPipeline().getValves();
+ for (int i = 0; i < valves.length; i++) {
+ Valve valve = valves[i];
+ Map entry = new LinkedHashMap<>();
+ entry.put("id", parentId + "/valve/" + i);
+ entry.put("type", "valve");
+ entry.put("className", valve.getClass().getName());
+ entry.put("name", valve.getClass().getSimpleName());
+ entry.put("basic", Boolean.valueOf(i == 0));
+ entry.put("children", new ArrayList>());
+ result.add(entry);
+ }
+ return result;
+ }
+
+
+ private List> childrenOfListeners(LifecycleBase component, String parentId) {
+ List> result = new ArrayList<>();
+ LifecycleListener[] listeners = component.findLifecycleListeners();
+ for (int i = 0; i < listeners.length; i++) {
+ LifecycleListener listener = listeners[i];
+ Map entry = new LinkedHashMap<>();
+ entry.put("id", parentId + "/listener/" + i);
+ entry.put("type", "listener");
+ entry.put("className", listener.getClass().getName());
+ entry.put("name", listener.getClass().getSimpleName());
+ entry.put("children", new ArrayList>());
+ result.add(entry);
+ }
+ return result;
+ }
+
+
+ /**
+ * The realm directly attached to the container, or {@code null} when the container has none of its own.
+ * {@code getRealm()} falls back to the parent container's realm, so the fallback (the same comparison storeconfig
+ * uses) must be excluded.
+ */
+ private static Realm ownRealm(Container container) {
+ Realm realm = container.getRealm();
+ if (realm == null) {
+ return null;
+ }
+ Container parent = container.getParent();
+ if (parent != null && realm == parent.getRealm()) {
+ return null;
+ }
+ return realm;
+ }
+
+
+ /**
+ * The realm the container resolves to (via {@code getRealm()}) once its own realm has been detached.
+ */
+ private static Realm fallbackRealm(Container container) {
+ Container parent = container.getParent();
+ return parent != null ? parent.getRealm() : null;
+ }
+
+
+ /**
+ * The tree entry for the realm directly attached to the container, if it has one.
+ */
+ private List> childrenOfRealm(Container container, String parentId) {
+ List> result = new ArrayList<>();
+ Realm realm = ownRealm(container);
+ if (realm != null) {
+ result.add(realmEntry(realm, parentId + "/realm/0"));
+ }
+ return result;
+ }
+
+
+ /**
+ * The tree entries of the (sub) realms nested in the given realm. Only combined realms hold sub realms.
+ */
+ private List> childrenOfSubRealms(Realm realm, String parentId) {
+ List> result = new ArrayList<>();
+ if (!(realm instanceof CombinedRealm combined)) {
+ return result;
+ }
+ Realm[] nested = combined.getNestedRealms();
+ for (int i = 0; i < nested.length; i++) {
+ result.add(realmEntry(nested[i], parentId + "/realm/" + i));
+ }
+ return result;
+ }
+
+
+ private Map realmEntry(Realm realm, String id) {
+ Map entry = new LinkedHashMap<>();
+ entry.put("id", id);
+ entry.put("type", "realm");
+ entry.put("className", realm.getClass().getName());
+ entry.put("name", realm.getClass().getSimpleName());
+ if (realm instanceof Lifecycle lifecycle) {
+ entry.put("state", lifecycle.getState().toString());
+ }
+ entry.put("children", childrenOfSubRealms(realm, id));
+ return entry;
+ }
+
+
+ /**
+ * The tree entries of the sub components of a context (manager, resources, loader, cookie processor). A running
+ * context always has all of them (the defaults are created at context start), so they are always shown once the
+ * context has started.
+ */
+ private List> childrenOfContextComponents(Context context, String parentId) {
+ List> result = new ArrayList<>();
+ Manager manager = context.getManager();
+ if (manager != null) {
+ result.add(build(manager, parentId + "/manager/0", "manager"));
+ }
+ WebResourceRoot resources = context.getResources();
+ if (resources != null) {
+ result.add(build(resources, parentId + "/resources/0", "resources"));
+ }
+ Loader loader = context.getLoader();
+ if (loader != null) {
+ result.add(build(loader, parentId + "/loader/0", "loader"));
+ }
+ CookieProcessor cookieProcessor = context.getCookieProcessor();
+ if (cookieProcessor != null) {
+ result.add(build(cookieProcessor, parentId + "/cookieProcessor/0", "cookieProcessor"));
+ }
+ return result;
+ }
+
+
+ /**
+ * The tree entry of the session id generator of a manager, if it has one (a running manager always does; the
+ * manager creates a default one at start).
+ */
+ private List> sessionIdGeneratorChildren(Manager manager, String parentId) {
+ List> result = new ArrayList<>();
+ SessionIdGenerator generator = manager.getSessionIdGenerator();
+ if (generator != null) {
+ result.add(build(generator, parentId + "/sessionIdGenerator/0", "sessionIdGenerator"));
+ }
+ return result;
+ }
+
+
+ /**
+ * The tree entries of the JNDI entries of a {@code NamingResourcesImpl}, keyed by their JNDI names. A server level
+ * instance (container is the {@code Server}) does not expose resource links: they are only part of a context JNDI
+ * environment and are not parsed from {@code }.
+ */
+ private List> childrenOfNamingResources(NamingResourcesImpl namingResources, String parentId) {
+ List> result = new ArrayList<>();
+ boolean global = namingResources.getContainer() instanceof Server;
+ for (ContextResource resource : namingResources.findResources()) {
+ result.add(namingEntry(resource, "resource", parentId));
+ }
+ if (!global) {
+ for (ContextResourceLink link : namingResources.findResourceLinks()) {
+ result.add(namingEntry(link, "resourceLink", parentId));
+ }
+ }
+ for (ContextResourceEnvRef resourceEnvRef : namingResources.findResourceEnvRefs()) {
+ result.add(namingEntry(resourceEnvRef, "resourceEnvRef", parentId));
+ }
+ for (ContextEnvironment environment : namingResources.findEnvironments()) {
+ result.add(namingEntry(environment, "environment", parentId));
+ }
+ for (ContextEjb ejb : namingResources.findEjbs()) {
+ result.add(namingEntry(ejb, "ejb", parentId));
+ }
+ for (ContextLocalEjb localEjb : namingResources.findLocalEjbs()) {
+ result.add(namingEntry(localEjb, "localEjb", parentId));
+ }
+ for (ContextService service : namingResources.findServices()) {
+ result.add(namingEntry(service, "serviceRef", parentId));
+ }
+ return result;
+ }
+
+
+ private Map namingEntry(ResourceBase entry, String type, String parentId) {
+ Map node = new LinkedHashMap<>();
+ node.put("id", parentId + "/" + type + "/" + enc(entry.getName()));
+ node.put("type", type);
+ node.put("className", entry.getClass().getName());
+ node.put("name", entry.getName());
+ node.put("children", new ArrayList>());
+ return node;
+ }
+
+
+ // ------------------------------------------------------ Cluster children
+
+
+ /**
+ * The cluster directly attached to the container, or {@code null} when the container has none of its own.
+ * {@code getCluster()} falls back to the parent container's cluster, so the fallback (the same comparison
+ * storeconfig uses) must be excluded.
+ */
+ private static Cluster ownCluster(Container container) {
+ Cluster cluster = container.getCluster();
+ if (cluster == null) {
+ return null;
+ }
+ Container parent = container.getParent();
+ if (parent != null && cluster == parent.getCluster()) {
+ return null;
+ }
+ return cluster;
+ }
+
+
+ /**
+ * The tree entry for the cluster directly attached to the container, if it has one.
+ */
+ private List> childrenOfCluster(Container container, String parentId) {
+ List> result = new ArrayList<>();
+ Cluster cluster = ownCluster(container);
+ if (cluster != null) {
+ result.add(build(cluster, parentId + "/cluster/0", "cluster"));
+ }
+ return result;
+ }
+
+
+ /**
+ * The tree children of a cluster: channel, deployer, valves, manager template (SimpleTcpCluster), lifecycle
+ * listeners and cluster listeners.
+ */
+ private List> clusterChildren(CatalinaCluster cluster, String parentId) {
+ List> result = new ArrayList<>();
+ Channel channel = cluster.getChannel();
+ if (channel != null) {
+ result.add(build(channel, parentId + "/channel/0", "channel"));
+ }
+ ClusterDeployer deployer = cluster.getClusterDeployer();
+ if (deployer != null) {
+ result.add(build(deployer, parentId + "/deployer/0", "deployer"));
+ }
+ Valve[] valves = cluster.getValves();
+ for (int i = 0; i < valves.length; i++) {
+ result.add(build(valves[i], parentId + "/clusterValve/" + i, "clusterValve"));
+ }
+ if (cluster instanceof SimpleTcpCluster tcp) {
+ ClusterManager manager = tcp.getManagerTemplate();
+ if (manager != null) {
+ result.add(build(manager, parentId + "/clusterManager/0", "clusterManager"));
+ }
+ if (cluster instanceof LifecycleBase base) {
+ LifecycleListener[] listeners = base.findLifecycleListeners();
+ for (int i = 0; i < listeners.length; i++) {
+ result.add(build(listeners[i], parentId + "/listener/" + i, "listener"));
+ }
+ }
+ int idx = 0;
+ for (ClusterListener listener : tcp.findClusterListeners()) {
+ if (listener == deployer) {
+ // The deployer is already shown as its own child.
+ continue;
+ }
+ result.add(build(listener, parentId + "/clusterListener/" + idx, "clusterListener"));
+ idx++;
+ }
+ }
+ return result;
+ }
+
+
+ /**
+ * The tree children of a channel: membership, sender, receiver and the (user configured) interceptors.
+ */
+ private List> channelChildren(ManagedChannel channel, String parentId) {
+ List> result = new ArrayList<>();
+ MembershipService membership = channel.getMembershipService();
+ if (membership != null) {
+ result.add(build(membership, parentId + "/membership/0", "membership"));
+ }
+ ChannelSender sender = channel.getChannelSender();
+ if (sender != null) {
+ result.add(build(sender, parentId + "/sender/0", "sender"));
+ }
+ ChannelReceiver receiver = channel.getChannelReceiver();
+ if (receiver != null) {
+ result.add(build(receiver, parentId + "/receiver/0", "receiver"));
+ }
+ Iterator interceptors = channel.getInterceptors();
+ int i = 0;
+ while (interceptors.hasNext()) {
+ result.add(build(interceptors.next(), parentId + "/interceptor/" + i, "interceptor"));
+ i++;
+ }
+ return result;
+ }
+
+
+ /**
+ * The tree children of a channel sender: the transport (a replication transmitter holds one).
+ */
+ private List> senderChildren(ChannelSender sender, String parentId) {
+ List> result = new ArrayList<>();
+ if (sender instanceof ReplicationTransmitter transmitter) {
+ MultiPointSender transport = transmitter.getTransport();
+ if (transport != null) {
+ result.add(build(transport, parentId + "/transport/0", "transport"));
+ }
+ }
+ return result;
+ }
+
+
+ /**
+ * The tree children of a membership service: the static members when the service is a static membership service.
+ */
+ private List> membershipChildren(MembershipService membership, String parentId) {
+ List> result = new ArrayList<>();
+ if (membership instanceof StaticMembershipService sms) {
+ Member local = sms.getLocalMember(false);
+ if (local != null) {
+ result.add(build(local, parentId + "/localMember/0", "member"));
+ }
+ List members = sms.getStaticMembers();
+ for (int i = 0; i < members.size(); i++) {
+ result.add(build(members.get(i), parentId + "/member/" + i, "member"));
+ }
+ }
+ return result;
+ }
+
+
+ /**
+ * The tree children of an interceptor: the local member when the interceptor is a static membership interceptor.
+ */
+ private List> interceptorChildren(ChannelInterceptor interceptor, String parentId) {
+ List> result = new ArrayList<>();
+ if (interceptor instanceof StaticMembershipInterceptor smi) {
+ Member local = smi.getLocalMember(false);
+ if (local != null) {
+ result.add(build(local, parentId + "/localMember/0", "member"));
+ }
+ }
+ return result;
+ }
+
+
+ private static String memberLabel(Member member) {
+ byte[] hostBytes = member.getHost();
+ String host = hostBytes == null ? null : new String(hostBytes);
+ if (host == null || host.isEmpty()) {
+ return member.getName();
+ }
+ return host + ":" + member.getPort();
+ }
+
+
+ private static String displayName(Object component, String type) {
+ if (component instanceof Service s) {
+ return s.getName();
+ }
+ if (component instanceof Engine e) {
+ return e.getName();
+ }
+ if (component instanceof Host h) {
+ return h.getName();
+ }
+ if (component instanceof Context c) {
+ // The root context has the empty path; display it as "/".
+ String path = c.getPath();
+ return path.isEmpty() ? "/" : path;
+ }
+ if (component instanceof Wrapper w) {
+ return w.getName();
+ }
+ if (component instanceof Executor e) {
+ return e.getName();
+ }
+ if (component instanceof Connector connector) {
+ return connectorLabel(connector);
+ }
+ if (component instanceof SSLHostConfig hostConfig) {
+ return hostConfig.getHostName();
+ }
+ if (component instanceof SSLHostConfigCertificate certificate) {
+ return certificateLabel(certificate);
+ }
+ if (component instanceof UpgradeProtocol upgradeProtocol) {
+ return upgradeProtocolLabel(upgradeProtocol);
+ }
+ if (component instanceof ResourceBase entry) {
+ return entry.getName();
+ }
+ if (component instanceof Member member) {
+ return memberLabel(member);
+ }
+ return component.getClass().getSimpleName();
+ }
+
+
+ // --------------------------------------------------------- Node details
+
+
+ private Map node(NodeRef ref) throws ConfigException {
+
+ Object component = ref.component;
+
+ Map out = new LinkedHashMap<>();
+ out.put("id", ref.id);
+ out.put("type", ref.type);
+ out.put("name", ref.aliasValue != null ? ref.aliasValue : displayName(component, ref.type));
+ out.put("className", component.getClass().getName());
+ if (component instanceof Lifecycle lifecycle) {
+ out.put("state", lifecycle.getState().toString());
+ }
+ if ("context".equals(ref.type) && component == selfContext) {
+ out.put("self", Boolean.TRUE);
+ }
+ // Whether a lifecycle listener can be added to this component.
+ // Not derivable on the client for a listener node, whose class may
+ // or may not implement Lifecycle (e.g. a valve used as a listener).
+ // An alias is excluded: its component is the parent host (an alias
+ // is just a name, not a component that holds listeners).
+ out.put("acceptsListener",
+ !"alias".equals(ref.type) && !CLUSTER_SUB_TYPES.contains(ref.type) && component instanceof Lifecycle);
+ // Whether the component has a lifecycle (and therefore supports
+ // the start / stop / restart operations).
+ if (component instanceof Lifecycle) {
+ out.put("lifecycle", Boolean.TRUE);
+ // Whether a start or stop of the component would interrupt
+ // access to this web application (only a restart is allowed
+ // for it; the client reconnects at the end of the operation).
+ // Not derivable on the client for the service, the engine
+ // and the connector (which of them route the requests of
+ // this web application is a server-side decision).
+ if (affectsSelf(ref)) {
+ out.put("affectsSelf", Boolean.TRUE);
+ }
+ }
+
+ if ("connector".equals(ref.type) && component instanceof Connector connector) {
+ out.put("sslEnabled", isSslEnabled(connector));
+ }
+ if ("realm".equals(ref.type)) {
+ // Only combined realms can hold (sub) realms. Not derivable on
+ // the client from the class name alone (subclasses).
+ out.put("acceptsSubRealm", component instanceof CombinedRealm);
+ }
+ if ("namingResources".equals(ref.type) && component instanceof NamingResourcesImpl namingResources) {
+ // The server level node does not accept resourceLink entries.
+ out.put("global", Boolean.valueOf(namingResources.getContainer() instanceof Server));
+ }
+ if ("sslHostConfig".equals(ref.type) && component instanceof SSLHostConfig hostConfig) {
+ Connector owner = connectorOfSsl(hostConfig);
+ if (owner != null) {
+ try {
+ out.put("isDefault", Boolean
+ .valueOf(endpointOf(owner).getDefaultSSLHostConfigName().equals(hostConfig.getHostName())));
+ } catch (ConfigException e) {
+ // No endpoint: leave isDefault out.
+ }
+ }
+ }
+
+ List> properties = new ArrayList<>();
+ // Some components have no modeler descriptor; their attribute
+ // list is defined explicitly. They are handled before the
+ // descriptor branch because the registry falls back to an
+ // introspected ManagedBean for them, which would otherwise
+ // shadow the (more complete) explicit list.
+ ExplicitSpec explicit = explicitAttributes(component, ref.type);
+ if (!explicit.attributes().isEmpty()) {
+ // Factory options of a resource are localized per factory (the
+ // same parameter name may carry a different text depending on
+ // the factory that consumes it).
+ String paramScope = "resource".equals(ref.type) && component instanceof ContextResource resource
+ ? factoryKey(effectiveFactory(resource)) : null;
+ for (ExplicitAttribute attribute : explicit.attributes()) {
+ Map entry = new LinkedHashMap<>();
+ entry.put("name", attribute.getName());
+ entry.put("type", attribute.getType());
+ String description = attributeDescription(explicit.scope(), paramScope, attribute);
+ if (description != null) {
+ entry.put("description", description);
+ }
+ entry.put("writable", Boolean.valueOf(attribute.isWritable()));
+ if (attribute.isParam()) {
+ entry.put("param", Boolean.TRUE);
+ }
+ entry.put("value", jsonSafe(readExplicitValue(component, attribute)));
+ properties.add(entry);
+ }
+ } else {
+ ManagedBean descriptor = descriptor(component);
+ if (descriptor != null) {
+ for (AttributeInfo attribute : descriptor.getAttributes()) {
+ if (!attribute.isReadable()) {
+ continue;
+ }
+ Map entry = new LinkedHashMap<>();
+ entry.put("name", attribute.getName());
+ entry.put("type", attribute.getType());
+ // The bundle wins when it defines the attribute (the
+ // hook that lets the standard, descriptor-provided
+ // descriptions be localized); otherwise the descriptor
+ // text is used as-is.
+ String description = Strings.sm().getString("manager2.attr." + ref.type + "." + attribute.getName());
+ if (description == null) {
+ description = attribute.getDescription();
+ }
+ if (description != null) {
+ entry.put("description", description);
+ }
+ entry.put("writable",
+ Boolean.valueOf(attribute.isWriteable() && EDITABLE_TYPES.contains(attribute.getType())));
+ entry.put("value", jsonSafe(readValue(component, attribute)));
+ properties.add(entry);
+ }
+ }
+ }
+ if ("connector".equals(ref.type) && component instanceof Connector connector) {
+ Map entry = new LinkedHashMap<>();
+ entry.put("name", "sslEnabled");
+ entry.put("type", "boolean");
+ entry.put("writable", Boolean.FALSE);
+ entry.put("value", Boolean.valueOf(isSslEnabled(connector)));
+ properties.add(entry);
+ }
+ out.put("properties", properties);
+
+ // The direct children of this node (one level, no recursion)
+ Map built = build(component, ref.id, ref.type);
+ out.put("children", built.get("children"));
+ return out;
+ }
+
+
+ /**
+ * The modeler descriptor (MBean contract) of the component's class, or {@code null} for classes without a
+ * descriptor.
+ */
+ private static ManagedBean descriptor(Object component) {
+ return Registry.getRegistry(null).findManagedBean(component.getClass().getName());
+ }
+
+
+ private static AttributeInfo findAttribute(ManagedBean descriptor, String name) {
+ if (descriptor != null) {
+ for (AttributeInfo attribute : descriptor.getAttributes()) {
+ if (attribute.getName().equals(name)) {
+ return attribute;
+ }
+ }
+ }
+ return null;
+ }
+
+
+ private static Object readValue(Object component, AttributeInfo attribute) {
+ String method = attribute.getGetMethod();
+ if (method == null) {
+ method = ("boolean".equals(attribute.getType()) || attribute.isIs())
+ ? "is" + capitalize(attribute.getName())
+ : "get" + capitalize(attribute.getName());
+ }
+ try {
+ Method m = component.getClass().getMethod(method);
+ return m.invoke(component);
+ } catch (Exception e) {
+ return null;
+ }
+ }
+
+
+ // ------------------------------------- Explicit component attributes
+
+
+ /**
+ * One explicitly defined attribute of a component whose class has no modeler MBean descriptor (the TLS components
+ * {@code SSLHostConfig}/{@code SSLHostConfigCertificate} and the context sub components {@code WebappLoader},
+ * {@code CookieProcessorBase} and {@code SessionIdGeneratorBase}), defined here instead of being derived.
+ * Descriptions are not carried here: they are looked up from the message bundle by scope and attribute name (see
+ * {@link #attributeDescription}).
+ */
+ private static final class ExplicitAttribute {
+
+ private final String name;
+
+ private final String type;
+
+ private final boolean writable;
+
+ private final boolean param;
+
+
+ ExplicitAttribute(String name, String type, boolean writable) {
+ this(name, type, writable, false);
+ }
+
+
+ ExplicitAttribute(String name, String type, boolean writable, boolean param) {
+ this.name = name;
+ this.type = type;
+ this.writable = writable;
+ this.param = param;
+ }
+
+
+ String getName() {
+ return name;
+ }
+
+
+ String getType() {
+ return type;
+ }
+
+
+ boolean isWritable() {
+ return writable;
+ }
+
+
+ /**
+ * {@code true} for attributes that are not bean properties but string parameters of the generic property map of
+ * a JNDI entry (the {@code ResourceBase} properties).
+ */
+ boolean isParam() {
+ return param;
+ }
+ }
+
+
+ private static final List SSL_HOST_CONFIG_ATTRIBUTES = List.of(
+ new ExplicitAttribute("hostName", "java.lang.String", false),
+ new ExplicitAttribute("protocols", "java.lang.String", true),
+ new ExplicitAttribute("certificateVerification", "java.lang.String", true),
+ new ExplicitAttribute("certificateVerificationDepth", "int", true),
+ new ExplicitAttribute("ciphers", "java.lang.String", true),
+ new ExplicitAttribute("cipherSuites", "java.lang.String", true),
+ new ExplicitAttribute("honorCipherOrder", "boolean", true),
+ new ExplicitAttribute("sessionCacheSize", "int", true),
+ new ExplicitAttribute("sessionTimeout", "int", true),
+ new ExplicitAttribute("groups", "java.lang.String", true),
+ new ExplicitAttribute("keyManagerAlgorithm", "java.lang.String", true),
+ new ExplicitAttribute("sslProtocol", "java.lang.String", true),
+ new ExplicitAttribute("revocationEnabled", "boolean", true),
+ new ExplicitAttribute("trustManagerClassName", "java.lang.String", true),
+ new ExplicitAttribute("truststoreAlgorithm", "java.lang.String", true),
+ new ExplicitAttribute("truststoreFile", "java.lang.String", true),
+ new ExplicitAttribute("truststorePassword", "java.lang.String", true),
+ new ExplicitAttribute("truststoreProvider", "java.lang.String", true),
+ new ExplicitAttribute("truststoreType", "java.lang.String", true),
+ new ExplicitAttribute("caCertificateFile", "java.lang.String", true),
+ new ExplicitAttribute("caCertificatePath", "java.lang.String", true),
+ new ExplicitAttribute("certificateRevocationListPath", "java.lang.String", true),
+ new ExplicitAttribute("disableCompression", "boolean", true),
+ new ExplicitAttribute("disableSessionTickets", "boolean", true),
+ new ExplicitAttribute("insecureRenegotiation", "boolean", true));
+
+
+ private static final List CERTIFICATE_ATTRIBUTES = List.of(
+ new ExplicitAttribute("type", "java.lang.String", false),
+ new ExplicitAttribute("certificateKeystoreFile", "java.lang.String", true),
+ new ExplicitAttribute("certificateKeystorePassword", "java.lang.String", true),
+ new ExplicitAttribute("certificateKeystorePasswordFile", "java.lang.String", true),
+ new ExplicitAttribute("certificateKeystoreType", "java.lang.String", true),
+ new ExplicitAttribute("certificateKeystoreProvider", "java.lang.String", true),
+ new ExplicitAttribute("certificateKeyAlias", "java.lang.String", true),
+ new ExplicitAttribute("certificateKeyPassword", "java.lang.String", true),
+ new ExplicitAttribute("certificateKeyPasswordFile", "java.lang.String", true),
+ new ExplicitAttribute("certificateFile", "java.lang.String", true),
+ new ExplicitAttribute("certificateChainFile", "java.lang.String", true),
+ new ExplicitAttribute("certificateKeyFile", "java.lang.String", true));
+
+
+ private static final List WEBAPP_LOADER_ATTRIBUTES = List.of(
+ new ExplicitAttribute("delegate", "boolean", true),
+ new ExplicitAttribute("loaderClass", "java.lang.String", true),
+ new ExplicitAttribute("jakartaConverter", "java.lang.String", true));
+
+
+ private static final List COOKIE_PROCESSOR_ATTRIBUTES = List.of(
+ new ExplicitAttribute("cookiesWithoutEquals", "java.lang.String", true),
+ new ExplicitAttribute("sameSiteCookies", "java.lang.String", true),
+ new ExplicitAttribute("partitioned", "boolean", true));
+
+
+ private static final List SESSION_ID_GENERATOR_ATTRIBUTES = List.of(
+ new ExplicitAttribute("secureRandomClass", "java.lang.String", true),
+ new ExplicitAttribute("jvmRoute", "java.lang.String", true),
+ new ExplicitAttribute("sessionIdLength", "int", true));
+
+
+ // The HTTP/2 upgrade protocol has no modeler descriptor either. Only the
+ // common, documented knobs are listed (like the cluster channel
+ // components). All changes take effect when the owning connector is
+ // (re)started, the same as the protocol itself.
+ private static final List HTTP2_PROTOCOL_ATTRIBUTES = List.of(
+ new ExplicitAttribute("readTimeout", "long", true),
+ new ExplicitAttribute("writeTimeout", "long", true),
+ new ExplicitAttribute("keepAliveTimeout", "long", true),
+ new ExplicitAttribute("streamReadTimeout", "long", true),
+ new ExplicitAttribute("streamWriteTimeout", "long", true),
+ new ExplicitAttribute("maxConcurrentStreams", "long", true),
+ new ExplicitAttribute("maxConcurrentStreamExecution", "int", true),
+ new ExplicitAttribute("initialWindowSize", "int", true),
+ new ExplicitAttribute("useSendfile", "boolean", true),
+ new ExplicitAttribute("allowSchemeMismatch", "boolean", true),
+ new ExplicitAttribute("maxHeaderCount", "int", true),
+ new ExplicitAttribute("maxHeaderSize", "int", false),
+ new ExplicitAttribute("maxTrailerCount", "int", true),
+ new ExplicitAttribute("maxTrailerSize", "int", false),
+ new ExplicitAttribute("overheadCountFactor", "int", true),
+ new ExplicitAttribute("overheadResetFactor", "int", true),
+ new ExplicitAttribute("overheadContinuationThreshold", "int", true),
+ new ExplicitAttribute("overheadDataThreshold", "int", true),
+ new ExplicitAttribute("overheadWindowUpdateThreshold", "int", true),
+ new ExplicitAttribute("initiatePingDisabled", "boolean", true),
+ new ExplicitAttribute("discardRequestsAndResponses", "boolean", true),
+ new ExplicitAttribute("drainTimeout", "long", true));
+
+
+ // --------------------------------- Cluster channel attributes
+
+ // The sub components of a cluster channel (GroupChannel, the multicast
+ // membership service, the receiver, the sender transport and the
+ // interceptors) have no modeler descriptors, so their attributes are
+ // defined explicitly. Only the common, documented knobs are listed.
+
+ private static final List CHANNEL_ATTRIBUTES = List.of(
+ new ExplicitAttribute("name", "java.lang.String", true),
+ new ExplicitAttribute("heartbeat", "boolean", true),
+ new ExplicitAttribute("heartbeatSleeptime", "long", true),
+ new ExplicitAttribute("jmxDomain", "java.lang.String", true),
+ new ExplicitAttribute("jmxPrefix", "java.lang.String", true),
+ new ExplicitAttribute("optionCheck", "boolean", true));
+
+ private static final List MCAST_ATTRIBUTES = List.of(
+ new ExplicitAttribute("address", "java.lang.String", true),
+ new ExplicitAttribute("port", "int", true),
+ new ExplicitAttribute("frequency", "long", true),
+ new ExplicitAttribute("dropTime", "long", true),
+ new ExplicitAttribute("ttl", "int", true),
+ new ExplicitAttribute("soTimeout", "int", true),
+ new ExplicitAttribute("recoveryEnabled", "boolean", true),
+ new ExplicitAttribute("recoverySleepTime", "long", true),
+ new ExplicitAttribute("localLoopbackDisabled", "boolean", true));
+
+ private static final List RECEIVER_ATTRIBUTES = List.of(
+ new ExplicitAttribute("port", "int", true),
+ new ExplicitAttribute("autoBind", "int", true),
+ new ExplicitAttribute("address", "java.lang.String", true),
+ new ExplicitAttribute("udpPort", "int", true),
+ new ExplicitAttribute("maxThreads", "int", true),
+ new ExplicitAttribute("minThreads", "int", true),
+ new ExplicitAttribute("selectorTimeout", "long", true),
+ new ExplicitAttribute("tcpNoDelay", "boolean", true),
+ new ExplicitAttribute("soKeepAlive", "boolean", true),
+ new ExplicitAttribute("soReuseAddress", "boolean", true));
+
+ private static final List TRANSPORT_ATTRIBUTES = List.of(
+ new ExplicitAttribute("poolSize", "int", true),
+ new ExplicitAttribute("timeout", "long", true),
+ new ExplicitAttribute("maxRetryAttempts", "int", true),
+ new ExplicitAttribute("udpPort", "int", true),
+ new ExplicitAttribute("directBuffer", "boolean", true),
+ new ExplicitAttribute("tcpNoDelay", "boolean", true),
+ new ExplicitAttribute("soKeepAlive", "boolean", true),
+ new ExplicitAttribute("soReuseAddress", "boolean", true));
+
+ private static final List MESSAGE_DISPATCH_INTERCEPTOR_ATTRIBUTES = List.of(
+ new ExplicitAttribute("maxQueueSize", "long", true),
+ new ExplicitAttribute("maxThreads", "int", true),
+ new ExplicitAttribute("maxSpareThreads", "int", true),
+ new ExplicitAttribute("keepAliveTime", "long", true),
+ new ExplicitAttribute("useDeepClone", "boolean", true),
+ new ExplicitAttribute("alwaysSend", "boolean", true));
+
+ private static final List TCP_FAILURE_DETECTOR_ATTRIBUTES = List.of(
+ new ExplicitAttribute("connectTimeout", "long", true),
+ new ExplicitAttribute("readTestTimeout", "long", true),
+ new ExplicitAttribute("performSendTest", "boolean", true),
+ new ExplicitAttribute("performReadTest", "boolean", true),
+ new ExplicitAttribute("removeSuspectsTimeout", "int", true));
+
+ private static final List INTERCEPTOR_ATTRIBUTES = List.of(new ExplicitAttribute("optionFlag", "int", true));
+
+
+ // ------------------------------------------------- JNDI entry attributes
+
+ // The JNDI entry types (children of a namingResources node).
+
+ private static final List RESOURCE_ATTRIBUTES = List.of(
+ new ExplicitAttribute("name", "java.lang.String", true),
+ new ExplicitAttribute("type", "java.lang.String", true),
+ new ExplicitAttribute("auth", "java.lang.String", true),
+ new ExplicitAttribute("scope", "java.lang.String", true),
+ new ExplicitAttribute("singleton", "boolean", true),
+ new ExplicitAttribute("closeMethod", "java.lang.String", true),
+ new ExplicitAttribute("lookupName", "java.lang.String", true),
+ new ExplicitAttribute("description", "java.lang.String", true));
+
+ private static final List RESOURCE_LINK_ATTRIBUTES = List.of(
+ new ExplicitAttribute("name", "java.lang.String", true),
+ new ExplicitAttribute("type", "java.lang.String", true),
+ new ExplicitAttribute("global", "java.lang.String", true),
+ new ExplicitAttribute("factory", "java.lang.String", true),
+ new ExplicitAttribute("description", "java.lang.String", true));
+
+ private static final List RESOURCE_ENV_REF_ATTRIBUTES = List.of(
+ new ExplicitAttribute("name", "java.lang.String", true),
+ new ExplicitAttribute("type", "java.lang.String", true),
+ new ExplicitAttribute("override", "boolean", true),
+ new ExplicitAttribute("description", "java.lang.String", true));
+
+ private static final List ENVIRONMENT_ATTRIBUTES = List.of(
+ new ExplicitAttribute("name", "java.lang.String", true),
+ new ExplicitAttribute("type", "java.lang.String", true),
+ new ExplicitAttribute("value", "java.lang.String", true),
+ new ExplicitAttribute("override", "boolean", true),
+ new ExplicitAttribute("description", "java.lang.String", true));
+
+ private static final List EJB_ATTRIBUTES = List.of(
+ new ExplicitAttribute("name", "java.lang.String", true),
+ new ExplicitAttribute("type", "java.lang.String", true),
+ new ExplicitAttribute("home", "java.lang.String", true),
+ new ExplicitAttribute("link", "java.lang.String", true),
+ new ExplicitAttribute("remote", "java.lang.String", true),
+ new ExplicitAttribute("description", "java.lang.String", true));
+
+ private static final List LOCAL_EJB_ATTRIBUTES = List.of(
+ new ExplicitAttribute("name", "java.lang.String", true),
+ new ExplicitAttribute("type", "java.lang.String", true),
+ new ExplicitAttribute("local", "java.lang.String", true),
+ new ExplicitAttribute("home", "java.lang.String", true),
+ new ExplicitAttribute("link", "java.lang.String", true),
+ new ExplicitAttribute("description", "java.lang.String", true));
+
+ private static final List SERVICE_ATTRIBUTES = List.of(
+ new ExplicitAttribute("name", "java.lang.String", true),
+ new ExplicitAttribute("type", "java.lang.String", true),
+ new ExplicitAttribute("interface", "java.lang.String", true),
+ new ExplicitAttribute("displayname", "java.lang.String", true),
+ new ExplicitAttribute("wsdlfile", "java.lang.String", true),
+ new ExplicitAttribute("description", "java.lang.String", true));
+
+ // The first party JNDI ObjectFactory implementations shipped with
+ // Tomcat and the string parameters (RefAddr keys) each one consumes.
+
+ private static final String BASIC_DATA_SOURCE_FACTORY = "org.apache.tomcat.dbcp.dbcp2.BasicDataSourceFactory";
+
+ private static final String MEMORY_USER_DATABASE_FACTORY = "org.apache.catalina.users.MemoryUserDatabaseFactory";
+
+ private static final String DATA_SOURCE_USER_DATABASE_FACTORY = "org.apache.catalina.users.DataSourceUserDatabaseFactory";
+
+ private static final String PER_USER_POOL_DATA_SOURCE_FACTORY = "org.apache.tomcat.dbcp.dbcp2.datasources.PerUserPoolDataSourceFactory";
+
+ private static final String SHARED_POOL_DATA_SOURCE_FACTORY = "org.apache.tomcat.dbcp.dbcp2.datasources.SharedPoolDataSourceFactory";
+
+ private static final List BASIC_DATA_SOURCE_FACTORY_OPTIONS = List.of(
+ option("defaultAutoCommit", "boolean"),
+ option("defaultReadOnly", "boolean"),
+ option("defaultTransactionIsolation", "java.lang.String"),
+ option("defaultCatalog", "java.lang.String"),
+ option("defaultSchema", "java.lang.String"),
+ option("cacheState", "boolean"),
+ option("driverClassName", "java.lang.String"),
+ option("lifo", "boolean"),
+ option("maxTotal", "int"),
+ option("maxIdle", "int"),
+ option("minIdle", "int"),
+ option("initialSize", "int"),
+ option("maxWaitMillis", "long"),
+ option("testOnCreate", "boolean"),
+ option("testOnBorrow", "boolean"),
+ option("testOnReturn", "boolean"),
+ option("timeBetweenEvictionRunsMillis", "long"),
+ option("numTestsPerEvictionRun", "int"),
+ option("minEvictableIdleTimeMillis", "long"),
+ option("softMinEvictableIdleTimeMillis", "long"),
+ option("evictionPolicyClassName", "java.lang.String"),
+ option("testWhileIdle", "boolean"),
+ option("password", "java.lang.String"),
+ option("url", "java.lang.String"),
+ option("username", "java.lang.String"),
+ option("validationQuery", "java.lang.String"),
+ option("validationQueryTimeout", "long"),
+ option("connectionInitSqls", "java.lang.String"),
+ option("accessToUnderlyingConnectionAllowed", "boolean"),
+ option("removeAbandonedOnBorrow", "boolean"),
+ option("removeAbandonedOnMaintenance", "boolean"),
+ option("removeAbandonedTimeout", "long"),
+ option("logAbandoned", "boolean"),
+ option("abandonedUsageTracking", "java.lang.String"),
+ option("poolPreparedStatements", "boolean"),
+ option("clearStatementPoolOnReturn", "boolean"),
+ option("maxOpenPreparedStatements", "int"),
+ option("connectionProperties", "java.lang.String"),
+ option("maxConnLifetimeMillis", "long"),
+ option("logExpiredConnections", "boolean"),
+ option("rollbackOnReturn", "boolean"),
+ option("enableAutoCommitOnReturn", "boolean"),
+ option("defaultQueryTimeout", "long"),
+ option("fastFailValidation", "boolean"),
+ option("disconnectionSqlCodes", "java.lang.String"),
+ option("disconnectionIgnoreSqlCodes", "java.lang.String"),
+ option("jmxName", "java.lang.String"),
+ option("registerConnectionMBean", "boolean"),
+ option("connectionFactoryClassName", "java.lang.String"));
+
+ private static final List MEMORY_USER_DATABASE_FACTORY_OPTIONS = List.of(
+ option("pathname", "java.lang.String"),
+ option("readonly", "boolean"),
+ option("watchSource", "boolean"));
+
+ private static final List DATA_SOURCE_USER_DATABASE_FACTORY_OPTIONS = List.of(
+ option("dataSourceName", "java.lang.String"),
+ option("readonly", "boolean"),
+ option("userTable", "java.lang.String"),
+ option("groupTable", "java.lang.String"),
+ option("roleTable", "java.lang.String"),
+ option("userRoleTable", "java.lang.String"),
+ option("userGroupTable", "java.lang.String"),
+ option("groupRoleTable", "java.lang.String"),
+ option("roleNameCol", "java.lang.String"),
+ option("roleAndGroupDescriptionCol", "java.lang.String"),
+ option("groupNameCol", "java.lang.String"),
+ option("userCredCol", "java.lang.String"),
+ option("userFullNameCol", "java.lang.String"),
+ option("userNameCol", "java.lang.String"));
+
+ private static final List POOL_DATA_SOURCE_FACTORY_OPTIONS = List.of(
+ option("instanceKey", "java.lang.String"),
+ option("description", "java.lang.String"),
+ option("loginTimeout", "int"),
+ option("blockWhenExhausted", "boolean"),
+ option("evictionPolicyClassName", "java.lang.String"),
+ option("lifo", "boolean"),
+ option("maxIdlePerKey", "int"),
+ option("maxTotalPerKey", "int"),
+ option("maxWaitMillis", "long"),
+ option("minEvictableIdleTimeMillis", "long"),
+ option("minIdlePerKey", "int"),
+ option("numTestsPerEvictionRun", "int"),
+ option("softMinEvictableIdleTimeMillis", "long"),
+ option("testOnCreate", "boolean"),
+ option("testOnBorrow", "boolean"),
+ option("testOnReturn", "boolean"),
+ option("testWhileIdle", "boolean"),
+ option("timeBetweenEvictionRunsMillis", "long"),
+ option("validationQuery", "java.lang.String"),
+ option("validationQueryTimeout", "int"),
+ option("rollbackAfterValidation", "boolean"),
+ option("maxConnLifetimeMillis", "long"),
+ option("defaultAutoCommit", "boolean"),
+ option("defaultTransactionIsolation", "int"),
+ option("defaultReadOnly", "boolean"));
+
+ private static final List PER_USER_POOL_DATA_SOURCE_FACTORY_OPTIONS = poolOptions(
+ option("defaultMaxTotal", "int"),
+ option("defaultMaxIdle", "int"),
+ option("defaultMaxWaitMillis", "long"));
+
+ private static final List SHARED_POOL_DATA_SOURCE_FACTORY_OPTIONS = poolOptions(
+ option("maxTotal", "int"));
+
+ private static List poolOptions(ExplicitAttribute... first) {
+ List result = new ArrayList<>(Arrays.asList(first));
+ result.addAll(POOL_DATA_SOURCE_FACTORY_OPTIONS);
+ return List.copyOf(result);
+ }
+
+ private static ExplicitAttribute option(String name, String type) {
+ return new ExplicitAttribute(name, type, true, true);
+ }
+
+
+ /**
+ * The factory options (RefAddr keys) of the given first party JNDI factory, or {@code null} when the factory is not
+ * one of the factories shipped with Tomcat (their parameters stay free form).
+ */
+ private static List factoryOptions(String factory) {
+ if (factory == null) {
+ return null;
+ }
+ return switch (factory) {
+ case BASIC_DATA_SOURCE_FACTORY -> BASIC_DATA_SOURCE_FACTORY_OPTIONS;
+ case MEMORY_USER_DATABASE_FACTORY -> MEMORY_USER_DATABASE_FACTORY_OPTIONS;
+ case DATA_SOURCE_USER_DATABASE_FACTORY -> DATA_SOURCE_USER_DATABASE_FACTORY_OPTIONS;
+ case PER_USER_POOL_DATA_SOURCE_FACTORY -> PER_USER_POOL_DATA_SOURCE_FACTORY_OPTIONS;
+ case SHARED_POOL_DATA_SOURCE_FACTORY -> SHARED_POOL_DATA_SOURCE_FACTORY_OPTIONS;
+ default -> null;
+ };
+ }
+
+
+ /**
+ * The factory a resource resolves to: the explicit {@code factory} parameter, or the default factory the
+ * {@code ResourceFactory} dispatches the resource type to.
+ */
+ private static String effectiveFactory(ContextResource resource) {
+ Object factory = resource.getProperty("factory");
+ if (factory != null && !String.valueOf(factory).isEmpty()) {
+ return String.valueOf(factory);
+ }
+ // Default dispatch of org.apache.naming.factory.ResourceFactory.
+ if ("javax.sql.DataSource".equals(resource.getType())) {
+ return BASIC_DATA_SOURCE_FACTORY;
+ }
+ return null;
+ }
+
+
+ private static boolean isNamingEntry(String type) {
+ return "resource".equals(type) || "resourceLink".equals(type) || "resourceEnvRef".equals(type) ||
+ "environment".equals(type) || "ejb".equals(type) || "localEjb".equals(type) ||
+ "serviceRef".equals(type);
+ }
+
+
+ /**
+ * The attribute list of one JNDI entry: the core attributes of the entry type, plus - for a resource whose factory
+ * is one of the first party factories with a closed set of parameters - the factory options, plus the free form
+ * parameters that are set but not covered by the list.
+ */
+ private static List namingEntryAttributes(Object component, String type) {
+ List result;
+ if ("resource".equals(type)) {
+ ContextResource resource = (ContextResource) component;
+ result = new ArrayList<>(RESOURCE_ATTRIBUTES);
+ List options = factoryOptions(effectiveFactory(resource));
+ if (options != null) {
+ result.addAll(options);
+ }
+ } else {
+ result = new ArrayList<>(switch (type) {
+ case "resourceLink" -> RESOURCE_LINK_ATTRIBUTES;
+ case "resourceEnvRef" -> RESOURCE_ENV_REF_ATTRIBUTES;
+ case "environment" -> ENVIRONMENT_ATTRIBUTES;
+ case "ejb" -> EJB_ATTRIBUTES;
+ case "localEjb" -> LOCAL_EJB_ATTRIBUTES;
+ case "serviceRef" -> SERVICE_ATTRIBUTES;
+ default -> List.of();
+ });
+ }
+ // The string parameters of the entry (the ResourceBase properties)
+ // that are not covered by the explicit attribute tables above.
+ appendParams((ResourceBase) component, result);
+ return result;
+ }
+
+
+ /**
+ * Append the string parameters of the given JNDI entry that are not already part of its explicit attribute list.
+ */
+ private static void appendParams(ResourceBase entry, List result) {
+ Set covered = new HashSet<>();
+ for (ExplicitAttribute attribute : result) {
+ covered.add(attribute.getName());
+ }
+ for (Iterator it = entry.listProperties(); it.hasNext();) {
+ String key = it.next();
+ if (covered.add(key)) {
+ result.add(new ExplicitAttribute(key, "java.lang.String", true, true));
+ }
+ }
+ }
+
+
+ /**
+ * The explicitly defined attributes of the given component, or an empty list when the component's class has a
+ * modeler descriptor (or is not one of the explicitly supported classes).
+ */
+ private static ExplicitSpec explicitAttributes(Object component, String type) {
+ if ("sslHostConfig".equals(type)) {
+ return new ExplicitSpec("sslHostConfig", SSL_HOST_CONFIG_ATTRIBUTES);
+ }
+ if ("certificate".equals(type)) {
+ return new ExplicitSpec("certificate", CERTIFICATE_ATTRIBUTES);
+ }
+ if (component instanceof WebappLoader) {
+ return new ExplicitSpec("loader", WEBAPP_LOADER_ATTRIBUTES);
+ }
+ if (component instanceof CookieProcessorBase) {
+ return new ExplicitSpec("cookieProcessor", COOKIE_PROCESSOR_ATTRIBUTES);
+ }
+ if (component instanceof SessionIdGeneratorBase) {
+ return new ExplicitSpec("sessionIdGenerator", SESSION_ID_GENERATOR_ATTRIBUTES);
+ }
+ if (component instanceof Http2Protocol) {
+ return new ExplicitSpec("http2Protocol", HTTP2_PROTOCOL_ATTRIBUTES);
+ }
+ if (component instanceof GroupChannel) {
+ return new ExplicitSpec("channel", CHANNEL_ATTRIBUTES);
+ }
+ if (component instanceof McastService) {
+ return new ExplicitSpec("membership", MCAST_ATTRIBUTES);
+ }
+ if (component instanceof ReceiverBase) {
+ return new ExplicitSpec("receiver", RECEIVER_ATTRIBUTES);
+ }
+ if (component instanceof AbstractSender) {
+ return new ExplicitSpec("transport", TRANSPORT_ATTRIBUTES);
+ }
+ if (component instanceof MessageDispatchInterceptor) {
+ return new ExplicitSpec("messageDispatchInterceptor", MESSAGE_DISPATCH_INTERCEPTOR_ATTRIBUTES);
+ }
+ if (component instanceof TcpFailureDetector) {
+ return new ExplicitSpec("tcpFailureDetector", TCP_FAILURE_DETECTOR_ATTRIBUTES);
+ }
+ if (component instanceof ChannelInterceptor) {
+ return new ExplicitSpec("channelInterceptor", INTERCEPTOR_ATTRIBUTES);
+ }
+ if (isNamingEntry(type) && component instanceof ResourceBase) {
+ return new ExplicitSpec(type, namingEntryAttributes(component, type));
+ }
+ return new ExplicitSpec(type, List.of());
+ }
+
+
+ /**
+ * The explicit attribute list of a component together with the key scope its descriptions are looked up under
+ * (see {@link #attributeDescription}).
+ */
+ private record ExplicitSpec(String scope, List attributes) {
+ }
+
+
+ /**
+ * The localized description of one explicitly defined attribute, looked up from the message bundle by its
+ * {@code name}: {@code manager2.attr..} for a bean attribute; for a string parameter,
+ * {@code manager2.param..} first (a factory with a closed parameter set may give the name its
+ * own text) and then {@code manager2.param.}.
+ *
+ * @param scope the key scope of the attribute list the attribute belongs to
+ * @param paramScope the factory key scope for the parameters of a resource bound to a first party factory, or
+ * {@code null}
+ * @param attribute the attribute
+ *
+ * @return the localized description, or {@code null} when the bundle defines no message for the attribute
+ */
+ private static String attributeDescription(String scope, String paramScope, ExplicitAttribute attribute) {
+ var sm = Strings.sm();
+ if (attribute.isParam()) {
+ if (paramScope != null) {
+ String scoped = sm.getString("manager2.param." + paramScope + "." + attribute.getName());
+ if (scoped != null) {
+ return scoped;
+ }
+ }
+ return sm.getString("manager2.param." + attribute.getName());
+ }
+ return sm.getString("manager2.attr." + scope + "." + attribute.getName());
+ }
+
+
+ /**
+ * The bundle key scope of the parameters of a first party JNDI factory (see
+ * {@link #attributeDescription(String, String, ExplicitAttribute)}).
+ *
+ * @param factory the factory class name, possibly {@code null}
+ *
+ * @return the key scope of the factory, or {@code null} for a factory that is not shipped with Tomcat
+ */
+ private static String factoryKey(String factory) {
+ if (factory == null) {
+ return null;
+ }
+ return switch (factory) {
+ case BASIC_DATA_SOURCE_FACTORY -> "basicDataSource";
+ case MEMORY_USER_DATABASE_FACTORY -> "memoryUserDatabase";
+ case DATA_SOURCE_USER_DATABASE_FACTORY -> "dataSourceUserDatabase";
+ case PER_USER_POOL_DATA_SOURCE_FACTORY -> "perUserPoolDataSource";
+ case SHARED_POOL_DATA_SOURCE_FACTORY -> "sharedPoolDataSource";
+ default -> null;
+ };
+ }
+
+
+ private static ExplicitAttribute findExplicitAttribute(Object component, String type, String name) {
+ for (ExplicitAttribute attribute : explicitAttributes(component, type).attributes()) {
+ if (attribute.getName().equals(name)) {
+ return attribute;
+ }
+ }
+ return null;
+ }
+
+
+ /**
+ * Read the value of one explicitly defined attribute. A few attributes need a dedicated reader: the protocol set is
+ * shown as the {@code +} separated list that {@code setProtocols} accepts, and the certificate verification level
+ * as its string form.
+ */
+ private static Object readExplicitValue(Object component, ExplicitAttribute attribute) {
+ String name = attribute.getName();
+ if (attribute.isParam()) {
+ Object value = ((ResourceBase) component).getProperty(name);
+ return value == null ? null : String.valueOf(value);
+ }
+ try {
+ if ("protocols".equals(name) && component instanceof SSLHostConfig hostConfig) {
+ StringBuilder protocols = new StringBuilder();
+ for (String protocol : hostConfig.getProtocols()) {
+ if (!protocols.isEmpty()) {
+ protocols.append('+');
+ }
+ protocols.append(protocol);
+ }
+ return protocols.toString();
+ }
+ if ("certificateVerification".equals(name) && component instanceof SSLHostConfig hostConfig) {
+ return hostConfig.getCertificateVerificationAsString();
+ }
+ try {
+ return component.getClass().getMethod("get" + capitalize(name)).invoke(component);
+ } catch (NoSuchMethodException nsm) {
+ return component.getClass().getMethod("is" + capitalize(name)).invoke(component);
+ }
+ } catch (Exception e) {
+ return null;
+ }
+ }
+
+
+ private static void setExplicitValue(Object component, ExplicitAttribute attribute, Object value)
+ throws ConfigException {
+ if (attribute.isParam()) {
+ // A string parameter of the generic property map of a JNDI
+ // entry; an empty value removes the parameter.
+ ResourceBase base = (ResourceBase) component;
+ if (value == null || (value instanceof String s && s.isEmpty())) {
+ base.removeProperty(attribute.getName());
+ } else {
+ base.setProperty(attribute.getName(), String.valueOf(value));
+ }
+ return;
+ }
+ String method = "set" + capitalize(attribute.getName());
+ try {
+ Method m = component.getClass().getMethod(method, classForType(attribute.getType()));
+ m.invoke(component, value);
+ } catch (NoSuchMethodException e) {
+ throw new ConfigException(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "NO_SETTER",
+ Strings.sm().getString("manager2.configNoSetter", method));
+ } catch (InvocationTargetException e) {
+ Throwable t = e.getTargetException();
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "SET_FAILED",
+ Strings.sm().getString("manager2.configSetFailed", attribute.getName(),
+ t.getMessage() == null ? t.getClass().getSimpleName() : t.getMessage()));
+ } catch (IllegalAccessException e) {
+ throw new ConfigException(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "NO_SETTER",
+ Strings.sm().getString("manager2.configNoSetter", method));
+ }
+ }
+
+
+ /**
+ * Convert an arbitrary component value to a JSON safe representation (null, String, Number, Boolean, List or Map).
+ */
+ private static Object jsonSafe(Object value) {
+ if (value == null) {
+ return null;
+ }
+ if (value instanceof String || value instanceof Boolean) {
+ return value;
+ }
+ if (value instanceof Number && !(value instanceof Double d && (d.isNaN() || d.isInfinite()))) {
+ return value;
+ }
+ if (value instanceof String[] array) {
+ return List.of(array);
+ }
+ if (value instanceof Object[] array) {
+ List list = new ArrayList<>(array.length);
+ for (Object item : array) {
+ list.add(String.valueOf(item));
+ }
+ return list;
+ }
+ if (value instanceof Map map) {
+ Map result = new LinkedHashMap<>();
+ for (Map.Entry e : map.entrySet()) {
+ result.put(String.valueOf(e.getKey()), String.valueOf(e.getValue()));
+ }
+ return result;
+ }
+ if (value instanceof Double d && (d.isNaN() || d.isInfinite())) {
+ return String.valueOf(value);
+ }
+ return String.valueOf(value);
+ }
+
+
+ // ---------------------------------------------------------- Resolving
+
+
+ /**
+ * A resolved tree node: the component, its parent (if it has one), the node type and, for alias nodes, the alias
+ * value.
+ */
+ private static final class NodeRef {
+
+ private final Object component;
+ private final Object parent;
+ private final String type;
+ private final String aliasValue;
+ private final String id;
+
+
+ NodeRef(Object component, Object parent, String type, String aliasValue, String id) {
+ this.component = component;
+ this.parent = parent;
+ this.type = type;
+ this.aliasValue = aliasValue;
+ this.id = id;
+ }
+ }
+
+
+ /**
+ * Resolve a node id (see the class javadoc for the grammar) to a component.
+ */
+ private NodeRef resolve(String id) throws ConfigException {
+
+ if (id == null || id.isEmpty()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_ID",
+ Strings.sm().getString("manager2.configInvalidId"));
+ }
+
+ String[] segments = id.split("/", -1);
+ if (!"server".equals(segments[0])) {
+ throw new ConfigException(HttpServletResponse.SC_NOT_FOUND, "NOT_FOUND",
+ Strings.sm().getString("manager2.configNotFound"));
+ }
+
+ Object current = server;
+ Object parent = null;
+ String type = "server";
+
+ for (int i = 1; i < segments.length; i += 2) {
+ if (i + 1 >= segments.length) {
+ throw new ConfigException(HttpServletResponse.SC_NOT_FOUND, "NOT_FOUND",
+ Strings.sm().getString("manager2.configNotFound"));
+ }
+ String kind = segments[i];
+ String value = dec(segments[i + 1]);
+
+ switch (kind) {
+ case "service" -> {
+ Service service = server.findService(value);
+ if (service == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = service;
+ }
+ case "engine" -> {
+ if (!(current instanceof StandardService service) ||
+ !(service.getContainer() instanceof Engine engine)) {
+ throw notFound();
+ }
+ parent = current;
+ current = engine;
+ }
+ case "host" -> {
+ if (!(current instanceof StandardEngine engine) ||
+ !(engine.findChild(value) instanceof Host host)) {
+ throw notFound();
+ }
+ parent = current;
+ current = host;
+ }
+ case "context" -> {
+ // The root context is registered under the empty name,
+ // not "/", so map the bare "+" segment accordingly.
+ String contextName = "+".equals(segments[i + 1]) ? "" : value;
+ if (!(current instanceof Host host) || !(host.findChild(contextName) instanceof Context context)) {
+ throw notFound();
+ }
+ parent = current;
+ current = context;
+ }
+ case "wrapper" -> {
+ if (!(current instanceof Context context) ||
+ !(context.findChild(value) instanceof Wrapper wrapper)) {
+ throw notFound();
+ }
+ parent = current;
+ current = wrapper;
+ }
+ case "alias" -> {
+ if (!(current instanceof Host host)) {
+ throw notFound();
+ }
+ if (!Arrays.asList(host.findAliases()).contains(value)) {
+ throw notFound();
+ }
+ return new NodeRef(host, host, "alias", value, id);
+ }
+ case "valve" -> {
+ if (!(current instanceof Container container)) {
+ throw notFound();
+ }
+ Valve[] valves = container.getPipeline().getValves();
+ int index = index(value);
+ if (index < 0 || index >= valves.length) {
+ throw notFound();
+ }
+ parent = current;
+ current = valves[index];
+ }
+ case "connector" -> {
+ if (!(current instanceof StandardService service)) {
+ throw notFound();
+ }
+ Connector[] connectors = service.findConnectors();
+ int idx = index(value);
+ if (idx < 0 || idx >= connectors.length) {
+ throw notFound();
+ }
+ parent = current;
+ current = connectors[idx];
+ }
+ case "executor" -> {
+ if (!(current instanceof StandardService service)) {
+ throw notFound();
+ }
+ Executor found = null;
+ for (Executor executor : service.findExecutors()) {
+ if (executor.getName().equals(value)) {
+ found = executor;
+ break;
+ }
+ }
+ if (found == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = found;
+ }
+ case "listener" -> {
+ if (!(current instanceof LifecycleBase base)) {
+ throw notFound();
+ }
+ LifecycleListener[] listeners = base.findLifecycleListeners();
+ int index = index(value);
+ if (index < 0 || index >= listeners.length) {
+ throw notFound();
+ }
+ parent = current;
+ current = listeners[index];
+ }
+ case "realm" -> {
+ int index = index(value);
+ Realm found = null;
+ if (current instanceof Container container) {
+ // A container holds at most one directly attached
+ // realm, addressed as index 0.
+ if (index == 0) {
+ found = ownRealm(container);
+ }
+ } else if (current instanceof CombinedRealm combined) {
+ Realm[] nested = combined.getNestedRealms();
+ if (index >= 0 && index < nested.length) {
+ found = nested[index];
+ }
+ }
+ if (found == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = found;
+ }
+ case "sslHostConfig" -> {
+ if (!(current instanceof Connector connector)) {
+ throw notFound();
+ }
+ SSLHostConfig[] hostConfigs = connector.findSslHostConfigs();
+ SSLHostConfig found = null;
+ if (hostConfigs != null) {
+ for (SSLHostConfig hostConfig : hostConfigs) {
+ // Host names are case-insensitive and stored
+ // in lower case.
+ if (hostConfig.getHostName().equalsIgnoreCase(value)) {
+ found = hostConfig;
+ break;
+ }
+ }
+ }
+ if (found == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = found;
+ }
+ case "upgradeProtocol" -> {
+ if (!(current instanceof Connector connector)) {
+ throw notFound();
+ }
+ UpgradeProtocol[] upgradeProtocols = connector.findUpgradeProtocols();
+ int index = index(value);
+ if (index < 0 || index >= upgradeProtocols.length) {
+ throw notFound();
+ }
+ parent = current;
+ current = upgradeProtocols[index];
+ }
+ case "certificate" -> {
+ if (!(current instanceof SSLHostConfig hostConfig)) {
+ throw notFound();
+ }
+ SSLHostConfigCertificate[] certificates = hostConfig.getCertificates()
+ .toArray(new SSLHostConfigCertificate[0]);
+ int index = index(value);
+ if (index < 0 || index >= certificates.length) {
+ throw notFound();
+ }
+ parent = current;
+ current = certificates[index];
+ }
+ case "manager" -> {
+ // A context holds exactly one manager, addressed as
+ // index 0.
+ if (!(current instanceof Context context) || index(value) != 0) {
+ throw notFound();
+ }
+ Manager manager = context.getManager();
+ if (manager == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = manager;
+ }
+ case "resources" -> {
+ if (!(current instanceof Context context) || index(value) != 0) {
+ throw notFound();
+ }
+ WebResourceRoot resources = context.getResources();
+ if (resources == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = resources;
+ }
+ case "loader" -> {
+ if (!(current instanceof Context context) || index(value) != 0) {
+ throw notFound();
+ }
+ Loader loader = context.getLoader();
+ if (loader == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = loader;
+ }
+ case "cookieProcessor" -> {
+ if (!(current instanceof Context context) || index(value) != 0) {
+ throw notFound();
+ }
+ CookieProcessor cookieProcessor = context.getCookieProcessor();
+ if (cookieProcessor == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = cookieProcessor;
+ }
+ case "sessionIdGenerator" -> {
+ // A manager holds at most one session id generator,
+ // addressed as index 0.
+ if (!(current instanceof Manager manager) || index(value) != 0) {
+ throw notFound();
+ }
+ SessionIdGenerator generator = manager.getSessionIdGenerator();
+ if (generator == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = generator;
+ }
+ case "namingResources" -> {
+ // The server and each context hold exactly one
+ // NamingResourcesImpl, addressed as index 0.
+ if (index(value) != 0) {
+ throw notFound();
+ }
+ NamingResourcesImpl namingResources = null;
+ if (current instanceof StandardServer s) {
+ namingResources = s.getGlobalNamingResources();
+ } else if (current instanceof Context context) {
+ namingResources = context.getNamingResources();
+ }
+ if (namingResources == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = namingResources;
+ }
+ case "resource" -> {
+ if (!(current instanceof NamingResourcesImpl namingResources) ||
+ namingResources.findResource(value) == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = namingResources.findResource(value);
+ }
+ case "resourceLink" -> {
+ if (!(current instanceof NamingResourcesImpl namingResources) ||
+ namingResources.findResourceLink(value) == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = namingResources.findResourceLink(value);
+ }
+ case "resourceEnvRef" -> {
+ if (!(current instanceof NamingResourcesImpl namingResources) ||
+ namingResources.findResourceEnvRef(value) == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = namingResources.findResourceEnvRef(value);
+ }
+ case "environment" -> {
+ if (!(current instanceof NamingResourcesImpl namingResources) ||
+ namingResources.findEnvironment(value) == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = namingResources.findEnvironment(value);
+ }
+ case "ejb" -> {
+ if (!(current instanceof NamingResourcesImpl namingResources) ||
+ namingResources.findEjb(value) == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = namingResources.findEjb(value);
+ }
+ case "localEjb" -> {
+ if (!(current instanceof NamingResourcesImpl namingResources) ||
+ namingResources.findLocalEjb(value) == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = namingResources.findLocalEjb(value);
+ }
+ case "serviceRef" -> {
+ if (!(current instanceof NamingResourcesImpl namingResources) ||
+ namingResources.findService(value) == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = namingResources.findService(value);
+ }
+ case "cluster" -> {
+ if (!(current instanceof Container container) || ownCluster(container) == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = container.getCluster();
+ }
+ case "channel" -> {
+ if (!(current instanceof CatalinaCluster cluster) || index(value) != 0) {
+ throw notFound();
+ }
+ Channel channel = cluster.getChannel();
+ if (channel == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = channel;
+ }
+ case "membership" -> {
+ if (!(current instanceof ManagedChannel managed) || index(value) != 0) {
+ throw notFound();
+ }
+ MembershipService membership = managed.getMembershipService();
+ if (membership == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = membership;
+ }
+ case "sender" -> {
+ if (!(current instanceof ManagedChannel managed) || index(value) != 0) {
+ throw notFound();
+ }
+ ChannelSender sender = managed.getChannelSender();
+ if (sender == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = sender;
+ }
+ case "transport" -> {
+ if (!(current instanceof ReplicationTransmitter transmitter) || index(value) != 0) {
+ throw notFound();
+ }
+ MultiPointSender transport = transmitter.getTransport();
+ if (transport == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = transport;
+ }
+ case "receiver" -> {
+ if (!(current instanceof ManagedChannel managed) || index(value) != 0) {
+ throw notFound();
+ }
+ ChannelReceiver receiver = managed.getChannelReceiver();
+ if (receiver == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = receiver;
+ }
+ case "interceptor" -> {
+ if (!(current instanceof ManagedChannel managed)) {
+ throw notFound();
+ }
+ int wantedInterceptor = index(value);
+ Iterator interceptorIter = managed.getInterceptors();
+ int interceptorIndex = 0;
+ ChannelInterceptor foundInterceptor = null;
+ while (interceptorIter.hasNext()) {
+ ChannelInterceptor interceptor = interceptorIter.next();
+ if (interceptorIndex == wantedInterceptor) {
+ foundInterceptor = interceptor;
+ break;
+ }
+ interceptorIndex++;
+ }
+ if (foundInterceptor == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = foundInterceptor;
+ }
+ case "clusterValve" -> {
+ if (!(current instanceof CatalinaCluster cluster)) {
+ throw notFound();
+ }
+ Valve[] clusterValves = cluster.getValves();
+ int valveIndex = index(value);
+ if (valveIndex < 0 || valveIndex >= clusterValves.length) {
+ throw notFound();
+ }
+ parent = current;
+ current = clusterValves[valveIndex];
+ }
+ case "deployer" -> {
+ if (!(current instanceof CatalinaCluster cluster) || index(value) != 0) {
+ throw notFound();
+ }
+ ClusterDeployer deployer = cluster.getClusterDeployer();
+ if (deployer == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = deployer;
+ }
+ case "clusterManager" -> {
+ if (!(current instanceof SimpleTcpCluster tcp) || index(value) != 0) {
+ throw notFound();
+ }
+ ClusterManager manager = tcp.getManagerTemplate();
+ if (manager == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = manager;
+ }
+ case "clusterListener" -> {
+ if (!(current instanceof SimpleTcpCluster tcp)) {
+ throw notFound();
+ }
+ int wantedListener = index(value);
+ int listenerIndex = 0;
+ ClusterListener foundListener = null;
+ for (ClusterListener listener : tcp.findClusterListeners()) {
+ if (listener == tcp.getClusterDeployer()) {
+ continue;
+ }
+ if (listenerIndex == wantedListener) {
+ foundListener = listener;
+ break;
+ }
+ listenerIndex++;
+ }
+ if (foundListener == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = foundListener;
+ }
+ case "localMember" -> {
+ Member foundLocalMember = null;
+ if (current instanceof StaticMembershipService sms) {
+ foundLocalMember = sms.getLocalMember(false);
+ } else if (current instanceof StaticMembershipInterceptor smi) {
+ foundLocalMember = smi.getLocalMember(false);
+ }
+ if (foundLocalMember == null) {
+ throw notFound();
+ }
+ parent = current;
+ current = foundLocalMember;
+ }
+ case "member" -> {
+ if (!(current instanceof StaticMembershipService sms)) {
+ throw notFound();
+ }
+ List staticMembers = sms.getStaticMembers();
+ int memberIndex = index(value);
+ if (memberIndex < 0 || memberIndex >= staticMembers.size()) {
+ throw notFound();
+ }
+ parent = current;
+ current = staticMembers.get(memberIndex);
+ }
+ default -> throw notFound();
+ }
+
+ type = "localMember".equals(kind) ? "member" : kind;
+ }
+
+ return new NodeRef(current, parent, type, null, id);
+ }
+
+
+ private static ConfigException notFound() {
+ return new ConfigException(HttpServletResponse.SC_NOT_FOUND, "NOT_FOUND",
+ Strings.sm().getString("manager2.configNotFound"));
+ }
+
+
+ private static int index(String value) {
+ try {
+ return Integer.parseInt(value);
+ } catch (NumberFormatException e) {
+ return -1;
+ }
+ }
+
+
+ // ------------------------------------------------- Attribute updating
+
+
+ private void updateAttribute(HttpServletResponse response, Map body) throws Exception {
+
+ String id = string(body.get("id"));
+ String name = string(body.get("name"));
+ if (id == null || name == null || name.isEmpty()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_ID",
+ Strings.sm().getString("manager2.configInvalidId"));
+ }
+
+ NodeRef ref = resolve(id);
+ if (!"server".equals(ref.type) && ref.component == selfContext &&
+ ("name".equals(name) || "path".equals(name))) {
+ throw new ConfigException(HttpServletResponse.SC_FORBIDDEN, "SELF_COMPONENT",
+ Strings.sm().getString("manager2.configSelfComponent"));
+ }
+
+ // Components without a modeler descriptor take their attributes
+ // from the explicit list.
+ if (!explicitAttributes(ref.component, ref.type).attributes().isEmpty()) {
+ updateExplicitAttribute(response, ref, name, body);
+ return;
+ }
+
+ ManagedBean descriptor = descriptor(ref.component);
+ AttributeInfo attribute = findAttribute(descriptor, name);
+ if (attribute == null) {
+ throw new ConfigException(HttpServletResponse.SC_NOT_FOUND, "ATTRIBUTE_NOT_FOUND",
+ Strings.sm().getString("manager2.configAttributeNotFound", name));
+ }
+ if (!attribute.isWriteable() || !EDITABLE_TYPES.contains(attribute.getType())) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "READ_ONLY",
+ Strings.sm().getString("manager2.configReadOnly", name));
+ }
+
+ if (RISKY_ATTRIBUTES.contains(name)) {
+ String confirm = string(body.get("confirm"));
+ // For a context the display name is the (possibly normalized)
+ // context path, which is also what the UI asks to be confirmed.
+ String expected = displayName(ref.component, ref.type);
+ if (!expected.equals(confirm)) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "CONFIRM_REQUIRED",
+ Strings.sm().getString("manager2.configConfirmRequired", expected));
+ }
+ }
+
+ Object value = convert(attribute.getType(), body.get("value"));
+ setValue(ref.component, attribute, value);
+
+ log(Strings.sm().getString("manager2.configAuditAttribute", name, displayName(ref.component, ref.type),
+ String.valueOf(value)));
+ Api.ok(response, Strings.sm().getString("manager2.configAttributeUpdated", name, displayName(ref.component, ref.type)));
+ }
+
+
+ /**
+ * Update one attribute of a component without a modeler descriptor (the {@code sslHostConfig} and
+ * {@code certificate} node types, and the {@code loader}, {@code cookieProcessor} and {@code sessionIdGenerator}
+ * node types of the standard implementations).
+ */
+ private void updateExplicitAttribute(HttpServletResponse response, NodeRef ref, String name,
+ Map body) throws Exception {
+
+ Object component = ref.component;
+ boolean namingEntry = isNamingEntry(ref.type);
+ ResourceBase entry = namingEntry ? (ResourceBase) component : null;
+ String oldEntryName = entry == null ? null : entry.getName();
+
+ // Renaming a JNDI entry changes its JNDI name; require the same
+ // type-to-confirm as the other renames.
+ if (namingEntry && RISKY_ATTRIBUTES.contains(name)) {
+ String confirm = string(body.get("confirm"));
+ String expected = displayName(component, ref.type);
+ if (!expected.equals(confirm)) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "CONFIRM_REQUIRED",
+ Strings.sm().getString("manager2.configConfirmRequired", expected));
+ }
+ }
+
+ ExplicitAttribute attribute = findExplicitAttribute(component, ref.type, name);
+ boolean param = false;
+ String oldParamValue = null;
+ if (attribute == null) {
+ // A free form string parameter of a JNDI entry: any parameter
+ // name is accepted, the JNDI factory decides which ones it
+ // consumes.
+ if (!namingEntry) {
+ throw new ConfigException(HttpServletResponse.SC_NOT_FOUND, "ATTRIBUTE_NOT_FOUND",
+ Strings.sm().getString("manager2.configAttributeNotFound", name));
+ }
+ param = true;
+ Object current = entry.getProperty(name);
+ oldParamValue = current == null ? null : String.valueOf(current);
+ attribute = new ExplicitAttribute(name, "java.lang.String", true, true);
+ } else if (!attribute.isWritable()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "READ_ONLY",
+ Strings.sm().getString("manager2.configReadOnly", name));
+ }
+
+ Object value;
+ if (attribute.isParam()) {
+ // Parameters (the free form parameters of a JNDI entry and
+ // the typed factory options) are stored as string properties
+ // of the entry: keep the raw string form (an empty value
+ // removes the parameter, see setExplicitValue) and validate
+ // it against the declared type of the option (free form
+ // parameters are strings and always pass).
+ String paramValue = string(body.get("value"));
+ if (paramValue != null && !paramValue.isEmpty()) {
+ validateParamValue(name, paramValue, attribute.getType());
+ }
+ value = paramValue;
+ } else {
+ value = convert(attribute.getType(), body.get("value"));
+ }
+ Object oldValue = param ? null : readExplicitValue(component, attribute);
+ setExplicitValue(component, attribute, value);
+
+ // A JNDI entry update is only visible to the live JNDI
+ // environment (the NamingContextListener reacts to the property
+ // change events) when the entry is removed and re-added.
+ if (namingEntry) {
+ try {
+ rebindEntry(ref, oldEntryName);
+ } catch (Exception e) {
+ // Roll the change back and re-register the entry as it
+ // was before the update.
+ try {
+ if (param) {
+ if (oldParamValue == null) {
+ entry.removeProperty(name);
+ } else {
+ entry.setProperty(name, oldParamValue);
+ }
+ } else {
+ setExplicitValue(component, attribute, oldValue);
+ }
+ entry.setName(oldEntryName);
+ rebindEntry(ref, oldEntryName);
+ } catch (Exception rollbackError) {
+ log(Strings.sm().getString("manager2.error.config"), rollbackError);
+ }
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "UPDATE_FAILED",
+ Strings.sm().getString("manager2.configSetFailed", name, rootMessage(e)));
+ }
+ }
+
+ // On a running, TLS enabled connector the change is applied (and
+ // validated) at once by re-creating the SSL context of the
+ // affected host configuration. When the new value does not
+ // validate the previous value is restored.
+ SSLHostConfig sslHostConfig = null;
+ Connector connector = null;
+ if ("sslHostConfig".equals(ref.type)) {
+ sslHostConfig = (SSLHostConfig) ref.component;
+ if (ref.parent instanceof Connector parent) {
+ connector = parent;
+ }
+ } else if ("certificate".equals(ref.type) && ref.parent instanceof SSLHostConfig parent) {
+ sslHostConfig = parent;
+ connector = connectorOfSsl(sslHostConfig);
+ }
+ if (connector != null && connector.getState().isAvailable() && isSslEnabled(connector)) {
+ try {
+ endpointOf(connector).reloadSslHostConfig(sslHostConfig.getHostName());
+ } catch (Exception e) {
+ setExplicitValue(ref.component, attribute, oldValue);
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "UPDATE_FAILED", Strings.sm().getString(
+ "manager2.configSslReloadFailed", name, displayName(ref.component, ref.type), rootMessage(e)));
+ }
+ }
+
+ log(Strings.sm().getString("manager2.configAuditAttribute", name, displayName(ref.component, ref.type),
+ String.valueOf(value)));
+ Api.ok(response, Strings.sm().getString("manager2.configAttributeUpdated", name, displayName(ref.component, ref.type)));
+ }
+
+
+ /**
+ * Re-register a JNDI entry whose state has changed in place: remove it (by the name it was registered under) and
+ * add it again. The remove and add fire the property change events that the {@code NamingContextListener} uses to
+ * update the live JNDI environment.
+ */
+ private void rebindEntry(NodeRef ref, String registeredName) throws Exception {
+ NamingResourcesImpl namingResources = (NamingResourcesImpl) ref.parent;
+ ResourceBase entry = (ResourceBase) ref.component;
+ String newName = entry.getName();
+ boolean renamed = !registeredName.equals(newName);
+ if (renamed) {
+ // The removal event carries the entry and the NamingContextListener
+ // unbinds the JNDI name the entry reports. Restore the name the
+ // entry was registered under so the old binding (not the new one)
+ // is the one that is removed.
+ entry.setName(registeredName);
+ }
+ try {
+ removeNamingEntry(namingResources, ref.type, registeredName);
+ } finally {
+ if (renamed) {
+ entry.setName(newName);
+ }
+ }
+ addNamingEntryTo(namingResources, ref.type, entry);
+ // The add is a silent no-op when the (new) name is already used
+ // by another entry; detect that so the caller can roll back.
+ if (findNamingEntry(namingResources, ref.type, newName) != entry) {
+ throw new IllegalStateException(Strings.sm().getString("manager2.configJndiNameTaken", newName));
+ }
+ }
+
+
+ private static ResourceBase findNamingEntry(NamingResourcesImpl namingResources, String type, String name) {
+ return switch (type) {
+ case "resource" -> namingResources.findResource(name);
+ case "resourceLink" -> namingResources.findResourceLink(name);
+ case "resourceEnvRef" -> namingResources.findResourceEnvRef(name);
+ case "environment" -> namingResources.findEnvironment(name);
+ case "ejb" -> namingResources.findEjb(name);
+ case "localEjb" -> namingResources.findLocalEjb(name);
+ case "serviceRef" -> namingResources.findService(name);
+ default -> null;
+ };
+ }
+
+
+ private static void removeNamingEntry(NamingResourcesImpl namingResources, String type, String name) {
+ switch (type) {
+ case "resource" -> namingResources.removeResource(name);
+ case "resourceLink" -> namingResources.removeResourceLink(name);
+ case "resourceEnvRef" -> namingResources.removeResourceEnvRef(name);
+ case "environment" -> namingResources.removeEnvironment(name);
+ case "ejb" -> namingResources.removeEjb(name);
+ case "localEjb" -> namingResources.removeLocalEjb(name);
+ case "serviceRef" -> namingResources.removeService(name);
+ default -> {
+ }
+ }
+ }
+
+
+ private static void addNamingEntryTo(NamingResourcesImpl namingResources, String type, ResourceBase entry) {
+ switch (type) {
+ case "resource" -> namingResources.addResource((ContextResource) entry);
+ case "resourceLink" -> namingResources.addResourceLink((ContextResourceLink) entry);
+ case "resourceEnvRef" -> namingResources.addResourceEnvRef((ContextResourceEnvRef) entry);
+ case "environment" -> namingResources.addEnvironment((ContextEnvironment) entry);
+ case "ejb" -> namingResources.addEjb((ContextEjb) entry);
+ case "localEjb" -> namingResources.addLocalEjb((ContextLocalEjb) entry);
+ case "serviceRef" -> namingResources.addService((ContextService) entry);
+ default -> {
+ }
+ }
+ }
+
+
+ /**
+ * Convert a JSON value to the Java type of the attribute.
+ */
+ private static Object convert(String type, Object json) throws ConfigException {
+ String message = Strings.sm().getString("manager2.configInvalidValue", type);
+ try {
+ switch (type) {
+ case "boolean":
+ if (json instanceof Boolean b) {
+ return b;
+ }
+ return Boolean.valueOf(Boolean.parseBoolean(String.valueOf(json)));
+ case "int":
+ return Integer.valueOf(Integer.parseInt(String.valueOf(json).trim()));
+ case "long":
+ return Long.valueOf(Long.parseLong(String.valueOf(json).trim()));
+ case "short":
+ return Short.valueOf(Short.parseShort(String.valueOf(json).trim()));
+ case "byte":
+ return Byte.valueOf(Byte.parseByte(String.valueOf(json).trim()));
+ case "float":
+ return Float.valueOf(Float.parseFloat(String.valueOf(json).trim()));
+ case "double":
+ return Double.valueOf(Double.parseDouble(String.valueOf(json).trim()));
+ case "java.lang.String":
+ return String.valueOf(json);
+ case "[Ljava.lang.String;":
+ if (json instanceof List list) {
+ String[] result = new String[list.size()];
+ for (int i = 0; i < list.size(); i++) {
+ result[i] = String.valueOf(list.get(i));
+ }
+ return result;
+ }
+ return String.valueOf(json).split(",");
+ default:
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "UNSUPPORTED_TYPE", message);
+ }
+ } catch (NumberFormatException e) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_VALUE", message);
+ }
+ }
+
+
+ private static void setValue(Object component, AttributeInfo attribute, Object value) throws ConfigException {
+
+ String method = attribute.getSetMethod();
+ if (method == null) {
+ method = "set" + capitalize(attribute.getName());
+ }
+ try {
+ Method m = component.getClass().getMethod(method, classForType(attribute.getType()));
+ m.invoke(component, value);
+ } catch (NoSuchMethodException e) {
+ throw new ConfigException(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "NO_SETTER",
+ Strings.sm().getString("manager2.configNoSetter", method));
+ } catch (InvocationTargetException e) {
+ Throwable t = e.getTargetException();
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "SET_FAILED",
+ Strings.sm().getString("manager2.configSetFailed", attribute.getName(),
+ t.getMessage() == null ? t.getClass().getSimpleName() : t.getMessage()));
+ } catch (IllegalAccessException e) {
+ throw new ConfigException(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "NO_SETTER",
+ Strings.sm().getString("manager2.configNoSetter", method));
+ }
+ }
+
+
+ private static Class classForType(String type) {
+ switch (type) {
+ case "boolean":
+ return boolean.class;
+ case "int":
+ return int.class;
+ case "long":
+ return long.class;
+ case "short":
+ return short.class;
+ case "byte":
+ return byte.class;
+ case "float":
+ return float.class;
+ case "double":
+ return double.class;
+ case "java.lang.String":
+ return String.class;
+ case "[Ljava.lang.String;":
+ return String[].class;
+ default:
+ try {
+ return Class.forName(type);
+ } catch (ClassNotFoundException e) {
+ return Object.class;
+ }
+ }
+ }
+
+
+ // ----------------------------------------------------- Structural ops
+
+
+ /**
+ * Register a new component (the {@code add} operation) and verify that it actually started. The register operations
+ * of the core components report a failed start inconsistently: some throw, some log and leave a failed component
+ * behind, the valve pipeline even cleans up silently. All cases are handled here: on a failed start the
+ * {@code undo} operation is attempted and a controlled error is raised, so that no broken component is left
+ * registered.
+ */
+ private void addChecked(String label, Object component, Runnable add, Runnable undo) throws ConfigException {
+ try {
+ add.run();
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.config"), e);
+ rollback(label, undo);
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "START_FAILED",
+ Strings.sm().getString("manager2.configStartFailed", label, rootMessage(e)));
+ }
+ if (component instanceof Lifecycle lifecycle && !lifecycle.getState().isAvailable()) {
+ rollback(label, undo);
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "START_FAILED",
+ Strings.sm().getString("manager2.configStartFailed", label, Strings.sm().getString("manager2.configNotStarted")));
+ }
+ }
+
+
+ private void rollback(String label, Runnable undo) {
+ try {
+ undo.run();
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.configRollbackFailed", label,
+ e.getMessage() == null ? e.getClass().getSimpleName() : e.getMessage()), e);
+ }
+ }
+
+
+ /**
+ * The message of the deepest cause of the given exception.
+ */
+ private static String rootMessage(Throwable t) {
+ Throwable current = t;
+ while (current.getCause() != null && current.getCause() != current) {
+ current = current.getCause();
+ }
+ String message = current.getMessage();
+ return (message == null || message.isEmpty()) ? current.getClass().getSimpleName() : message;
+ }
+
+
+ private void addChild(HttpServletResponse response, Map body) throws Exception {
+
+ String parentId = string(body.get("parent"));
+ String type = string(body.get("type"));
+ if (parentId == null || type == null) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_ID",
+ Strings.sm().getString("manager2.configInvalidId"));
+ }
+ NodeRef parent = resolve(parentId);
+
+ // The only child of an SSL host configuration is a certificate,
+ // and in its request body the "type" field carries the
+ // certificate type (RSA, DSA, ...), not a child component type.
+ if (parent.component instanceof SSLHostConfig) {
+ addCertificate(response, parent, body);
+ return;
+ }
+
+ switch (type) {
+ case "service" -> addService(response, parent, body);
+ case "host" -> addHost(response, parent, body);
+ case "context" -> addContext(response, parent, body);
+ case "wrapper" -> addWrapper(response, parent, body);
+ case "valve" -> addValve(response, parent, body);
+ case "connector" -> addConnector(response, parent, body);
+ case "executor" -> addExecutor(response, parent, body);
+ case "alias" -> addAlias(response, parent, body);
+ case "listener" -> addListener(response, parent, body);
+ case "realm" -> addRealm(response, parent, body);
+ case "manager" -> addContextComponent(response, parent, body, "manager");
+ case "resources" -> addContextComponent(response, parent, body, "resources");
+ case "loader" -> addContextComponent(response, parent, body, "loader");
+ case "cookieProcessor" -> addContextComponent(response, parent, body, "cookieProcessor");
+ case "sessionIdGenerator" -> addSessionIdGenerator(response, parent, body);
+ case "resource" -> addNamingEntry(response, parent, body, "resource");
+ case "resourceLink" -> addNamingEntry(response, parent, body, "resourceLink");
+ case "resourceEnvRef" -> addNamingEntry(response, parent, body, "resourceEnvRef");
+ case "environment" -> addNamingEntry(response, parent, body, "environment");
+ case "ejb" -> addNamingEntry(response, parent, body, "ejb");
+ case "localEjb" -> addNamingEntry(response, parent, body, "localEjb");
+ case "serviceRef" -> addNamingEntry(response, parent, body, "serviceRef");
+ case "sslHostConfig" -> addSslHostConfig(response, parent, body);
+ case "upgradeProtocol" -> addUpgradeProtocol(response, parent, body);
+ case "certificate" -> addCertificate(response, parent, body);
+ case "cluster" -> addCluster(response, parent, body);
+ case "clusterValve" -> addClusterValve(response, parent, body);
+ case "channel" -> addClusterChannel(response, parent, body);
+ case "membership" -> addClusterMembership(response, parent, body);
+ case "sender" -> addClusterSender(response, parent, body);
+ case "receiver" -> addClusterReceiver(response, parent, body);
+ case "interceptor" -> addInterceptor(response, parent, body);
+ case "deployer" -> addClusterDeployer(response, parent, body);
+ case "clusterManager" -> addClusterManager(response, parent, body);
+ case "transport" -> addClusterTransport(response, parent, body);
+ case "clusterListener" -> addClusterListener(response, parent, body);
+ default -> throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "UNSUPPORTED_TYPE",
+ Strings.sm().getString("manager2.configTypeUnsupported", type));
+ }
+ }
+
+
+ private void addAlias(HttpServletResponse response, NodeRef parent, Map body) throws Exception {
+
+ if (!(parent.component instanceof Host host)) {
+ throw badParent("alias");
+ }
+ String alias = string(body.get("alias"));
+ if (alias == null || alias.isEmpty() || alias.contains(" ") || alias.contains(",")) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_NAME",
+ Strings.sm().getString("manager2.configInvalidName", alias));
+ }
+ if (Arrays.asList(host.findAliases()).contains(alias)) {
+ throw duplicate(alias);
+ }
+ host.addAlias(alias);
+ log(Strings.sm().getString("manager2.configAuditAdd", "alias", alias));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", alias));
+ }
+
+
+ /**
+ * A service in this Tomcat version holds exactly one engine (its {@code container}), so adding a service creates
+ * the service together with a new engine of the same name.
+ */
+ private void addService(HttpServletResponse response, NodeRef parent, Map body) throws Exception {
+
+ if (!(parent.component instanceof Server)) {
+ throw badParent("service");
+ }
+ String name = requiredName(body.get("name"));
+ if (server.findService(name) != null) {
+ throw duplicate(name);
+ }
+ StandardService service = new StandardService();
+ service.setName(name);
+ StandardEngine engine = new StandardEngine();
+ engine.setName(name);
+ engine.setRealm(new MemoryRealm());
+ service.setContainer(engine);
+ Server serverComponent = (Server) parent.component;
+ addChecked(name, service, () -> serverComponent.addService(service),
+ () -> serverComponent.removeService(service));
+ log(Strings.sm().getString("manager2.configAuditAdd", "service", name));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", name));
+ }
+
+
+ private void addHost(HttpServletResponse response, NodeRef parent, Map body) throws Exception {
+
+ if (!(parent.component instanceof StandardEngine engine)) {
+ throw badParent("host");
+ }
+ String name = requiredName(body.get("name"));
+ if (engine.findChild(name) instanceof Host) {
+ throw duplicate(name);
+ }
+
+ String appBase = string(body.get("appBase"));
+ if (appBase == null || appBase.isEmpty()) {
+ appBase = name;
+ }
+ File appBaseFile = new File(appBase);
+ if (!appBaseFile.isAbsolute()) {
+ appBaseFile = new File(engine.getCatalinaBase(), appBaseFile.getPath());
+ }
+ appBaseFile = appBaseFile.getCanonicalFile();
+ if (!appBaseFile.getPath().startsWith(engine.getCatalinaBase().getPath() + File.separator) &&
+ !appBaseFile.getPath().equals(engine.getCatalinaBase().getPath())) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH",
+ Strings.sm().getString("manager2.configInvalidPath", appBase));
+ }
+ if (!appBaseFile.mkdirs() && !appBaseFile.isDirectory()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH",
+ Strings.sm().getString("manager2.configInvalidPath", appBase));
+ }
+
+ StandardHost host = new StandardHost();
+ host.setName(name);
+ host.setAppBase(appBase);
+ host.addLifecycleListener(new HostConfig());
+ for (String alias : stringList(body.get("aliases"))) {
+ host.addAlias(alias);
+ }
+ host.setAutoDeploy(bool(body.get("autoDeploy"), true));
+ host.setDeployOnStartup(bool(body.get("deployOnStartup"), true));
+ host.setDeployXML(bool(body.get("deployXML"), true));
+ host.setUnpackWARs(bool(body.get("unpackWARs"), true));
+ host.setCopyXML(bool(body.get("copyXML"), false));
+ addChecked(name, host, () -> engine.addChild(host), () -> engine.removeChild(host));
+ log(Strings.sm().getString("manager2.configAuditAdd", "host", name));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", name));
+ }
+
+
+ private void addContext(HttpServletResponse response, NodeRef parent, Map body) throws Exception {
+
+ if (!(parent.component instanceof Host)) {
+ throw badParent("context");
+ }
+ Host host = (Host) parent.component;
+ String path = string(body.get("path"));
+ if (path == null || !path.startsWith("/") || path.length() < 2 || path.contains("..") || path.contains(" ")) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH",
+ Strings.sm().getString("manager2.configInvalidPath", path));
+ }
+ if (host.findChild(path) instanceof Context) {
+ throw duplicate(path);
+ }
+
+ StandardContext context = new StandardContext();
+ context.setPath(path);
+ context.setName(path);
+ // A docBase is interpreted exactly like in server.xml: a relative
+ // value is resolved against the appBase of the host. The default
+ // (as for HostConfig) is the context path below the appBase.
+ String docBase = string(body.get("docBase"));
+ if (docBase != null && !docBase.isEmpty()) {
+ context.setDocBase(docBase);
+ } else {
+ context.setDocBase(path.length() > 1 ? path.substring(1) : "ROOT");
+ }
+ context.setParent(host);
+ File docBaseFile = contextDocBaseFile(context);
+ if (docBaseFile != null && !docBaseFile.getName().endsWith(".war") && !docBaseFile.isDirectory() &&
+ !docBaseFile.mkdirs()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_PATH",
+ Strings.sm().getString("manager2.configDocBaseMissing", docBaseFile.getPath()));
+ }
+ String displayName = string(body.get("displayName"));
+ if (displayName != null && !displayName.isEmpty()) {
+ context.setDisplayName(displayName);
+ }
+ context.addLifecycleListener(new ContextConfig());
+ addChecked(path, context, () -> host.addChild(context), () -> host.removeChild(context));
+ log(Strings.sm().getString("manager2.configAuditAdd", "context", path));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", path));
+ }
+
+
+ /**
+ * The resolved location of the context document base (a relative {@code docBase} is resolved against the appBase of
+ * the host).
+ */
+ private static File contextDocBaseFile(StandardContext context) {
+ File file = new File(context.getDocBase());
+ if (!file.isAbsolute() && context.getParent() instanceof Host host) {
+ file = new File(host.getAppBaseFile(), file.getPath());
+ }
+ return file;
+ }
+
+
+ private void addWrapper(HttpServletResponse response, NodeRef parent, Map body) throws Exception {
+
+ if (!(parent.component instanceof Context)) {
+ throw badParent("wrapper");
+ }
+ Context context = (Context) parent.component;
+ String servletClass = string(body.get("servletClass"));
+ if (servletClass == null || servletClass.isEmpty()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_NAME",
+ Strings.sm().getString("manager2.configInvalidName", "servletClass"));
+ }
+ String name = string(body.get("name"));
+ if (name == null || name.isEmpty()) {
+ name = servletClass;
+ }
+ if (!SAFE_NAME.matcher(name).matches()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_NAME",
+ Strings.sm().getString("manager2.configInvalidName", name));
+ }
+ if (context.findChild(name) instanceof Wrapper) {
+ throw duplicate(name);
+ }
+
+ StandardWrapper wrapper = new StandardWrapper();
+ wrapper.setName(name);
+ wrapper.setServletClass(servletClass);
+ wrapper.setLoadOnStartup(intValue(body.get("loadOnStartup"), 0));
+ addChecked(name, wrapper, () -> context.addChild(wrapper), () -> context.removeChild(wrapper));
+ for (String pattern : stringList(body.get("urlPatterns"))) {
+ context.addServletMapping(pattern, name);
+ }
+ log(Strings.sm().getString("manager2.configAuditAdd", "wrapper", name));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", name));
+ }
+
+
+ private void addValve(HttpServletResponse response, NodeRef parent, Map body) throws Exception {
+
+ if (!(parent.component instanceof Container)) {
+ throw badParent("valve");
+ }
+ String className = string(body.get("className"));
+ if (className == null || className.isEmpty()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_NAME",
+ Strings.sm().getString("manager2.configInvalidName", "className"));
+ }
+ Valve valve;
+ try {
+ // Valves are server level classes: never use the webapp class
+ // loader.
+ valve = (Valve) Class.forName(className, true, server.getClass().getClassLoader()).getConstructor()
+ .newInstance();
+ } catch (Exception e) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_CLASS",
+ Strings.sm().getString("manager2.configInvalidClass", className));
+ }
+ Pipeline pipeline = ((Container) parent.component).getPipeline();
+ addChecked(className, valve, () -> pipeline.addValve(valve), () -> pipeline.removeValve(valve));
+ log(Strings.sm().getString("manager2.configAuditAdd", "valve", className));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", className));
+ }
+
+
+ private void addListener(HttpServletResponse response, NodeRef parent, Map body) throws Exception {
+
+ // Every component that implements Lifecycle accepts a lifecycle
+ // listener (containers, valves, connectors, executors, ...). An
+ // alias is excluded: it is just a name on the host, not a
+ // component that holds listeners.
+ if ("alias".equals(parent.type) || !(parent.component instanceof Lifecycle lifecycle)) {
+ throw badParent("listener");
+ }
+ String className = string(body.get("className"));
+ if (className == null || className.isEmpty()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_NAME",
+ Strings.sm().getString("manager2.configInvalidName", "className"));
+ }
+ LifecycleListener listener;
+ try {
+ // Listeners are server level classes: never use the webapp
+ // class loader.
+ listener = (LifecycleListener) Class.forName(className, true, server.getClass().getClassLoader())
+ .getConstructor().newInstance();
+ } catch (Exception e) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_CLASS",
+ Strings.sm().getString("manager2.configInvalidClass", className));
+ }
+ // A listener is registered, not started: the parent never drives
+ // its lifecycle (a listener that is itself a Lifecycle, such as a
+ // valve used as a listener, legitimately stays not started).
+ try {
+ lifecycle.addLifecycleListener(listener);
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.config"), e);
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "ADD_FAILED",
+ Strings.sm().getString("manager2.configAddFailed", className, rootMessage(e)));
+ }
+ log(Strings.sm().getString("manager2.configAuditAdd", "listener", className));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", className));
+ }
+
+
+ // ------------------------------------------- Cluster components
+
+
+ /**
+ * Instantiate a cluster component (a class from the clustering jars) using the server class loader, or a sensible
+ * default when no class name is given.
+ */
+ private T newClusterComponent(String className, String defaultClassName, Class type) throws ConfigException {
+ String name = (className == null || className.isEmpty()) ? defaultClassName : className;
+ try {
+ return type
+ .cast(Class.forName(name, true, server.getClass().getClassLoader()).getConstructor().newInstance());
+ } catch (Exception e) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_CLASS",
+ Strings.sm().getString("manager2.configInvalidClass", name));
+ }
+ }
+
+
+ /**
+ * Add a cluster to a container (engine, host or context). The cluster is a lifecycle component: when the container
+ * is running, {@code setCluster} starts it (which starts the channel and applies the cluster defaults), so the
+ * start is verified and rolled back on failure.
+ */
+ private void addCluster(HttpServletResponse response, NodeRef parent, Map body) throws Exception {
+ if (!(parent.component instanceof Container container)) {
+ throw badParent("cluster");
+ }
+ String className = string(body.get("className"));
+ String label = (className == null || className.isEmpty()) ? SimpleTcpCluster.class.getName() : className;
+ CatalinaCluster cluster = newClusterComponent(className, SimpleTcpCluster.class.getName(),
+ CatalinaCluster.class);
+ addChecked(label, cluster, () -> container.setCluster(cluster), () -> container.setCluster(null));
+ log(Strings.sm().getString("manager2.configAuditAdd", "cluster", label));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", label));
+ }
+
+
+ /**
+ * Add a cluster valve (a {@code Valve} that implements {@code ClusterValve}) to the cluster.
+ */
+ private void addClusterValve(HttpServletResponse response, NodeRef parent, Map body)
+ throws Exception {
+ if (!(parent.component instanceof CatalinaCluster cluster)) {
+ throw badParent("clusterValve");
+ }
+ String className = string(body.get("className"));
+ if (className == null || className.isEmpty()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_NAME",
+ Strings.sm().getString("manager2.configInvalidName", "className"));
+ }
+ Valve valve;
+ try {
+ valve = (Valve) Class.forName(className, true, server.getClass().getClassLoader()).getConstructor()
+ .newInstance();
+ } catch (Exception e) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_CLASS",
+ Strings.sm().getString("manager2.configInvalidClass", className));
+ }
+ if (!(valve instanceof ClusterValve)) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_CLASS",
+ Strings.sm().getString("manager2.configInvalidClass", className));
+ }
+ try {
+ cluster.addValve(valve);
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.config"), e);
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "ADD_FAILED",
+ Strings.sm().getString("manager2.configAddFailed", className, rootMessage(e)));
+ }
+ log(Strings.sm().getString("manager2.configAuditAdd", "clusterValve", className));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", className));
+ }
+
+
+ /**
+ * Replace the channel of the cluster.
+ */
+ private void addClusterChannel(HttpServletResponse response, NodeRef parent, Map body)
+ throws Exception {
+ if (!(parent.component instanceof CatalinaCluster cluster)) {
+ throw badParent("channel");
+ }
+ String className = string(body.get("className"));
+ String label = (className == null || className.isEmpty()) ? GroupChannel.class.getName() : className;
+ Channel channel = newClusterComponent(className, GroupChannel.class.getName(), Channel.class);
+ Channel previous = cluster.getChannel();
+ try {
+ cluster.setChannel(channel);
+ } catch (Exception e) {
+ cluster.setChannel(previous);
+ throw addFailed(label, e);
+ }
+ log(Strings.sm().getString("manager2.configAuditAdd", "channel", label));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", label));
+ }
+
+
+ /**
+ * Replace the membership service of the channel.
+ */
+ private void addClusterMembership(HttpServletResponse response, NodeRef parent, Map body)
+ throws Exception {
+ if (!(parent.component instanceof ManagedChannel managed)) {
+ throw badParent("membership");
+ }
+ String className = string(body.get("className"));
+ String label = (className == null || className.isEmpty()) ? McastService.class.getName() : className;
+ MembershipService membership = newClusterComponent(className, McastService.class.getName(),
+ MembershipService.class);
+ MembershipService previous = managed.getMembershipService();
+ try {
+ managed.setMembershipService(membership);
+ } catch (Exception e) {
+ managed.setMembershipService(previous);
+ throw addFailed(label, e);
+ }
+ log(Strings.sm().getString("manager2.configAuditAdd", "membership", label));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", label));
+ }
+
+
+ /**
+ * Replace the sender of the channel.
+ */
+ private void addClusterSender(HttpServletResponse response, NodeRef parent, Map body)
+ throws Exception {
+ if (!(parent.component instanceof ManagedChannel managed)) {
+ throw badParent("sender");
+ }
+ String className = string(body.get("className"));
+ String label = (className == null || className.isEmpty()) ? ReplicationTransmitter.class.getName() : className;
+ ChannelSender sender = newClusterComponent(className, ReplicationTransmitter.class.getName(),
+ ChannelSender.class);
+ ChannelSender previous = managed.getChannelSender();
+ try {
+ managed.setChannelSender(sender);
+ } catch (Exception e) {
+ managed.setChannelSender(previous);
+ throw addFailed(label, e);
+ }
+ log(Strings.sm().getString("manager2.configAuditAdd", "sender", label));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", label));
+ }
+
+
+ /**
+ * Replace the receiver of the channel.
+ */
+ private void addClusterReceiver(HttpServletResponse response, NodeRef parent, Map body)
+ throws Exception {
+ if (!(parent.component instanceof ManagedChannel managed)) {
+ throw badParent("receiver");
+ }
+ String className = string(body.get("className"));
+ String label = (className == null || className.isEmpty())
+ ? "org.apache.catalina.tribes.transport.nio.NioReceiver"
+ : className;
+ ChannelReceiver receiver = newClusterComponent(className,
+ "org.apache.catalina.tribes.transport.nio.NioReceiver", ChannelReceiver.class);
+ ChannelReceiver previous = managed.getChannelReceiver();
+ try {
+ managed.setChannelReceiver(receiver);
+ } catch (Exception e) {
+ managed.setChannelReceiver(previous);
+ throw addFailed(label, e);
+ }
+ log(Strings.sm().getString("manager2.configAuditAdd", "receiver", label));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", label));
+ }
+
+
+ /**
+ * Add an interceptor to the channel.
+ */
+ private void addInterceptor(HttpServletResponse response, NodeRef parent, Map body)
+ throws Exception {
+ if (!(parent.component instanceof ManagedChannel managed)) {
+ throw badParent("interceptor");
+ }
+ String className = string(body.get("className"));
+ if (className == null || className.isEmpty()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_NAME",
+ Strings.sm().getString("manager2.configInvalidName", "className"));
+ }
+ ChannelInterceptor interceptor = newClusterComponent(className, null, ChannelInterceptor.class);
+ try {
+ managed.addInterceptor(interceptor);
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.config"), e);
+ throw addFailed(className, e);
+ }
+ log(Strings.sm().getString("manager2.configAuditAdd", "interceptor", className));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", className));
+ }
+
+
+ /**
+ * Replace the deployer of the cluster.
+ */
+ private void addClusterDeployer(HttpServletResponse response, NodeRef parent, Map body)
+ throws Exception {
+ if (!(parent.component instanceof CatalinaCluster cluster)) {
+ throw badParent("deployer");
+ }
+ String className = string(body.get("className"));
+ String label = (className == null || className.isEmpty()) ? "org.apache.catalina.ha.deploy.FarmWarDeployer"
+ : className;
+ ClusterDeployer deployer = newClusterComponent(className, "org.apache.catalina.ha.deploy.FarmWarDeployer",
+ ClusterDeployer.class);
+ ClusterDeployer previous = cluster.getClusterDeployer();
+ try {
+ cluster.setClusterDeployer(deployer);
+ } catch (Exception e) {
+ cluster.setClusterDeployer(previous);
+ throw addFailed(label, e);
+ }
+ log(Strings.sm().getString("manager2.configAuditAdd", "deployer", label));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", label));
+ }
+
+
+ /**
+ * Replace the manager template of the cluster.
+ */
+ private void addClusterManager(HttpServletResponse response, NodeRef parent, Map body)
+ throws Exception {
+ if (!(parent.component instanceof SimpleTcpCluster tcp)) {
+ throw badParent("clusterManager");
+ }
+ String className = string(body.get("className"));
+ String label = (className == null || className.isEmpty()) ? "org.apache.catalina.ha.session.DeltaManager"
+ : className;
+ ClusterManager manager = newClusterComponent(className, "org.apache.catalina.ha.session.DeltaManager",
+ ClusterManager.class);
+ ClusterManager previous = tcp.getManagerTemplate();
+ try {
+ tcp.setManagerTemplate(manager);
+ } catch (Exception e) {
+ tcp.setManagerTemplate(previous);
+ throw addFailed(label, e);
+ }
+ log(Strings.sm().getString("manager2.configAuditAdd", "clusterManager", label));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", label));
+ }
+
+
+ /**
+ * Replace the transport of the sender (a replication transmitter).
+ */
+ private void addClusterTransport(HttpServletResponse response, NodeRef parent, Map body)
+ throws Exception {
+ if (!(parent.component instanceof ReplicationTransmitter transmitter)) {
+ throw badParent("transport");
+ }
+ String className = string(body.get("className"));
+ String label = (className == null || className.isEmpty())
+ ? "org.apache.catalina.tribes.transport.nio.PooledParallelSender"
+ : className;
+ MultiPointSender transport = newClusterComponent(className,
+ "org.apache.catalina.tribes.transport.nio.PooledParallelSender", MultiPointSender.class);
+ MultiPointSender previous = transmitter.getTransport();
+ try {
+ transmitter.setTransport(transport);
+ } catch (Exception e) {
+ transmitter.setTransport(previous);
+ throw addFailed(label, e);
+ }
+ log(Strings.sm().getString("manager2.configAuditAdd", "transport", label));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", label));
+ }
+
+
+ /**
+ * Add a cluster listener to the cluster.
+ */
+ private void addClusterListener(HttpServletResponse response, NodeRef parent, Map body)
+ throws Exception {
+ if (!(parent.component instanceof CatalinaCluster cluster)) {
+ throw badParent("clusterListener");
+ }
+ String className = string(body.get("className"));
+ if (className == null || className.isEmpty()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_NAME",
+ Strings.sm().getString("manager2.configInvalidName", "className"));
+ }
+ ClusterListener listener = newClusterComponent(className, null, ClusterListener.class);
+ try {
+ cluster.addClusterListener(listener);
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.config"), e);
+ throw addFailed(className, e);
+ }
+ log(Strings.sm().getString("manager2.configAuditAdd", "clusterListener", className));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", className));
+ }
+
+
+ private static ConfigException addFailed(String label, Exception e) {
+ return new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "ADD_FAILED",
+ Strings.sm().getString("manager2.configAddFailed", label, rootMessage(e)));
+ }
+
+
+ /**
+ * Add a realm: to a container (the container's own realm) or to a combined realm (a sub realm). The realm class is
+ * a server level class and is identified by its class name.
+ */
+ private void addRealm(HttpServletResponse response, NodeRef parent, Map body) throws Exception {
+
+ String className = string(body.get("className"));
+ if (className == null || className.isEmpty()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_NAME",
+ Strings.sm().getString("manager2.configInvalidName", "className"));
+ }
+ Realm realm;
+ try {
+ // Realms are server level classes: never use the webapp class
+ // loader.
+ realm = (Realm) Class.forName(className, true, server.getClass().getClassLoader()).getConstructor()
+ .newInstance();
+ } catch (Exception e) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_CLASS",
+ Strings.sm().getString("manager2.configInvalidClass", className));
+ }
+
+ if (parent.component instanceof Container container) {
+ addContainerRealm(response, container, realm, className);
+ } else if (parent.component instanceof CombinedRealm combined) {
+ addSubRealm(response, combined, realm, className);
+ } else {
+ throw badParent("realm");
+ }
+ }
+
+
+ private void addContainerRealm(HttpServletResponse response, Container container, Realm realm, String className)
+ throws Exception {
+
+ if (ownRealm(container) != null) {
+ throw duplicate(className);
+ }
+ Realm oldRealm = container.getRealm();
+ boolean running = container.getState().isAvailable();
+ try {
+ // setRealm wires the realm to the container and, on a running
+ // container, starts it.
+ container.setRealm(realm);
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.config"), e);
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "ADD_FAILED",
+ Strings.sm().getString("manager2.configAddFailed", className, rootMessage(e)));
+ }
+ // A realm that does not start on a running container is not
+ // useful; roll the change back. On a stopped container the realm
+ // is started when the container starts, so no check is needed.
+ if (running && realm instanceof Lifecycle lifecycle && !lifecycle.getState().isAvailable()) {
+ container.setRealm(oldRealm);
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "START_FAILED",
+ Strings.sm().getString("manager2.configStartFailed", className, Strings.sm().getString("manager2.configNotStarted")));
+ }
+ log(Strings.sm().getString("manager2.configAuditAdd", "realm", className));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", className));
+ }
+
+
+ private void addSubRealm(HttpServletResponse response, CombinedRealm combined, Realm realm, String className)
+ throws Exception {
+
+ // The XML parser accepts at most this many nested Realm elements;
+ // keep runtime additions within the same bound so that the state
+ // still round trips through server.xml.
+ if (nestedRealmDepth(combined) >= MAX_NESTED_REALM_LEVELS) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_VALUE",
+ Strings.sm().getString("manager2.configMaxNestedRealms"));
+ }
+ boolean running = combined.getState().isAvailable();
+ try {
+ combined.addRealm(realm);
+ // Mirror what the XML flow achieves when the container
+ // attaches the combined realm: give the sub realm a container
+ // (for logging) and a distinct realm path (for JMX naming),
+ // and start it while the combined realm is running (the
+ // combined realm only starts sub realms at its own start).
+ Container owner = combined.getContainer();
+ if (owner != null) {
+ realm.setContainer(owner);
+ if (realm instanceof RealmBase realmBase) {
+ realmBase
+ .setRealmPath(combined.getRealmPath() + "/realm" + (combined.getNestedRealms().length - 1));
+ }
+ }
+ if (running && realm instanceof Lifecycle lifecycle) {
+ lifecycle.start();
+ }
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.config"), e);
+ combined.removeRealm(realm);
+ if (realm instanceof Lifecycle lifecycle && lifecycle.getState().isAvailable()) {
+ try {
+ lifecycle.stop();
+ } catch (Exception ignored) {
+ // Best effort; the removal failure is already logged.
+ }
+ }
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "ADD_FAILED",
+ Strings.sm().getString("manager2.configAddFailed", className, rootMessage(e)));
+ }
+ log(Strings.sm().getString("manager2.configAuditAdd", "realm", className));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", className));
+ }
+
+
+ /**
+ * The number of realm levels in the chain starting at the given realm (the realm itself counts as one), following
+ * the first sub realm of each combined realm.
+ */
+ private static int nestedRealmDepth(Realm realm) {
+ int depth = 0;
+ for (Realm current = realm; current != null; current = firstSubRealm(current)) {
+ depth++;
+ }
+ return depth;
+ }
+
+
+ private static Realm firstSubRealm(Realm realm) {
+ if (!(realm instanceof CombinedRealm combined)) {
+ return null;
+ }
+ Realm[] nested = combined.getNestedRealms();
+ return nested.length > 0 ? nested[0] : null;
+ }
+
+
+ /**
+ * Add (replace) one of the sub components that a context holds exactly one of: the manager, the resources, the
+ * loader or the cookie processor. A context always has one of each (the defaults are created at context start), so
+ * the current instance is replaced by a new instance of the given class. The component class is a server level
+ * class and is identified by its class name.
+ */
+ private void addContextComponent(HttpServletResponse response, NodeRef parent, Map body,
+ String type) throws Exception {
+
+ if (!(parent.component instanceof Context context)) {
+ throw badParent(type);
+ }
+ // Replacing the session manager (or the class loader) of this
+ // web application's own context would destroy the admin session
+ // (or the classes of the running application) mid-request.
+ if (context == selfContext && ("manager".equals(type) || "loader".equals(type))) {
+ throw self();
+ }
+ String className = string(body.get("className"));
+ if (className == null || className.isEmpty()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_NAME",
+ Strings.sm().getString("manager2.configInvalidName", "className"));
+ }
+ Object component;
+ try {
+ // These are server level classes: never use the webapp class
+ // loader.
+ Object instance = Class.forName(className, true, server.getClass().getClassLoader()).getConstructor()
+ .newInstance();
+ switch (type) {
+ case "manager" -> component = (Manager) instance;
+ case "resources" -> component = (WebResourceRoot) instance;
+ case "loader" -> component = (Loader) instance;
+ default -> component = (CookieProcessor) instance;
+ }
+ } catch (Exception e) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_CLASS",
+ Strings.sm().getString("manager2.configInvalidClass", className));
+ }
+
+ boolean running = context.getState().isAvailable();
+ switch (type) {
+ case "manager" -> {
+ Manager oldManager = context.getManager();
+ try {
+ // setManager wires the manager to the context and, on
+ // a running context, stops the old manager and starts
+ // the new one.
+ context.setManager((Manager) component);
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.config"), e);
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "ADD_FAILED",
+ Strings.sm().getString("manager2.configAddFailed", className, rootMessage(e)));
+ }
+ // A manager that does not start on a running context is
+ // not useful; roll the change back. On a stopped context
+ // the manager is started when the context starts.
+ if (running && component instanceof Lifecycle lifecycle && !lifecycle.getState().isAvailable()) {
+ context.setManager(oldManager);
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "START_FAILED",
+ Strings.sm().getString("manager2.configStartFailed", className, Strings.sm().getString("manager2.configNotStarted")));
+ }
+ }
+ case "loader" -> {
+ Loader oldLoader = context.getLoader();
+ try {
+ // setLoader wires the loader to the context and, on a
+ // running context, stops the old loader and starts
+ // the new one.
+ context.setLoader((Loader) component);
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.config"), e);
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "ADD_FAILED",
+ Strings.sm().getString("manager2.configAddFailed", className, rootMessage(e)));
+ }
+ if (running && component instanceof Lifecycle lifecycle && !lifecycle.getState().isAvailable()) {
+ context.setLoader(oldLoader);
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "START_FAILED",
+ Strings.sm().getString("manager2.configStartFailed", className, Strings.sm().getString("manager2.configNotStarted")));
+ }
+ }
+ case "resources" -> {
+ // The context refuses to change its resources while it
+ // is running: the resource tree of a live web
+ // application cannot be swapped out from under it.
+ if (running) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "CONTEXT_RUNNING",
+ Strings.sm().getString("manager2.configContextMustBeStopped", displayName(context, "context")));
+ }
+ try {
+ // setResources wires the resources to the context.
+ // Their lifecycle is driven by the context (start).
+ context.setResources((WebResourceRoot) component);
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.config"), e);
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "ADD_FAILED",
+ Strings.sm().getString("manager2.configAddFailed", className, rootMessage(e)));
+ }
+ }
+ default -> {
+ // The cookie processor has no lifecycle; the context
+ // uses it from the moment it is set.
+ try {
+ context.setCookieProcessor((CookieProcessor) component);
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.config"), e);
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "ADD_FAILED",
+ Strings.sm().getString("manager2.configAddFailed", className, rootMessage(e)));
+ }
+ }
+ }
+ log(Strings.sm().getString("manager2.configAuditAdd", type, className));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", className));
+ }
+
+
+ /**
+ * Add (replace) the session id generator of a manager. The manager uses it from the moment it is set; on a running
+ * manager the old generator is stopped and the new one started.
+ */
+ private void addSessionIdGenerator(HttpServletResponse response, NodeRef parent, Map body)
+ throws Exception {
+
+ if (!(parent.component instanceof Manager manager)) {
+ throw badParent("sessionIdGenerator");
+ }
+ String className = string(body.get("className"));
+ if (className == null || className.isEmpty()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_NAME",
+ Strings.sm().getString("manager2.configInvalidName", "className"));
+ }
+ SessionIdGenerator generator;
+ try {
+ // Session id generators are server level classes: never use
+ // the webapp class loader.
+ generator = (SessionIdGenerator) Class.forName(className, true, server.getClass().getClassLoader())
+ .getConstructor().newInstance();
+ } catch (Exception e) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_CLASS",
+ Strings.sm().getString("manager2.configInvalidClass", className));
+ }
+
+ // The Manager interface does not extend Lifecycle; all standard
+ // managers do (ManagerBase), so the state is read conditionally.
+ boolean running = manager instanceof Lifecycle && ((Lifecycle) manager).getState().isAvailable();
+ SessionIdGenerator old = manager.getSessionIdGenerator();
+ boolean oldRunning = running && old instanceof Lifecycle && ((Lifecycle) old).getState().isAvailable();
+ try {
+ if (oldRunning) {
+ ((Lifecycle) old).stop();
+ }
+ manager.setSessionIdGenerator(generator);
+ // The manager stamps its jvm route onto the generator at
+ // start; mirror that for a live replacement.
+ if (manager instanceof ManagerBase managerBase) {
+ generator.setJvmRoute(managerBase.getJvmRoute());
+ }
+ if (running && generator instanceof Lifecycle lifecycle) {
+ lifecycle.start();
+ }
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.config"), e);
+ // Best effort rollback: stop the new generator (if it
+ // started) and restore the previous one (the setter rejects
+ // null, so "none" cannot be restored).
+ try {
+ if (generator instanceof Lifecycle lifecycle && lifecycle.getState().isAvailable()) {
+ lifecycle.stop();
+ }
+ if (manager.getSessionIdGenerator() == generator && old != null) {
+ manager.setSessionIdGenerator(old);
+ }
+ if (oldRunning && old instanceof Lifecycle lifecycle && !lifecycle.getState().isAvailable()) {
+ lifecycle.start();
+ }
+ } catch (Exception ignored) {
+ // Best effort; the failure is already logged.
+ }
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "ADD_FAILED",
+ Strings.sm().getString("manager2.configAddFailed", className, rootMessage(e)));
+ }
+ log(Strings.sm().getString("manager2.configAuditAdd", "sessionIdGenerator", className));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", className));
+ }
+
+
+ /**
+ * Add one JNDI entry to a {@code NamingResourcesImpl}. The entry takes effect in the live JNDI environment of the
+ * server (the global context) or of the context ({@code java:comp/env}) immediately: the add fires the property
+ * change event the {@code NamingContextListener} reacts to.
+ *
+ * The request body carries the entry fields: {@code name} (the JNDI name), {@code jndiType} (the type of the
+ * object) and the type specific fields ({@code auth}, {@code factory}, ...). A nested {@code params} object is
+ * applied as the free form string parameters of the entry; for the first party JNDI factories with a closed set of
+ * parameters the values are validated against the type the factory parses them as.
+ */
+ private void addNamingEntry(HttpServletResponse response, NodeRef parent, Map body, String type)
+ throws Exception {
+
+ if (!(parent.component instanceof NamingResourcesImpl namingResources)) {
+ throw badParent(type);
+ }
+ // Resource links are only part of a context JNDI environment;
+ // they are not parsed from .
+ if ("resourceLink".equals(type) && namingResources.getContainer() instanceof Server) {
+ throw badParent(type);
+ }
+ String name = string(body.get("name"));
+ if (name == null || name.isEmpty()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_ID",
+ Strings.sm().getString("manager2.configInvalidId"));
+ }
+ if (findNamingEntry(namingResources, type, name) != null) {
+ throw duplicate(name);
+ }
+ String jndiType = string(body.get("jndiType"));
+ if (jndiType == null || jndiType.isEmpty()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "MISSING_FIELD",
+ Strings.sm().getString("manager2.configJndiTypeRequired", type));
+ }
+
+ ResourceBase entry;
+ switch (type) {
+ case "resource" -> {
+ ContextResource resource = new ContextResource();
+ resource.setName(name);
+ resource.setType(jndiType);
+ String auth = string(body.get("auth"));
+ if (auth != null) {
+ resource.setAuth(auth);
+ }
+ resource.setSingleton(bool(body.get("singleton"), true));
+ String closeMethod = string(body.get("closeMethod"));
+ if (closeMethod != null) {
+ resource.setCloseMethod(closeMethod);
+ }
+ String lookupName = string(body.get("lookupName"));
+ if (lookupName != null) {
+ resource.setLookupName(lookupName);
+ }
+ String description = string(body.get("description"));
+ if (description != null) {
+ resource.setDescription(description);
+ }
+ entry = resource;
+ }
+ case "resourceLink" -> {
+ ContextResourceLink link = new ContextResourceLink();
+ link.setName(name);
+ link.setType(jndiType);
+ String global = string(body.get("global"));
+ if (global == null || global.isEmpty()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "MISSING_FIELD",
+ Strings.sm().getString("manager2.configJndiGlobalRequired"));
+ }
+ link.setGlobal(global);
+ String description = string(body.get("description"));
+ if (description != null) {
+ link.setDescription(description);
+ }
+ entry = link;
+ }
+ case "resourceEnvRef" -> {
+ ContextResourceEnvRef resourceEnvRef = new ContextResourceEnvRef();
+ resourceEnvRef.setName(name);
+ resourceEnvRef.setType(jndiType);
+ resourceEnvRef.setOverride(bool(body.get("override"), true));
+ String description = string(body.get("description"));
+ if (description != null) {
+ resourceEnvRef.setDescription(description);
+ }
+ entry = resourceEnvRef;
+ }
+ case "environment" -> {
+ ContextEnvironment environment = new ContextEnvironment();
+ environment.setName(name);
+ environment.setType(jndiType);
+ String value = string(body.get("value"));
+ if (value != null) {
+ environment.setValue(value);
+ }
+ environment.setOverride(bool(body.get("override"), true));
+ String description = string(body.get("description"));
+ if (description != null) {
+ environment.setDescription(description);
+ }
+ entry = environment;
+ }
+ case "ejb" -> {
+ ContextEjb ejb = new ContextEjb();
+ ejb.setName(name);
+ ejb.setType(jndiType);
+ String home = string(body.get("home"));
+ if (home != null) {
+ ejb.setHome(home);
+ }
+ String link = string(body.get("link"));
+ if (link != null) {
+ ejb.setLink(link);
+ }
+ String remote = string(body.get("remote"));
+ if (remote != null) {
+ ejb.setRemote(remote);
+ }
+ String description = string(body.get("description"));
+ if (description != null) {
+ ejb.setDescription(description);
+ }
+ entry = ejb;
+ }
+ case "localEjb" -> {
+ ContextLocalEjb localEjb = new ContextLocalEjb();
+ localEjb.setName(name);
+ localEjb.setType(jndiType);
+ String local = string(body.get("local"));
+ if (local != null) {
+ localEjb.setLocal(local);
+ }
+ String home = string(body.get("home"));
+ if (home != null) {
+ localEjb.setHome(home);
+ }
+ String link = string(body.get("link"));
+ if (link != null) {
+ localEjb.setLink(link);
+ }
+ String description = string(body.get("description"));
+ if (description != null) {
+ localEjb.setDescription(description);
+ }
+ entry = localEjb;
+ }
+ default -> {
+ ContextService service = new ContextService();
+ service.setName(name);
+ service.setType(jndiType);
+ String serviceInterface = string(body.get("interface"));
+ if (serviceInterface != null) {
+ service.setInterface(serviceInterface);
+ }
+ String displayname = string(body.get("displayname"));
+ if (displayname != null) {
+ service.setDisplayname(displayname);
+ }
+ String wsdlfile = string(body.get("wsdlfile"));
+ if (wsdlfile != null) {
+ service.setWsdlfile(wsdlfile);
+ }
+ String description = string(body.get("description"));
+ if (description != null) {
+ service.setDescription(description);
+ }
+ entry = service;
+ }
+ }
+
+ // The factory: a string parameter of a resource, a first class
+ // attribute of a resource link.
+ String factory = string(body.get("factory"));
+ if (factory != null && !factory.isEmpty()) {
+ checkFactoryLoadable(factory);
+ if (entry instanceof ContextResourceLink link) {
+ link.setFactory(factory);
+ } else if (entry instanceof ContextResource) {
+ entry.setProperty("factory", factory);
+ }
+ }
+ // The generic string parameters of the entry (the ResourceBase
+ // property map). For the types whose factory is one of the first
+ // party factories with a closed set of options the values are
+ // validated against that set; for the others (and for open set
+ // factories) they are stored as-is.
+ applyNamingParams(entry, factory, body.get("params"));
+
+ try {
+ addNamingEntryTo(namingResources, type, entry);
+ } catch (Exception e) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "ADD_FAILED",
+ Strings.sm().getString("manager2.configAddFailed", name, rootMessage(e)));
+ }
+ log(Strings.sm().getString("manager2.configAuditAdd", type, name));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", name));
+ }
+
+
+ /**
+ * Apply the free form string parameters of a new JNDI entry, validating the values against the closed parameter set
+ * of the first party factory (the factories parse them at JNDI lookup time, which is too late for a useful error
+ * message).
+ */
+ private void applyNamingParams(ResourceBase entry, String factory, Object params) throws ConfigException {
+ if (!(params instanceof Map map) || map.isEmpty()) {
+ return;
+ }
+ List options = factoryOptions(factory);
+ for (Map.Entry e : map.entrySet()) {
+ String key = String.valueOf(e.getKey());
+ String value = string(e.getValue());
+ if (value == null) {
+ continue;
+ }
+ if (options != null) {
+ for (ExplicitAttribute option : options) {
+ if (option.getName().equals(key)) {
+ validateParamValue(key, value, option.getType());
+ break;
+ }
+ }
+ }
+ entry.setProperty(key, value);
+ }
+ }
+
+
+ private static void validateParamValue(String name, String value, String type) throws ConfigException {
+ try {
+ String trimmed = value.trim();
+ switch (type) {
+ case "int" -> Integer.parseInt(trimmed);
+ case "long" -> Long.parseLong(trimmed);
+ case "boolean" -> {
+ String v = trimmed.toLowerCase(Locale.ROOT);
+ if (!"true".equals(v) && !"false".equals(v)) {
+ throw new NumberFormatException(trimmed);
+ }
+ }
+ default -> {
+ // A string.
+ }
+ }
+ } catch (NumberFormatException e) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "SET_FAILED",
+ Strings.sm().getString("manager2.configSetFailed", name, Strings.sm().getString("manager2.configInvalidType", type)));
+ }
+ }
+
+
+ private void checkFactoryLoadable(String factory) throws ConfigException {
+ try {
+ // The factory is instantiated with the container class
+ // loader at JNDI lookup time.
+ Class.forName(factory, false, server.getClass().getClassLoader());
+ } catch (ClassNotFoundException e) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_CLASS",
+ Strings.sm().getString("manager2.configFactoryInvalid", factory));
+ }
+ }
+
+
+ private void addConnector(HttpServletResponse response, NodeRef parent, Map body) throws Exception {
+
+ if (!(parent.component instanceof StandardService service)) {
+ throw badParent("connector");
+ }
+ String protocol = string(body.get("protocol"));
+ if (protocol == null || protocol.isEmpty()) {
+ protocol = "HTTP/1.1";
+ }
+ Integer port = intValue(body.get("port"), -1);
+ if (port < 1 || port > 65535) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_VALUE",
+ Strings.sm().getString("manager2.configInvalidValue", "port"));
+ }
+ Connector connector = new Connector(protocol);
+ connector.setPort(port);
+ addChecked(connectorLabel(connector), connector, () -> service.addConnector(connector),
+ () -> service.removeConnector(connector));
+ log(Strings.sm().getString("manager2.configAuditAdd", "connector", protocol + " (port " + port + ")"));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", protocol + " (port " + port + ")"));
+ }
+
+
+ private void addExecutor(HttpServletResponse response, NodeRef parent, Map body) throws Exception {
+
+ if (!(parent.component instanceof StandardService service)) {
+ throw badParent("executor");
+ }
+ String name = requiredName(body.get("name"));
+ for (Executor executor : service.findExecutors()) {
+ if (executor.getName().equals(name)) {
+ throw duplicate(name);
+ }
+ }
+ StandardThreadExecutor executor = new StandardThreadExecutor();
+ executor.setName(name);
+ Integer maxThreads = intValue(body.get("maxThreads"), -1);
+ if (maxThreads > 0) {
+ executor.setMaxThreads(maxThreads);
+ }
+ Integer minSpare = intValue(body.get("minSpareThreads"), -1);
+ if (minSpare >= 0) {
+ executor.setMinSpareThreads(minSpare);
+ }
+ // The thread pool refuses to start when the minimum number of
+ // threads exceeds the maximum (the defaults are 25 and 200, so an
+ // explicit maxThreads below the default minimum must be rejected).
+ if (executor.getMinSpareThreads() > executor.getMaxThreads()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_VALUE",
+ Strings.sm().getString("manager2.configExecutorInvalid"));
+ }
+ addChecked(name, executor, () -> service.addExecutor(executor), () -> service.removeExecutor(executor));
+ log(Strings.sm().getString("manager2.configAuditAdd", "executor", name));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", name));
+ }
+
+
+ /**
+ * Add an SSL host configuration (one TLS virtual host) to a connector. Adding the first SSL host configuration
+ * enables TLS on the connector. A running connector is restarted so that the TLS configuration takes effect; when
+ * the restart fails (typically because no valid certificate is configured) the change is rolled back and the
+ * connector is left running as it was.
+ */
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ private void addSslHostConfig(HttpServletResponse response, NodeRef parent, Map body)
+ throws Exception {
+
+ if (!(parent.component instanceof Connector connector)) {
+ throw badParent("sslHostConfig");
+ }
+ AbstractHttp11Protocol http11 = sslProtocolHandler(connector);
+ if (http11 == null) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "BAD_PARENT",
+ Strings.sm().getString("manager2.configSslUnsupported", connector.getProtocolHandlerClassName()));
+ }
+ if (isSelfConnector(connector)) {
+ throw self();
+ }
+ String hostName = string(body.get("hostName"));
+ if (hostName == null || hostName.isEmpty()) {
+ // The default host configuration name ("_default_") is not
+ // exposed by a public constant.
+ hostName = "_default_";
+ }
+ if (!SAFE_NAME.matcher(hostName).matches()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_NAME",
+ Strings.sm().getString("manager2.configInvalidName", hostName));
+ }
+ String hostNameLower = hostName.toLowerCase(Locale.ENGLISH);
+ SSLHostConfig[] existing = connector.findSslHostConfigs();
+ if (existing != null) {
+ for (SSLHostConfig hostConfig : existing) {
+ if (hostConfig.getHostName().equals(hostNameLower)) {
+ throw duplicate(hostNameLower);
+ }
+ }
+ }
+
+ boolean wasSslEnabled = http11.isSSLEnabled();
+ boolean wasRunning = connector.getState().isAvailable();
+
+ SSLHostConfig sslHostConfig = new SSLHostConfig();
+ sslHostConfig.setHostName(hostNameLower);
+ // An optional initial certificate. On a running connector that
+ // is not TLS enabled yet it is required: a connector without
+ // any certificate cannot complete a single TLS handshake.
+ boolean certificateProvided = body.get("certificate") instanceof Map;
+ if (wasRunning && !wasSslEnabled && !certificateProvided) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_VALUE",
+ Strings.sm().getString("manager2.configSslCertificateRequired"));
+ }
+ if (certificateProvided) {
+ SSLHostConfigCertificate certificate = buildCertificate(sslHostConfig,
+ (Map) body.get("certificate"));
+ try {
+ sslHostConfig.addCertificate(certificate);
+ } catch (IllegalArgumentException e) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_VALUE",
+ Strings.sm().getString("manager2.configInvalidValue", "certificate"));
+ }
+ }
+
+ try {
+ connector.addSslHostConfig(sslHostConfig);
+ } catch (IllegalArgumentException e) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "ADD_FAILED",
+ Strings.sm().getString("manager2.configAddFailed", hostNameLower, rootMessage(e)));
+ }
+
+ if (wasRunning && !wasSslEnabled) {
+ // The endpoint is already bound, so its TLS configuration
+ // (SSL implementation and the SSL contexts, which is where
+ // the keystores are loaded) is initialized here instead of
+ // at bind time. This validates the new TLS configuration
+ // without interrupting the connector: from this point on,
+ // new connections are served over TLS.
+ try {
+ endpointOf(connector).initialiseSsl();
+ } catch (Exception e) {
+ // TLS is switched off first: the endpoint refuses to
+ // remove its default host configuration while it is
+ // still serving TLS.
+ http11.setSSLEnabled(false);
+ try {
+ endpointOf(connector).removeSslHostConfig(hostNameLower);
+ } catch (Exception e2) {
+ log(Strings.sm().getString("manager2.configRollbackFailed", hostNameLower, rootMessage(e2)), e2);
+ }
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "ADD_FAILED",
+ Strings.sm().getString("manager2.configAddFailed", hostNameLower, rootMessage(e)));
+ }
+ }
+
+ log(Strings.sm().getString("manager2.configAuditAdd", "sslHostConfig", hostNameLower));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", hostNameLower));
+ }
+
+
+ /**
+ * Add an upgrade protocol (e.g. the HTTP/2 one) to a connector through {@code AbstractHttp11Protocol
+ * .addUpgradeProtocol}. An upgrade protocol is only referenced when the connector is initialised, so the new
+ * instance does not take effect on a running connector: it becomes active the next time the connector is
+ * (re)started (see the lifecycle operations). No live activation is attempted.
+ */
+ private void addUpgradeProtocol(HttpServletResponse response, NodeRef parent, Map body)
+ throws Exception {
+
+ if (!(parent.component instanceof Connector connector)) {
+ throw badParent("upgradeProtocol");
+ }
+ if (http11ProtocolHandler(connector) == null) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "BAD_PARENT",
+ Strings.sm().getString("manager2.configUpgradeUnsupported", connector.getProtocolHandlerClassName()));
+ }
+ String className = string(body.get("className"));
+ if (className == null || className.isEmpty()) {
+ // The only UpgradeProtocol shipped with Tomcat is the HTTP/2 one.
+ className = "org.apache.coyote.http2.Http2Protocol";
+ }
+ UpgradeProtocol upgradeProtocol;
+ try {
+ // Upgrade protocols are server level classes: never use the webapp
+ // class loader.
+ upgradeProtocol = (UpgradeProtocol) Class.forName(className, true, server.getClass().getClassLoader())
+ .getConstructor().newInstance();
+ } catch (Exception e) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_CLASS",
+ Strings.sm().getString("manager2.configInvalidClass", className));
+ }
+ // The protocol handler keeps the protocols in a plain list without
+ // checking for duplicates; a second protocol with the same name would
+ // be silently shadowed when the connector is next initialised, so
+ // reject it here.
+ String label = upgradeProtocolLabel(upgradeProtocol);
+ for (UpgradeProtocol existing : connector.findUpgradeProtocols()) {
+ if (label.equals(upgradeProtocolLabel(existing))) {
+ throw duplicate(label);
+ }
+ }
+ connector.addUpgradeProtocol(upgradeProtocol);
+ log(Strings.sm().getString("manager2.configAuditAdd", "upgradeProtocol", label));
+ Api.ok(response, Strings.sm().getString("manager2.configUpgradeProtocolAdded", label));
+ }
+
+
+ /**
+ * Add a certificate configuration to an SSL host configuration. On a running, TLS enabled connector the new
+ * certificate is applied at once (the SSL context of the virtual host is re-created, which also validates the
+ * keystore); when that fails the certificate is rolled back.
+ */
+ @SuppressWarnings("rawtypes")
+ private void addCertificate(HttpServletResponse response, NodeRef parent, Map body)
+ throws Exception {
+
+ if (!(parent.component instanceof SSLHostConfig sslHostConfig)) {
+ throw badParent("certificate");
+ }
+ SSLHostConfigCertificate certificate = buildCertificate(sslHostConfig, body);
+ try {
+ sslHostConfig.addCertificate(certificate);
+ } catch (IllegalArgumentException e) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "ADD_FAILED",
+ Strings.sm().getString("manager2.configAddFailed", certificateLabel(certificate), rootMessage(e)));
+ }
+
+ Connector connector = connectorOfSsl(sslHostConfig);
+ AbstractHttp11Protocol http11 = (connector != null) ? sslProtocolHandler(connector) : null;
+ if (connector != null && connector.getState().isAvailable() && http11 != null && http11.isSSLEnabled()) {
+ try {
+ endpointOf(connector).reloadSslHostConfig(sslHostConfig.getHostName());
+ } catch (Exception e) {
+ sslHostConfig.getCertificates().remove(certificate);
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "ADD_FAILED",
+ Strings.sm().getString("manager2.configAddFailed", certificateLabel(certificate), rootMessage(e)));
+ }
+ }
+
+ log(Strings.sm().getString("manager2.configAuditAdd", "certificate", certificateLabel(certificate)));
+ Api.ok(response, Strings.sm().getString("manager2.configAdded", certificateLabel(certificate)));
+ }
+
+
+ /**
+ * Build a (not yet registered) certificate configuration from a JSON object. The same builder is used for the
+ * certificate of a new SSL host configuration and for standalone certificates.
+ */
+ private static SSLHostConfigCertificate buildCertificate(SSLHostConfig sslHostConfig, Map body)
+ throws ConfigException {
+ String typeName = string(body.get("type"));
+ SSLHostConfigCertificate.Type type;
+ if (typeName == null || typeName.isEmpty()) {
+ type = SSLHostConfigCertificate.Type.UNDEFINED;
+ } else {
+ try {
+ type = SSLHostConfigCertificate.Type.valueOf(typeName.trim().toUpperCase(Locale.ENGLISH));
+ } catch (IllegalArgumentException e) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_NAME",
+ Strings.sm().getString("manager2.configInvalidName", typeName));
+ }
+ }
+ SSLHostConfigCertificate certificate = new SSLHostConfigCertificate(sslHostConfig, type);
+ setIfPresent(certificate, "certificateKeystoreFile", body);
+ setIfPresent(certificate, "certificateKeystorePassword", body);
+ setIfPresent(certificate, "certificateKeystorePasswordFile", body);
+ setIfPresent(certificate, "certificateKeystoreType", body);
+ setIfPresent(certificate, "certificateKeystoreProvider", body);
+ setIfPresent(certificate, "certificateKeyAlias", body);
+ setIfPresent(certificate, "certificateKeyPassword", body);
+ setIfPresent(certificate, "certificateKeyPasswordFile", body);
+ setIfPresent(certificate, "certificateFile", body);
+ setIfPresent(certificate, "certificateChainFile", body);
+ setIfPresent(certificate, "certificateKeyFile", body);
+ return certificate;
+ }
+
+
+ /**
+ * Call one string setter on the target when the body carries a non-empty value for the property.
+ */
+ private static void setIfPresent(Object target, String name, Map body) throws ConfigException {
+ Object value = body.get(name);
+ if (value == null) {
+ return;
+ }
+ String s = String.valueOf(value);
+ if (s.isEmpty()) {
+ return;
+ }
+ try {
+ target.getClass().getMethod("set" + capitalize(name), String.class).invoke(target, s);
+ } catch (Exception e) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_VALUE",
+ Strings.sm().getString("manager2.configInvalidValue", name));
+ }
+ }
+
+
+ /**
+ * The protocol handler of the connector when it is the HTTP/1.1 variant, otherwise {@code null} (for example an AJP
+ * connector).
+ */
+ @SuppressWarnings("rawtypes")
+ private static AbstractHttp11Protocol http11ProtocolHandler(Connector connector) {
+ if (connector.getProtocolHandler() instanceof AbstractHttp11Protocol http11) {
+ return http11;
+ }
+ return null;
+ }
+
+
+ /**
+ * The protocol handler of the connector when it is the HTTP/1.1 variant that supports TLS, otherwise {@code null}
+ * (for example an AJP connector).
+ */
+ @SuppressWarnings("rawtypes")
+ private static AbstractHttp11Protocol sslProtocolHandler(Connector connector) {
+ return http11ProtocolHandler(connector);
+ }
+
+
+ /**
+ * Whether the connector's protocol handler has TLS enabled.
+ */
+ @SuppressWarnings("rawtypes")
+ private static boolean isSslEnabled(Connector connector) {
+ AbstractHttp11Protocol http11 = sslProtocolHandler(connector);
+ return http11 != null && http11.isSSLEnabled();
+ }
+
+
+ /**
+ * The connector that owns the given SSL host configuration, or {@code null} when it is not attached to any
+ * connector.
+ */
+ private Connector connectorOfSsl(SSLHostConfig sslHostConfig) {
+ for (Service service : server.findServices()) {
+ for (Connector connector : service.findConnectors()) {
+ SSLHostConfig[] hostConfigs = connector.findSslHostConfigs();
+ if (hostConfigs == null) {
+ continue;
+ }
+ for (SSLHostConfig candidate : hostConfigs) {
+ if (candidate == sslHostConfig) {
+ return connector;
+ }
+ }
+ }
+ }
+ return null;
+ }
+
+
+ /**
+ * The endpoint of the connector's protocol handler. The endpoint (and with it the SSL host configuration operations
+ * that are not on the {@code ProtocolHandler} interface, such as {@code removeSslHostConfig} and
+ * {@code reloadSslHostConfig}) is only reachable through the protected accessor of {@code AbstractProtocol}, so it
+ * is invoked reflectively.
+ */
+ private AbstractEndpoint endpointOf(Connector connector) throws ConfigException {
+ try {
+ Method m = AbstractProtocol.class.getDeclaredMethod("getEndpoint");
+ m.setAccessible(true);
+ return (AbstractEndpoint) m.invoke(connector.getProtocolHandler());
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.config"), e);
+ throw new ConfigException(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "SERVER_UNAVAILABLE",
+ Strings.sm().getString("manager2.configServerUnavailable"));
+ }
+ }
+
+
+ /**
+ * Whether the connector routes requests for the host that deploys this web application (the connector must never be
+ * stopped or restarted, as that would destroy the admin session mid-request).
+ */
+ private boolean isSelfConnector(Connector connector) {
+ Service service = connector.getService();
+ return service != null && service.getContainer() != null && selfHost.getParent() == service.getContainer();
+ }
+
+
+ @SuppressWarnings("rawtypes")
+ private void removeChild(HttpServletResponse response, Map body) throws Exception {
+
+ String id = string(body.get("id"));
+ if (id == null) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_ID",
+ Strings.sm().getString("manager2.configInvalidId"));
+ }
+ NodeRef ref = resolve(id);
+
+ // Guards against removing the components that host this web
+ // application (the session would be destroyed mid-request). An
+ // alias is excluded: it is not a container, so removing one cannot
+ // change where this web application is deployed, even on the
+ // manager's own host.
+ if (!"alias".equals(ref.type) && ref.component == selfContext) {
+ throw self();
+ }
+ if (!"alias".equals(ref.type) && ref.component == selfHost) {
+ throw self();
+ }
+ // The last service cannot be removed. Checked before the service
+ // self-host check: with a single service both apply and the
+ // structural invariant is the more informative answer.
+ if (ref.type.equals("service") && server.findServices().length <= 1) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "LAST_SERVICE",
+ Strings.sm().getString("manager2.configLastService"));
+ }
+ if (ref.type.equals("service") && containsSelf((StandardService) ref.component)) {
+ throw self();
+ }
+ if (ref.type.equals("engine") && ref.component instanceof Engine engine &&
+ engine.findChild(selfHost.getName()) instanceof Host) {
+ throw self();
+ }
+
+ if (ref.type.equals("valve") && isBasicValve(ref)) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "BASIC_COMPONENT",
+ Strings.sm().getString("manager2.configBasicValve"));
+ }
+ // The sub components a context holds exactly one of (and the
+ // manager's session id generator) are required: they cannot be
+ // removed, only replaced.
+ if (Set.of("manager", "resources", "loader", "cookieProcessor", "sessionIdGenerator").contains(ref.type)) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "REQUIRED_COMPONENT",
+ Strings.sm().getString("manager2.configRequiredComponent", ref.type));
+ }
+ // The JNDI naming resources of the server and of a context are
+ // always present and required: they cannot be removed.
+ if (ref.type.equals("namingResources")) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "REQUIRED_COMPONENT",
+ Strings.sm().getString("manager2.configRequiredNamingResources"));
+ }
+ // Cluster valves and channel interceptors are repeatable sub
+ // components that have no removal API on a running cluster; only
+ // the cluster itself and its single-valued sub components can be
+ // detached.
+ if (ref.type.equals("clusterValve") || ref.type.equals("interceptor")) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "REMOVE_NOT_SUPPORTED",
+ Strings.sm().getString("manager2.configRemoveNotSupported", ref.type));
+ }
+ // A service holds exactly one engine (its container); it cannot be
+ // removed while it still contains hosts.
+ if (ref.type.equals("engine") && ref.component instanceof Engine engine && countHosts(engine) > 0) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "NOT_EMPTY",
+ Strings.sm().getString("manager2.configNotEmpty", "engine"));
+ }
+ // A directly attached realm can only be removed when the container
+ // falls back to a parent realm afterwards; otherwise the container
+ // (and everything below it) would have no realm at all.
+ if (ref.type.equals("realm") && ref.parent instanceof Container container && fallbackRealm(container) == null) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "LAST_REALM",
+ Strings.sm().getString("manager2.configLastRealm"));
+ }
+
+ String label = ref.aliasValue != null ? ref.aliasValue : displayName(ref.component, ref.type);
+ if (Set.of("host", "context", "service", "engine", "connector", "executor", "wrapper", "valve", "sslHostConfig",
+ "upgradeProtocol", "realm", "cluster", "resource", "resourceLink", "resourceEnvRef", "environment",
+ "ejb", "localEjb", "serviceRef").contains(ref.type)) {
+ String confirm = string(body.get("confirm"));
+ if (!label.equals(confirm)) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "CONFIRM_REQUIRED",
+ Strings.sm().getString("manager2.configConfirmRequired", label));
+ }
+ }
+
+ if ("sslHostConfig".equals(ref.type)) {
+ removeSslHostConfig(response, ref, label);
+ return;
+ }
+ if ("certificate".equals(ref.type)) {
+ removeCertificate(response, ref);
+ return;
+ }
+
+ try {
+ switch (ref.type) {
+ case "host" -> ((Container) ref.parent).removeChild((Host) ref.component);
+ case "context" -> ((Container) ref.parent).removeChild((Context) ref.component);
+ case "wrapper" -> ((Container) ref.parent).removeChild((Wrapper) ref.component);
+ case "valve" -> ((Container) ref.parent).getPipeline().removeValve((Valve) ref.component);
+ case "connector" -> ((StandardService) ref.parent).removeConnector((Connector) ref.component);
+ case "executor" -> ((StandardService) ref.parent).removeExecutor((Executor) ref.component);
+ case "alias" -> ((Host) ref.component).removeAlias(ref.aliasValue);
+ case "listener" ->
+ ((LifecycleBase) ref.parent).removeLifecycleListener((LifecycleListener) ref.component);
+ case "upgradeProtocol" -> {
+ AbstractHttp11Protocol http11 = http11ProtocolHandler((Connector) ref.parent);
+ if (http11 == null) {
+ throw notFound();
+ }
+ http11.removeUpgradeProtocol((UpgradeProtocol) ref.component);
+ }
+ case "realm" -> removeRealm((Realm) ref.component, ref.parent);
+ case "engine" -> ((StandardService) ref.parent).setContainer(null);
+ case "service" -> server.removeService((Service) ref.component);
+ case "resource" -> removeNamingEntry((NamingResourcesImpl) ref.parent, "resource",
+ ((ResourceBase) ref.component).getName());
+ case "resourceLink" -> removeNamingEntry((NamingResourcesImpl) ref.parent, "resourceLink",
+ ((ResourceBase) ref.component).getName());
+ case "resourceEnvRef" -> removeNamingEntry((NamingResourcesImpl) ref.parent, "resourceEnvRef",
+ ((ResourceBase) ref.component).getName());
+ case "environment" -> removeNamingEntry((NamingResourcesImpl) ref.parent, "environment",
+ ((ResourceBase) ref.component).getName());
+ case "ejb" -> removeNamingEntry((NamingResourcesImpl) ref.parent, "ejb",
+ ((ResourceBase) ref.component).getName());
+ case "localEjb" -> removeNamingEntry((NamingResourcesImpl) ref.parent, "localEjb",
+ ((ResourceBase) ref.component).getName());
+ case "serviceRef" -> removeNamingEntry((NamingResourcesImpl) ref.parent, "serviceRef",
+ ((ResourceBase) ref.component).getName());
+ case "cluster" -> ((Container) ref.parent).setCluster(null);
+ case "channel" -> ((CatalinaCluster) ref.parent).setChannel(null);
+ case "membership" -> ((ManagedChannel) ref.parent).setMembershipService(null);
+ case "sender" -> ((ManagedChannel) ref.parent).setChannelSender(null);
+ case "receiver" -> ((ManagedChannel) ref.parent).setChannelReceiver(null);
+ case "deployer" -> ((CatalinaCluster) ref.parent).setClusterDeployer(null);
+ case "clusterManager" -> ((SimpleTcpCluster) ref.parent).setManagerTemplate(null);
+ case "transport" -> ((ReplicationTransmitter) ref.parent).setTransport(null);
+ case "clusterListener" ->
+ ((CatalinaCluster) ref.parent).removeClusterListener((ClusterListener) ref.component);
+ case "member" -> removeClusterMember(ref);
+ default -> throw notFound();
+ }
+ } catch (ConfigException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "REMOVE_FAILED",
+ Strings.sm().getString("manager2.configRemoveFailed",
+ e.getMessage() == null ? e.getClass().getSimpleName() : e.getMessage()));
+ }
+
+ log(Strings.sm().getString("manager2.configAuditRemove", ref.type, label));
+ Api.ok(response, Strings.sm().getString("manager2.configRemoved", label));
+ }
+
+
+ /**
+ * Remove a static member (the local member or a static member) from a static membership service or interceptor.
+ */
+ private void removeClusterMember(NodeRef ref) {
+ Member member = (Member) ref.component;
+ if (ref.parent instanceof StaticMembershipService sms) {
+ if (sms.getLocalMember(false) == member) {
+ sms.setLocalMember(null);
+ } else {
+ sms.removeStaticMember((StaticMember) member);
+ }
+ } else if (ref.parent instanceof StaticMembershipInterceptor smi) {
+ if (smi.getLocalMember(false) == member) {
+ smi.setLocalMember(null);
+ } else {
+ smi.removeStaticMember(member);
+ }
+ }
+ }
+
+
+ /**
+ * Remove a realm. A directly attached realm is detached from its container (the container then falls back to the
+ * parent realm) and a sub realm is removed from its combined realm and stopped.
+ */
+ private static void removeRealm(Realm realm, Object parent) throws Exception {
+ if (parent instanceof CombinedRealm combined) {
+ if (!combined.removeRealm(realm)) {
+ throw notFound();
+ }
+ if (realm instanceof Lifecycle lifecycle && lifecycle.getState().isAvailable()) {
+ lifecycle.stop();
+ }
+ } else if (parent instanceof Container container) {
+ // Detach: the container falls back to the parent realm.
+ container.setRealm(null);
+ } else {
+ throw notFound();
+ }
+ }
+
+
+ /**
+ * Remove an SSL host configuration from its connector. When this disables TLS on the connector (no configurations
+ * left) and the connector is running, it is restarted so that it serves plain HTTP again, with a rollback that
+ * restores the configuration.
+ */
+ @SuppressWarnings("rawtypes")
+ private void removeSslHostConfig(HttpServletResponse response, NodeRef ref, String label) throws Exception {
+
+ if (!(ref.component instanceof SSLHostConfig sslHostConfig) || !(ref.parent instanceof Connector connector)) {
+ throw notFound();
+ }
+ if (isSelfConnector(connector)) {
+ throw self();
+ }
+ AbstractHttp11Protocol http11 = sslProtocolHandler(connector);
+ boolean sslEnabled = isSslEnabled(connector);
+ boolean running = connector.getState().isAvailable();
+ int remaining = (connector.findSslHostConfigs() == null) ? 0 : connector.findSslHostConfigs().length - 1;
+ if (sslEnabled && running && remaining > 0 &&
+ sslHostConfig.getHostName().equalsIgnoreCase(endpointOf(connector).getDefaultSSLHostConfigName())) {
+ // The default host configuration is the fallback for
+ // handshakes without a matching SNI name; it cannot be
+ // removed from a running, TLS enabled connector while other
+ // configurations remain.
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "SSL_DEFAULT",
+ Strings.sm().getString("manager2.configSslDefault"));
+ }
+
+ boolean disablesSsl = sslEnabled && remaining == 0;
+ if (disablesSsl) {
+ // TLS is disabled for this connector from now on. The flag
+ // is switched off before the removal because the endpoint
+ // refuses to remove its default host configuration while it
+ // is still serving TLS.
+ http11.setSSLEnabled(false);
+ }
+ try {
+ endpointOf(connector).removeSslHostConfig(sslHostConfig.getHostName());
+ } catch (IllegalArgumentException e) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "REMOVE_FAILED",
+ Strings.sm().getString("manager2.configRemoveFailed", rootMessage(e)));
+ }
+ // When the removal disabled TLS no further action is needed: the
+ // endpoint decides per accepted connection whether it is TLS, so
+ // new connections are served over plain HTTP from this point on
+ // (in-flight TLS connections complete normally).
+
+ log(Strings.sm().getString("manager2.configAuditRemove", ref.type, label));
+ Api.ok(response, Strings.sm().getString("manager2.configRemoved", label));
+ }
+
+
+ /**
+ * Remove a certificate configuration from its SSL host configuration. On a running, TLS enabled connector the
+ * change is applied at once (the SSL context of the virtual host is re-created) and rolled back when the remaining
+ * configuration does not validate. The last certificate of such a connector cannot be removed: the connector would
+ * no longer be able to start.
+ */
+ private void removeCertificate(HttpServletResponse response, NodeRef ref) throws Exception {
+
+ if (!(ref.component instanceof SSLHostConfigCertificate certificate) ||
+ !(ref.parent instanceof SSLHostConfig sslHostConfig)) {
+ throw notFound();
+ }
+ Connector connector = connectorOfSsl(sslHostConfig);
+ boolean live = connector != null && connector.getState().isAvailable() && isSslEnabled(connector);
+ if (live && sslHostConfig.getCertificates().size() <= 1) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "SSL_LAST_CERTIFICATE",
+ Strings.sm().getString("manager2.configSslLastCertificate", connectorLabel(connector)));
+ }
+
+ Set certificates = sslHostConfig.getCertificates();
+ certificates.remove(certificate);
+ if (live) {
+ try {
+ endpointOf(connector).reloadSslHostConfig(sslHostConfig.getHostName());
+ } catch (Exception e) {
+ certificates.add(certificate);
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "REMOVE_FAILED",
+ Strings.sm().getString("manager2.configRemoveFailed", rootMessage(e)));
+ }
+ }
+
+ String label = displayName(certificate, "certificate");
+ log(Strings.sm().getString("manager2.configAuditRemove", "certificate", label));
+ Api.ok(response, Strings.sm().getString("manager2.configRemoved", label));
+ }
+
+
+ private boolean containsSelf(StandardService service) {
+ Engine engine = service.getContainer();
+ return engine != null && engine.findChild(selfHost.getName()) instanceof Host;
+ }
+
+
+ private static int countHosts(Engine engine) {
+ int count = 0;
+ for (Container child : engine.findChildren()) {
+ if (child instanceof Host) {
+ count++;
+ }
+ }
+ return count;
+ }
+
+
+ private boolean isBasicValve(NodeRef ref) {
+ // The first valve of a pipeline is the basic valve and cannot be
+ // removed.
+ if (ref.parent instanceof Container container) {
+ Valve[] valves = container.getPipeline().getValves();
+ return valves.length > 0 && valves[0] == ref.component;
+ }
+ return false;
+ }
+
+
+ private static ConfigException self() {
+ return new ConfigException(HttpServletResponse.SC_FORBIDDEN, "SELF_COMPONENT",
+ Strings.sm().getString("manager2.configSelfComponent"));
+ }
+
+
+ private static ConfigException duplicate(String name) {
+ return new ConfigException(HttpServletResponse.SC_CONFLICT, "DUPLICATE",
+ Strings.sm().getString("manager2.configDuplicate", name));
+ }
+
+
+ private static ConfigException badParent(String type) {
+ return new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "BAD_PARENT",
+ Strings.sm().getString("manager2.configParentInvalid", type));
+ }
+
+
+ // -------------------------------------------------------- Lifecycle ops
+
+
+ /**
+ * Start, stop or restart one component of the server tree.
+ *
+ * A {@code start} or {@code stop} of a component that would interrupt access to this web application itself (see
+ * {@link #affectsSelf(NodeRef)}) is refused (403 {@code SELF_COMPONENT}): the request would lose its way back. A
+ * {@code restart} (a stop, when the component is running, followed by a start) remains possible for those
+ * components: the client's connection may be interrupted during the operation, but the component is running again
+ * at the end and the client reconnects (re-logging in when the admin session was reset by the restart).
+ */
+ private void lifecycle(HttpServletResponse response, Map body) throws Exception {
+
+ String id = string(body.get("id"));
+ String op = string(body.get("op"));
+ if (id == null || op == null || op.isEmpty()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_ID",
+ Strings.sm().getString("manager2.configInvalidId"));
+ }
+ boolean start = "start".equals(op);
+ boolean stop = "stop".equals(op);
+ boolean restart = "restart".equals(op);
+ if (!start && !stop && !restart) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_OP",
+ Strings.sm().getString("manager2.configInvalidOp", op));
+ }
+
+ NodeRef ref = resolve(id);
+ if (!(ref.component instanceof Lifecycle lifecycle)) {
+ String label = ref.aliasValue != null ? ref.aliasValue : displayName(ref.component, ref.type);
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "NOT_A_LIFECYCLE",
+ Strings.sm().getString("manager2.configNotALifecycle", label));
+ }
+ if (!restart && affectsSelf(ref)) {
+ throw self();
+ }
+ String label = ref.aliasValue != null ? ref.aliasValue : displayName(ref.component, ref.type);
+
+ if (stop) {
+ if (!lifecycle.getState().isAvailable()) {
+ Api.ok(response, Strings.sm().getString("manager2.configAlreadyStopped", label));
+ return;
+ }
+ stopChecked(lifecycle, label);
+ log(Strings.sm().getString("manager2.configAuditLifecycle", "stopped", label));
+ Api.ok(response, Strings.sm().getString("manager2.configStopped", label));
+ return;
+ }
+
+ if (restart && lifecycle.getState().isAvailable()) {
+ stopChecked(lifecycle, label);
+ }
+ if (start && lifecycle.getState().isAvailable()) {
+ Api.ok(response, Strings.sm().getString("manager2.configAlreadyRunning", label));
+ return;
+ }
+ startChecked(lifecycle, label);
+ log(Strings.sm().getString("manager2.configAuditLifecycle", restart ? "restarted" : "started", label));
+ Api.ok(response, Strings.sm().getString(restart ? "manager2.configRestarted" : "manager2.configStarted", label));
+ }
+
+
+ /**
+ * Stop the component, raising a controlled error when it cannot be stopped or does not stop.
+ */
+ private void stopChecked(Lifecycle lifecycle, String label) throws ConfigException {
+ try {
+ lifecycle.stop();
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.config"), e);
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "STOP_FAILED",
+ Strings.sm().getString("manager2.configStopFailed", label, rootMessage(e)));
+ }
+ if (lifecycle.getState().isAvailable()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "STOP_FAILED",
+ Strings.sm().getString("manager2.configStopFailed", label, Strings.sm().getString("manager2.configNotStopped")));
+ }
+ }
+
+
+ /**
+ * Start the component, raising a controlled error when it cannot be started or does not start.
+ */
+ private void startChecked(Lifecycle lifecycle, String label) throws ConfigException {
+ try {
+ lifecycle.start();
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.config"), e);
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "START_FAILED",
+ Strings.sm().getString("manager2.configStartFailed", label, rootMessage(e)));
+ }
+ if (!lifecycle.getState().isAvailable()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "START_FAILED",
+ Strings.sm().getString("manager2.configStartFailed", label, Strings.sm().getString("manager2.configNotStarted")));
+ }
+ }
+
+
+ /**
+ * Whether stopping or starting this component would interrupt access to this web application: the component is the
+ * server itself, or the service, engine, host, context, connector or wrapper that route or host the requests of
+ * this web application. A {@code restart} of such a component remains possible (the client reconnects at the end of
+ * the operation).
+ */
+ private boolean affectsSelf(NodeRef ref) {
+ Object component = ref.component;
+ return switch (ref.type) {
+ case "server" -> true;
+ case "service" -> component instanceof StandardService service && containsSelf(service);
+ case "engine" -> component instanceof Engine engine && engine.findChild(selfHost.getName()) instanceof Host;
+ case "host" -> component == selfHost;
+ case "context" -> component == selfContext;
+ case "connector" -> component instanceof Connector connector && isSelfConnector(connector);
+ case "wrapper" -> component instanceof Wrapper wrapper && wrapper.getParent() == selfContext;
+ default -> false;
+ };
+ }
+
+
+ // ------------------------------------------------------------- Store
+
+
+ /**
+ * Build a ready to use {@link StoreConfig} that writes the live state of this server. The storeconfig MBean is not
+ * required (and is not registered unless the {@code StoreConfigLifecycleListener} is configured in server.xml), so
+ * the instance is created on demand from the default classpath registry.
+ */
+ private StoreConfig buildStoreConfig() throws Exception {
+ StoreLoader loader = new StoreLoader();
+ loader.load(null);
+ StoreConfig storeConfig = new StoreConfig();
+ storeConfig.setRegistry(loader.getRegistry());
+ storeConfig.setServer(server);
+ return storeConfig;
+ }
+
+
+ private void store(HttpServletResponse response) throws Exception {
+
+ File confDir = new File(storeBase(), "conf");
+ Set before = serverXmlBackups(confDir);
+
+ StoreConfig storeConfig = buildStoreConfig();
+ // Same sequence as StoreConfig.store(Server), but keeping each
+ // context in its current storage location (see
+ // storeServerPreservingContexts).
+ StoreFileMover mover = new StoreFileMover(storeBase(), storeConfig.getServerFilename(),
+ storeConfig.getRegistry().getEncoding());
+ try (PrintWriter writer = mover.getWriter()) {
+ storeServerPreservingContexts(storeConfig, writer);
+ } catch (Exception e) {
+ log(Strings.sm().getString("manager2.error.config"), e);
+ throw new ConfigException(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "STORE_FAILED",
+ Strings.sm().getString("manager2.configStoreFailed"));
+ }
+ mover.move();
+
+ Set after = serverXmlBackups(confDir);
+ after.removeAll(before);
+ String backup = after.isEmpty() ? null : after.iterator().next();
+
+ log(Strings.sm().getString("manager2.configAuditStore", backup));
+ Map payload = new LinkedHashMap<>();
+ payload.put("ok", Boolean.TRUE);
+ payload.put("message", Strings.sm().getString("manager2.configStored", "conf/server.xml", backup == null ? "-" : backup));
+ payload.put("file", "conf/server.xml");
+ payload.put("backup", backup);
+ Api.json(response, payload);
+ }
+
+
+ /**
+ * The Catalina base directory that the store writes to. Normally the base of the running server. The
+ * {@code manager2.store.base} system property overrides it (used by the integration tests to redirect the write to
+ * a throw-away directory).
+ */
+ private static String storeBase() {
+ String base = System.getProperty("manager2.store.base");
+ return (base != null && !base.isEmpty()) ? base : Bootstrap.getCatalinaBase();
+ }
+
+
+ /**
+ * The names of the storeconfig backup files ({@code server.xml.*}) in the conf directory.
+ */
+ private static Set serverXmlBackups(File confDir) {
+ Set result = new HashSet<>();
+ File[] files = confDir.listFiles();
+ if (files != null) {
+ for (File file : files) {
+ if (file.isFile() && file.getName().startsWith("server.xml.")) {
+ result.add(file.getName());
+ }
+ }
+ }
+ return result;
+ }
+
+
+ private void preview(HttpServletResponse response) throws Exception {
+ StoreConfig storeConfig = buildStoreConfig();
+ StringWriter writer = new StringWriter();
+ CapturingContextSF capturing = previewServerPreservingContexts(storeConfig, writer);
+ Map payload = new LinkedHashMap<>();
+ payload.put("xml", writer.toString());
+ payload.put("files", new ArrayList(capturing.getCaptured().keySet()));
+ // The save restarts the manager (and resets the admin session) only
+ // when the file of the context this manager runs in is rewritten.
+ payload.put("restartsManager", selfContext != null && selfContext.getConfigFile() != null);
+ Api.json(response, payload);
+ }
+
+
+ /**
+ * Store the live server state to the given writer, keeping every context in its current storage location, as
+ * regular StoreConfig does. The external context files are written to disk.
+ */
+ private void storeServerPreservingContexts(StoreConfig storeConfig, PrintWriter writer) throws Exception {
+ storeServer(storeConfig, writer, null);
+ }
+
+
+ /**
+ * Read-only variant of {@link #storeServerPreservingContexts} used by the store preview: the external context files
+ * are captured in memory (see {@link CapturingContextSF}) instead of being written to disk, so the preview never
+ * modifies the configuration on disk.
+ */
+ private CapturingContextSF previewServerPreservingContexts(StoreConfig storeConfig, StringWriter writer)
+ throws Exception {
+ CapturingContextSF capturing = new CapturingContextSF();
+ storeServer(storeConfig, new PrintWriter(writer), capturing);
+ return capturing;
+ }
+
+
+ /**
+ * Store the live server state to the given writer, keeping each context in the location it currently lives in, as
+ * regular StoreConfig does: a context backed by its own configuration file is written back to that file, a context
+ * defined inline stays inline in {@code server.xml}.
+ *
+ * The flags are set so that external contexts are written to their file ({@code storeSeparate=true},
+ * {@code externalAllowed=true}) while inline contexts are not turned into new external files
+ * ({@code externalOnly=false}). The previous flag values (and the store factory, when {@code capturing} is used)
+ * are restored afterwards. When {@code capturing} is non-null (the read-only preview), the external files are
+ * captured in memory by that factory instead of being written.
+ */
+ private void storeServer(StoreConfig storeConfig, PrintWriter writer, CapturingContextSF capturing)
+ throws Exception {
+ StoreFileMover mover =
+ new StoreFileMover(Bootstrap.getCatalinaBase(), storeConfig.getServerFilename(), storeConfig.getRegistry().getEncoding());
+
+ StoreDescription desc = storeConfig.getRegistry().findDescription(StandardContext.class);
+ boolean oldSeparate = desc.isStoreSeparate();
+ boolean oldAllowed = desc.isExternalAllowed();
+ boolean oldOnly = desc.isExternalOnly();
+ IStoreFactory oldFactory = desc.getStoreFactory();
+ try {
+ desc.setStoreSeparate(true);
+ desc.setExternalAllowed(true);
+ desc.setExternalOnly(false);
+ if (capturing != null) {
+ capturing.setRegistry(storeConfig.getRegistry());
+ if (oldFactory != null) {
+ capturing.setStoreAppender(oldFactory.getStoreAppender());
+ }
+ desc.setStoreFactory(capturing);
+ }
+ StringWriter buffer = new StringWriter();
+ storeConfig.store(new PrintWriter(buffer), -2, server);
+ writer.write(XMLFormatPreserver.preserve(mover.getConfigOld(), buffer.toString(),
+ storeConfig.getRegistry().getEncoding()));
+ } finally {
+ desc.setStoreSeparate(oldSeparate);
+ desc.setExternalAllowed(oldAllowed);
+ desc.setExternalOnly(oldOnly);
+ desc.setStoreFactory(oldFactory);
+ }
+ }
+
+
+ /**
+ * A {@link StandardContextSF} that stores external context files into in-memory buffers instead of on disk, for the
+ * read-only store preview. Writing the (watched) context files would restart the running contexts, so during a
+ * preview they are only captured.
+ */
+ private static final class CapturingContextSF extends StandardContextSF {
+
+ private final Map captured = new LinkedHashMap<>();
+
+ public Map getCaptured() {
+ return captured;
+ }
+
+ @Override
+ public void store(PrintWriter aWriter, int indent, Object aContext) throws Exception {
+ if (aContext instanceof StandardContext context && getRegistry() != null) {
+ StoreDescription desc = getRegistry().findDescription(context.getClass());
+ if (desc != null && desc.isStoreSeparate() && desc.isExternalAllowed()) {
+ URL configFile = context.getConfigFile();
+ if (configFile == null && !desc.isExternalOnly() && !context.getDeployedFromServerXml()) {
+ // The store creates a new configuration file for a context that was not deployed from
+ // server.xml. Compute the path that file would get, without setting it on the context.
+ Host host = (Host) context.getParent();
+ ContextName cn = new ContextName(context.getName(), false);
+ File config = new File(host.getConfigBaseFile(), cn.getBaseName() + ".xml");
+ configFile = config.toURI().toURL();
+ }
+ if (configFile != null) {
+ // Capture the (new) external context file in memory instead of writing it. The element is
+ // written inline (storeSeparate is temporarily off) so the separate-file branch of
+ // StandardContextSF.store is not re-entered.
+ StringWriter buffer = new StringWriter();
+ PrintWriter w = new PrintWriter(buffer);
+ storeXMLHead(w);
+ boolean savedSeparate = desc.isStoreSeparate();
+ desc.setStoreSeparate(false);
+ try {
+ super.store(w, -2, aContext);
+ } finally {
+ desc.setStoreSeparate(savedSeparate);
+ }
+ w.flush();
+ captured.put(displayPath(configFile), buffer.toString());
+ return;
+ }
+ }
+ }
+ super.store(aWriter, indent, aContext);
+ }
+ }
+
+
+ /**
+ * A context configuration file path for display: relative to the Catalina base where possible, otherwise the
+ * absolute path.
+ */
+ private static String displayPath(URL configFile) {
+ try {
+ File file = new File(configFile.toURI());
+ String base = Bootstrap.getCatalinaBase();
+ if (base != null && !base.isEmpty()) {
+ String rel = new File(base).toPath().relativize(file.toPath()).toString();
+ if (!rel.startsWith("..")) {
+ return rel.replace(File.separatorChar, '/');
+ }
+ }
+ return file.getPath().replace(File.separatorChar, '/');
+ } catch (Exception e) {
+ return String.valueOf(configFile);
+ }
+ }
+
+
+ // ------------------------------------------------------------ Helpers
+
+
+ private void requireServer() throws ConfigException {
+ if (server == null) {
+ throw new ConfigException(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "SERVER_UNAVAILABLE",
+ Strings.sm().getString("manager2.configServerUnavailable"));
+ }
+ }
+
+
+ private static String path(HttpServletRequest request) {
+ String path = request.getServletPath();
+ String info = request.getPathInfo();
+ if (info != null && !info.isEmpty()) {
+ path = path + info;
+ }
+ if (path == null || path.isEmpty()) {
+ path = "/api/config";
+ }
+ return path;
+ }
+
+
+ private static Map readJson(HttpServletRequest request) throws IOException {
+ String body = new String(request.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
+ if (body.isBlank()) {
+ return new LinkedHashMap<>();
+ }
+ try {
+ return new JSONParser(body).parseObject();
+ } catch (Exception e) {
+ throw new IllegalArgumentException(Strings.sm().getString("manager2.invalidJson", e.getMessage()), e);
+ }
+ }
+
+
+ private static String string(Object value) {
+ return value == null ? null : String.valueOf(value);
+ }
+
+
+ private static boolean bool(Object value, boolean defaultValue) {
+ if (value instanceof Boolean b) {
+ return b;
+ }
+ if (value instanceof String s) {
+ return Boolean.parseBoolean(s);
+ }
+ return defaultValue;
+ }
+
+
+ private static Integer intValue(Object value, int defaultValue) {
+ if (value instanceof Number n) {
+ return n.intValue();
+ }
+ if (value instanceof String s && !s.isEmpty()) {
+ try {
+ return Integer.parseInt(s.trim());
+ } catch (NumberFormatException e) {
+ return defaultValue;
+ }
+ }
+ return defaultValue;
+ }
+
+
+ private static List stringList(Object value) {
+ List result = new ArrayList<>();
+ if (value instanceof List list) {
+ for (Object item : list) {
+ String s = String.valueOf(item).trim();
+ if (!s.isEmpty()) {
+ result.add(s);
+ }
+ }
+ } else if (value instanceof String s && !s.isEmpty()) {
+ for (String part : s.split(",")) {
+ String trimmed = part.trim();
+ if (!trimmed.isEmpty()) {
+ result.add(trimmed);
+ }
+ }
+ }
+ return result;
+ }
+
+
+ private static String requiredName(Object value) throws ConfigException {
+ String name = string(value);
+ if (name == null || name.isEmpty() || !SAFE_NAME.matcher(name).matches()) {
+ throw new ConfigException(HttpServletResponse.SC_BAD_REQUEST, "INVALID_NAME",
+ Strings.sm().getString("manager2.configInvalidName", name));
+ }
+ return name;
+ }
+
+
+ private static String capitalize(String name) {
+ return name.substring(0, 1).toUpperCase() + name.substring(1);
+ }
+
+
+ /**
+ * Encode a value for use as a node id segment. The value is URL encoded and the {@code %2F} sequences (originating
+ * from {@code /} characters, e.g. in context paths) are replaced with a bare {@code +}, since Tomcat rejects
+ * {@code %2F} in the request URI. A literal {@code +} in the value is percent encoded, so the replacement is
+ * unambiguous.
+ */
+ private static String enc(String value) {
+ return URLEncoder.encode(value, StandardCharsets.UTF_8).replace("%2F", "+");
+ }
+
+
+ /**
+ * Encode a context path for use as a node id segment. The root context (whose path is the empty string) is encoded
+ * as a bare {@code +}, the same segment that a path of {@code /} would produce, since {@link #dec(String)} turns a
+ * bare {@code +} back into a context path.
+ */
+ private static String encContextPath(String path) {
+ if (path.isEmpty()) {
+ return "+";
+ }
+ return enc(path);
+ }
+
+
+ /**
+ * The inverse of {@link #enc(String)}.
+ */
+ private static String dec(String value) {
+ return URLDecoder.decode(value.replace("+", "%2F"), StandardCharsets.UTF_8);
+ }
+
+
+ /**
+ * A controlled failure of one API operation, carrying the HTTP status, the machine readable code and the (already
+ * localized) message.
+ */
+ private static final class ConfigException extends Exception {
+
+ @Serial
+ private static final long serialVersionUID = 1L;
+
+ private final int status;
+
+ private final String code;
+
+
+ ConfigException(int status, String code, String message) {
+ super(message);
+ this.status = status;
+ this.code = code;
+ }
+ }
+}
diff --git a/modules/manager2/src/main/java/org/apache/tomcat/manager2/Constants.java b/modules/manager2/src/main/java/org/apache/tomcat/manager2/Constants.java
new file mode 100644
index 000000000000..8e0a1ade1e10
--- /dev/null
+++ b/modules/manager2/src/main/java/org/apache/tomcat/manager2/Constants.java
@@ -0,0 +1,53 @@
+/*
+ * 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.
+ */
+package org.apache.tomcat.manager2;
+
+
+/**
+ * Common constants for the Manager2 API.
+ */
+public final class Constants {
+
+
+ /**
+ * The name of this package. Used to obtain the StringManager instance.
+ */
+ public static final String Package = "org.apache.tomcat.manager2";
+
+
+ /**
+ * The character set used for all JSON responses.
+ */
+ public static final String CHARSET = "UTF-8";
+
+
+ /**
+ * The name of the request and response header that carries the CSRF token.
+ */
+ public static final String CSRF_HEADER = "X-CSRF-Token";
+
+
+ /**
+ * The session attribute that holds the current CSRF token.
+ */
+ public static final String CSRF_TOKEN_SESSION_KEY = "org.apache.tomcat.manager2.CsrfFilter.token";
+
+
+ private Constants() {
+ // Utility class, do not instantiate
+ }
+}
diff --git a/modules/manager2/src/main/java/org/apache/tomcat/manager2/CsrfFilter.java b/modules/manager2/src/main/java/org/apache/tomcat/manager2/CsrfFilter.java
new file mode 100644
index 000000000000..f91772abb453
--- /dev/null
+++ b/modules/manager2/src/main/java/org/apache/tomcat/manager2/CsrfFilter.java
@@ -0,0 +1,144 @@
+/*
+ * 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.
+ */
+package org.apache.tomcat.manager2;
+
+import java.io.IOException;
+import java.security.MessageDigest;
+import java.security.SecureRandom;
+
+import jakarta.servlet.Filter;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.FilterConfig;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.servlet.http.HttpSession;
+
+import org.apache.juli.logging.Log;
+import org.apache.juli.logging.LogFactory;
+
+
+/**
+ * CSRF protection filter for the Manager2 JSON API (synchronizer token pattern).
+ *
+ * A 128-bit random token is generated per session and exposed to the client in the {@code X-CSRF-Token} response header
+ * of every API response. State-changing requests (anything but GET, HEAD, OPTIONS and TRACE) must echo the token in the
+ * {@code X-CSRF-Token} request header. Requests without a valid token are rejected with a 403.
+ *
+ * As defence in depth, all mutation endpoints also require {@code Content-Type: application/json} (or a multipart
+ * upload for the WAR upload endpoint) and the web application sets no CORS headers, so cross-origin requests are
+ * additionally blocked by the browser same-origin policy.
+ */
+public class CsrfFilter implements Filter {
+
+
+ /**
+ */
+ private static final SecureRandom RANDOM = new SecureRandom();
+
+ private static final int TOKEN_BYTES = 16;
+
+ private static final char[] HEX = "0123456789abcdef".toCharArray();
+
+ private static final String[] SAFE_METHODS = { "GET", "HEAD", "OPTIONS", "TRACE" };
+
+
+ private final Log log = LogFactory.getLog(CsrfFilter.class); // must not be static
+
+
+ @Override
+ public void init(FilterConfig filterConfig) {
+ // Nothing to initialize
+ }
+
+
+ @Override
+ public void destroy() {
+ // Nothing to destroy
+ }
+
+
+ @Override
+ public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
+ throws IOException, ServletException {
+
+ HttpServletRequest req = (HttpServletRequest) request;
+ HttpServletResponse resp = (HttpServletResponse) response;
+
+ HttpSession session = req.getSession();
+ String token = (String) session.getAttribute(Constants.CSRF_TOKEN_SESSION_KEY);
+ if (token == null) {
+ token = generateToken();
+ session.setAttribute(Constants.CSRF_TOKEN_SESSION_KEY, token);
+ }
+
+ // Expose the token to the client. Header must be set before the
+ // response is committed (i.e. before the servlet writes).
+ resp.setHeader(Constants.CSRF_HEADER, token);
+
+ if (isSafeMethod(req.getMethod())) {
+ chain.doFilter(request, response);
+ return;
+ }
+
+ String provided = req.getHeader(Constants.CSRF_HEADER);
+ if (provided == null || !constantTimeEquals(token, provided)) {
+ log(req, Strings.sm().getString("csrfFilter.invalid"));
+ Api.error(resp, HttpServletResponse.SC_FORBIDDEN, "CSRF", Strings.sm().getString("csrfFilter.invalid"));
+ return;
+ }
+
+ chain.doFilter(request, response);
+ }
+
+
+ private static boolean isSafeMethod(String method) {
+ for (String safe : SAFE_METHODS) {
+ if (safe.equals(method)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+
+ private static boolean constantTimeEquals(String a, String b) {
+ byte[] ab = a.getBytes(java.nio.charset.StandardCharsets.US_ASCII);
+ byte[] bb = b.getBytes(java.nio.charset.StandardCharsets.US_ASCII);
+ return MessageDigest.isEqual(ab, bb);
+ }
+
+
+ private static String generateToken() {
+ byte[] bytes = new byte[TOKEN_BYTES];
+ RANDOM.nextBytes(bytes);
+ char[] chars = new char[bytes.length * 2];
+ for (int i = 0; i < bytes.length; i++) {
+ chars[i * 2] = HEX[(bytes[i] >> 4) & 0xF];
+ chars[i * 2 + 1] = HEX[bytes[i] & 0xF];
+ }
+ return new String(chars);
+ }
+
+
+ private void log(HttpServletRequest req, String message) {
+ log.info(message + " method=[" + req.getMethod() + "] uri=[" + req.getRequestURI() + "] remoteAddr=[" +
+ req.getRemoteAddr() + "] principal=[" + req.getUserPrincipal() + "]");
+ }
+}
diff --git a/modules/manager2/src/main/java/org/apache/tomcat/manager2/ErrorServlet.java b/modules/manager2/src/main/java/org/apache/tomcat/manager2/ErrorServlet.java
new file mode 100644
index 000000000000..829c134a249d
--- /dev/null
+++ b/modules/manager2/src/main/java/org/apache/tomcat/manager2/ErrorServlet.java
@@ -0,0 +1,60 @@
+/*
+ * 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.
+ */
+package org.apache.tomcat.manager2;
+
+import java.io.IOException;
+
+import jakarta.servlet.RequestDispatcher;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServlet;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+
+
+/**
+ * Renders the 403 and 404 error pages. The pages are rendered from their templates (instead of being served as static
+ * resources) so that a {@code } element can be injected: error pages can be displayed at arbitrary URLs (the
+ * browser keeps the URL of the failed request) and the relative link to the CSS would otherwise break.
+ */
+public class ErrorServlet extends HttpServlet {
+
+
+ private static final long serialVersionUID = 1L;
+
+ private static final String TEMPLATE_403 = "/error-403.html";
+ private static final String TEMPLATE_404 = "/error-404.html";
+
+
+ @Override
+ protected void doGet(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ int status = HttpServletResponse.SC_NOT_FOUND;
+ Object errorStatus = request.getAttribute(RequestDispatcher.ERROR_STATUS_CODE);
+ if (errorStatus instanceof Integer code) {
+ status = code;
+ }
+
+ String template = Html.readTemplate(getServletContext(),
+ status == HttpServletResponse.SC_FORBIDDEN ? TEMPLATE_403 : TEMPLATE_404);
+ if (template == null) {
+ return; // Let the container render the default error page.
+ }
+
+ Html.render(request, response, template);
+ }
+}
diff --git a/modules/manager2/src/main/java/org/apache/tomcat/manager2/HeadersFilter.java b/modules/manager2/src/main/java/org/apache/tomcat/manager2/HeadersFilter.java
new file mode 100644
index 000000000000..dc14c51c0cd9
--- /dev/null
+++ b/modules/manager2/src/main/java/org/apache/tomcat/manager2/HeadersFilter.java
@@ -0,0 +1,67 @@
+/*
+ * 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.
+ */
+package org.apache.tomcat.manager2;
+
+import java.io.IOException;
+
+import jakarta.servlet.Filter;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.FilterConfig;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.http.HttpServletResponse;
+
+
+/**
+ * Adds the security headers that {@link org.apache.catalina.filters.HttpHeaderSecurityFilter} does not cover (a
+ * Content-Security-Policy and a Referrer-Policy) to every response. The web application uses no inline scripts, no
+ * external resources and no frames, so the policy does not need any 'unsafe-*' directives.
+ */
+public class HeadersFilter implements Filter {
+
+
+ private static final String CSP = "default-src 'self'; script-src 'self'; style-src 'self'; " +
+ "img-src 'self' data:; connect-src 'self'; frame-ancestors 'none'; " +
+ "base-uri 'self'; form-action 'self'";
+
+ private static final String REFERRER_POLICY = "no-referrer";
+
+
+ @Override
+ public void init(FilterConfig filterConfig) {
+ // Nothing to initialize
+ }
+
+
+ @Override
+ public void destroy() {
+ // Nothing to destroy
+ }
+
+
+ @Override
+ public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
+ throws IOException, ServletException {
+
+ HttpServletResponse resp = (HttpServletResponse) response;
+ resp.setHeader("Content-Security-Policy", CSP);
+ resp.setHeader("Referrer-Policy", REFERRER_POLICY);
+
+ chain.doFilter(request, response);
+ }
+}
diff --git a/modules/manager2/src/main/java/org/apache/tomcat/manager2/HomeServlet.java b/modules/manager2/src/main/java/org/apache/tomcat/manager2/HomeServlet.java
new file mode 100644
index 000000000000..1ac6fad5ea88
--- /dev/null
+++ b/modules/manager2/src/main/java/org/apache/tomcat/manager2/HomeServlet.java
@@ -0,0 +1,85 @@
+/*
+ * 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.
+ */
+package org.apache.tomcat.manager2;
+
+import java.io.IOException;
+
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServlet;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+
+
+/**
+ * Serves the SPA entry point and the SPA deep-link routes (e.g. {@code /apps}, {@code /hosts}, {@code /monitoring},
+ * {@code /diagnostics}) which have no server-side resource of their own.
+ *
+ * Unauthenticated visitors are forwarded to the login page. Authenticated users get the SPA shell (rendered from
+ * {@code /index.html}, with the {@code } element injected) so that the browser keeps the requested URL (deep
+ * links survive a reload). Rendering the shell as a template - instead of forwarding to the static file - is what
+ * makes multi-segment deep links (e.g. {@code /apps/localhost/myapp}) work: without a base element the browser would
+ * resolve the shell's relative asset URLs against the deep path.
+ *
+ * The SPA shell itself is deliberately not protected with a security constraint: a constraint on {@code /}
+ * would match every request in the context (including the CSS and JS that the login page needs) and would poison the
+ * FORM authentication "saved request" with asset URLs. Access control for the data is enforced by the constraints on
+ * {@code /api/*}.
+ */
+public class HomeServlet extends HttpServlet {
+
+
+ private static final long serialVersionUID = 1L;
+
+
+ @Override
+ protected void doGet(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ if (request.getServletPath().isEmpty() && !request.getRequestURI().endsWith("/")) {
+ // The request targets the context root without a trailing slash
+ // (e.g. /manager2). Redirect to the trailing-slash form so that
+ // the browser resolves this application's relative URLs (CSS,
+ // JS, images) against the context instead of the server root.
+ // The mapper's own context root redirect
+ // (Context#setMapperContextRootRedirectEnabled) cannot do this:
+ // it only applies when no servlet is mapped to the context
+ // root, but this servlet is (via the empty URL pattern, which
+ // the mapper registers as the exact match "/").
+ response.sendRedirect(request.getContextPath() + "/");
+ return;
+ }
+
+ if (request.getUserPrincipal() != null) {
+ String template = Html.readTemplate(getServletContext(), "/index.html");
+ if (template == null) {
+ response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
+ Strings.manager(request).getString("manager2.shellMissing"));
+ return;
+ }
+ Html.render(request, response, template);
+ } else {
+ request.getRequestDispatcher("/login").forward(request, response);
+ }
+ }
+
+
+ @Override
+ protected void doPost(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
+ }
+}
diff --git a/modules/manager2/src/main/java/org/apache/tomcat/manager2/HostsApiServlet.java b/modules/manager2/src/main/java/org/apache/tomcat/manager2/HostsApiServlet.java
new file mode 100644
index 000000000000..61b810567678
--- /dev/null
+++ b/modules/manager2/src/main/java/org/apache/tomcat/manager2/HostsApiServlet.java
@@ -0,0 +1,248 @@
+/*
+ * 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.
+ */
+package org.apache.tomcat.manager2;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.io.Serial;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+
+import org.apache.catalina.Container;
+import org.apache.catalina.Host;
+import org.apache.catalina.manager.host.HostManagerServlet;
+import org.apache.tomcat.util.json.JSONParser;
+import org.apache.tomcat.util.res.StringManager;
+
+
+/**
+ * The Manager2 virtual host API. Delegates the actual operations to the protected methods of
+ * {@link HostManagerServlet}.
+ */
+public class HostsApiServlet extends HostManagerServlet {
+
+
+ @Serial
+ private static final long serialVersionUID = 1L;
+
+
+ @Override
+ public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
+
+ String path = path(request);
+
+ if (path.equals("/api/hosts")) {
+ Api.json(response, hosts());
+ } else {
+ Api.notFound(response);
+ }
+ }
+
+
+ @Override
+ public void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException {
+
+ String path = path(request);
+
+ if (path.equals("/api/hosts")) {
+ try {
+ handleAdd(request, response);
+ } catch (IllegalArgumentException e) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "INVALID_JSON", e.getMessage());
+ }
+ } else if (path.equals("/api/hosts/persist")) {
+ sendResult(response, invoke(pw -> super.persist(pw, legacySm(request))));
+ } else if (path.matches("/api/hosts/[^/]+/start")) {
+ sendResult(response, invoke(pw -> super.start(pw, nameOf(path), legacySm(request))));
+ } else if (path.matches("/api/hosts/[^/]+/stop")) {
+ sendResult(response, invoke(pw -> super.stop(pw, nameOf(path), legacySm(request))));
+ } else {
+ Api.notFound(response);
+ }
+ }
+
+
+ @Override
+ public void doDelete(HttpServletRequest request, HttpServletResponse response) throws IOException {
+
+ String path = path(request);
+
+ if (path.matches("/api/hosts/[^/]+")) {
+ String name = nameOf(path);
+ sendResult(response, invoke(pw -> super.remove(pw, name, legacySm(request))));
+ } else {
+ Api.notFound(response);
+ }
+ }
+
+
+ private void handleAdd(HttpServletRequest request, HttpServletResponse response) throws IOException {
+ Map body = readJson(request);
+
+ String name = string(body.get("name"));
+ String aliases = aliasesOf(body.get("aliases"));
+ String appBase = string(body.get("appBase"));
+ boolean manager = booleanValue(body.get("manager"), false);
+ boolean autoDeploy = booleanValue(body.get("autoDeploy"), true);
+ boolean deployOnStartup = booleanValue(body.get("deployOnStartup"), true);
+ boolean deployXML = booleanValue(body.get("deployXML"), true);
+ boolean unpackWARs = booleanValue(body.get("unpackWARs"), true);
+ boolean copyXML = booleanValue(body.get("copyXML"), false);
+
+ sendResult(response, invoke(pw -> super.add(pw, name, aliases, appBase, manager, autoDeploy, deployOnStartup,
+ deployXML, unpackWARs, copyXML, legacySm(request))));
+ }
+
+
+ private List> hosts() {
+ List> result = new ArrayList<>();
+ Container[] children = engine.findChildren();
+ for (Container child : children) {
+ Host h = (Host) child;
+ Map entry = new LinkedHashMap<>();
+ entry.put("name", h.getName());
+ entry.put("aliases", List.of(h.findAliases()));
+ entry.put("appBase", h.getAppBaseFile() != null ? h.getAppBaseFile().getPath() : null);
+ entry.put("state", h.getState().toString());
+ // Whether the host is up and accepting applications: the same
+ // test the classic host manager uses for start/stop.
+ entry.put("started", h.getState().isAvailable());
+ entry.put("self", Boolean.valueOf(h == installedHost));
+ result.add(entry);
+ }
+ result.sort((a, b) -> String.valueOf(a.get("name")).compareTo(String.valueOf(b.get("name"))));
+ return result;
+ }
+
+
+ /**
+ * The servlet path plus the path info, so the mapping can be either a path mapping ({@code /api/hosts/*}) or an
+ * exact mapping.
+ */
+ private static String path(HttpServletRequest request) {
+ String path = request.getServletPath();
+ String info = request.getPathInfo();
+ if (info != null && !info.isEmpty()) {
+ path = path + info;
+ }
+ if (path == null || path.isEmpty()) {
+ path = "/api/hosts";
+ }
+ return path;
+ }
+
+
+ private static String nameOf(String path) {
+ String[] parts = path.split("/");
+ // path is /api/hosts/{name} or /api/hosts/{name}/{action}
+ if (parts.length >= 3 && ("start".equals(parts[parts.length - 1]) || "stop".equals(parts[parts.length - 1]))) {
+ return parts[parts.length - 2];
+ }
+ return parts[parts.length - 1];
+ }
+
+
+ private static String string(Object value) {
+ return value == null ? null : String.valueOf(value);
+ }
+
+
+ /**
+ * Convert the {@code aliases} JSON value (array or comma separated string) to the comma separated string expected
+ * by {@link HostManagerServlet#add}.
+ */
+ private static String aliasesOf(Object value) {
+ if (value instanceof List list) {
+ List parts = new ArrayList<>();
+ for (Object item : list) {
+ parts.add(String.valueOf(item));
+ }
+ return String.join(",", parts);
+ }
+ if (value instanceof String s && !s.isEmpty()) {
+ return s;
+ }
+ return null;
+ }
+
+
+ private static boolean booleanValue(Object value, boolean defaultValue) {
+ if (value instanceof Boolean b) {
+ return b;
+ }
+ if (value instanceof String s) {
+ return Boolean.parseBoolean(s);
+ }
+ return defaultValue;
+ }
+
+
+ private static Map readJson(HttpServletRequest request) throws IOException {
+ String body = new String(request.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
+ if (body.isBlank()) {
+ return new LinkedHashMap<>();
+ }
+ try {
+ return new JSONParser(body).parseObject();
+ } catch (Exception e) {
+ throw new IllegalArgumentException(Strings.sm().getString("manager2.invalidJson", e.getMessage()), e);
+ }
+ }
+
+
+ /**
+ * Run one of the inherited text-based operations, capturing the result message.
+ */
+ private String invoke(Operation operation) {
+ StringWriter stringWriter = new StringWriter();
+ try (PrintWriter writer = new PrintWriter(stringWriter)) {
+ operation.run(writer);
+ }
+ return stringWriter.toString().trim();
+ }
+
+
+ /**
+ * A StringManager for the legacy host-manager message bundle. All the inherited operations report their results
+ * using the {@code org.apache.catalina.manager.host} strings.
+ */
+ private static StringManager legacySm(HttpServletRequest request) {
+ return StringManager.getManager("org.apache.catalina.manager.host", request.getLocales());
+ }
+
+
+ @FunctionalInterface
+ private interface Operation {
+ void run(PrintWriter writer);
+ }
+
+
+ private void sendResult(HttpServletResponse response, String message) throws IOException {
+ if (message.startsWith("FAIL -")) {
+ Api.error(response, HttpServletResponse.SC_BAD_REQUEST, "OPERATION_FAILED", message);
+ } else {
+ Api.ok(response, message);
+ }
+ }
+}
diff --git a/modules/manager2/src/main/java/org/apache/tomcat/manager2/Html.java b/modules/manager2/src/main/java/org/apache/tomcat/manager2/Html.java
new file mode 100644
index 000000000000..b3ac04a5d6f2
--- /dev/null
+++ b/modules/manager2/src/main/java/org/apache/tomcat/manager2/Html.java
@@ -0,0 +1,163 @@
+/*
+ * 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.
+ */
+package org.apache.tomcat.manager2;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Locale;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import jakarta.servlet.ServletContext;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+
+import org.apache.tomcat.util.res.StringManager;
+
+
+/**
+ * Renders the static HTML pages that are served by a servlet (the SPA shell, the login page and the error pages)
+ * instead of by the default servlet. The pages are rendered from their templates so that a {@code } element can
+ * be injected. The base element is required because these pages can be displayed at arbitrary URLs (the browser keeps
+ * the URL of the request that triggered the forward to the page), which would break the relative links to the CSS.
+ *
+ * Rendering also localizes the templates: {@code #{key}} tokens are replaced with the messages of the
+ * {@link StringManager} matching the locales sent by the client, and the {@code {{lang}}} token with the language tag
+ * of that {@link StringManager}'s locale.
+ */
+final class Html {
+
+
+ /**
+ * Placeholder for the {@code } element in the HTML templates. It must be on a line of its own inside the
+ * {@code
} element.
+ */
+ static final String BASE_PLACEHOLDER = "";
+
+ /**
+ * Token in the HTML templates that is replaced with the localized messages identified by the key inside the
+ * braces, e.g. {@code #{manager2.ui.login.title}}.
+ */
+ static final Pattern MESSAGE_TOKEN = Pattern.compile("#\\{([^{}\\s]+)\\}");
+
+ /**
+ * Token in the HTML templates that is replaced with the language tag of the locale of the response, for the
+ * {@code lang} attribute of the {@code } element.
+ */
+ static final String LANG_TOKEN = "{{lang}}";
+
+
+ private Html() {
+ // Utility class
+ }
+
+
+ /**
+ * Read a template from the web application.
+ *
+ * @param context the servlet context
+ * @param path the context-relative template path, e.g. {@code /login.html}
+ *
+ * @return the template content, or {@code null} if it is missing
+ */
+ static String readTemplate(ServletContext context, String path) {
+ try (InputStream is = context.getResourceAsStream(path)) {
+ if (is == null) {
+ return null;
+ }
+ return new String(is.readAllBytes(), StandardCharsets.UTF_8);
+ } catch (IOException e) {
+ return null;
+ }
+ }
+
+
+ /**
+ * Render a template: localize it with the locales of the request, inject the base element and write the result to
+ * the response.
+ *
+ * @param request the current request (used for the context path and the locales)
+ * @param response the response to write
+ * @param template the template content
+ *
+ * @throws IOException if writing the response fails
+ */
+ static void render(HttpServletRequest request, HttpServletResponse response, String template) throws IOException {
+ render(request, response, template, Strings.manager(request));
+ }
+
+
+ /**
+ * Render a template: localize it with the given string manager, inject the base element and write the result to
+ * the response.
+ *
+ * @param request the current request (used for the context path)
+ * @param response the response to write
+ * @param template the template content
+ * @param sm the string manager holding the localized messages
+ *
+ * @throws IOException if writing the response fails
+ */
+ static void render(HttpServletRequest request, HttpServletResponse response, String template,
+ StringManager sm) throws IOException {
+
+ String html = localize(template, sm);
+ html = html.replace(BASE_PLACEHOLDER, "");
+ response.setContentType("text/html");
+ response.setCharacterEncoding("UTF-8");
+ response.getWriter().print(html);
+ }
+
+
+ /**
+ * Replace the message and language tokens of a template with localized values.
+ *
+ * @param template the template content
+ * @param sm the string manager holding the localized messages
+ *
+ * @return the localized template
+ */
+ static String localize(String template, StringManager sm) {
+ Matcher matcher = MESSAGE_TOKEN.matcher(template);
+ StringBuilder result = new StringBuilder(template.length());
+ while (matcher.find()) {
+ String message = sm.getString(matcher.group(1));
+ // Unknown keys are left as-is so that they stand out in the page
+ String replacement = message == null ? matcher.group() : escapeHtml(message);
+ matcher.appendReplacement(result, Matcher.quoteReplacement(replacement));
+ }
+ matcher.appendTail(result);
+ return result.toString().replace(LANG_TOKEN, sm.getLocale().toLanguageTag());
+ }
+
+
+ private static String escapeHtml(String value) {
+ StringBuilder result = new StringBuilder(value.length());
+ for (int i = 0; i < value.length(); i++) {
+ char c = value.charAt(i);
+ switch (c) {
+ case '&' -> result.append("&");
+ case '<' -> result.append("<");
+ case '>' -> result.append(">");
+ case '"' -> result.append(""");
+ default -> result.append(c);
+ }
+ }
+ return result.toString();
+ }
+}
diff --git a/modules/manager2/src/main/java/org/apache/tomcat/manager2/I18nServlet.java b/modules/manager2/src/main/java/org/apache/tomcat/manager2/I18nServlet.java
new file mode 100644
index 000000000000..08f4e71e6dc7
--- /dev/null
+++ b/modules/manager2/src/main/java/org/apache/tomcat/manager2/I18nServlet.java
@@ -0,0 +1,126 @@
+/*
+ * 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.
+ */
+package org.apache.tomcat.manager2;
+
+import java.io.IOException;
+import java.io.Serial;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import jakarta.servlet.Servlet;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServlet;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+
+import org.apache.tomcat.util.res.StringManager;
+
+
+/**
+ * Serves the client-side messages of this web application (the {@code manager2.ui.*} keys of the
+ * {@code LocalStrings} bundle) as JSON, localized with the locales the browser sends in its {@code Accept-Language}
+ * header, so that the scripts localize the interface with the same bundle as the server side.
+ *
+ * The endpoint is deliberately outside {@code /api/*}: it is not protected by a security constraint (the login page
+ * needs it too) and it is not covered by the CSRF filter. It exposes only message templates from the bundle, never
+ * server data, and it answers GET requests only.
+ */
+public class I18nServlet extends HttpServlet implements Servlet {
+
+
+ @Serial
+ private static final long serialVersionUID = 1L;
+
+
+ /**
+ * Prefix of the keys of the {@code LocalStrings} bundle that the client renders.
+ */
+ static final String CLIENT_KEY_PREFIX = "manager2.ui.";
+
+
+ /**
+ * The keys to serve, sorted, read once from the base bundle.
+ */
+ private volatile List keys;
+
+ /**
+ * The rendered JSON payloads, keyed by the (internally cached) string managers. Bounded, since the string manager
+ * cache itself is bounded.
+ */
+ private final Map payloadCache = Collections.synchronizedMap(
+ new LinkedHashMap<>(16, 0.75f, true) {
+ @Serial
+ private static final long serialVersionUID = 1L;
+
+ @Override
+ protected boolean removeEldestEntry(Map.Entry eldest) {
+ return size() > 16;
+ }
+ });
+
+
+ @Override
+ protected void doGet(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ StringManager sm = Strings.manager(request);
+ String body = payloadCache.computeIfAbsent(sm, this::buildPayload);
+
+ response.setStatus(HttpServletResponse.SC_OK);
+ response.setContentType("application/json; charset=" + Constants.CHARSET);
+ response.setCharacterEncoding(Constants.CHARSET);
+ response.setHeader("Cache-Control", "private, max-age=3600");
+ response.setHeader("Vary", "Accept-Language");
+ response.setContentLength(body.getBytes(java.nio.charset.StandardCharsets.UTF_8).length);
+ response.getWriter().print(body);
+ }
+
+
+ @Override
+ protected void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException {
+ response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
+ }
+
+
+ private String buildPayload(StringManager sm) {
+ Map messages = new LinkedHashMap<>();
+ for (String key : clientKeys()) {
+ String message = sm.getString(key);
+ if (message != null) {
+ messages.put(key, message);
+ }
+ }
+ Map payload = new LinkedHashMap<>();
+ payload.put("locale", sm.getLocale().toLanguageTag());
+ payload.put("messages", messages);
+ return Json.write(payload);
+ }
+
+
+ private List clientKeys() {
+ List result = keys;
+ if (result == null) {
+ result = new ArrayList<>(Strings.keys(CLIENT_KEY_PREFIX));
+ result.sort(String::compareTo);
+ keys = result;
+ }
+ return result;
+ }
+}
diff --git a/modules/manager2/src/main/java/org/apache/tomcat/manager2/Json.java b/modules/manager2/src/main/java/org/apache/tomcat/manager2/Json.java
new file mode 100644
index 000000000000..793a5c45e98b
--- /dev/null
+++ b/modules/manager2/src/main/java/org/apache/tomcat/manager2/Json.java
@@ -0,0 +1,124 @@
+/*
+ * 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.
+ */
+package org.apache.tomcat.manager2;
+
+import java.util.List;
+import java.util.Map;
+
+
+/**
+ * Minimal JSON writer used by the Manager2 API. The supported value types are {@code null}, {@link String},
+ * {@link Number}, {@link Boolean}, {@link Map} and {@link List}.
+ */
+public final class Json {
+
+
+ /**
+ * Serialize the given value to JSON.
+ *
+ * @param value the value to serialize
+ *
+ * @return the JSON representation
+ */
+ public static String write(Object value) {
+ StringBuilder result = new StringBuilder(128);
+ writeValue(result, value);
+ return result.toString();
+ }
+
+
+ /**
+ * Escape a string for inclusion in a JSON string literal (quotes and backslashes only; the value is written by the
+ * caller between double quotes).
+ *
+ * @param value the value to escape
+ *
+ * @return the escaped value
+ */
+ public static String escape(String value) {
+ StringBuilder result = new StringBuilder(value.length() + 8);
+ for (int i = 0; i < value.length(); i++) {
+ char c = value.charAt(i);
+ switch (c) {
+ case '"' -> result.append("\\\"");
+ case '\\' -> result.append("\\\\");
+ case '\b' -> result.append("\\b");
+ case '\f' -> result.append("\\f");
+ case '\n' -> result.append("\\n");
+ case '\r' -> result.append("\\r");
+ case '\t' -> result.append("\\t");
+ default -> {
+ if (c < 0x20) {
+ result.append(String.format("\\u%04x", (int) c));
+ } else {
+ result.append(c);
+ }
+ }
+ }
+ }
+ return result.toString();
+ }
+
+
+ private static void writeValue(StringBuilder sb, Object value) {
+ if (value == null) {
+ sb.append("null");
+ } else if (value instanceof String s) {
+ sb.append('"').append(escape(s)).append('"');
+ } else if (value instanceof Boolean b) {
+ sb.append(b);
+ } else if (value instanceof Number n) {
+ // Render integral numbers without a fractional part
+ if (n instanceof Double d && d == Math.floor(d) && !Double.isInfinite(d)) {
+ sb.append(n.longValue());
+ } else {
+ sb.append(n);
+ }
+ } else if (value instanceof Map map) {
+ sb.append('{');
+ boolean first = true;
+ for (Map.Entry entry : map.entrySet()) {
+ if (!first) {
+ sb.append(',');
+ }
+ first = false;
+ sb.append('"').append(escape(String.valueOf(entry.getKey()))).append("\":");
+ writeValue(sb, entry.getValue());
+ }
+ sb.append('}');
+ } else if (value instanceof List list) {
+ sb.append('[');
+ boolean first = true;
+ for (Object item : list) {
+ if (!first) {
+ sb.append(',');
+ }
+ first = false;
+ writeValue(sb, item);
+ }
+ sb.append(']');
+ } else {
+ // Fallback: treat as string
+ sb.append('"').append(escape(String.valueOf(value))).append('"');
+ }
+ }
+
+
+ private Json() {
+ // Utility class, do not instantiate
+ }
+}
diff --git a/modules/manager2/src/main/java/org/apache/tomcat/manager2/LocalStrings.properties b/modules/manager2/src/main/java/org/apache/tomcat/manager2/LocalStrings.properties
new file mode 100644
index 000000000000..c9174dea76cd
--- /dev/null
+++ b/modules/manager2/src/main/java/org/apache/tomcat/manager2/LocalStrings.properties
@@ -0,0 +1,1056 @@
+# -----------------------------------------------------------------------------
+# 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.
+# -----------------------------------------------------------------------------
+
+csrfFilter.invalid=CSRF token missing or invalid. Reload the page and try again.
+
+manager2.error.jmx=Error querying the MBean server
+manager2.error.status=Error collecting runtime status
+manager2.error.upload=Error during WAR upload
+manager2.history.invalidParameter=The init parameter [{0}] of the status API servlet has an invalid value [{1}]. The default value will be used.
+manager2.historyNotAvailable=The status history is not available.
+manager2.error.logs=Error reading a log file
+manager2.logsDirMissing=The logs directory of this Tomcat instance could not be found.
+manager2.invalidLogName=The log file name is missing or invalid.
+manager2.accessPatternDangling=The access log pattern [{0}] ends with a trailing percent sign.
+manager2.accessPatternMalformed=The access log pattern [{0}] is malformed.
+manager2.accessPatternUnsupported=The access log pattern contains an unsupported directive [{0}].
+manager2.accessPatternInvalid=The access log pattern [{0}] is invalid.
+
+manager2.error.users=Error managing the user database
+manager2.userDatabaseMissing=No user database is configured for this server. Add a UserDatabase JNDI resource (for example the file based one from the default server.xml) to manage users, groups and roles.
+manager2.userDatabaseLookup=Error looking up the JNDI resource [{0}]
+manager2.userDatabaseNotFound=The user database [{0}] is not configured for this server.
+manager2.userDatabaseReadonly=The user database [{0}] is read-only. Add readonly="false" to its Resource definition in server.xml and restart the server to allow changes.
+manager2.userDatabaseNotWritable=The user database [{0}] cannot be persisted: its storage location is not writable.
+manager2.userDatabaseSaveFailed=The changes could not be saved to the user database: {0}
+manager2.usersSaved=The changes were saved to the user database.
+manager2.userExists=The user [{0}] already exists.
+manager2.groupExists=The group [{0}] already exists.
+manager2.roleExists=The role [{0}] already exists.
+manager2.userNotFound=The user [{0}] was not found in the user database.
+manager2.groupNotFound=The group [{0}] was not found in the user database.
+manager2.roleNotFound=The role [{0}] was not found in the user database.
+manager2.selfRemoval=The user cannot be removed while signed in as that user.
+manager2.selfRoleRemoval=The role [{0}] cannot be removed while signed in as a user that holds it, directly or through a group.
+manager2.unknownGroupMember=Unknown user(s) in the group members: {0}
+manager2.usernameMissing=The user name [{0}] is missing or invalid.
+manager2.groupnameMissing=The group name [{0}] is missing or invalid.
+manager2.rolenameMissing=The role name [{0}] is missing or invalid.
+manager2.passwordMissing=The password is missing.
+
+manager2.invalidJson=Invalid JSON in request body: {0}
+manager2.expectedStringArray=expected an array of strings
+manager2.missingPath=The context path was not specified or is invalid.
+manager2.sessionNotFound=Session [{0}] was not found.
+manager2.attributeRemoved=Session attribute [{0}] removed.
+manager2.attributeNotFound=The session did not contain any attribute named [{0}].
+manager2.pathCheckFail=Invalid target path [{0}] for the host appBase [{1}].
+manager2.pathCheckError=Error checking the target path [{0}] for the host appBase [{1}]: {2}
+
+manager2.error.config=Error during a configuration operation
+manager2.configServerUnavailable=The server component could not be determined.
+manager2.configInvalidId=The component id is missing or invalid.
+manager2.configNotFound=The component was not found.
+manager2.configAttributeNotFound=The attribute [{0}] is not defined for this component.
+manager2.configReadOnly=The attribute [{0}] is read-only.
+manager2.configInvalidValue=The value for the attribute [{0}] is not valid.
+manager2.configInvalidName=The component name [{0}] is missing or invalid.
+manager2.configInvalidPath=The path [{0}] is missing or invalid.
+manager2.configInvalidClass=The component class [{0}] could not be instantiated.
+manager2.configNoSetter=No setter is available for the attribute (method [{0}]).
+manager2.configSetFailed=The attribute [{0}] could not be updated: {1}
+manager2.configAttributeUpdated=Attribute [{0}] of [{1}] has been updated.
+manager2.configConfirmRequired=This operation requires confirmation. Type [{0}] to confirm.
+manager2.configRequiredComponent=The {0} of a context is required and cannot be removed. Replace it with a different implementation instead.
+manager2.configRequiredNamingResources=The JNDI naming resources cannot be removed.
+manager2.configContextMustBeStopped=The resources of a running context cannot be replaced. Stop the context [{0}] first.
+manager2.configSelfComponent=This component hosts the manager web application itself and cannot be renamed, removed, started or stopped.
+manager2.configBasicValve=The basic valve of a container cannot be removed.
+manager2.configLastRealm=The realm of this container cannot be removed: the container would be left without a realm. Add a replacement realm first.
+manager2.configLastService=The last service of the server cannot be removed.
+manager2.configMaxNestedRealms=A realm can be nested at most 3 levels deep.
+manager2.configNotEmpty=The {0} still contains components and cannot be removed.
+manager2.configRemoveNotSupported=A {0} cannot be removed from a running cluster. Remove the cluster itself and re-add it, or edit server.xml directly.
+manager2.configDuplicate=A component named [{0}] already exists.
+manager2.configParentInvalid=The parent component does not accept a child of type [{0}].
+manager2.configTypeUnsupported=The component type [{0}] is not supported.
+manager2.configAdded=The component [{0}] has been added.
+manager2.configStartFailed=The component [{0}] could not be started: {1}
+manager2.configAddFailed=The component [{0}] could not be added: {1}
+manager2.configRollbackFailed=The failed component [{0}] could not be rolled back: {1}
+manager2.configExecutorInvalid=The executor settings are invalid: minSpareThreads must be less than or equal to maxThreads.
+manager2.configDocBaseMissing=The document base [{0}] of the context does not exist and could not be created.
+manager2.configRemoveFailed=The component could not be removed: {0}
+manager2.configRemoved=The component [{0}] has been removed.
+manager2.configJndiTypeRequired=The JNDI type (jndiType) is required for a {0}.
+manager2.configJndiGlobalRequired=The JNDI name of the global resource (global) is required for a resourceLink.
+manager2.configJndiNameTaken=The JNDI name [{0}] is already in use.
+manager2.configInvalidType=not a valid {0}
+manager2.configFactoryInvalid=The JNDI factory class [{0}] could not be loaded.
+manager2.configSslUnsupported=The protocol handler [{0}] of this connector does not support TLS.
+manager2.configSslCertificateRequired=A running connector cannot be switched to TLS without a certificate. Provide the certificate together with the SSL host configuration.
+manager2.configSslDefault=The default SSL host configuration of a running, TLS enabled connector cannot be removed while other configurations remain.
+manager2.configSslLastCertificate=The last certificate of the running, TLS enabled connector [{0}] cannot be removed. Stop the connector first.
+manager2.configSslReloadFailed=The attribute [{0}] of [{1}] was reverted: the TLS configuration of the connector does not accept it: {2}
+manager2.configUpgradeUnsupported=The protocol handler [{0}] of this connector does not support upgrade protocols.
+manager2.configUpgradeProtocolAdded=The upgrade protocol [{0}] has been added. Restart the connector to make it take effect.
+manager2.configStoreFailed=The configuration could not be written to server.xml.
+manager2.configStored=The configuration has been written to {0}. Backup: {1}
+manager2.configInvalidOp=The lifecycle operation [{0}] is not valid.
+manager2.configNotALifecycle=The component [{0}] has no lifecycle: it cannot be started, stopped or restarted.
+manager2.configStopFailed=The component [{0}] could not be stopped: {1}
+manager2.configStopped=The component [{0}] has been stopped.
+manager2.configStarted=The component [{0}] has been started.
+manager2.configRestarted=The component [{0}] has been restarted.
+manager2.configAlreadyRunning=The component [{0}] is already running.
+manager2.configAlreadyStopped=The component [{0}] is already stopped.
+manager2.configNotStarted=the component did not start
+manager2.configNotStopped=the component did not stop
+manager2.configAuditAttribute=Config: set attribute [{0}] of [{1}] to [{2}]
+manager2.configAuditAdd=Config: added {0} [{1}]
+manager2.configAuditRemove=Config: removed {0} [{1}]
+manager2.configAuditStore=Config: stored configuration to conf/server.xml (backup: {0})
+manager2.configAuditLifecycle=Config: {0} component [{1}]
+
+
+# ----------------------------------------------------------------
+# User interface strings. The manager2.ui.* keys are delivered to the
+# browser by the /i18n endpoint (and substituted into the static
+# HTML templates by Html.render); everything else is server-side
+# only.
+# ----------------------------------------------------------------
+manager2.ui.accesslog.subtitle=Access log files. The available filters (method, status, user, session ID) depend on the configured log format.
+manager2.ui.api.csrfTokenMissing=CSRF token not available. Reload the page and try again.
+manager2.ui.api.forbidden=Access denied (403): the signed-in account does not have the role required for this operation.
+manager2.ui.api.requestFailed=Request failed with status {0}
+manager2.ui.apps.attributeRemoved=Attribute removed.
+manager2.ui.apps.attributes=Attributes
+manager2.ui.apps.avgSessionLifetime=Avg session lifetime
+manager2.ui.apps.cannotUndeploySelf=Cannot undeploy the manager itself
+manager2.ui.apps.colClass=Class
+manager2.ui.apps.colCreated=Created
+manager2.ui.apps.colId=Id
+manager2.ui.apps.colLastAccessed=Last accessed
+manager2.ui.apps.colLocale=Locale
+manager2.ui.apps.colMaxTime=Max time
+manager2.ui.apps.colTimeout=Timeout (s)
+manager2.ui.apps.colValue=Value
+manager2.ui.apps.contextPath=Context path
+manager2.ui.apps.contextPathHint=Defaults to the WAR file name.
+manager2.ui.apps.contextPathOptional=Context path (optional)
+manager2.ui.apps.deploy=Deploy
+manager2.ui.apps.deployButton=Deploy application
+manager2.ui.apps.deployTitle=Deploy application
+manager2.ui.apps.details=Details
+manager2.ui.apps.displayName=Display name
+manager2.ui.apps.docBase=Doc base
+manager2.ui.apps.expireIdle=Expire idle
+manager2.ui.apps.expiredSessions=Expired sessions
+manager2.ui.apps.idleSecondsPlaceholder=idle seconds
+manager2.ui.apps.idleTimeoutNeeded=Enter an idle timeout in seconds.
+manager2.ui.apps.invalidateSelected=Invalidate selected
+manager2.ui.apps.invalidateSession=Invalidate session
+manager2.ui.apps.invalidateSessionConfirm=Invalidate session {0}?
+manager2.ui.apps.invalidateSessionTitle=Invalidate session
+manager2.ui.apps.invalidateSessionsConfirm=Invalidate {0} session(s)?
+manager2.ui.apps.invalidateSessionsTitle=Invalidate sessions
+manager2.ui.apps.jspFiles=JSP files
+manager2.ui.apps.jsps=JSPs
+manager2.ui.apps.mappings=Mappings
+manager2.ui.apps.maxSessionLife=Max session life
+manager2.ui.apps.minutes={0} min
+manager2.ui.apps.noApps=No applications deployed
+manager2.ui.apps.noAttributes=No attributes
+manager2.ui.apps.noSessions=No sessions
+manager2.ui.apps.notFound=Application not found.
+manager2.ui.apps.reloadConfirmTitle=Reload application
+manager2.ui.apps.reloads=Reloads
+manager2.ui.apps.removeAttributeConfirm=Remove attribute {0}?
+manager2.ui.apps.removeAttributeTitle=Remove attribute
+manager2.ui.apps.replaceExisting=Replace an existing deployment
+manager2.ui.apps.seconds={0} s
+manager2.ui.apps.selectSessions=Select sessions to invalidate.
+manager2.ui.apps.selectWarFirst=Select a WAR file first.
+manager2.ui.apps.servlets=Servlets
+manager2.ui.apps.sessionActive=active
+manager2.ui.apps.sessionProxy=proxy
+manager2.ui.apps.sessionTimeout=Session timeout
+manager2.ui.apps.sessionTitle=Session {0}
+manager2.ui.apps.stopConfirmTitle=Stop application
+manager2.ui.apps.stopOrReloadConfirm=Stop or reload {0}?
+manager2.ui.apps.subtitle=Deploy, start, stop, reload and undeploy web applications.
+manager2.ui.apps.tabMetrics=Metrics
+manager2.ui.apps.tabOverview=Overview
+manager2.ui.apps.tabServer=From server
+manager2.ui.apps.tabSessions=Sessions
+manager2.ui.apps.tabUpload=Upload
+manager2.ui.apps.timeoutLabel=Timeout
+manager2.ui.apps.undeploy=Undeploy
+manager2.ui.apps.undeployConfirm=Undeploy {0}? The deployed files are kept on disk.
+manager2.ui.apps.undeployConfirmTitle=Undeploy application
+manager2.ui.apps.uploadFailedStatus=Upload failed with status {0}
+manager2.ui.apps.uploadNetworkError=Upload failed (network error)
+manager2.ui.apps.versionOptional=Version (optional)
+manager2.ui.apps.warFile=WAR file
+manager2.ui.apps.warLocationOptional=WAR location (optional)
+manager2.ui.apps.xmlConfigOptional=XML configuration (optional)
+manager2.ui.brand.name=Tomcat Manager
+manager2.ui.col.actions=Actions
+manager2.ui.col.aliases=Aliases
+manager2.ui.col.committed=Committed
+manager2.ui.col.description=Description
+manager2.ui.col.errors=Errors
+manager2.ui.col.groups=Groups
+manager2.ui.col.host=Host
+manager2.ui.col.max=Max
+manager2.ui.col.members=Members
+manager2.ui.col.name=Name
+manager2.ui.col.password=Password
+manager2.ui.col.path=Path
+manager2.ui.col.requests=Requests
+manager2.ui.col.roles=Roles
+manager2.ui.col.sessions=Sessions
+manager2.ui.col.state=State
+manager2.ui.col.used=Used
+manager2.ui.col.user=User
+manager2.ui.col.username=User name
+manager2.ui.col.version=Version
+manager2.ui.common.add=Add
+manager2.ui.common.all=All
+manager2.ui.common.apply=Apply
+manager2.ui.common.cancel=Cancel
+manager2.ui.common.close=Close
+manager2.ui.common.confirm=Confirm
+manager2.ui.common.download=Download
+manager2.ui.common.empty=(empty)
+manager2.ui.common.errorTitle=Something went wrong
+manager2.ui.common.loading=Loading
+manager2.ui.common.moreActions=More actions
+manager2.ui.common.noData=No data
+manager2.ui.common.notFoundPath=Not found: {0}
+manager2.ui.common.refresh=Refresh
+manager2.ui.common.reload=Reload
+manager2.ui.common.remove=Remove
+manager2.ui.common.restart=Restart
+manager2.ui.common.save=Save
+manager2.ui.common.start=Start
+manager2.ui.common.stop=Stop
+manager2.ui.config.addChild=+ Add
+manager2.ui.config.addChildTitle=Add {0} child
+manager2.ui.config.addParameter=+ Add parameter
+manager2.ui.config.alias=Alias
+manager2.ui.config.auth=Auth
+manager2.ui.config.cannotRemoveSelf=Cannot remove the component the manager is installed in
+manager2.ui.config.certType=Certificate type
+manager2.ui.config.change=Change
+manager2.ui.config.changeMessage=Changing {0} of {1} may break routing. Continue?
+manager2.ui.config.changeTitle=Change {0}
+manager2.ui.config.children=Children
+manager2.ui.config.className=Class name
+manager2.ui.config.commaSeparated=comma, separated
+manager2.ui.config.componentType=Component type
+manager2.ui.config.components=Components
+manager2.ui.config.docBasePlaceholder=relative to the host app base, or a .war
+manager2.ui.config.factory=Factory
+manager2.ui.config.factoryOptionsNote=The options of a first party factory are shown as fields; further parameters can be edited in the entry detail.
+manager2.ui.config.globalJndiName=Global JNDI name
+manager2.ui.config.hostName=Host name
+manager2.ui.config.jndiName=JNDI name
+manager2.ui.config.keyAlias=Key alias
+manager2.ui.config.keystoreFile=Keystore file
+manager2.ui.config.keystorePassword=Keystore password
+manager2.ui.config.keystoreType=Keystore type
+manager2.ui.config.link=Link
+manager2.ui.config.maxThreads=Max threads
+manager2.ui.config.minSpareThreads=Min spare threads
+manager2.ui.config.name=Name
+manager2.ui.config.noChanges=No changes to apply.
+manager2.ui.config.noParameters=No parameters set. Use "+ Add parameter" to add one.
+manager2.ui.config.noProperties=This component exposes no editable properties.
+manager2.ui.config.notSet=not set
+manager2.ui.config.paramNamePlaceholder=parameter name (e.g. url, maxTotal)
+manager2.ui.config.paramNameRequired=A parameter name is required.
+manager2.ui.config.paramNotSet=This parameter is not set.
+manager2.ui.config.parameter=parameter
+manager2.ui.config.path=Path
+manager2.ui.config.port=Port
+manager2.ui.config.properties=Properties
+manager2.ui.config.protocol=Protocol
+manager2.ui.config.reconnectFailed=Could not reconnect after the operation. The component may still be stopped - check the server status and try again.
+manager2.ui.config.reconnected=Reconnected. Reloading the components.
+manager2.ui.config.reconnecting=The connection was interrupted during the operation - this is expected when the component that serves this page is restarted. Reconnecting...
+manager2.ui.config.removeMessage=Remove {0} from the running server? This cannot be undone without a reload.
+manager2.ui.config.removeParameter=Remove this parameter
+manager2.ui.config.removeTitle=Remove {0}
+manager2.ui.config.replaceNote=Replaces the current {0} ({1}).
+manager2.ui.config.restartHelp=Stop the component and start it again
+manager2.ui.config.restartMessage=Restart {0}?
+manager2.ui.config.restartMessageSelf=Restart {0}? This component serves this page: the connection is interrupted during the operation and the page reconnects when it is done. When the restarted component holds the admin sessions (the server, a service, an engine, a host or this context) you will need to sign in again.
+manager2.ui.config.restartTitle=Restart {0}
+manager2.ui.config.save=Save to server.xml
+manager2.ui.config.selectComponent=Select a component in the tree to inspect and edit it.
+manager2.ui.config.selfImpactTitle=This component serves this page: starting or stopping it would interrupt access to the manager. Use Restart instead.
+manager2.ui.config.servletClass=Servlet class
+manager2.ui.config.stopMessage=Stop {0}? Any in-memory state it holds (e.g. the sessions of the contexts below it) is lost.
+manager2.ui.config.stopTitle=Stop {0}
+manager2.ui.config.storeFiles=It will also rewrite the following context configuration files:
+manager2.ui.config.storeManagerWarning=the file of the context this manager runs in is among them. Saving will restart the manager and reset your session - you will need to log in again.
+manager2.ui.config.storeWarning=This will overwrite conf/server.xml with the live state (a timestamped backup is kept).
+manager2.ui.config.subtitle=The live component tree of this server. Changes apply immediately; save to make them permanent.
+manager2.ui.config.thisApp=this app
+manager2.ui.config.toggle=Toggle
+manager2.ui.config.typeHomeInterface=Type (home interface)
+manager2.ui.config.typeLabel=Type
+manager2.ui.config.typeLocalHome=Type (local home)
+manager2.ui.config.typeLocalInterface=Local (business interface)
+manager2.ui.config.typeServiceInterface=Type (service interface)
+manager2.ui.config.unnamed=(unnamed)
+manager2.ui.config.upgradeProtocolNote=The default class is the HTTP/2 upgrade protocol. The protocol only becomes active when the connector is restarted.
+manager2.ui.config.urlPatterns=URL patterns (comma separated)
+manager2.ui.config.valueLabel=Value
+manager2.ui.config.valuePlaceholder=value
+manager2.ui.config.warning=Warning:
+manager2.ui.confirm.typeToConfirm=Type {0} to confirm
+manager2.ui.dashboard.chart.heap=JVM heap
+manager2.ui.dashboard.chart.network=Network
+manager2.ui.dashboard.chart.requestRate=Request rate
+manager2.ui.dashboard.chart.threads=Busy threads
+manager2.ui.dashboard.kpi.activeSessions=Active sessions
+manager2.ui.dashboard.kpi.busyThreads=Busy threads
+manager2.ui.dashboard.kpi.errorsPerSecond=Errors / s
+manager2.ui.dashboard.kpi.heapUsed=Heap used
+manager2.ui.dashboard.kpi.requestsPerSecond=Requests / s
+manager2.ui.dashboard.legend.committed=committed
+manager2.ui.dashboard.legend.errorsPerSecond=errors/s
+manager2.ui.dashboard.legend.receivedPerSecond=received B/s
+manager2.ui.dashboard.legend.requestsPerSecond=requests/s
+manager2.ui.dashboard.legend.sentPerSecond=sent B/s
+manager2.ui.dashboard.legend.used=used
+manager2.ui.dashboard.of=of {0}
+manager2.ui.dashboard.subtitle=Charts show the last {0} of server activity. One sample every {1} s, collected in the background.
+manager2.ui.dashboard.title=Dashboard
+manager2.ui.diagnostics.allTypes=All types
+manager2.ui.diagnostics.certificates=Certificates
+manager2.ui.diagnostics.cipherSuites=Cipher suites
+manager2.ui.diagnostics.colClass=Class
+manager2.ui.diagnostics.jvmDescription=VM information and a thread dump of this process.
+manager2.ui.diagnostics.leaksCheck=Check for leaks
+manager2.ui.diagnostics.leaksChecking=Checking\u2026 this can take a while.
+manager2.ui.diagnostics.leaksDescription=Check whether the deployed web applications hold any memory-leaking references (class loaders, threads or file handles).
+manager2.ui.diagnostics.leaksNone=No leaks found.
+manager2.ui.diagnostics.noResources=No resources found.
+manager2.ui.diagnostics.noSslConnector=No SSL connector configured on this server.
+manager2.ui.diagnostics.sslReloadButton=Reload SSL context
+manager2.ui.diagnostics.sslReloadConfirm=Reload the SSL context? Connections in flight are interrupted.
+manager2.ui.diagnostics.sslReloadConfirmButton=Reload
+manager2.ui.diagnostics.sslReloadTitle=Reload SSL
+manager2.ui.diagnostics.subtitle=SSL, memory leaks, JNDI resources and JVM diagnostics.
+manager2.ui.diagnostics.tab.jndi=JNDI resources
+manager2.ui.diagnostics.tab.jvm=JVM
+manager2.ui.diagnostics.tab.leaks=Memory leaks
+manager2.ui.diagnostics.tab.ssl=SSL
+manager2.ui.diagnostics.threadDump=Thread dump
+manager2.ui.diagnostics.tlsHostPlaceholder=TLS SNI host name (optional)
+manager2.ui.diagnostics.trustedCertificates=Trusted certificates
+manager2.ui.diagnostics.vmInfo=VM information
+manager2.ui.error.403.heading=Access denied
+manager2.ui.error.403.text=Your account does not have permission to perform this action. If you believe this is an error, contact your server administrator.
+manager2.ui.error.404.heading=Not found
+manager2.ui.error.404.text=The page or resource you requested does not exist.
+manager2.ui.error.back=Back to dashboard
+manager2.ui.hosts.add=Add host
+manager2.ui.hosts.addTitle=Add virtual host
+manager2.ui.hosts.aliasesLabel=Aliases (comma separated)
+manager2.ui.hosts.aliasesPlaceholder=example.com, www.example.com
+manager2.ui.hosts.appBase=App base
+manager2.ui.hosts.autoDeploy=Auto deploy
+manager2.ui.hosts.cannotRemoveSelf=Cannot remove the host the manager is installed in
+manager2.ui.hosts.copyXml=Copy XML
+manager2.ui.hosts.copyXmlHelp=Copy context XML from the deployed WAR into META-INF/context.xml
+manager2.ui.hosts.deployOnStartup=Deploy on startup
+manager2.ui.hosts.deployXml=Deploy XML
+manager2.ui.hosts.empty=No virtual hosts configured
+manager2.ui.hosts.managerWebapp=Manager webapp
+manager2.ui.hosts.managerWebappHelp=Deploy the manager webapp to this host
+manager2.ui.hosts.nameMissing=Enter a host name.
+manager2.ui.hosts.namePlaceholder=localhost
+manager2.ui.hosts.removeConfirm=Remove host {0}? Applications on it will be undeployed (files are kept).
+manager2.ui.hosts.removeConfirmTitle=Remove host
+manager2.ui.hosts.save=Save to server.xml
+manager2.ui.hosts.selfColumn=Self
+manager2.ui.hosts.stopConfirm=Stop host {0}? All applications on it will be stopped.
+manager2.ui.hosts.stopConfirmTitle=Stop host
+manager2.ui.hosts.subtitle=Add, start, stop and remove virtual hosts on this engine.
+manager2.ui.hosts.thisHost=this host
+manager2.ui.hosts.title=Virtual hosts
+manager2.ui.hosts.unpackWars=Unpack WARs
+manager2.ui.login.brand=Apache Tomcat
+manager2.ui.login.errorText=Your user name or password was incorrect.
+manager2.ui.login.errorTitle=Sign in failed.
+manager2.ui.login.foot=Use an account with the manager-gui role for full access or manager-status for read-only monitoring.
+manager2.ui.login.password=Password
+manager2.ui.login.submit=Sign in
+manager2.ui.login.subtitle=Manager \u2014 sign in to manage your server.
+manager2.ui.login.title=Log in \u00b7 Tomcat Manager
+manager2.ui.login.username=User name
+manager2.ui.logs.subtitle=Server log files (JULI). Filter by severity and search the records.
+manager2.ui.logviewer.allSeverities=All severities
+manager2.ui.logviewer.col.connection=Connection
+manager2.ui.logviewer.col.elapsed=Elapsed
+manager2.ui.logviewer.col.elapsedSeconds=Elapsed (s)
+manager2.ui.logviewer.col.firstByte=First byte
+manager2.ui.logviewer.col.level=Level
+manager2.ui.logviewer.col.localAddr=Local addr
+manager2.ui.logviewer.col.message=Message
+manager2.ui.logviewer.col.method=Method
+manager2.ui.logviewer.col.port=Port
+manager2.ui.logviewer.col.protocol=Protocol
+manager2.ui.logviewer.col.query=Query
+manager2.ui.logviewer.col.raw=Line
+manager2.ui.logviewer.col.remoteAddr=Remote addr
+manager2.ui.logviewer.col.request=Request
+manager2.ui.logviewer.col.server=Server
+manager2.ui.logviewer.col.session=Session
+manager2.ui.logviewer.col.size=Size
+manager2.ui.logviewer.col.sizeNoContentLength=Size (no C-L)
+manager2.ui.logviewer.col.source=Source
+manager2.ui.logviewer.col.status=Status
+manager2.ui.logviewer.col.thread=Thread
+manager2.ui.logviewer.col.throwable=Stack trace
+manager2.ui.logviewer.col.time=Time
+manager2.ui.logviewer.col.user=User
+manager2.ui.logviewer.file=File
+manager2.ui.logviewer.filterBySessionId=Filter by session ID
+manager2.ui.logviewer.filterByUser=Filter by user
+manager2.ui.logviewer.maxLines=Max lines
+manager2.ui.logviewer.noAccessLogFiles=No access log files were found in the logs directory.
+manager2.ui.logviewer.noFiles=No log files found
+manager2.ui.logviewer.noLogFiles=No log files were found in the logs directory.
+manager2.ui.logviewer.noMatches=No lines match the current filters.
+manager2.ui.logviewer.recordTitle=Record
+manager2.ui.logviewer.search=Search
+manager2.ui.logviewer.searchPlaceholder=Search
+manager2.ui.logviewer.sessionId=Session ID
+manager2.ui.logviewer.severity=Severity
+manager2.ui.logviewer.summaryPlural=Showing {0} of {1} matching lines (total {2})
+manager2.ui.logviewer.summarySingular=Showing {0} of {1} matching line (total {2})
+manager2.ui.logviewer.truncated=file truncated to the last {0} MiB
+manager2.ui.monitoring.col.bytesIn=Bytes in
+manager2.ui.monitoring.col.bytesOut=Bytes out
+manager2.ui.monitoring.col.connector=Connector
+manager2.ui.monitoring.col.errors=Errors
+manager2.ui.monitoring.col.keepAlive=Keep-alive
+manager2.ui.monitoring.col.processingTime=Processing time
+manager2.ui.monitoring.col.received=Received
+manager2.ui.monitoring.col.remoteAddress=Remote address
+manager2.ui.monitoring.col.request=Request
+manager2.ui.monitoring.col.requests=Requests
+manager2.ui.monitoring.col.sent=Sent
+manager2.ui.monitoring.col.stage=Stage
+manager2.ui.monitoring.col.threads=Threads
+manager2.ui.monitoring.col.threadsBusyCurrentMax=Threads (busy / current / max)
+manager2.ui.monitoring.col.time=Time
+manager2.ui.monitoring.col.virtualHost=Virtual host
+manager2.ui.monitoring.connectors=Connectors
+manager2.ui.monitoring.cores=Cores
+manager2.ui.monitoring.cpu=CPU
+manager2.ui.monitoring.daemonThreads=Daemon threads
+manager2.ui.monitoring.heapCommitted=Heap committed
+manager2.ui.monitoring.heapUnbounded={0} (unbounded)
+manager2.ui.monitoring.jvmHeap=JVM heap
+manager2.ui.monitoring.loadAverage=Load average
+manager2.ui.monitoring.memory=Memory
+manager2.ui.monitoring.noConnectors=No connectors found
+manager2.ui.monitoring.noWorkers=No active sockets
+manager2.ui.monitoring.nonHeapUsed=Non-heap used
+manager2.ui.monitoring.none=none
+manager2.ui.monitoring.notAvailable=Not available
+manager2.ui.monitoring.peakThreads=Peak threads
+manager2.ui.monitoring.physicalMemory=Physical memory
+manager2.ui.monitoring.pool=Pool
+manager2.ui.monitoring.processCpu=JVM process CPU
+manager2.ui.monitoring.processingTime={0} (max {1})
+manager2.ui.monitoring.stage.finishing=Finishing
+manager2.ui.monitoring.stage.keepAlive=Keep-alive
+manager2.ui.monitoring.stage.parsing=Parsing request
+manager2.ui.monitoring.stage.ready=Ready
+manager2.ui.monitoring.stage.service=Service
+manager2.ui.monitoring.stage.unknown=Unknown
+manager2.ui.monitoring.subtitle=Instant CPU and memory snapshot, live connectors and worker (socket) table. Refreshes every 5 seconds; paused while the tab is hidden.
+manager2.ui.monitoring.swap=Swap
+manager2.ui.monitoring.systemCpu=System CPU
+manager2.ui.monitoring.threads=Threads
+manager2.ui.monitoring.threadsLive={0} live
+manager2.ui.monitoring.usedOfTotal={0} / {1}
+manager2.ui.monitoring.workerCount={0} active \u00b7 {1} idle
+manager2.ui.monitoring.workers=Active workers
+manager2.ui.nav.accessLog=Access log
+manager2.ui.nav.apps=Applications
+manager2.ui.nav.configuration=Configuration
+manager2.ui.nav.dashboard=Dashboard
+manager2.ui.nav.diagnostics=Diagnostics
+manager2.ui.nav.hosts=Hosts
+manager2.ui.nav.logs=Logs
+manager2.ui.nav.monitoring=Monitoring
+manager2.ui.nav.users=Users
+manager2.ui.shell.logout=Log out
+manager2.ui.shell.nav=Main navigation
+manager2.ui.shell.noscript=The Tomcat Manager requires JavaScript.
+manager2.ui.shell.theme.toggle=Toggle theme
+manager2.ui.shell.uptime=up {0}
+manager2.ui.state.running=Running
+manager2.ui.state.stopped=Stopped
+manager2.ui.type.alias=alias
+manager2.ui.type.certificate=certificate
+manager2.ui.type.channel=channel
+manager2.ui.type.cluster=cluster
+manager2.ui.type.clusterListener=clusterListener
+manager2.ui.type.clusterManager=clusterManager
+manager2.ui.type.clusterValve=clusterValve
+manager2.ui.type.connector=connector
+manager2.ui.type.context=context
+manager2.ui.type.cookieProcessor=cookieProcessor
+manager2.ui.type.deployer=deployer
+manager2.ui.type.ejb=ejb
+manager2.ui.type.engine=engine
+manager2.ui.type.environment=environment
+manager2.ui.type.executor=executor
+manager2.ui.type.host=host
+manager2.ui.type.interceptor=interceptor
+manager2.ui.type.listener=listener
+manager2.ui.type.loader=loader
+manager2.ui.type.localEjb=localEjb
+manager2.ui.type.manager=manager
+manager2.ui.type.membership=membership
+manager2.ui.type.namingResources=namingResources
+manager2.ui.type.realm=realm
+manager2.ui.type.receiver=receiver
+manager2.ui.type.resource=resource
+manager2.ui.type.resourceEnvRef=resourceEnvRef
+manager2.ui.type.resourceLink=resourceLink
+manager2.ui.type.resources=resources
+manager2.ui.type.sender=sender
+manager2.ui.type.server=server
+manager2.ui.type.service=service
+manager2.ui.type.serviceRef=serviceRef
+manager2.ui.type.sessionIdGenerator=sessionIdGenerator
+manager2.ui.type.sslHostConfig=sslHostConfig
+manager2.ui.type.transport=transport
+manager2.ui.type.upgradeProtocol=upgradeProtocol
+manager2.ui.type.valve=valve
+manager2.ui.type.wrapper=wrapper
+manager2.ui.users.addGroup=Add group
+manager2.ui.users.addRole=Add role
+manager2.ui.users.addUser=Add user
+manager2.ui.users.badgeNotWritable=not writable
+manager2.ui.users.badgeReadonly=read-only
+manager2.ui.users.badgeWritable=writable
+manager2.ui.users.dbSelect=User database
+manager2.ui.users.descriptionField=Description (optional)
+manager2.ui.users.fullNameField=Full name (optional)
+manager2.ui.users.groupAdded=Group added.
+manager2.ui.users.groupColumn=Group
+manager2.ui.users.groupNameField=Group name
+manager2.ui.users.groupRemoved=Group removed.
+manager2.ui.users.groupsHeading=Groups
+manager2.ui.users.inheritedTitle=Inherited through group membership
+manager2.ui.users.jndiId=\ (id {0})
+manager2.ui.users.jndiResource=JNDI resource {0}
+manager2.ui.users.membersField=Members (comma separated)
+manager2.ui.users.membersOf=Members of {0}
+manager2.ui.users.membersSaved=Members saved.
+manager2.ui.users.newPassword=New password
+manager2.ui.users.noGroups=No groups in this database.
+manager2.ui.users.noRoles=No roles defined in this database.
+manager2.ui.users.noUsers=No users in this database.
+manager2.ui.users.passwordFor=Password for {0}
+manager2.ui.users.passwordHint=Stored with the same semantics as the password attribute of tomcat-users.xml.
+manager2.ui.users.passwordSaved=Password saved.
+manager2.ui.users.readonlyBanner=This user database is read-only. Add {0} to its {1} definition in {2} and restart the server to allow changes.
+manager2.ui.users.removeGroupConfirm=Remove the group "{0}" and its membership from all users?
+manager2.ui.users.removeGroupTitle=Remove group
+manager2.ui.users.removeRoleConfirm=Remove the role "{0}"? It will be detached from all users and groups that hold it.
+manager2.ui.users.removeRoleTitle=Remove role
+manager2.ui.users.removeUserConfirm=Remove the user "{0}" and all of its roles and group memberships?
+manager2.ui.users.removeUserTitle=Remove user
+manager2.ui.users.roleAdded=Role added.
+manager2.ui.users.roleColumn=Role
+manager2.ui.users.roleNameField=Role name
+manager2.ui.users.roleRemoved=Role removed.
+manager2.ui.users.rolesField=Roles (comma separated)
+manager2.ui.users.rolesFor=Roles for {0}
+manager2.ui.users.rolesHeading=Roles
+manager2.ui.users.rolesHint=Roles can also be created implicitly when assigned to a user or group.
+manager2.ui.users.rolesSaved=Roles saved.
+manager2.ui.users.userAdded=User added.
+manager2.ui.users.userRemoved=User removed.
+
+# Server-side responses of the manager2 API endpoints.
+manager2.alreadyDeployed=The application at context path [{0}] is already deployed
+manager2.contextInService=The context [{0}] is in multiple services or not attached at all, and cannot be safely handled by name-only commands
+manager2.deployFailed=The application was not deployed at context path [{0}]
+manager2.deployed=The application has been deployed at context path [{0}]
+manager2.deployedNotStarted=The application has been deployed at context path [{0}] but has not been configured to start
+manager2.loginTemplateMissing=The login page template (login.html) is missing
+manager2.notFound=Not found
+manager2.sessionsInvalidated={0} sessions invalidated.
+manager2.shellMissing=The manager application shell (index.html) is missing
+manager2.uploadDeleteFailed=Failed to delete the previously deployed war file [{0}]
+manager2.uploadFailed=File upload failed, cause: [{0}]
+manager2.uploadNoFile=File upload failed - no file
+manager2.uploadNotWar=File upload failed - [{0}] is not a war file
+manager2.uploadRenameFailed=Failed to rename [{0}] to [{1}]
+manager2.uploadWarExists=Deployment of the war file failed because [{0}] is already deployed
+manager2.ui.apps.invalidate=Invalidate
+
+# ----------------------------------------------------------------
+# Descriptions of the configuration editor attributes, looked up
+# dynamically by attribute name: manager2.attr.. for
+# component and JNDI entry attributes, manager2.param. for the
+# factory options of a JNDI resource (scoped by factory with
+# manager2.param.. when the text is factory
+# specific).
+# ----------------------------------------------------------------
+manager2.attr.certificate.certificateChainFile=The certificate chain file (PEM, OpenSSL).
+manager2.attr.certificate.certificateFile=The certificate file (PEM, OpenSSL).
+manager2.attr.certificate.certificateKeyAlias=The alias of the key entry in the keystore.
+manager2.attr.certificate.certificateKeyFile=The private key file (PEM, OpenSSL)
+manager2.attr.certificate.certificateKeyPassword=The private key password (if different from the keystore password).
+manager2.attr.certificate.certificateKeyPasswordFile=The file that contains the private key password.
+manager2.attr.certificate.certificateKeystoreFile=The keystore file (JKS or PKCS12).
+manager2.attr.certificate.certificateKeystorePassword=The keystore password.
+manager2.attr.certificate.certificateKeystorePasswordFile=The file that contains the keystore password.
+manager2.attr.certificate.certificateKeystoreProvider=The keystore provider.
+manager2.attr.certificate.certificateKeystoreType=The keystore type (e.g. PKCS12).
+manager2.attr.certificate.type=The certificate type (the default certificate has no type).
+manager2.attr.channel.heartbeat=Whether the channel manages its own heartbeat thread.
+manager2.attr.channel.heartbeatSleeptime=The interval in milliseconds between heartbeats.
+manager2.attr.channel.jmxDomain=The JMX domain for the channel components.
+manager2.attr.channel.jmxPrefix=The JMX name prefix for the channel components.
+manager2.attr.channel.name=The name of the channel.
+manager2.attr.channel.optionCheck=Whether to check that the channel is correctly configured before starting.
+manager2.attr.channelInterceptor.optionFlag=The option flag that controls the behaviour of the interceptor.
+manager2.attr.cookieProcessor.cookiesWithoutEquals=How to handle cookie names without an equals sign in the cookie header.
+manager2.attr.cookieProcessor.partitioned=Whether the Partitioned attribute is added to the cookies of this web application.
+manager2.attr.cookieProcessor.sameSiteCookies=The SameSite attribute added to the cookies of this web application (Unset, None, Lax or Strict).
+manager2.attr.ejb.description=The description of the EJB reference.
+manager2.attr.ejb.home=The fully qualified name of the home interface (alternative to type).
+manager2.attr.ejb.link=The JNDI name of the remote EJB the reference links to.
+manager2.attr.ejb.name=The JNDI name of the EJB reference.
+manager2.attr.ejb.remote=The fully qualified name of the remote interface.
+manager2.attr.ejb.type=The fully qualified name of the home interface.
+manager2.attr.environment.description=The description of the entry.
+manager2.attr.environment.name=The JNDI name of the environment entry.
+manager2.attr.environment.override=Whether the context entry overrides a global entry with the same name.
+manager2.attr.environment.type=The type of the entry (e.g. java.lang.String, javax.sql.DataSource).
+manager2.attr.environment.value=The value of the entry.
+manager2.attr.http2Protocol.allowSchemeMismatch=Whether HTTP/2 streams may provide a scheme that does not match the transport.
+manager2.attr.http2Protocol.discardRequestsAndResponses=Whether requests and responses are discarded after processing instead of being recycled.
+manager2.attr.http2Protocol.drainTimeout=The additional time in nanoseconds between the first and the final GOAWAY while a connection is drained.
+manager2.attr.http2Protocol.initialWindowSize=The initial window size advertised to the client in bytes.
+manager2.attr.http2Protocol.initiatePingDisabled=Whether the periodic PING frames that keep the connection alive are disabled.
+manager2.attr.http2Protocol.keepAliveTimeout=The keep alive timeout in milliseconds.
+manager2.attr.http2Protocol.maxConcurrentStreamExecution=The maximum number of concurrently executing streams per connection.
+manager2.attr.http2Protocol.maxConcurrentStreams=The maximum number of concurrent streams per connection.
+manager2.attr.http2Protocol.maxHeaderCount=The maximum number of headers allowed per request.
+manager2.attr.http2Protocol.maxHeaderSize=The maximum size of request headers in bytes (set on the HTTP/1.1 protocol handler).
+manager2.attr.http2Protocol.maxTrailerCount=The maximum number of trailer headers allowed per request.
+manager2.attr.http2Protocol.maxTrailerSize=The maximum size of trailer headers in bytes (set on the HTTP/1.1 protocol handler).
+manager2.attr.http2Protocol.overheadContinuationThreshold=The payload size threshold for CONTINUATION frame overhead tracking in bytes.
+manager2.attr.http2Protocol.overheadCountFactor=The overhead count factor used for overhead frame tracking.
+manager2.attr.http2Protocol.overheadDataThreshold=The payload size threshold for DATA frame overhead tracking in bytes.
+manager2.attr.http2Protocol.overheadResetFactor=The overhead reset factor used for RST frame tracking.
+manager2.attr.http2Protocol.overheadWindowUpdateThreshold=The payload size threshold for WINDOW_UPDATE frame overhead tracking in bytes.
+manager2.attr.http2Protocol.readTimeout=The socket level read timeout in milliseconds.
+manager2.attr.http2Protocol.streamReadTimeout=The stream level read timeout in milliseconds.
+manager2.attr.http2Protocol.streamWriteTimeout=The stream level write timeout in milliseconds.
+manager2.attr.http2Protocol.useSendfile=Whether to use sendfile for file transfers.
+manager2.attr.http2Protocol.writeTimeout=The socket level write timeout in milliseconds.
+manager2.attr.loader.delegate=Whether the web application class loader delegates to the parent class loader first.
+manager2.attr.loader.jakartaConverter=The class that converts Jakarta Servlet API classes to their equivalent in the deployed application.
+manager2.attr.loader.loaderClass=The class of the web application class loader instance.
+manager2.attr.localEjb.description=The description of the local EJB reference.
+manager2.attr.localEjb.home=The fully qualified name of the local home interface (alternative to type).
+manager2.attr.localEjb.link=The JNDI name of the local EJB the reference links to.
+manager2.attr.localEjb.local=The fully qualified name of the local business interface.
+manager2.attr.localEjb.name=The JNDI name of the local EJB reference.
+manager2.attr.localEjb.type=The fully qualified name of the local home interface.
+manager2.attr.membership.address=The multicast address to join (e.g. 228.0.0.4).
+manager2.attr.membership.dropTime=The time in milliseconds a member may be silent before being dropped.
+manager2.attr.membership.frequency=The interval in milliseconds between membership messages.
+manager2.attr.membership.localLoopbackDisabled=Whether local loopback of multicast packets is disabled.
+manager2.attr.membership.port=The multicast port to join (e.g. 45564).
+manager2.attr.membership.recoveryEnabled=Whether membership recovery is enabled.
+manager2.attr.membership.recoverySleepTime=The sleep time in milliseconds between recovery attempts.
+manager2.attr.membership.soTimeout=The socket timeout in milliseconds.
+manager2.attr.membership.ttl=The time to live for multicast packets.
+manager2.attr.messageDispatchInterceptor.alwaysSend=Whether to always send messages even with no other members.
+manager2.attr.messageDispatchInterceptor.keepAliveTime=The keep alive time in milliseconds for idle threads.
+manager2.attr.messageDispatchInterceptor.maxQueueSize=The maximum number of messages to queue.
+manager2.attr.messageDispatchInterceptor.maxSpareThreads=The maximum number of idle threads to keep.
+manager2.attr.messageDispatchInterceptor.maxThreads=The maximum number of threads in the dispatch pool.
+manager2.attr.messageDispatchInterceptor.useDeepClone=Whether messages are deep cloned before dispatch.
+manager2.attr.receiver.address=The address to bind to.
+manager2.attr.receiver.autoBind=The number of attempts to auto bind an available port.
+manager2.attr.receiver.maxThreads=The maximum number of listener threads.
+manager2.attr.receiver.minThreads=The minimum number of listener threads.
+manager2.attr.receiver.port=The TCP port to listen on.
+manager2.attr.receiver.selectorTimeout=The selector timeout in milliseconds.
+manager2.attr.receiver.soKeepAlive=Whether SO_KEEPALIVE is set on the sockets.
+manager2.attr.receiver.soReuseAddress=Whether SO_REUSEADDR is set on the sockets.
+manager2.attr.receiver.tcpNoDelay=Whether TCP_NODELAY is set on the sockets.
+manager2.attr.receiver.udpPort=The UDP port to listen on.
+manager2.attr.resource.auth=The JNDI authentication mode (Application or Container).
+manager2.attr.resource.closeMethod=The method invoked to close the resource when it is unbound.
+manager2.attr.resource.description=The description of the resource.
+manager2.attr.resource.lookupName=A JNDI name to look up; when set, the other parameters are ignored.
+manager2.attr.resource.name=The JNDI name of the resource (e.g. jdbc/MyDB).
+manager2.attr.resource.scope=The JNDI scope of the resource (Shareable or Unshareable).
+manager2.attr.resource.singleton=Whether the resource is a shared, long lived instance.
+manager2.attr.resource.type=The type of the object to look up (e.g. javax.sql.DataSource).
+manager2.attr.resourceEnvRef.description=The description of the resource.
+manager2.attr.resourceEnvRef.name=The JNDI name of the resource.
+manager2.attr.resourceEnvRef.override=Whether the context environment entry overrides a global resource with the same name.
+manager2.attr.resourceEnvRef.type=The type of the object to look up.
+manager2.attr.resourceLink.description=The description of the resource link.
+manager2.attr.resourceLink.factory=The JNDI ObjectFactory used to resolve the global resource.
+manager2.attr.resourceLink.global=The JNDI name of the (global) resource the link points to.
+manager2.attr.resourceLink.name=The local JNDI name of the resource link.
+manager2.attr.resourceLink.type=The type of the object the link resolves to.
+manager2.attr.serviceRef.description=The description of the service reference.
+manager2.attr.serviceRef.displayname=The display name of the service reference.
+manager2.attr.serviceRef.interface=The fully qualified name of the service interface (alternative to type).
+manager2.attr.serviceRef.name=The JNDI name of the service reference.
+manager2.attr.serviceRef.type=The fully qualified name of the service interface.
+manager2.attr.serviceRef.wsdlfile=The WSDL document of the service.
+manager2.attr.sessionIdGenerator.jvmRoute=The jvm route appended to the generated session ids (cluster failover).
+manager2.attr.sessionIdGenerator.secureRandomClass=The secure random number generator class used to create the session ids.
+manager2.attr.sessionIdGenerator.sessionIdLength=The length of the generated session ids in bytes.
+manager2.attr.sslHostConfig.caCertificateFile=The CA certificate file (OpenSSL).
+manager2.attr.sslHostConfig.caCertificatePath=The CA certificate directory (OpenSSL).
+manager2.attr.sslHostConfig.certificateRevocationListPath=The certificate revocation list directory (OpenSSL).
+manager2.attr.sslHostConfig.certificateVerification=Client certificate verification: none, optional, optionalNoCA or required.
+manager2.attr.sslHostConfig.certificateVerificationDepth=The depth of the client certificate chain verification.
+manager2.attr.sslHostConfig.cipherSuites=The cipher suite list for TLS 1.3.
+manager2.attr.sslHostConfig.ciphers=The cipher list for TLS 1.2 and below (OpenSSL or JSSE names).
+manager2.attr.sslHostConfig.disableCompression=Whether TLS compression is disabled (OpenSSL).
+manager2.attr.sslHostConfig.disableSessionTickets=Whether TLS session tickets are disabled (OpenSSL).
+manager2.attr.sslHostConfig.groups=The enabled named groups (comma separated).
+manager2.attr.sslHostConfig.honorCipherOrder=Whether to honor the server cipher order.
+manager2.attr.sslHostConfig.hostName=The SNI host name this configuration applies to (lower case).
+manager2.attr.sslHostConfig.insecureRenegotiation=Whether insecure renegotiation is allowed (OpenSSL)
+manager2.attr.sslHostConfig.keyManagerAlgorithm=The key manager algorithm (JSSE).
+manager2.attr.sslHostConfig.protocols=Enabled TLS protocols, e.g. TLSv1.2+TLSv1.3, or All.
+manager2.attr.sslHostConfig.revocationEnabled=Whether CRL/OCSP revocation checking is enabled (JSSE).
+manager2.attr.sslHostConfig.sessionCacheSize=The SSL session cache size.
+manager2.attr.sslHostConfig.sessionTimeout=The SSL session timeout in seconds.
+manager2.attr.sslHostConfig.sslProtocol=The SSL protocol (JSSE).
+manager2.attr.sslHostConfig.trustManagerClassName=The trust manager class name (JSSE).
+manager2.attr.sslHostConfig.truststoreAlgorithm=The truststore algorithm (JSSE).
+manager2.attr.sslHostConfig.truststoreFile=The truststore file (JSSE).
+manager2.attr.sslHostConfig.truststorePassword=The truststore password (JSSE).
+manager2.attr.sslHostConfig.truststoreProvider=The truststore provider (JSSE).
+manager2.attr.sslHostConfig.truststoreType=The truststore type (JSSE).
+manager2.attr.tcpFailureDetector.connectTimeout=The timeout in milliseconds for the connection test.
+manager2.attr.tcpFailureDetector.performReadTest=Whether to perform a read test.
+manager2.attr.tcpFailureDetector.performSendTest=Whether to perform a send test.
+manager2.attr.tcpFailureDetector.readTestTimeout=The timeout in milliseconds for the read test.
+manager2.attr.tcpFailureDetector.removeSuspectsTimeout=The time in milliseconds a suspect member is kept before removal.
+manager2.attr.transport.directBuffer=Whether to use direct (off heap) buffers.
+manager2.attr.transport.maxRetryAttempts=The number of attempts to retransmit a message.
+manager2.attr.transport.poolSize=The number of sockets in the pool (pooled senders).
+manager2.attr.transport.soKeepAlive=Whether SO_KEEPALIVE is set on the sockets.
+manager2.attr.transport.soReuseAddress=Whether SO_REUSEADDR is set on the sockets.
+manager2.attr.transport.tcpNoDelay=Whether TCP_NODELAY is set on the sockets.
+manager2.attr.transport.timeout=The socket timeout in milliseconds.
+manager2.attr.transport.udpPort=The UDP port to send to.
+manager2.param.abandonedUsageTracking=The stack trace tracking mode for abandoned connections.
+manager2.param.accessToUnderlyingConnectionAllowed=Whether the underlying driver connection can be obtained.
+manager2.param.blockWhenExhausted=Whether to block when the pool is exhausted.
+manager2.param.cacheState=Whether to cache the connection state on the wrapper.
+manager2.param.clearStatementPoolOnReturn=Whether the statement pool is cleared when the connection is returned.
+manager2.param.connectionFactoryClassName=A custom connection factory class (instead of the driver).
+manager2.param.connectionInitSqls=Semicolon separated statements executed on each new connection.
+manager2.param.connectionProperties=Semicolon separated key=value pairs passed to the driver.
+manager2.param.dataSourceName=The JNDI name of the DataSource to use.
+manager2.param.defaultAutoCommit=The default auto commit mode of the connections.
+manager2.param.defaultCatalog=The default catalog of the connections.
+manager2.param.defaultMaxIdle=The default maximum number of idle connections per user.
+manager2.param.defaultMaxTotal=The default maximum number of connections per user.
+manager2.param.defaultMaxWaitMillis=The default maximum wait time in milliseconds per user.
+manager2.param.defaultQueryTimeout=The default query timeout in seconds.
+manager2.param.defaultReadOnly=The default read only mode of the connections.
+manager2.param.defaultSchema=The default schema of the connections.
+manager2.param.defaultTransactionIsolation=The default transaction isolation level (JDBC constant).
+manager2.param.description=A description of the pool.
+manager2.param.disconnectionIgnoreSqlCodes=Comma separated SQL state codes ignored during disconnection checks.
+manager2.param.disconnectionSqlCodes=Comma separated SQL state codes treated as disconnections.
+manager2.param.driverClassName=The JDBC driver class name.
+manager2.param.enableAutoCommitOnReturn=Whether to re-enable auto commit on return.
+manager2.param.evictionPolicyClassName=The class of the idle object eviction policy.
+manager2.param.fastFailValidation=Whether validation fails fast on a known dead connection.
+manager2.param.groupNameCol=The column name of the group name.
+manager2.param.groupRoleTable=The name of the group/role mapping table.
+manager2.param.groupTable=The name of the group table.
+manager2.param.initialSize=The number of connections created at pool startup.
+manager2.param.instanceKey=The unique key of this pool instance (defaults to the JNDI name).
+manager2.param.jmxName=The JMX ObjectName under which the pool is registered.
+manager2.param.lifo=Whether to allocate idle connections in LIFO order.
+manager2.param.logAbandoned=Whether to log the stack trace of abandoned connections.
+manager2.param.logExpiredConnections=Whether to log the expiration of pooled connections.
+manager2.param.loginTimeout=The login timeout in seconds.
+manager2.param.maxConnLifetimeMillis=The maximum lifetime in milliseconds of a connection.
+manager2.param.maxIdle=The maximum number of idle connections in the pool.
+manager2.param.maxIdlePerKey=The maximum number of idle connections per instance key.
+manager2.param.maxOpenPreparedStatements=The maximum number of pooled prepared statements per connection.
+manager2.param.maxTotal=The maximum number of active connections in the pool.
+manager2.param.maxTotalPerKey=The maximum number of active connections per instance key.
+manager2.param.maxWaitMillis=The maximum time in milliseconds to wait for a connection.
+manager2.param.minEvictableIdleTimeMillis=The minimum idle time in milliseconds before a connection is evicted.
+manager2.param.minIdle=The minimum number of idle connections to retain.
+manager2.param.minIdlePerKey=The minimum number of idle connections per instance key.
+manager2.param.numTestsPerEvictionRun=The number of connections tested per eviction run.
+manager2.param.password=The JDBC connection password.
+manager2.param.pathname=The path of the XML user file (default conf/tomcat-users.xml).
+manager2.param.poolPreparedStatements=Whether prepared statements are pooled.
+manager2.param.readonly=Whether the user database is read only.
+manager2.param.registerConnectionMBean=Whether each connection is registered as an MBean.
+manager2.param.removeAbandonedOnBorrow=Whether abandoned connections are removed on borrow.
+manager2.param.removeAbandonedOnMaintenance=Whether abandoned connections are removed during maintenance.
+manager2.param.removeAbandonedTimeout=The timeout in seconds after which a connection is considered abandoned.
+manager2.param.roleAndGroupDescriptionCol=The column name of the role/group description.
+manager2.param.roleNameCol=The column name of the role name.
+manager2.param.roleTable=The name of the role table.
+manager2.param.rollbackAfterValidation=Whether to roll back after a validation query.
+manager2.param.rollbackOnReturn=Whether to roll back uncommitted transactions on return.
+manager2.param.softMinEvictableIdleTimeMillis=The soft minimum idle time in milliseconds.
+manager2.param.testOnBorrow=Whether to validate a connection when it is borrowed.
+manager2.param.testOnCreate=Whether to validate a connection when it is created.
+manager2.param.testOnReturn=Whether to validate a connection when it is returned.
+manager2.param.testWhileIdle=Whether to validate connections while they are idle.
+manager2.param.timeBetweenEvictionRunsMillis=The time in milliseconds between eviction runs.
+manager2.param.url=The JDBC connection URL.
+manager2.param.userCredCol=The column name of the user credential (password).
+manager2.param.userFullNameCol=The column name of the user full name.
+manager2.param.userGroupTable=The name of the user/group mapping table.
+manager2.param.userNameCol=The column name of the user name.
+manager2.param.userRoleTable=The name of the user/role mapping table.
+manager2.param.userTable=The name of the user table.
+manager2.param.username=The JDBC connection user name.
+manager2.param.validationQuery=The SQL query used to validate connections.
+manager2.param.validationQueryTimeout=The timeout in seconds for the validation query.
+manager2.param.watchSource=Whether the user file is watched for changes and reloaded.
+
+# ----------------------------------------------------------------
+# Descriptions of the standard MBean descriptor attributes of the
+# configuration editor (connector, engine, host, ...). They override
+# the English text of the descriptors shipped with the container so
+# that it can be translated. Kept in sync with the descriptors by
+# TestManager2Descriptions.
+# ----------------------------------------------------------------
+manager2.attr.cluster.channelSendOptions=This sets channel behaviour on sent messages.
+manager2.attr.cluster.channelSendOptionsName=channelSendOptions name.
+manager2.attr.cluster.channelStartOptions=This sets channel start behaviour.
+manager2.attr.cluster.clusterName=name of cluster
+manager2.attr.cluster.heartbeatBackgroundEnabled=enable that container background thread call channel heartbeat, default is that channel manage heartbeat itself.
+manager2.attr.cluster.notifyLifecycleListenerOnFailure=notify lifecycleListener from message transfer failure
+manager2.attr.connector.URIEncoding=Character encoding used to decode the URI
+manager2.attr.connector.acceptCount=The accept count for this Connector
+manager2.attr.connector.address=The IP address on which to bind
+manager2.attr.connector.ajpFlush=Send AJP flush package for each explicit flush
+manager2.attr.connector.allowTrace=Allow disabling TRACE method
+manager2.attr.connector.allowedRequestAttributesPattern=Regular expression that any custom request attributes must match else the request will be rejected
+manager2.attr.connector.ciphers=Comma-separated list of requested cipher suites
+manager2.attr.connector.ciphersUsed=Array of ciphers suites in use
+manager2.attr.connector.connectionLinger=Linger value on the incoming connection
+manager2.attr.connector.connectionTimeout=Timeout value on the incoming connection
+manager2.attr.connector.enableLookups=The 'enable DNS lookups' flag for this Connector
+manager2.attr.connector.executorName=The name of the executor - if any - associated with this Connector
+manager2.attr.connector.keepAliveTimeout=The number of milliseconds Tomcat will wait for a subsequent request before closing the connection
+manager2.attr.connector.localPort=The port number on which this connector is listening to requests. If the special value for port of zero is used then this method will report the actual port bound.
+manager2.attr.connector.maxHeaderCount=The maximum number of headers that are allowed by the container. 100 by default. A value of less than 0 means no limit.
+manager2.attr.connector.maxKeepAliveRequests=Maximum number of Keep-Alive requests to honor per connection
+manager2.attr.connector.maxParameterCount=The maximum number of parameters (GET plus POST) which will be automatically parsed by the container. 1000 by default. A value of less than 0 means no limit.
+manager2.attr.connector.maxPostSize=Maximum size in bytes of a POST which will be handled by the servlet API provided features
+manager2.attr.connector.maxSavePostSize=Maximum size of a POST which will be saved by the container during authentication
+manager2.attr.connector.maxSwallowSize=The maximum number of request body bytes to be swallowed by Tomcat for an aborted upload
+manager2.attr.connector.maxThreads=The maximum number of request processing threads to be created for the internal Executor. -1 indicates an external Executor is being used.
+manager2.attr.connector.minSpareThreads=The number of request processing threads that will be created for the internal Executor. -1 indicates an external Executor is being used.
+manager2.attr.connector.packetSize=The ajp packet size.
+manager2.attr.connector.port=The port number (excluding any offset) on which this connector is configured to listen for requests. The special value of 0 means select a random free port when the socket is bound.
+manager2.attr.connector.portOffset=The offset that will be applied to port to determine the actual port number used.
+manager2.attr.connector.portWithOffset=The actual port number (including any offset) on which this connector is configured to listen for requests.
+manager2.attr.connector.processorCache=The processor cache size.
+manager2.attr.connector.protocol=Coyote protocol handler in use
+manager2.attr.connector.proxyName=The Server name to which we should pretend requests to this Connector
+manager2.attr.connector.proxyPort=The Server port to which we should pretend requests to this Connector
+manager2.attr.connector.redirectPort=The redirect port (excluding any offset) for non-SSL to SSL redirects
+manager2.attr.connector.redirectPortWithOffset=The actual redirect port (including any offset) for non-SSL to SSL redirects.
+manager2.attr.connector.scheme=Protocol name for this Connector (http, https)
+manager2.attr.connector.secretRequired=Must secret be set to a non-null, non-zero-length String?
+manager2.attr.connector.secure=Is this a secure (SSL) Connector?
+manager2.attr.connector.sslProtocols=Comma-separated list of SSL protocol variants to be enabled
+manager2.attr.connector.tcpNoDelay=Should we use TCP no delay?
+manager2.attr.connector.threadPriority=The thread priority for processors using the internal Executor. -1 indicates an external Executor is being used.
+manager2.attr.connector.useBodyEncodingForURI=Should the body encoding be used for URI query parameters
+manager2.attr.connector.useIPVHosts=Should IP-based virtual hosting be used?
+manager2.attr.connector.xpoweredBy=Is generation of X-Powered-By response header enabled/disabled?
+manager2.attr.context.altDDName=The alternate deployment descriptor name.
+manager2.attr.context.antiResourceLocking=Take care to not lock resources
+manager2.attr.context.baseName=The base name used for directories, WAR files (with .war appended) and context.xml files (with .xml appended).
+manager2.attr.context.clearReferencesRmiTargets=Should Tomcat look for memory leaks in RMI Targets and clear them if found as a work around for application coding errors?
+manager2.attr.context.clearReferencesStopThreads=Should Tomcat attempt to terminate threads that have been started by the web application? Advisable to be used only in a development environment.
+manager2.attr.context.clearReferencesStopTimerThreads=Should Tomcat attempt to terminate TimerThreads that have been started by the web application? Advisable to be used only in a development environment.
+manager2.attr.context.clearReferencesThreadLocals=Should Tomcat attempt to clear ThreadLocal variables that have been populated with classes loaded by the web application?
+manager2.attr.context.configFile=Location of the context.xml resource or file
+manager2.attr.context.configured=The correctly configured flag for this Context.
+manager2.attr.context.cookies=Should we attempt to use cookies for session id communication?
+manager2.attr.context.crossContext=Should we allow the ServletContext.getContext() method to access the context of other web applications in this server?
+manager2.attr.context.defaultContextXml=Location of the default context.xml resource or file
+manager2.attr.context.defaultWebXml=Location of the default web.xml resource or file
+manager2.attr.context.displayName=The display name of this web application
+manager2.attr.context.distributable=The distributable flag for this web application.
+manager2.attr.context.docBase=The document root for this web application
+manager2.attr.context.encodedPath=The encoded path
+manager2.attr.context.errorCount=Cumulative error count of all servlets in this context
+manager2.attr.context.ignoreAnnotations=Ignore annotations flag.
+manager2.attr.context.logEffectiveWebXml=Should the effective web.xml be logged when the context starts?
+manager2.attr.context.mapperContextRootRedirectEnabled=Should the Mapper be used for context root redirects
+manager2.attr.context.mapperDirectoryRedirectEnabled=Should the Mapper be used for directory redirects
+manager2.attr.context.maxTime=Maximum execution time of all servlets in this context
+manager2.attr.context.minTime=Minimum execution time of all servlets in this context
+manager2.attr.context.name=The name of this Context
+manager2.attr.context.originalDocBase=The original document root for this web application
+manager2.attr.context.override=The default context.xml override flag for this web application
+manager2.attr.context.parallelAnnotationScanning=The parallel annotation scanning flag
+manager2.attr.context.path=The context path for this Context
+manager2.attr.context.paused=The request processing pause flag (while reloading occurs)
+manager2.attr.context.privileged=Access to tomcat internals
+manager2.attr.context.processingTime=Cumulative execution times of all servlets in this context
+manager2.attr.context.publicId=The public identifier of the DTD for the web application deployment descriptor version that is being parsed
+manager2.attr.context.reloadable=The reloadable flag for this web application
+manager2.attr.context.renewThreadsWhenStoppingContext=Should Tomcat renew the threads of the thread pool when the application is stopped to avoid memory leaks because of uncleaned ThreadLocal variables.
+manager2.attr.context.requestCount=Cumulative request count of all servlets in this context
+manager2.attr.context.sessionCookieDomain=The domain to use for session cookies.'null' indicates that the domain is controlled by the application.
+manager2.attr.context.sessionCookieName=The name to use for session cookies.'null' indicates that the name is controlled by the application.
+manager2.attr.context.sessionCookiePath=The path to use for session cookies.'null' indicates that the path is controlled by the application.
+manager2.attr.context.sessionTimeout=The session timeout (in minutes) for this web application
+manager2.attr.context.startTime=Time (in milliseconds since January 1, 1970, 00:00:00) when this context was started
+manager2.attr.context.startupTime=Time (in milliseconds) it took to start this context
+manager2.attr.context.swallowOutput=Flag to set to cause the system.out and system.err to be redirected to the logger when executing a servlet
+manager2.attr.context.tldScanTime=Time spend scanning jars for TLDs for this context
+manager2.attr.context.tldValidation=Should the parsing of *.tld files be performed by a validating parser?
+manager2.attr.context.unloadDelay=Amount of ms that the container will wait for servlets to unload
+manager2.attr.context.unpackWAR=Unpack WAR property
+manager2.attr.context.useHttpOnly=Indicates that session cookies should use HttpOnly
+manager2.attr.context.useNaming=Create a JNDI naming context for this application?
+manager2.attr.context.useRelativeRedirects=When generating location headers for 302 responses, should a relative URI be used?
+manager2.attr.context.webappVersion=The version of this web application - used in parallel deployment to differentiate different versions of the same web application
+manager2.attr.context.welcomeFiles=The welcome files for this context
+manager2.attr.context.workDir=The pathname to the work directory for this context
+manager2.attr.context.xmlNamespaceAware=Should the parsing of web.xml and web-fragment.xml files be performed by a namespace aware parser?
+manager2.attr.context.xmlValidation=Should the parsing of web.xml and web-fragment.xml files be performed by a validating parser?
+manager2.attr.engine.backgroundProcessorDelay=The processor delay for this component.
+manager2.attr.engine.catalinaBase=Base (instance) directory for this Engine, typically same as catalina.base system property
+manager2.attr.engine.defaultHost=Name of the default Host for this Engine
+manager2.attr.engine.jvmRoute=Route used for load balancing
+manager2.attr.engine.managedResource=The managed resource this MBean is associated with
+manager2.attr.engine.modelerType=Type of the modeled resource. Can be set only once
+manager2.attr.engine.name=Unique name of this Engine
+manager2.attr.engine.realm=Associated realm.
+manager2.attr.engine.startChildren=Will children be started automatically when they are added.
+manager2.attr.engine.startStopThreads=The number of threads to use when starting and stopping child Hosts
+manager2.attr.engine.stateName=The name of the LifecycleState that this component is currently in
+manager2.attr.executor.activeCount=Number of threads currently processing a task
+manager2.attr.executor.completedTaskCount=Number of tasks completed by the executor
+manager2.attr.executor.corePoolSize=Core size of the thread pool
+manager2.attr.executor.daemon=Run threads in daemon or non-daemon state?
+manager2.attr.executor.largestPoolSize=Peak number of threads
+manager2.attr.executor.maxIdleTime=Max number of milliseconds a thread can be idle before it can be shutdown
+manager2.attr.executor.maxQueueSize=Maximum number of tasks for the pending task queue
+manager2.attr.executor.maxThreads=Maximum number of allocated threads
+manager2.attr.executor.minSpareThreads=Minimum number of allocated threads
+manager2.attr.executor.name=Unique name of this Executor
+manager2.attr.executor.namePrefix=Name prefix for thread names created by this executor
+manager2.attr.executor.poolSize=Number of threads in the pool
+manager2.attr.executor.queueSize=Number of tasks waiting to be processed
+manager2.attr.executor.threadPriority=The thread priority for threads in this thread pool
+manager2.attr.executor.threadRenewalDelay=After a context is stopped, threads in the pool are renewed. To avoid renewing all threads at the same time, this delay is observed between 2 threads being renewed. Value is in ms, default value is 1000ms. If negative, threads are not renewed.
+manager2.attr.host.aliases=Host aliases
+manager2.attr.host.appBase=The application root for this Host
+manager2.attr.host.autoDeploy=The auto deploy flag for this Host
+manager2.attr.host.backgroundProcessorDelay=The processor delay for this component.
+manager2.attr.host.configClass=The configuration class for contexts
+manager2.attr.host.contextClass=The Java class name of the default Context implementation class for deployed web applications.
+manager2.attr.host.copyXML=Should XML files be copied to $CATALINA_BASE/conf/{engine}/{host} by default when a web application is deployed?
+manager2.attr.host.createDirs=Should we create directories upon startup for appBase and xmlBase?
+manager2.attr.host.deployIgnore=Paths within appBase ignored for automatic deployment
+manager2.attr.host.deployOnStartup=The deploy on startup flag for this Host
+manager2.attr.host.deployXML=deploy Context XML config files property
+manager2.attr.host.errorReportValveClass=The Java class name of the default error reporter implementation class for deployed web applications.
+manager2.attr.host.legacyAppBase=The legacy (Java EE) application root for this Host
+manager2.attr.host.name=Unique name of this Host
+manager2.attr.host.realm=Associated realm.
+manager2.attr.host.startChildren=Will children be started automatically when they are added?
+manager2.attr.host.startStopThreads=The number of threads to use when starting, stopping and deploying child Contexts
+manager2.attr.host.undeployOldVersions=Determines if old versions of applications deployed using parallel deployment are automatically undeployed when no longer used. Requires autoDeploy to be enabled.
+manager2.attr.host.unpackWARs=Unpack WARs property
+manager2.attr.host.workDir=Work Directory base for applications
+manager2.attr.host.xmlBase=The XML root for this Host.
+manager2.attr.manager.activeSessions=Number of active sessions at this moment
+manager2.attr.manager.expiredSessions=Number of sessions that expired ( doesn't include explicit invalidations )
+manager2.attr.manager.jvmRoute=Retrieve the JvmRoute for the enclosing Engine
+manager2.attr.manager.maxActive=Maximum number of active sessions so far
+manager2.attr.manager.maxActiveSessions=The maximum number of active Sessions allowed, or -1 for no limit
+manager2.attr.manager.name=The descriptive name of this Manager implementation (for logging)
+manager2.attr.manager.pathname=Path name of the disk file in which active sessions
+manager2.attr.manager.persistAuthentication=Indicates whether sessions shall persist authentication information when being persisted (e.g. across application restarts).
+manager2.attr.manager.processExpiresFrequency=The frequency of the manager checks (expiration and passivation)
+manager2.attr.manager.processingTime=Time spent doing housekeeping and expiration
+manager2.attr.manager.rejectedSessions=Number of sessions we rejected due to maxActive being reached
+manager2.attr.manager.secureRandomAlgorithm=The secure random number generator algorithm name
+manager2.attr.manager.secureRandomClass=The secure random number generator class name
+manager2.attr.manager.secureRandomProvider=The secure random number generator provider name
+manager2.attr.manager.sessionAttributeNameFilter=The string pattern used for including session attributes in distribution. Null means all attributes are included.
+manager2.attr.manager.sessionAttributeValueClassNameFilter=The regular expression used to filter session attributes based on the implementation class of the value. The regular expression is anchored and must match the fully qualified class name.
+manager2.attr.manager.sessionAverageAliveTime=Average time an expired session had been alive
+manager2.attr.manager.sessionCounter=Total number of sessions created by this manager
+manager2.attr.manager.sessionCreateRate=Session creation rate in sessions per minute
+manager2.attr.manager.sessionExpireRate=Session expiration rate in sessions per minute
+manager2.attr.manager.sessionMaxAliveTime=Longest time an expired session had been alive
+manager2.attr.manager.warnOnSessionAttributeFilterFailure=Should a WARN level log message be generated if a session attribute fails to match sessionAttributeNameFilter or sessionAttributeClassNameFilter?
+manager2.attr.server.address=The address on which we wait for shutdown commands.
+manager2.attr.server.port=TCP port (excluding any offset) for shutdown messages
+manager2.attr.server.portOffset=The offset applied to port and to the port attributes of any nested connectors
+manager2.attr.server.portWithOffset=Actual TCP port (including any offset) for shutdown messages
+manager2.attr.server.serverBuilt=Tomcat server built timestamp
+manager2.attr.server.serverInfo=Tomcat server release identifier
+manager2.attr.server.serverNumber=Tomcat server's version number
+manager2.attr.server.shutdown=Shutdown password
+manager2.attr.service.name=Unique name of this Service
+manager2.attr.wrapper.asyncSupported=Async support
+manager2.attr.wrapper.available=The date and time at which this servlet will become available (in milliseconds since the epoch), or zero if the servlet is available. If this value equals Long.MAX_VALUE, the unavailability of this servlet is considered permanent.
+manager2.attr.wrapper.backgroundProcessorDelay=The processor delay for this component.
+manager2.attr.wrapper.classLoadTime=Time taken to load the Servlet class
+manager2.attr.wrapper.errorCount=Error count
+manager2.attr.wrapper.loadOnStartup=The load-on-startup order value (negative value means load on first call) for this servlet.
+manager2.attr.wrapper.loadTime=Time taken to load and initialise the Servlet
+manager2.attr.wrapper.maxTime=Maximum processing time of a request
+manager2.attr.wrapper.minTime=Minimum processing time of a request
+manager2.attr.wrapper.processingTime=Total execution time of the servlet's service method
+manager2.attr.wrapper.requestCount=Number of requests processed by this wrapper
+manager2.attr.wrapper.runAs=The run-as identity for this servlet.
diff --git a/modules/manager2/src/main/java/org/apache/tomcat/manager2/LocaleFilter.java b/modules/manager2/src/main/java/org/apache/tomcat/manager2/LocaleFilter.java
new file mode 100644
index 000000000000..29094a82cd98
--- /dev/null
+++ b/modules/manager2/src/main/java/org/apache/tomcat/manager2/LocaleFilter.java
@@ -0,0 +1,48 @@
+/*
+ * 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.
+ */
+package org.apache.tomcat.manager2;
+
+import java.io.IOException;
+
+import jakarta.servlet.Filter;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.http.HttpServletRequest;
+
+
+/**
+ * Binds the locales sent by the client (the {@code Accept-Language} header) to the request thread, so that the
+ * messages of the response - API envelopes, rendered HTML templates and log lines emitted during the request - are
+ * localized with the {@link Strings#sm()} manager matching those locales. Must be the first filter of the chain.
+ */
+public class LocaleFilter implements Filter {
+
+
+ @Override
+ public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
+ throws IOException, ServletException {
+
+ Strings.bindRequest((HttpServletRequest) request);
+ try {
+ chain.doFilter(request, response);
+ } finally {
+ Strings.unbindRequest();
+ }
+ }
+}
diff --git a/modules/manager2/src/main/java/org/apache/tomcat/manager2/LogParser.java b/modules/manager2/src/main/java/org/apache/tomcat/manager2/LogParser.java
new file mode 100644
index 000000000000..40f324a9bf53
--- /dev/null
+++ b/modules/manager2/src/main/java/org/apache/tomcat/manager2/LogParser.java
@@ -0,0 +1,295 @@
+/*
+ * 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.
+ */
+package org.apache.tomcat.manager2;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.tomcat.util.json.JSONParser;
+
+
+/**
+ * Parsers for the two log families displayed by manager2.
+ *