001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017:
018: package org.apache.catalina.users;
019:
020: import java.util.ArrayList;
021: import java.util.Iterator;
022:
023: import org.apache.catalina.Group;
024: import org.apache.catalina.Role;
025: import org.apache.catalina.UserDatabase;
026: import org.apache.catalina.util.RequestUtil;
027:
028: /**
029: * <p>Concrete implementation of {@link org.apache.catalina.User} for the
030: * {@link MemoryUserDatabase} implementation of {@link UserDatabase}.</p>
031: *
032: * @author Craig R. McClanahan
033: * @version $Revision: 467222 $ $Date: 2006-10-24 05:17:11 +0200 (mar., 24 oct. 2006) $
034: * @since 4.1
035: */
036:
037: public class MemoryUser extends AbstractUser {
038:
039: // ----------------------------------------------------------- Constructors
040:
041: /**
042: * Package-private constructor used by the factory method in
043: * {@link MemoryUserDatabase}.
044: *
045: * @param database The {@link MemoryUserDatabase} that owns this user
046: * @param username Logon username of the new user
047: * @param password Logon password of the new user
048: * @param fullName Full name of the new user
049: */
050: MemoryUser(MemoryUserDatabase database, String username,
051: String password, String fullName) {
052:
053: super ();
054: this .database = database;
055: setUsername(username);
056: setPassword(password);
057: setFullName(fullName);
058:
059: }
060:
061: // ----------------------------------------------------- Instance Variables
062:
063: /**
064: * The {@link MemoryUserDatabase} that owns this user.
065: */
066: protected MemoryUserDatabase database = null;
067:
068: /**
069: * The set of {@link Group}s that this user is a member of.
070: */
071: protected ArrayList groups = new ArrayList();
072:
073: /**
074: * The set of {@link Role}s associated with this user.
075: */
076: protected ArrayList roles = new ArrayList();
077:
078: // ------------------------------------------------------------- Properties
079:
080: /**
081: * Return the set of {@link Group}s to which this user belongs.
082: */
083: public Iterator getGroups() {
084:
085: synchronized (groups) {
086: return (groups.iterator());
087: }
088:
089: }
090:
091: /**
092: * Return the set of {@link Role}s assigned specifically to this user.
093: */
094: public Iterator getRoles() {
095:
096: synchronized (roles) {
097: return (roles.iterator());
098: }
099:
100: }
101:
102: /**
103: * Return the {@link UserDatabase} within which this User is defined.
104: */
105: public UserDatabase getUserDatabase() {
106:
107: return (this .database);
108:
109: }
110:
111: // --------------------------------------------------------- Public Methods
112:
113: /**
114: * Add a new {@link Group} to those this user belongs to.
115: *
116: * @param group The new group
117: */
118: public void addGroup(Group group) {
119:
120: synchronized (groups) {
121: if (!groups.contains(group)) {
122: groups.add(group);
123: }
124: }
125:
126: }
127:
128: /**
129: * Add a new {@link Role} to those assigned specifically to this user.
130: *
131: * @param role The new role
132: */
133: public void addRole(Role role) {
134:
135: synchronized (roles) {
136: if (!roles.contains(role)) {
137: roles.add(role);
138: }
139: }
140:
141: }
142:
143: /**
144: * Is this user in the specified group?
145: *
146: * @param group The group to check
147: */
148: public boolean isInGroup(Group group) {
149:
150: synchronized (groups) {
151: return (groups.contains(group));
152: }
153:
154: }
155:
156: /**
157: * Is this user specifically assigned the specified {@link Role}? This
158: * method does <strong>NOT</strong> check for roles inherited based on
159: * {@link Group} membership.
160: *
161: * @param role The role to check
162: */
163: public boolean isInRole(Role role) {
164:
165: synchronized (roles) {
166: return (roles.contains(role));
167: }
168:
169: }
170:
171: /**
172: * Remove a {@link Group} from those this user belongs to.
173: *
174: * @param group The old group
175: */
176: public void removeGroup(Group group) {
177:
178: synchronized (groups) {
179: groups.remove(group);
180: }
181:
182: }
183:
184: /**
185: * Remove all {@link Group}s from those this user belongs to.
186: */
187: public void removeGroups() {
188:
189: synchronized (groups) {
190: groups.clear();
191: }
192:
193: }
194:
195: /**
196: * Remove a {@link Role} from those assigned to this user.
197: *
198: * @param role The old role
199: */
200: public void removeRole(Role role) {
201:
202: synchronized (roles) {
203: roles.remove(role);
204: }
205:
206: }
207:
208: /**
209: * Remove all {@link Role}s from those assigned to this user.
210: */
211: public void removeRoles() {
212:
213: synchronized (roles) {
214: roles.clear();
215: }
216:
217: }
218:
219: /**
220: * <p>Return a String representation of this user in XML format.</p>
221: *
222: * <p><strong>IMPLEMENTATION NOTE</strong> - For backwards compatibility,
223: * the reader that processes this entry will accept either
224: * <code>username</code> or </code>name</code> for the username
225: * property.</p>
226: */
227: public String toString() {
228:
229: StringBuffer sb = new StringBuffer("<user username=\"");
230: sb.append(RequestUtil.filter(username));
231: sb.append("\" password=\"");
232: sb.append(RequestUtil.filter(password));
233: sb.append("\"");
234: if (fullName != null) {
235: sb.append(" fullName=\"");
236: sb.append(RequestUtil.filter(fullName));
237: sb.append("\"");
238: }
239: synchronized (groups) {
240: if (groups.size() > 0) {
241: sb.append(" groups=\"");
242: int n = 0;
243: Iterator values = groups.iterator();
244: while (values.hasNext()) {
245: if (n > 0) {
246: sb.append(',');
247: }
248: n++;
249: sb.append(RequestUtil
250: .filter(((Group) values.next())
251: .getGroupname()));
252: }
253: sb.append("\"");
254: }
255: }
256: synchronized (roles) {
257: if (roles.size() > 0) {
258: sb.append(" roles=\"");
259: int n = 0;
260: Iterator values = roles.iterator();
261: while (values.hasNext()) {
262: if (n > 0) {
263: sb.append(',');
264: }
265: n++;
266: sb.append(RequestUtil.filter(((Role) values.next())
267: .getRolename()));
268: }
269: sb.append("\"");
270: }
271: }
272: sb.append("/>");
273: return (sb.toString());
274:
275: }
276:
277: }
|