37518343506

Committed 06 Oct 2026 07:21PM UTC coverage: 66.431% (-0.03%) from 66.459%

Build # 37518343506

Build Type

push

github

Committed by

dkayiwa

Commit Message

TRUNK-6819: Start the JobRunr job server only once OpenMRS has started (#6654)

The background job server was started while its application context was
still being created, so jobs could run before the context was ready. On
jetty:run this logged "EntityManagerFactory is closed" for a job that ran
during the context refresh after modules start, against the closed session
factory of the context being replaced, and "Task class ... not found" for a
module's job that ran after the first, core-only refresh, before modules
were loaded.

The server is now started by a SmartLifecycle once its context has finished
refreshing and stopped before the context closes. The webapp defers that
start until SchedulerService.onStartup(), which runs once modules have
started; contexts refreshed after startup start their server right away.

The webapp never closes its application context, so Context.shutdown() now
calls SchedulerService.onShutdown() first, as it did before the move to
JobRunr, and JobRunrSchedulerService stops the job server there, before the
modules and the session factory are shut down.

On 2.9.x, JobRunr 6 does not return the server in its configuration
result, so the lifecycle takes it from JobRunr, and the scheduler service
is declared in applicationContext-service.xml, so its lifecycle is set
there rather than with @Autowired.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NK4kFG8qyevx9Bk9jWoEgS
Claude-Session: https://claude.ai/code/session_01PdDdZrB8Q5eMgej5FmRx4R
Claude-Session: https://claude.ai/code/session_01LZ92BDLHrn6xACczVMtSiR

Coverage Stats

33 of 37 new or added lines in 5 files covered. (89.19%)

38 existing lines in 9 files now uncovered.

25960 of 39078 relevant lines covered (66.43%)

0.66 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.23

/api/src/main/java/org/openmrs/api/context/UserContext.java

/**
 * This Source Code Form is subject to the terms of the Mozilla Public License,
 * v. 2.0. If a copy of the MPL was not distributed with this file, You can
 * obtain one at http://mozilla.org/MPL/2.0/. OpenMRS is also distributed under
 * the terms of the Healthcare Disclaimer located at http://openmrs.org/license.
 *
 * Copyright (C) OpenMRS Inc. OpenMRS is a registered trademark and the OpenMRS
 * graphic logo is a trademark of OpenMRS Inc.
 */
package org.openmrs.api.context;

import org.apache.commons.lang3.StringUtils;
import org.openmrs.Location;
import org.openmrs.PrivilegeListener;
import org.openmrs.Role;
import org.openmrs.User;
import org.openmrs.UserSessionListener;
import org.openmrs.UserSessionListener.Event;
import org.openmrs.UserSessionListener.Status;
import org.openmrs.api.APIAuthenticationException;
import org.openmrs.api.LocationService;
import org.openmrs.api.cache.RolePrivilegeCache;
import org.openmrs.api.cache.RolePrivileges;
import org.openmrs.util.LocaleUtility;
import org.openmrs.util.OpenmrsConstants;
import org.openmrs.util.RoleConstants;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * Represents an OpenMRS <code>User Context</code> which stores the current user information. Only
 * one <code>User</code> may be authenticated within a UserContext at any given time. The
 * UserContext should not be accessed directly, but rather used through the <code>Context</code>.
 * This class should be kept light-weight. There is one instance of this class per user that is
 * logged into the system.
 *
 * @see org.openmrs.api.context.Context
 */
public class UserContext implements Serializable {
        
        private static final long serialVersionUID = -806631231941890648L;
        
        /**
         * Logger - shared by entire class
         */
        private static final Logger log = LoggerFactory.getLogger(UserContext.class);
        
        /**
         * Guards the one-time warning emitted when the role privilege cache component cannot be obtained
         * outside of a context refresh. Static so the warning is emitted once across all user contexts
         * rather than once per session.
         */
        private static final AtomicBoolean rolePrivilegeCacheUnavailableWarned = new AtomicBoolean(false);

        /**
         * User object containing details about the authenticated user
         */
        private User user = null;
        
        /**
         * User's permission proxies
         */
        private final List<String> proxies = Collections.synchronizedList(new ArrayList<>());
        
        /**
         * User's locale
         */
        private Locale locale = null;
        
        /**
         * Cached Role given to all authenticated users
         */
        private Role authenticatedRole = null;
        
        /**
         * Cache Role given to all users
         */
        private Role anonymousRole = null;
        
        /**
         * User's defined location
         */
        private Integer locationId;
        
        /**
         * The authentication scheme for this user
         */
        private final AuthenticationScheme authenticationScheme;
        
        /**
         * Creates a user context based on the provided auth. scheme.
         *
         * @param authenticationScheme The auth. scheme that applies for this user context.
         * @since 2.3.0
         */
        public UserContext(AuthenticationScheme authenticationScheme) {
                this.authenticationScheme = authenticationScheme;
        }
        
        /**
         * Authenticate user with the provided credentials. The authentication scheme must be Spring wired, see {@link Context#getAuthenticationScheme()}.
         *
         * @param credentials The credentials to use to authenticate
         * @return The authenticated client information
         * @throws ContextAuthenticationException if authentication fails
         * @since 2.3.0
         */
        public Authenticated authenticate(Credentials credentials)
                throws ContextAuthenticationException {
                
                log.debug("Authenticating client '{}' with scheme '{}'", credentials.getClientName(),
                        credentials.getAuthenticationScheme());
                
                Authenticated authenticated = null;
                try {
                        authenticated = authenticationScheme.authenticate(credentials);
                        this.user = authenticated.getUser();
                        notifyUserSessionListener(this.user, Event.LOGIN, Status.SUCCESS);
                }
                catch (ContextAuthenticationException e) {
                        User loggingInUser = new User();
                        loggingInUser.setUsername(credentials.getClientName());
                        notifyUserSessionListener(loggingInUser, Event.LOGIN, Status.FAIL);
                        throw e;
                }
                
                setUserLocation(true);
                setUserLocale(true);
                
                log.debug("Authenticated as: {}", this.user);
                
                return authenticated;
        }
        
        /**
         * Refresh the authenticated user object in this UserContext. This should be used when updating
         * information in the database about the current user and it needs to be reflecting in the
         * (cached) {@link #getAuthenticatedUser()} User object.
         *
         * @since 1.5
         */
        public void refreshAuthenticatedUser() {
                log.debug("Refreshing authenticated user");
                
                if (user != null) {
                        user = Context.getUserService().getUser(user.getUserId());
                        //update the stored location in the user's session
                        setUserLocation(false);
                        setUserLocale(false);
                }
        }
        
        /**
         * Change current authentication to become another user. (You can only do this if you're already
         * authenticated as a superuser.)
         *
         * @param systemId
         * @return The new user that this context has been set to. (null means no change was made)
         * @throws ContextAuthenticationException
         */
        public User becomeUser(String systemId) throws ContextAuthenticationException {
                if (!Daemon.isDaemonThread() && !Context.getAuthenticatedUser().isSuperUser()) {
                        throw new APIAuthenticationException("You must be a superuser to assume another user's identity");
                }
                
                log.debug("Turning the authenticated user into user with systemId: {}", systemId);
                
                User userToBecome = Context.getUserService().getUserByUsername(systemId);
                
                if (userToBecome == null) {
                        throw new ContextAuthenticationException("User not found with systemId: " + systemId);
                }
                
                // hydrate the user object
                if (userToBecome.getAllRoles() != null) {
                        userToBecome.getAllRoles().size();
                }
                
                if (userToBecome.getUserProperties() != null) {
                        userToBecome.getUserProperties().size();
                }
                
                if (userToBecome.getPrivileges() != null) {
                        userToBecome.getPrivileges().size();
                }
                
                this.user = userToBecome;
                
                //update the user's location and locale
                setUserLocation(false);
                setUserLocale(false);
                
                log.debug("Becoming user: {}", user);
                
                return userToBecome;
        }
        
        /**
         * @return "active" user who has been authenticated, otherwise <code>null</code>
         */
        public User getAuthenticatedUser() {
                return user;
        }
        
        /**
         * @return true if user has been authenticated in this UserContext
         */
        public boolean isAuthenticated() {
                return user != null;
        }
        
        /**
         * logs out the "active" (authenticated) user within this UserContext
         *
         * @see #authenticate
         */
        public void logout() {
                log.debug("setting user to null on logout");
                notifyUserSessionListener(user, Event.LOGOUT, Status.SUCCESS);
                user = null;
                locationId = null;
                locale = null;
                proxies.clear();
        }
        
        /**
         * Gives the given privilege to all calls to hasPrivilege. This method was visualized as being
         * used as follows (try/finally is important):
         *
         * <pre>
         * try {
         *   Context.addProxyPrivilege(&quot;AAA&quot;);
         *   Context.get*Service().methodRequiringAAAPrivilege();
         * }
         * finally {
         *   Context.removeProxyPrivilege(&quot;AAA&quot;);
         * }
         * </pre>
         *
         * @param privilege to give to users
         */
        public void addProxyPrivilege(String privilege) {
                if (privilege == null) {
                        throw new IllegalArgumentException("UserContext.addProxyPrivilege does not accept null privileges");
                }

                log.debug("Adding proxy privilege: {}", privilege);
                proxies.add(privilege);
        }
        
        /**
         * Will remove one instance of privilege from the privileges that are currently proxied
         *
         * @param privilege Privilege to remove in string form
         */
        public void removeProxyPrivilege(String privilege) {
                if (privilege == null) {
                        return;
                }

                log.debug("Removing privilege: {}", privilege);
                proxies.remove(privilege);
        }
        
        /**
         * Adds one or more privileges to the list of privileges that that {@link #hasPrivilege(String)} will
         * regard as available regardless of whether the user would otherwise have the privilege.
         * <p/>
         * This is useful for situations where a system process may need access to some piece of data that the
         * user would not otherwise have access to, like a GlobalProperty. <strong>This facility should not be
         * used to return data to the user that they otherwise would be unable to see.</strong>
         * <p/>
         * The expected usage is:
         * <p/>
         * <pre>{@code
         * try {
         *   Context.addProxyPrivilege(&quot;AAA&quot;);
         *   Context.get*Service().methodRequiringAAAPrivilege();
         * }
         * finally {
         *   Context.removeProxyPrivilege(&quot;AAA&quot;);
         * }}
         * </pre>
         * <p/>
         *
         * @param privileges privileges to add in string form
         * @see #hasPrivilege(String)
         * @see #removeProxyPrivilege(String...)
         */
        public void addProxyPrivilege(String... privileges) {
                if (privileges == null || Arrays.stream(privileges).anyMatch(Objects::isNull)) {
                        throw new IllegalArgumentException("UserContext.addProxyPrivilege does not accept null privileges");
                }
                
                for (String privilege : privileges) {
                        addProxyPrivilege(privilege);
                }
        }
        
        /**
         * Removes one or more privileges to the list of privileges that that {@link #hasPrivilege(String)} will
         * regard as available regardless of whether the user would otherwise have the privilege.
         * <p/>
         * This is the compliment for {@link #addProxyPrivilege(String...)} to clean-up the context.
         * <p/>
         *
         * @param privileges privileges to remove in string form
         * @see #hasPrivilege(String)
         * @see #addProxyPrivilege(String...)
         */
        public void removeProxyPrivilege(String... privileges) {
                if (privileges == null || Arrays.stream(privileges).allMatch(Objects::isNull)) {
                        return;
                }
                
                for (String privilege : privileges) {
                        if (privilege != null) {
                                removeProxyPrivilege(privilege);
                        }
                }
        }

        /**
         * @return true if there are any proxy privileges
         * @since 2.9.0
         */
        public boolean hasProxyPrivileges() {
                return !proxies.isEmpty();
        }
        
        /**
         * @param locale new locale for this context
         */
        public void setLocale(Locale locale) {
                this.locale = locale;
        }
        
        /**
         * @return current locale for this context
         */
        public Locale getLocale() {
                if (locale == null) {
                        // don't cache default locale - allows recognition of changed default at login page
                        return LocaleUtility.getDefaultLocale();
                }
                
                return locale;
        }
        
        /**
         * Gets all the roles for the (un)authenticated user. Anonymous and Authenticated roles are
         * appended if necessary
         *
         * @return all expanded roles for a user
         * @throws Exception
         */
        public Set<Role> getAllRoles() throws Exception {
                return getAllRoles(getAuthenticatedUser());
        }
        
        /**
         * Gets all the roles for a user. Anonymous and Authenticated roles are appended if necessary
         *
         * @param user
         * @return all expanded roles for a user
         * <strong>Should</strong> not fail with null user
         * <strong>Should</strong> add anonymous role to all users
         * <strong>Should</strong> add authenticated role to all authenticated users
         * <strong>Should</strong> return same roles as user getAllRoles method
         */
        public Set<Role> getAllRoles(User user) throws Exception {
                Set<Role> roles = new HashSet<>();
                
                // add the Anonymous Role
                roles.add(getAnonymousRole());
                
                // add the Authenticated role
                if (getAuthenticatedUser() != null && getAuthenticatedUser().equals(user)) {
                        roles.addAll(user.getAllRoles());
                        roles.add(getAuthenticatedRole());
                }
                
                return roles;
        }
        
        /**
         * Tests whether the currently authenticated user has a particular privilege
         *
         * @param privilege The privilege to check if it's available
         * @return true if authenticated user has given privilege
         * <strong>Should</strong> authorize if authenticated user has specified privilege
         * <strong>Should</strong> authorize if authenticated role has specified privilege
         * <strong>Should</strong> authorize if proxied user has specified privilege
         * <strong>Should</strong> authorize if anonymous user has specified privilege
         * <strong>Should</strong> not authorize if authenticated user does not have specified privilege
         * <strong>Should</strong> not authorize if authenticated role does not have specified privilege
         * <strong>Should</strong> not authorize if proxied user does not have specified privilege
         * <strong>Should</strong> not authorize if anonymous user does not have specified privilege
         */
        public boolean hasPrivilege(String privilege) {
                return hasPrivilege(privilege, true);
        }

        /**
         * Tests whether the current user has a particular privilege, optionally excluding proxy privileges.
         * <p>
         * Passing <code>false</code> resolves the privilege only from the user's roles (and the anonymous
         * and authenticated roles), ignoring any {@link #addProxyPrivilege(String...) proxy privileges}.
         * This is intended for per-resource access checks that must reflect the user's actual granted roles
         * and must not be satisfied by a proxy privilege added merely to invoke the surrounding service
         * method. Role privileges are still resolved authoritatively (from the role privilege cache),
         * unlike {@link User#hasPrivilege(String)} which reads a potentially stale in-memory role graph.
         *
         * @param privilege The privilege to check if it's available
         * @param includeProxyPrivileges whether proxy privileges may satisfy the check
         * @return true if the current user has the given privilege
         * @since 3.0.0, 2.9.0, 2.8.9
         */
        public boolean hasPrivilege(String privilege, boolean includeProxyPrivileges) {
                if (includeProxyPrivileges) {
                        log.debug("Checking '{}' against proxies: {}", privilege, proxies);
                        // check proxied privileges; ArrayList so we have a consistent view
                        for (String s : new ArrayList<>(proxies)) {
                                if (s.equals(privilege)) {
                                        notifyPrivilegeListeners(getAuthenticatedUser(), privilege, true);
                                        return true;
                                }
                        }
                }

                boolean hasPrivilege = resolvePrivilege(privilege);
                notifyPrivilegeListeners(getAuthenticatedUser(), privilege, hasPrivilege);
                return hasPrivilege;
        }

        /**
         * Resolves whether the current user (authenticated or anonymous) holds the given privilege by
         * consulting the per-role privilege cache instead of recursively re-expanding the role graph on
         * every call. Proxy privileges are handled separately by {@link #hasPrivilege(String)}.
         *
         * @param privilege the privilege to check
         * @return true if the privilege is granted
         */
        private boolean resolvePrivilege(String privilege) {
                RolePrivilegeCache cache = getRolePrivilegeCache();

                // if a user has logged in, check their privileges
                if (isAuthenticated()) {
                        // All authenticated users have the "" (empty) privilege, matching User.hasPrivilege.
                        if (StringUtils.isEmpty(privilege)) {
                                return true;
                        }

                        User authenticatedUser = getAuthenticatedUser();
                        if (authenticatedUser.getRoles() != null) {
                                for (Role role : authenticatedUser.getRoles()) {
                                        if (roleGrants(cache, role, privilege)) {
                                                return true;
                                        }
                                }
                        }

                        if (roleGrants(cache, getAuthenticatedRole(), privilege)) {
                                return true;
                        }
                }

                return roleGrants(cache, getAnonymousRole(), privilege);
        }

        /**
         * Tests whether a single role (and its inherited closure) grants the given privilege, using the
         * cached flattening when available and falling back to a direct computation otherwise.
         *
         * @param cache the role privilege cache, or <code>null</code> if unavailable
         * @param role the directly assigned role to test
         * @param privilege the privilege to check
         * @return true if the role grants superuser status or contains the privilege
         */
        private boolean roleGrants(RolePrivilegeCache cache, Role role, String privilege) {
                RolePrivileges rolePrivileges = (cache != null) ? cache.getRolePrivileges(role)
                        : RolePrivilegeCache.computeRolePrivileges(role);
                return rolePrivileges.grantsSuperuser() || rolePrivileges.containsPrivilege(privilege);
        }

        /**
         * Looks up the {@link RolePrivilegeCache} component, or returns <code>null</code> so callers fall
         * back to direct computation. Absence during a context refresh is expected (logged at debug);
         * absence otherwise is a misconfiguration that silently drops every check to the uncached path, so
         * it is warned once.
         *
         * @return the cache component, or <code>null</code> if unavailable
         */
        private RolePrivilegeCache getRolePrivilegeCache() {
                try {
                        return Context.getRegisteredComponent("rolePrivilegeCache", RolePrivilegeCache.class);
                } catch (Exception e) {
                        if (Context.isRefreshingContext()) {
                                log.debug("Role privilege cache is unavailable while the context is refreshing; "
                                        + "computing role privileges directly",
                                    e);
                        } else if (rolePrivilegeCacheUnavailableWarned.compareAndSet(false, true)) {
                                log.warn("Could not obtain the rolePrivilegeCache component; privilege checks will recompute role "
                                        + "privileges on every call until this is resolved",
                                    e);
                        }
                        return null;
                }
        }
        
        /**
         * Convenience method to get the Role in the system designed to be given to all users
         *
         * @return Role
         * <strong>Should</strong> fail if database doesn't contain anonymous role
         */
        private Role getAnonymousRole() {
                if (anonymousRole != null) {
                        return anonymousRole;
                }
                
                anonymousRole = Context.getUserService().getRole(RoleConstants.ANONYMOUS);
                if (anonymousRole == null) {
                        throw new RuntimeException(
                                "Database out of sync with code: " + RoleConstants.ANONYMOUS + " role does not exist");
                }
                
                return anonymousRole;
        }
        
        /**
         * Convenience method to get the Role in the system designed to be given to all users that have
         * authenticated in some manner
         *
         * @return Role
         * <strong>Should</strong> fail if database doesn't contain authenticated role
         */
        private Role getAuthenticatedRole() {
                if (authenticatedRole != null) {
                        return authenticatedRole;
                }
                
                authenticatedRole = Context.getUserService().getRole(RoleConstants.AUTHENTICATED);
                if (authenticatedRole == null) {
                        throw new RuntimeException("Database out of sync with code: " + RoleConstants.AUTHENTICATED
                                + " role does not exist");
                }
                
                return authenticatedRole;
        }
        
        /**
         * @return locationId for this user context if any is set
         * @since 1.10
         */
        public Integer getLocationId() {
                return locationId;
        }
        
        /**
         * @param locationId locationId to set
         * @since 1.10
         */
        public void setLocationId(Integer locationId) {
                this.locationId = locationId;
        }
        
        /**
         * @return current location for this user context if any is set
         * @since 1.9
         */
        public Location getLocation() {
                if (locationId == null) {
                        return null;
                }
                return Context.getLocationService().getLocation(locationId);
        }
        
        /**
         * @param location the location to set to
         * @since 1.9
         */
        public void setLocation(Location location) {
                if (location != null) {
                        this.locationId = location.getLocationId();
                }
        }
        
        /**
         * Convenience method that sets the default location of the currently authenticated user using
         * the value of the user's default location property
         */
        private void setUserLocation(boolean useDefault) {
                // location should be null if no user is logged in
                if (this.user == null) {
                        this.locationId = null;
                        return;
                }
                
                // intended to be when the user initially authenticates
                if (this.locationId == null && useDefault) {
                        this.locationId = getDefaultLocationId(this.user);
                }
        }

        /**
         * Convenience method that sets the default locale used by the currently authenticated user, using
         * the value of the user's default local property
         */
        private void setUserLocale(boolean useDefault) {
                // local should be null if no user is logged in
                if (this.user == null) {
                        this.locale = null;
                        return;
                }

                // intended to be when the user initially authenticates
                if (user.getUserProperties().containsKey("defaultLocale")) {
                        String localeString = user.getUserProperty("defaultLocale");
                        locale = LocaleUtility.fromSpecification(localeString);
                }

                if (locale == null && useDefault) {
                        locale = LocaleUtility.getDefaultLocale();
                }

        }
        
        protected Integer getDefaultLocationId(User user) {
                String defaultLocation = user.getUserProperty(OpenmrsConstants.USER_PROPERTY_DEFAULT_LOCATION);
                if (StringUtils.isNotBlank(defaultLocation)) {
                        LocationService ls = Context.getLocationService();
                        //only go ahead if it has actually changed OR if wasn't set before
                        try {
                                int defaultId = Integer.parseInt(defaultLocation);
                                if (this.locationId == null || this.locationId != defaultId) {
                                        // validate that the id is a valid id
                                        if (ls.getLocation(defaultId) != null) {
                                                return defaultId;
                                        }
                                }
                        }
                        catch (NumberFormatException ignored) {
                        }

                        Location possibleLocation = ls.getLocationByUuid(defaultLocation);

                        if (possibleLocation != null && (this.locationId == null || !this.locationId.equals(possibleLocation.getId()))) {
                                return possibleLocation.getId();
                        }

                        log.warn("The default location for user '{}' is set to '{}', which is not a valid location",
                                user.getUsername(), defaultLocation);
                }
                
                return null;
        }
        
        /**
         * Notifies privilege listener beans about any privilege check.
         * <p>
         * It is called by {@link UserContext#hasPrivilege(java.lang.String)}.
         *
         * @param user         the authenticated user or <code>null</code> if not authenticated
         * @param privilege    the checked privilege
         * @param hasPrivilege <code>true</code> if the authenticated user has the required privilege or
         *                     if it is a proxy privilege
         * @see PrivilegeListener
         * @since 1.8.4, 1.9.1, 1.10
         */
        private void notifyPrivilegeListeners(User user, String privilege, boolean hasPrivilege) {
                for (PrivilegeListener privilegeListener : Context.getRegisteredComponents(PrivilegeListener.class)) {
                        try {
                                privilegeListener.privilegeChecked(user, privilege, hasPrivilege);
                        }
                        catch (Exception e) {
                                log.error("Privilege listener has failed", e);
                        }
                }
        }
        
        private void notifyUserSessionListener(User user, Event event, Status status) {
                for (UserSessionListener userSessionListener : Context.getRegisteredComponents(UserSessionListener.class)) {
                        userSessionListener.loggedInOrOut(user, event, status);
                }
        }
}

openmrs / openmrs-core / 37518343506

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous