| /* |
| * 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.catalina.users; |
| |
| import java.sql.Connection; |
| import java.sql.PreparedStatement; |
| import java.sql.ResultSet; |
| import java.sql.SQLException; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.concurrent.ConcurrentHashMap; |
| import java.util.concurrent.locks.Lock; |
| import java.util.concurrent.locks.ReentrantReadWriteLock; |
| |
| import javax.sql.DataSource; |
| |
| import org.apache.catalina.Group; |
| import org.apache.catalina.Role; |
| import org.apache.catalina.User; |
| import org.apache.juli.logging.Log; |
| import org.apache.juli.logging.LogFactory; |
| import org.apache.tomcat.util.res.StringManager; |
| |
| /** |
| * UserDatabase backed by a data source. |
| */ |
| public class DataSourceUserDatabase extends SparseUserDatabase { |
| |
| private static final Log log = LogFactory.getLog(DataSourceUserDatabase.class); |
| private static final StringManager sm = StringManager.getManager(DataSourceUserDatabase.class); |
| |
| public DataSourceUserDatabase(DataSource dataSource, String id) { |
| this.dataSource = dataSource; |
| this.id = id; |
| } |
| |
| |
| /** |
| * DataSource to use. |
| */ |
| protected final DataSource dataSource; |
| |
| |
| /** |
| * The unique global identifier of this user database. |
| */ |
| protected final String id; |
| |
| protected final ConcurrentHashMap<String,User> createdUsers = new ConcurrentHashMap<>(); |
| protected final ConcurrentHashMap<String,User> modifiedUsers = new ConcurrentHashMap<>(); |
| protected final ConcurrentHashMap<String,User> removedUsers = new ConcurrentHashMap<>(); |
| |
| protected final ConcurrentHashMap<String,Group> createdGroups = new ConcurrentHashMap<>(); |
| protected final ConcurrentHashMap<String,Group> modifiedGroups = new ConcurrentHashMap<>(); |
| protected final ConcurrentHashMap<String,Group> removedGroups = new ConcurrentHashMap<>(); |
| |
| protected final ConcurrentHashMap<String,Role> createdRoles = new ConcurrentHashMap<>(); |
| protected final ConcurrentHashMap<String,Role> modifiedRoles = new ConcurrentHashMap<>(); |
| protected final ConcurrentHashMap<String,Role> removedRoles = new ConcurrentHashMap<>(); |
| |
| |
| // ----------------------------------------------------- Instance Variables |
| |
| |
| /** |
| * The generated string for the all users PreparedStatement |
| */ |
| private String preparedAllUsers = null; |
| |
| |
| /** |
| * The generated string for the all groups PreparedStatement |
| */ |
| private String preparedAllGroups = null; |
| |
| |
| /** |
| * The generated string for the all roles PreparedStatement |
| */ |
| private String preparedAllRoles = null; |
| |
| |
| /** |
| * The generated string for the group PreparedStatement |
| */ |
| private String preparedGroup = null; |
| |
| |
| /** |
| * The generated string for the role PreparedStatement |
| */ |
| private String preparedRole = null; |
| |
| |
| /** |
| * The generated string for the roles PreparedStatement |
| */ |
| private String preparedUserRoles = null; |
| |
| |
| /** |
| * The generated string for the user PreparedStatement |
| */ |
| private String preparedUser = null; |
| |
| |
| /** |
| * The generated string for the groups PreparedStatement |
| */ |
| private String preparedUserGroups = null; |
| |
| |
| /** |
| * The generated string for the groups PreparedStatement |
| */ |
| private String preparedGroupRoles = null; |
| |
| |
| /** |
| * The name of the JNDI JDBC DataSource |
| */ |
| protected String dataSourceName = null; |
| |
| |
| /** |
| * The column in the user role table that names a role |
| */ |
| protected String roleNameCol = null; |
| |
| |
| /** |
| * The column in the role and group tables for the description |
| */ |
| protected String roleAndGroupDescriptionCol = null; |
| |
| |
| /** |
| * The column in the user group table that names a group |
| */ |
| protected String groupNameCol = null; |
| |
| |
| /** |
| * The column in the user table that holds the user's credentials |
| */ |
| protected String userCredCol = null; |
| |
| |
| /** |
| * The column in the user table that holds the user's full name |
| */ |
| protected String userFullNameCol = null; |
| |
| |
| /** |
| * The column in the user table that holds the user's name |
| */ |
| protected String userNameCol = null; |
| |
| |
| /** |
| * The table that holds the relation between users and roles |
| */ |
| protected String userRoleTable = null; |
| |
| |
| /** |
| * The table that holds the relation between users and groups |
| */ |
| protected String userGroupTable = null; |
| |
| |
| /** |
| * The table that holds the relation between groups and roles |
| */ |
| protected String groupRoleTable = null; |
| |
| |
| /** |
| * The table that holds user data. |
| */ |
| protected String userTable = null; |
| |
| |
| /** |
| * The table that holds user data. |
| */ |
| protected String groupTable = null; |
| |
| |
| /** |
| * The table that holds user data. |
| */ |
| protected String roleTable = null; |
| |
| |
| /** |
| * Last connection attempt. |
| */ |
| private volatile boolean connectionSuccess = true; |
| |
| |
| /** |
| * A flag, indicating if the user database is read only. |
| */ |
| protected boolean readonly = true; |
| |
| // The write lock on the database is assumed to include the write locks |
| // for groups, users and roles. |
| private final ReentrantReadWriteLock dbLock = new ReentrantReadWriteLock(); |
| private final Lock dbReadLock = dbLock.readLock(); |
| private final Lock dbWriteLock = dbLock.writeLock(); |
| |
| private final ReentrantReadWriteLock groupsLock = new ReentrantReadWriteLock(); |
| private final Lock groupsReadLock = groupsLock.readLock(); |
| private final Lock groupsWriteLock = groupsLock.writeLock(); |
| |
| private final ReentrantReadWriteLock usersLock = new ReentrantReadWriteLock(); |
| private final Lock usersReadLock = usersLock.readLock(); |
| private final Lock usersWriteLock = usersLock.writeLock(); |
| |
| private final ReentrantReadWriteLock rolesLock = new ReentrantReadWriteLock(); |
| private final Lock rolesReadLock = rolesLock.readLock(); |
| private final Lock rolesWriteLock = rolesLock.writeLock(); |
| |
| |
| // ------------------------------------------------------------- Properties |
| |
| /** |
| * @return the name of the JNDI JDBC DataSource. |
| */ |
| public String getDataSourceName() { |
| return dataSourceName; |
| } |
| |
| /** |
| * Set the name of the JNDI JDBC DataSource. |
| * |
| * @param dataSourceName the name of the JNDI JDBC DataSource |
| */ |
| public void setDataSourceName(String dataSourceName) { |
| this.dataSourceName = dataSourceName; |
| } |
| |
| /** |
| * @return the column in the user role table that names a role. |
| */ |
| public String getRoleNameCol() { |
| return roleNameCol; |
| } |
| |
| /** |
| * Set the column in the user role table that names a role. |
| * |
| * @param roleNameCol The column name |
| */ |
| public void setRoleNameCol(String roleNameCol) { |
| this.roleNameCol = roleNameCol; |
| } |
| |
| /** |
| * @return the column in the user table that holds the user's credentials. |
| */ |
| public String getUserCredCol() { |
| return userCredCol; |
| } |
| |
| /** |
| * Set the column in the user table that holds the user's credentials. |
| * |
| * @param userCredCol The column name |
| */ |
| public void setUserCredCol(String userCredCol) { |
| this.userCredCol = userCredCol; |
| } |
| |
| /** |
| * @return the column in the user table that holds the user's name. |
| */ |
| public String getUserNameCol() { |
| return userNameCol; |
| } |
| |
| /** |
| * Set the column in the user table that holds the user's name. |
| * |
| * @param userNameCol The column name |
| */ |
| public void setUserNameCol(String userNameCol) { |
| this.userNameCol = userNameCol; |
| } |
| |
| /** |
| * @return the table that holds the relation between user's and roles. |
| */ |
| public String getUserRoleTable() { |
| return userRoleTable; |
| } |
| |
| /** |
| * Set the table that holds the relation between user's and roles. |
| * |
| * @param userRoleTable The table name |
| */ |
| public void setUserRoleTable(String userRoleTable) { |
| this.userRoleTable = userRoleTable; |
| } |
| |
| /** |
| * @return the table that holds user data |
| */ |
| public String getUserTable() { |
| return userTable; |
| } |
| |
| /** |
| * Set the table that holds user data. |
| * |
| * @param userTable The table name |
| */ |
| public void setUserTable(String userTable) { |
| this.userTable = userTable; |
| } |
| |
| |
| /** |
| * @return the roleAndGroupDescriptionCol |
| */ |
| public String getRoleAndGroupDescriptionCol() { |
| return this.roleAndGroupDescriptionCol; |
| } |
| |
| /** |
| * @param roleAndGroupDescriptionCol the roleAndGroupDescriptionCol to set |
| */ |
| public void setRoleAndGroupDescriptionCol(String roleAndGroupDescriptionCol) { |
| this.roleAndGroupDescriptionCol = roleAndGroupDescriptionCol; |
| } |
| |
| /** |
| * @return the groupNameCol |
| */ |
| public String getGroupNameCol() { |
| return this.groupNameCol; |
| } |
| |
| /** |
| * @param groupNameCol the groupNameCol to set |
| */ |
| public void setGroupNameCol(String groupNameCol) { |
| this.groupNameCol = groupNameCol; |
| } |
| |
| /** |
| * @return the userFullNameCol |
| */ |
| public String getUserFullNameCol() { |
| return this.userFullNameCol; |
| } |
| |
| /** |
| * @param userFullNameCol the userFullNameCol to set |
| */ |
| public void setUserFullNameCol(String userFullNameCol) { |
| this.userFullNameCol = userFullNameCol; |
| } |
| |
| /** |
| * @return the userGroupTable |
| */ |
| public String getUserGroupTable() { |
| return this.userGroupTable; |
| } |
| |
| /** |
| * @param userGroupTable the userGroupTable to set |
| */ |
| public void setUserGroupTable(String userGroupTable) { |
| this.userGroupTable = userGroupTable; |
| } |
| |
| /** |
| * @return the groupRoleTable |
| */ |
| public String getGroupRoleTable() { |
| return this.groupRoleTable; |
| } |
| |
| /** |
| * @param groupRoleTable the groupRoleTable to set |
| */ |
| public void setGroupRoleTable(String groupRoleTable) { |
| this.groupRoleTable = groupRoleTable; |
| } |
| |
| /** |
| * @return the groupTable |
| */ |
| public String getGroupTable() { |
| return this.groupTable; |
| } |
| |
| /** |
| * @param groupTable the groupTable to set |
| */ |
| public void setGroupTable(String groupTable) { |
| this.groupTable = groupTable; |
| } |
| |
| /** |
| * @return the roleTable |
| */ |
| public String getRoleTable() { |
| return this.roleTable; |
| } |
| |
| /** |
| * @param roleTable the roleTable to set |
| */ |
| public void setRoleTable(String roleTable) { |
| this.roleTable = roleTable; |
| } |
| |
| /** |
| * @return the readonly |
| */ |
| public boolean getReadonly() { |
| return this.readonly; |
| } |
| |
| /** |
| * @param readonly the readonly to set |
| */ |
| public void setReadonly(boolean readonly) { |
| this.readonly = readonly; |
| } |
| |
| @Override |
| public String getId() { |
| return id; |
| } |
| |
| @Override |
| public Iterator<Group> getGroups() { |
| dbReadLock.lock(); |
| try { |
| groupsReadLock.lock(); |
| try { |
| HashMap<String,Group> groups = new HashMap<>(); |
| groups.putAll(createdGroups); |
| groups.putAll(modifiedGroups); |
| |
| try (Connection dbConnection = openConnection()) { |
| if (dbConnection != null && preparedAllGroups != null) { |
| try (PreparedStatement stmt = dbConnection.prepareStatement(preparedAllGroups)) { |
| try (ResultSet rs = stmt.executeQuery()) { |
| while (rs.next()) { |
| String groupName = rs.getString(1); |
| if (groupName != null) { |
| if (!groups.containsKey(groupName) && !removedGroups.containsKey(groupName)) { |
| Group group = findGroupInternal(dbConnection, groupName); |
| if (group != null) { |
| groups.put(groupName, group); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| return groups.values().iterator(); |
| } finally { |
| groupsReadLock.unlock(); |
| } |
| } finally { |
| dbReadLock.unlock(); |
| } |
| } |
| |
| @Override |
| public Iterator<Role> getRoles() { |
| dbReadLock.lock(); |
| try { |
| rolesReadLock.lock(); |
| try { |
| HashMap<String,Role> roles = new HashMap<>(); |
| roles.putAll(createdRoles); |
| roles.putAll(modifiedRoles); |
| |
| try (Connection dbConnection = openConnection()) { |
| if (dbConnection != null && preparedAllRoles != null) { |
| try (PreparedStatement stmt = dbConnection.prepareStatement(preparedAllRoles)) { |
| try (ResultSet rs = stmt.executeQuery()) { |
| while (rs.next()) { |
| String roleName = rs.getString(1); |
| if (roleName != null) { |
| if (!roles.containsKey(roleName) && !removedRoles.containsKey(roleName)) { |
| Role role = findRoleInternal(dbConnection, roleName); |
| if (role != null) { |
| roles.put(roleName, role); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| return roles.values().iterator(); |
| } finally { |
| rolesReadLock.unlock(); |
| } |
| } finally { |
| dbReadLock.unlock(); |
| } |
| } |
| |
| @Override |
| public Iterator<User> getUsers() { |
| dbReadLock.lock(); |
| try { |
| usersReadLock.lock(); |
| try { |
| HashMap<String,User> users = new HashMap<>(); |
| users.putAll(createdUsers); |
| users.putAll(modifiedUsers); |
| |
| Connection dbConnection = openConnection(); |
| if (dbConnection != null) { |
| try (PreparedStatement stmt = dbConnection.prepareStatement(preparedAllUsers)) { |
| try (ResultSet rs = stmt.executeQuery()) { |
| while (rs.next()) { |
| String userName = rs.getString(1); |
| if (userName != null) { |
| if (!users.containsKey(userName) && !removedUsers.containsKey(userName)) { |
| User user = findUserInternal(dbConnection, userName); |
| if (user != null) { |
| users.put(userName, user); |
| } |
| } |
| } |
| } |
| } |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } finally { |
| closeConnection(dbConnection); |
| } |
| } |
| return users.values().iterator(); |
| } finally { |
| usersReadLock.unlock(); |
| } |
| } finally { |
| dbReadLock.unlock(); |
| } |
| } |
| |
| @Override |
| public void close() throws Exception { |
| } |
| |
| @Override |
| public Group createGroup(String groupname, String description) { |
| dbReadLock.lock(); |
| try { |
| groupsWriteLock.lock(); |
| try { |
| Group group = new GenericGroup<>(this, groupname, description, null); |
| createdGroups.put(groupname, group); |
| modifiedGroups.remove(groupname); |
| return group; |
| } finally { |
| groupsWriteLock.unlock(); |
| } |
| } finally { |
| dbReadLock.unlock(); |
| } |
| } |
| |
| @Override |
| public Role createRole(String rolename, String description) { |
| dbReadLock.lock(); |
| try { |
| rolesWriteLock.lock(); |
| try { |
| Role role = new GenericRole<>(this, rolename, description); |
| createdRoles.put(rolename, role); |
| modifiedRoles.remove(rolename); |
| return role; |
| } finally { |
| rolesWriteLock.unlock(); |
| } |
| } finally { |
| dbReadLock.unlock(); |
| } |
| } |
| |
| @Override |
| public User createUser(String username, String password, String fullName) { |
| dbReadLock.lock(); |
| try { |
| usersWriteLock.lock(); |
| try { |
| User user = new GenericUser<>(this, username, password, fullName, null, null); |
| createdUsers.put(username, user); |
| modifiedUsers.remove(username); |
| return user; |
| } finally { |
| usersWriteLock.unlock(); |
| } |
| } finally { |
| dbReadLock.unlock(); |
| } |
| } |
| |
| @Override |
| public Group findGroup(String groupname) { |
| dbReadLock.lock(); |
| try { |
| groupsReadLock.lock(); |
| try { |
| // Check local changes first |
| Group group = createdGroups.get(groupname); |
| if (group != null) { |
| return group; |
| } |
| group = modifiedGroups.get(groupname); |
| if (group != null) { |
| return group; |
| } |
| group = removedGroups.get(groupname); |
| if (group != null) { |
| return null; |
| } |
| |
| if (isGroupStoreDefined()) { |
| Connection dbConnection = openConnection(); |
| if (dbConnection == null) { |
| return null; |
| } |
| try { |
| return findGroupInternal(dbConnection, groupname); |
| } finally { |
| closeConnection(dbConnection); |
| } |
| } else { |
| return null; |
| } |
| } finally { |
| groupsReadLock.unlock(); |
| } |
| } finally { |
| dbReadLock.unlock(); |
| } |
| } |
| |
| public Group findGroupInternal(Connection dbConnection, String groupName) { |
| Group group = null; |
| try (PreparedStatement stmt = dbConnection.prepareStatement(preparedGroup)) { |
| stmt.setString(1, groupName); |
| try (ResultSet rs = stmt.executeQuery()) { |
| if (rs.next()) { |
| if (rs.getString(1) != null) { |
| String description = (roleAndGroupDescriptionCol != null) ? rs.getString(2) : null; |
| ArrayList<Role> groupRoles = new ArrayList<>(); |
| if (groupName != null) { |
| groupName = groupName.trim(); |
| try (PreparedStatement stmt2 = dbConnection.prepareStatement(preparedGroupRoles)) { |
| stmt2.setString(1, groupName); |
| try (ResultSet rs2 = stmt2.executeQuery()) { |
| while (rs2.next()) { |
| String roleName = rs2.getString(1); |
| if (roleName != null) { |
| Role groupRole = findRoleInternal(dbConnection, roleName); |
| if (groupRole != null) { |
| groupRoles.add(groupRole); |
| } |
| } |
| } |
| } |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| group = new GenericGroup<>(this, groupName, description, groupRoles); |
| } |
| } |
| } |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| return group; |
| } |
| |
| @Override |
| public Role findRole(String rolename) { |
| dbReadLock.lock(); |
| try { |
| rolesReadLock.lock(); |
| try { |
| // Check local changes first |
| Role role = createdRoles.get(rolename); |
| if (role != null) { |
| return role; |
| } |
| role = modifiedRoles.get(rolename); |
| if (role != null) { |
| return role; |
| } |
| role = removedRoles.get(rolename); |
| if (role != null) { |
| return null; |
| } |
| |
| if (userRoleTable != null && roleNameCol != null) { |
| Connection dbConnection = openConnection(); |
| if (dbConnection == null) { |
| return null; |
| } |
| try { |
| return findRoleInternal(dbConnection, rolename); |
| } finally { |
| closeConnection(dbConnection); |
| } |
| } else { |
| return null; |
| } |
| } finally { |
| rolesReadLock.unlock(); |
| } |
| } finally { |
| dbReadLock.unlock(); |
| } |
| } |
| |
| public Role findRoleInternal(Connection dbConnection, String roleName) { |
| Role role = null; |
| try (PreparedStatement stmt = dbConnection.prepareStatement(preparedRole)) { |
| stmt.setString(1, roleName); |
| try (ResultSet rs = stmt.executeQuery()) { |
| if (rs.next()) { |
| if (rs.getString(1) != null) { |
| String description = (roleAndGroupDescriptionCol != null) ? rs.getString(2) : null; |
| role = new GenericRole<>(this, roleName, description); |
| } |
| } |
| } |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| return role; |
| } |
| |
| @Override |
| public User findUser(String username) { |
| dbReadLock.lock(); |
| try { |
| usersReadLock.lock(); |
| try { |
| // Check local changes first |
| User user = createdUsers.get(username); |
| if (user != null) { |
| return user; |
| } |
| user = modifiedUsers.get(username); |
| if (user != null) { |
| return user; |
| } |
| user = removedUsers.get(username); |
| if (user != null) { |
| return null; |
| } |
| |
| Connection dbConnection = openConnection(); |
| if (dbConnection == null) { |
| return null; |
| } |
| try { |
| return findUserInternal(dbConnection, username); |
| } finally { |
| closeConnection(dbConnection); |
| } |
| } finally { |
| usersReadLock.unlock(); |
| } |
| } finally { |
| dbReadLock.unlock(); |
| } |
| } |
| |
| public User findUserInternal(Connection dbConnection, String userName) { |
| String dbCredentials = null; |
| String fullName = null; |
| |
| try (PreparedStatement stmt = dbConnection.prepareStatement(preparedUser)) { |
| stmt.setString(1, userName); |
| |
| try (ResultSet rs = stmt.executeQuery()) { |
| if (rs.next()) { |
| dbCredentials = rs.getString(1); |
| if (userFullNameCol != null) { |
| fullName = rs.getString(2); |
| } |
| } |
| |
| dbCredentials = (dbCredentials != null) ? dbCredentials.trim() : null; |
| } |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| |
| // Lookup groups |
| ArrayList<Group> groups = new ArrayList<>(); |
| if (isGroupStoreDefined()) { |
| try (PreparedStatement stmt = dbConnection.prepareStatement(preparedUserGroups)) { |
| stmt.setString(1, userName); |
| try (ResultSet rs = stmt.executeQuery()) { |
| while (rs.next()) { |
| String groupName = rs.getString(1); |
| if (groupName != null) { |
| Group group = findGroupInternal(dbConnection, groupName); |
| if (group != null) { |
| groups.add(group); |
| } |
| } |
| } |
| } |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| |
| ArrayList<Role> roles = new ArrayList<>(); |
| if (userRoleTable != null && roleNameCol != null) { |
| try (PreparedStatement stmt = dbConnection.prepareStatement(preparedUserRoles)) { |
| stmt.setString(1, userName); |
| try (ResultSet rs = stmt.executeQuery()) { |
| while (rs.next()) { |
| String roleName = rs.getString(1); |
| if (roleName != null) { |
| Role role = findRoleInternal(dbConnection, roleName); |
| if (role != null) { |
| roles.add(role); |
| } |
| } |
| } |
| } |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| |
| return new GenericUser<>(this, userName, dbCredentials, fullName, groups, roles); |
| } |
| |
| @Override |
| public void modifiedGroup(Group group) { |
| dbReadLock.lock(); |
| try { |
| groupsWriteLock.lock(); |
| try { |
| String name = group.getName(); |
| if (!createdGroups.containsKey(name) && !removedGroups.containsKey(name)) { |
| modifiedGroups.put(name, group); |
| } |
| } finally { |
| groupsWriteLock.unlock(); |
| } |
| } finally { |
| dbReadLock.unlock(); |
| } |
| } |
| |
| @Override |
| public void modifiedRole(Role role) { |
| dbReadLock.lock(); |
| try { |
| rolesWriteLock.lock(); |
| try { |
| String name = role.getName(); |
| if (!createdRoles.containsKey(name) && !removedRoles.containsKey(name)) { |
| modifiedRoles.put(name, role); |
| } |
| } finally { |
| rolesWriteLock.unlock(); |
| } |
| } finally { |
| dbReadLock.unlock(); |
| } |
| } |
| |
| @Override |
| public void modifiedUser(User user) { |
| dbReadLock.lock(); |
| try { |
| usersWriteLock.lock(); |
| try { |
| String name = user.getName(); |
| if (!createdUsers.containsKey(name) && !removedUsers.containsKey(name)) { |
| modifiedUsers.put(name, user); |
| } |
| } finally { |
| usersWriteLock.unlock(); |
| } |
| } finally { |
| dbReadLock.unlock(); |
| } |
| } |
| |
| @Override |
| public void open() throws Exception { |
| |
| if (log.isDebugEnabled()) { |
| // As there are lots of parameters to configure, log some debug to help out |
| log.debug(sm.getString("dataSourceUserDatabase.features", |
| Boolean.toString(userRoleTable != null && roleNameCol != null), |
| Boolean.toString(isRoleStoreDefined()), Boolean.toString(isGroupStoreDefined()))); |
| } |
| |
| dbWriteLock.lock(); |
| try { |
| |
| StringBuilder temp = new StringBuilder("SELECT "); |
| temp.append(userCredCol); |
| if (userFullNameCol != null) { |
| temp.append(',').append(userFullNameCol); |
| } |
| temp.append(" FROM "); |
| temp.append(userTable); |
| temp.append(" WHERE "); |
| temp.append(userNameCol); |
| temp.append(" = ?"); |
| preparedUser = temp.toString(); |
| |
| temp = new StringBuilder("SELECT "); |
| temp.append(userNameCol); |
| temp.append(" FROM "); |
| temp.append(userTable); |
| preparedAllUsers = temp.toString(); |
| |
| temp = new StringBuilder("SELECT "); |
| temp.append(roleNameCol); |
| temp.append(" FROM "); |
| temp.append(userRoleTable); |
| temp.append(" WHERE "); |
| temp.append(userNameCol); |
| temp.append(" = ?"); |
| preparedUserRoles = temp.toString(); |
| |
| if (isGroupStoreDefined()) { |
| temp = new StringBuilder("SELECT "); |
| temp.append(groupNameCol); |
| temp.append(" FROM "); |
| temp.append(userGroupTable); |
| temp.append(" WHERE "); |
| temp.append(userNameCol); |
| temp.append(" = ?"); |
| preparedUserGroups = temp.toString(); |
| |
| temp = new StringBuilder("SELECT "); |
| temp.append(roleNameCol); |
| temp.append(" FROM "); |
| temp.append(groupRoleTable); |
| temp.append(" WHERE "); |
| temp.append(groupNameCol); |
| temp.append(" = ?"); |
| preparedGroupRoles = temp.toString(); |
| |
| temp = new StringBuilder("SELECT "); |
| temp.append(groupNameCol); |
| if (roleAndGroupDescriptionCol != null) { |
| temp.append(',').append(roleAndGroupDescriptionCol); |
| } |
| temp.append(" FROM "); |
| temp.append(groupTable); |
| temp.append(" WHERE "); |
| temp.append(groupNameCol); |
| temp.append(" = ?"); |
| preparedGroup = temp.toString(); |
| |
| temp = new StringBuilder("SELECT "); |
| temp.append(groupNameCol); |
| temp.append(" FROM "); |
| temp.append(groupTable); |
| preparedAllGroups = temp.toString(); |
| } |
| |
| if (isRoleStoreDefined()) { |
| // Create the role PreparedStatement string |
| temp = new StringBuilder("SELECT "); |
| temp.append(roleNameCol); |
| if (roleAndGroupDescriptionCol != null) { |
| temp.append(',').append(roleAndGroupDescriptionCol); |
| } |
| temp.append(" FROM "); |
| temp.append(roleTable); |
| temp.append(" WHERE "); |
| temp.append(roleNameCol); |
| temp.append(" = ?"); |
| preparedRole = temp.toString(); |
| |
| temp = new StringBuilder("SELECT "); |
| temp.append(roleNameCol); |
| temp.append(" FROM "); |
| temp.append(roleTable); |
| preparedAllRoles = temp.toString(); |
| } else if (userRoleTable != null && roleNameCol != null) { |
| // Validate roles existence from the user <-> roles table |
| temp = new StringBuilder("SELECT "); |
| temp.append(roleNameCol); |
| temp.append(" FROM "); |
| temp.append(userRoleTable); |
| temp.append(" WHERE "); |
| temp.append(roleNameCol); |
| temp.append(" = ?"); |
| preparedRole = temp.toString(); |
| } |
| |
| } finally { |
| dbWriteLock.unlock(); |
| } |
| |
| } |
| |
| @Override |
| public void removeGroup(Group group) { |
| dbReadLock.lock(); |
| try { |
| groupsWriteLock.lock(); |
| try { |
| String name = group.getName(); |
| createdGroups.remove(name); |
| modifiedGroups.remove(name); |
| removedGroups.put(name, group); |
| } finally { |
| groupsWriteLock.unlock(); |
| } |
| } finally { |
| dbReadLock.unlock(); |
| } |
| } |
| |
| @Override |
| public void removeRole(Role role) { |
| dbReadLock.lock(); |
| try { |
| rolesWriteLock.lock(); |
| try { |
| String name = role.getName(); |
| createdRoles.remove(name); |
| modifiedRoles.remove(name); |
| removedRoles.put(name, role); |
| } finally { |
| rolesWriteLock.unlock(); |
| } |
| } finally { |
| dbReadLock.unlock(); |
| } |
| } |
| |
| @Override |
| public void removeUser(User user) { |
| dbReadLock.lock(); |
| try { |
| usersWriteLock.lock(); |
| try { |
| String name = user.getName(); |
| createdUsers.remove(name); |
| modifiedUsers.remove(name); |
| removedUsers.put(name, user); |
| } finally { |
| usersWriteLock.unlock(); |
| } |
| } finally { |
| dbReadLock.unlock(); |
| } |
| } |
| |
| @Override |
| public void save() throws Exception { |
| if (readonly) { |
| return; |
| } |
| |
| Connection dbConnection = openConnection(); |
| if (dbConnection == null) { |
| return; |
| } |
| |
| dbWriteLock.lock(); |
| try { |
| try { |
| saveInternal(dbConnection); |
| } finally { |
| closeConnection(dbConnection); |
| } |
| } finally { |
| dbWriteLock.unlock(); |
| } |
| } |
| |
| protected void saveInternal(Connection dbConnection) { |
| |
| StringBuilder temp = null; |
| StringBuilder tempRelation; |
| StringBuilder tempRelationDelete = null; |
| |
| if (isRoleStoreDefined()) { |
| |
| // Removed roles |
| if (!removedRoles.isEmpty()) { |
| temp = new StringBuilder("DELETE FROM "); |
| temp.append(roleTable); |
| temp.append(" WHERE ").append(roleNameCol); |
| temp.append(" = ?"); |
| if (groupRoleTable != null) { |
| tempRelationDelete = new StringBuilder("DELETE FROM "); |
| tempRelationDelete.append(groupRoleTable); |
| tempRelationDelete.append(" WHERE "); |
| tempRelationDelete.append(roleNameCol); |
| tempRelationDelete.append(" = ?"); |
| } |
| StringBuilder tempRelationDelete2 = new StringBuilder("DELETE FROM "); |
| tempRelationDelete2.append(userRoleTable); |
| tempRelationDelete2.append(" WHERE "); |
| tempRelationDelete2.append(roleNameCol); |
| tempRelationDelete2.append(" = ?"); |
| for (Role role : removedRoles.values()) { |
| if (tempRelationDelete != null) { |
| try (PreparedStatement stmt = dbConnection.prepareStatement(tempRelationDelete.toString())) { |
| stmt.setString(1, role.getRolename()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| try (PreparedStatement stmt = dbConnection.prepareStatement(tempRelationDelete2.toString())) { |
| stmt.setString(1, role.getRolename()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| try (PreparedStatement stmt = dbConnection.prepareStatement(temp.toString())) { |
| stmt.setString(1, role.getRolename()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| removedRoles.clear(); |
| } |
| |
| // Created roles |
| if (!createdRoles.isEmpty()) { |
| temp = new StringBuilder("INSERT INTO "); |
| temp.append(roleTable); |
| temp.append('(').append(roleNameCol); |
| if (roleAndGroupDescriptionCol != null) { |
| temp.append(',').append(roleAndGroupDescriptionCol); |
| } |
| temp.append(") VALUES (?"); |
| if (roleAndGroupDescriptionCol != null) { |
| temp.append(", ?"); |
| } |
| temp.append(')'); |
| for (Role role : createdRoles.values()) { |
| try (PreparedStatement stmt = dbConnection.prepareStatement(temp.toString())) { |
| stmt.setString(1, role.getRolename()); |
| if (roleAndGroupDescriptionCol != null) { |
| stmt.setString(2, role.getDescription()); |
| } |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| createdRoles.clear(); |
| } |
| |
| // Modified roles |
| if (!modifiedRoles.isEmpty() && roleAndGroupDescriptionCol != null) { |
| temp = new StringBuilder("UPDATE "); |
| temp.append(roleTable); |
| temp.append(" SET ").append(roleAndGroupDescriptionCol); |
| temp.append(" = ? WHERE ").append(roleNameCol); |
| temp.append(" = ?"); |
| for (Role role : modifiedRoles.values()) { |
| try (PreparedStatement stmt = dbConnection.prepareStatement(temp.toString())) { |
| stmt.setString(1, role.getDescription()); |
| stmt.setString(2, role.getRolename()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| modifiedRoles.clear(); |
| } |
| |
| } else if (userRoleTable != null && roleNameCol != null) { |
| // Only remove role from users |
| tempRelationDelete = new StringBuilder("DELETE FROM "); |
| tempRelationDelete.append(userRoleTable); |
| tempRelationDelete.append(" WHERE "); |
| tempRelationDelete.append(roleNameCol); |
| tempRelationDelete.append(" = ?"); |
| for (Role role : removedRoles.values()) { |
| try (PreparedStatement stmt = dbConnection.prepareStatement(tempRelationDelete.toString())) { |
| stmt.setString(1, role.getRolename()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| removedRoles.clear(); |
| } |
| |
| if (isGroupStoreDefined()) { |
| |
| tempRelation = new StringBuilder("INSERT INTO "); |
| tempRelation.append(groupRoleTable); |
| tempRelation.append('(').append(groupNameCol).append(", "); |
| tempRelation.append(roleNameCol); |
| tempRelation.append(") VALUES (?, ?)"); |
| String groupRoleRelation = tempRelation.toString(); |
| // Always drop and recreate all group <-> role relations |
| tempRelationDelete = new StringBuilder("DELETE FROM "); |
| tempRelationDelete.append(groupRoleTable); |
| tempRelationDelete.append(" WHERE "); |
| tempRelationDelete.append(groupNameCol); |
| tempRelationDelete.append(" = ?"); |
| String groupRoleRelationDelete = tempRelationDelete.toString(); |
| |
| // Removed groups |
| if (!removedGroups.isEmpty()) { |
| temp = new StringBuilder("DELETE FROM "); |
| temp.append(groupTable); |
| temp.append(" WHERE ").append(groupNameCol); |
| temp.append(" = ?"); |
| StringBuilder tempRelationDelete2 = new StringBuilder("DELETE FROM "); |
| tempRelationDelete2.append(userGroupTable); |
| tempRelationDelete2.append(" WHERE "); |
| tempRelationDelete2.append(groupNameCol); |
| tempRelationDelete2.append(" = ?"); |
| for (Group group : removedGroups.values()) { |
| try (PreparedStatement stmt = dbConnection.prepareStatement(groupRoleRelationDelete)) { |
| stmt.setString(1, group.getGroupname()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| try (PreparedStatement stmt = dbConnection.prepareStatement(tempRelationDelete2.toString())) { |
| stmt.setString(1, group.getGroupname()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| try (PreparedStatement stmt = dbConnection.prepareStatement(temp.toString())) { |
| stmt.setString(1, group.getGroupname()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| removedGroups.clear(); |
| } |
| |
| // Created groups |
| if (!createdGroups.isEmpty()) { |
| temp = new StringBuilder("INSERT INTO "); |
| temp.append(groupTable); |
| temp.append('(').append(groupNameCol); |
| if (roleAndGroupDescriptionCol != null) { |
| temp.append(',').append(roleAndGroupDescriptionCol); |
| } |
| temp.append(") VALUES (?"); |
| if (roleAndGroupDescriptionCol != null) { |
| temp.append(", ?"); |
| } |
| temp.append(')'); |
| for (Group group : createdGroups.values()) { |
| try (PreparedStatement stmt = dbConnection.prepareStatement(temp.toString())) { |
| stmt.setString(1, group.getGroupname()); |
| if (roleAndGroupDescriptionCol != null) { |
| stmt.setString(2, group.getDescription()); |
| } |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| Iterator<Role> roles = group.getRoles(); |
| while (roles.hasNext()) { |
| Role role = roles.next(); |
| try (PreparedStatement stmt = dbConnection.prepareStatement(groupRoleRelation)) { |
| stmt.setString(1, group.getGroupname()); |
| stmt.setString(2, role.getRolename()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| } |
| createdGroups.clear(); |
| } |
| |
| // Modified groups |
| if (!modifiedGroups.isEmpty()) { |
| if (roleAndGroupDescriptionCol != null) { |
| temp = new StringBuilder("UPDATE "); |
| temp.append(groupTable); |
| temp.append(" SET ").append(roleAndGroupDescriptionCol); |
| temp.append(" = ? WHERE ").append(groupNameCol); |
| temp.append(" = ?"); |
| } |
| for (Group group : modifiedGroups.values()) { |
| if (temp != null) { |
| try (PreparedStatement stmt = dbConnection.prepareStatement(temp.toString())) { |
| stmt.setString(1, group.getDescription()); |
| stmt.setString(2, group.getGroupname()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| try (PreparedStatement stmt = dbConnection.prepareStatement(groupRoleRelationDelete)) { |
| stmt.setString(1, group.getGroupname()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| Iterator<Role> roles = group.getRoles(); |
| while (roles.hasNext()) { |
| Role role = roles.next(); |
| try (PreparedStatement stmt = dbConnection.prepareStatement(groupRoleRelation)) { |
| stmt.setString(1, group.getGroupname()); |
| stmt.setString(2, role.getRolename()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| } |
| modifiedGroups.clear(); |
| } |
| |
| } |
| |
| String userRoleRelation = null; |
| String userRoleRelationDelete = null; |
| if (userRoleTable != null && roleNameCol != null) { |
| tempRelation = new StringBuilder("INSERT INTO "); |
| tempRelation.append(userRoleTable); |
| tempRelation.append('(').append(userNameCol).append(", "); |
| tempRelation.append(roleNameCol); |
| tempRelation.append(") VALUES (?, ?)"); |
| userRoleRelation = tempRelation.toString(); |
| // Always drop and recreate all user <-> role relations |
| tempRelationDelete = new StringBuilder("DELETE FROM "); |
| tempRelationDelete.append(userRoleTable); |
| tempRelationDelete.append(" WHERE "); |
| tempRelationDelete.append(userNameCol); |
| tempRelationDelete.append(" = ?"); |
| userRoleRelationDelete = tempRelationDelete.toString(); |
| } |
| String userGroupRelation = null; |
| String userGroupRelationDelete = null; |
| if (isGroupStoreDefined()) { |
| tempRelation = new StringBuilder("INSERT INTO "); |
| tempRelation.append(userGroupTable); |
| tempRelation.append('(').append(userNameCol).append(", "); |
| tempRelation.append(groupNameCol); |
| tempRelation.append(") VALUES (?, ?)"); |
| userGroupRelation = tempRelation.toString(); |
| // Always drop and recreate all user <-> group relations |
| tempRelationDelete = new StringBuilder("DELETE FROM "); |
| tempRelationDelete.append(userGroupTable); |
| tempRelationDelete.append(" WHERE "); |
| tempRelationDelete.append(userNameCol); |
| tempRelationDelete.append(" = ?"); |
| userGroupRelationDelete = tempRelationDelete.toString(); |
| } |
| |
| // Removed users |
| if (!removedUsers.isEmpty()) { |
| temp = new StringBuilder("DELETE FROM "); |
| temp.append(userTable); |
| temp.append(" WHERE ").append(userNameCol); |
| temp.append(" = ?"); |
| for (User user : removedUsers.values()) { |
| if (userRoleRelationDelete != null) { |
| try (PreparedStatement stmt = dbConnection.prepareStatement(userRoleRelationDelete)) { |
| stmt.setString(1, user.getUsername()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| if (userGroupRelationDelete != null) { |
| try (PreparedStatement stmt = dbConnection.prepareStatement(userGroupRelationDelete)) { |
| stmt.setString(1, user.getUsername()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| try (PreparedStatement stmt = dbConnection.prepareStatement(temp.toString())) { |
| stmt.setString(1, user.getUsername()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| removedUsers.clear(); |
| } |
| |
| // Created users |
| if (!createdUsers.isEmpty()) { |
| temp = new StringBuilder("INSERT INTO "); |
| temp.append(userTable); |
| temp.append('(').append(userNameCol); |
| temp.append(", ").append(userCredCol); |
| if (userFullNameCol != null) { |
| temp.append(',').append(userFullNameCol); |
| } |
| temp.append(") VALUES (?, ?"); |
| if (userFullNameCol != null) { |
| temp.append(", ?"); |
| } |
| temp.append(')'); |
| for (User user : createdUsers.values()) { |
| try (PreparedStatement stmt = dbConnection.prepareStatement(temp.toString())) { |
| stmt.setString(1, user.getUsername()); |
| stmt.setString(2, user.getPassword()); |
| if (userFullNameCol != null) { |
| stmt.setString(3, user.getFullName()); |
| } |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| if (userRoleRelation != null) { |
| Iterator<Role> roles = user.getRoles(); |
| while (roles.hasNext()) { |
| Role role = roles.next(); |
| try (PreparedStatement stmt = dbConnection.prepareStatement(userRoleRelation)) { |
| stmt.setString(1, user.getUsername()); |
| stmt.setString(2, role.getRolename()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| } |
| if (userGroupRelation != null) { |
| Iterator<Group> groups = user.getGroups(); |
| while (groups.hasNext()) { |
| Group group = groups.next(); |
| try (PreparedStatement stmt = dbConnection.prepareStatement(userGroupRelation)) { |
| stmt.setString(1, user.getUsername()); |
| stmt.setString(2, group.getGroupname()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| } |
| } |
| createdUsers.clear(); |
| } |
| |
| // Modified users |
| if (!modifiedUsers.isEmpty()) { |
| temp = new StringBuilder("UPDATE "); |
| temp.append(userTable); |
| temp.append(" SET ").append(userCredCol); |
| temp.append(" = ?"); |
| if (userFullNameCol != null) { |
| temp.append(", ").append(userFullNameCol).append(" = ?"); |
| } |
| temp.append(" WHERE ").append(userNameCol); |
| temp.append(" = ?"); |
| for (User user : modifiedUsers.values()) { |
| try (PreparedStatement stmt = dbConnection.prepareStatement(temp.toString())) { |
| stmt.setString(1, user.getPassword()); |
| if (userFullNameCol != null) { |
| stmt.setString(2, user.getFullName()); |
| stmt.setString(3, user.getUsername()); |
| } else { |
| stmt.setString(2, user.getUsername()); |
| } |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| if (userRoleRelationDelete != null) { |
| try (PreparedStatement stmt = dbConnection.prepareStatement(userRoleRelationDelete)) { |
| stmt.setString(1, user.getUsername()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| if (userGroupRelationDelete != null) { |
| try (PreparedStatement stmt = dbConnection.prepareStatement(userGroupRelationDelete)) { |
| stmt.setString(1, user.getUsername()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| if (userRoleRelation != null) { |
| Iterator<Role> roles = user.getRoles(); |
| while (roles.hasNext()) { |
| Role role = roles.next(); |
| try (PreparedStatement stmt = dbConnection.prepareStatement(userRoleRelation)) { |
| stmt.setString(1, user.getUsername()); |
| stmt.setString(2, role.getRolename()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| } |
| if (userGroupRelation != null) { |
| Iterator<Group> groups = user.getGroups(); |
| while (groups.hasNext()) { |
| Group group = groups.next(); |
| try (PreparedStatement stmt = dbConnection.prepareStatement(userGroupRelation)) { |
| stmt.setString(1, user.getUsername()); |
| stmt.setString(2, group.getGroupname()); |
| stmt.executeUpdate(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| } |
| } |
| } |
| modifiedGroups.clear(); |
| } |
| |
| } |
| |
| @Override |
| public boolean isAvailable() { |
| return connectionSuccess; |
| } |
| |
| /** |
| * Only use groups if the tables are fully defined. |
| * |
| * @return true when groups are used |
| */ |
| protected boolean isGroupStoreDefined() { |
| return groupTable != null && userGroupTable != null && groupNameCol != null && groupRoleTable != null && |
| isRoleStoreDefined(); |
| } |
| |
| |
| /** |
| * Only use roles if the tables are fully defined. |
| * |
| * @return true when roles are used |
| */ |
| protected boolean isRoleStoreDefined() { |
| return roleTable != null && userRoleTable != null && roleNameCol != null; |
| } |
| |
| |
| /** |
| * Open the specified database connection. |
| * |
| * @return Connection to the database |
| */ |
| protected Connection openConnection() { |
| if (dataSource == null) { |
| return null; |
| } |
| try { |
| Connection connection = dataSource.getConnection(); |
| connectionSuccess = true; |
| return connection; |
| } catch (Exception e) { |
| connectionSuccess = false; |
| // Log the problem for posterity |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| return null; |
| } |
| |
| /** |
| * Close the specified database connection. |
| * |
| * @param dbConnection The connection to be closed |
| */ |
| protected void closeConnection(Connection dbConnection) { |
| |
| // Do nothing if the database connection is already closed |
| if (dbConnection == null) { |
| return; |
| } |
| |
| // Commit if not auto committed |
| try { |
| if (!dbConnection.getAutoCommit()) { |
| dbConnection.commit(); |
| } |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| |
| // Close this database connection, and log any errors |
| try { |
| dbConnection.close(); |
| } catch (SQLException e) { |
| log.error(sm.getString("dataSourceUserDatabase.exception"), e); |
| } |
| |
| } |
| |
| |
| } |
