001 /* 002 * CDDL HEADER START 003 * 004 * The contents of this file are subject to the terms of the 005 * Common Development and Distribution License, Version 1.0 only 006 * (the "License"). You may not use this file except in compliance 007 * with the License. 008 * 009 * You can obtain a copy of the license at 010 * trunk/opends/resource/legal-notices/OpenDS.LICENSE 011 * or https://OpenDS.dev.java.net/OpenDS.LICENSE. 012 * See the License for the specific language governing permissions 013 * and limitations under the License. 014 * 015 * When distributing Covered Code, include this CDDL HEADER in each 016 * file and include the License file at 017 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable, 018 * add the following below this CDDL HEADER, with the fields enclosed 019 * by brackets "[]" replaced with your own identifying information: 020 * Portions Copyright [yyyy] [name of copyright owner] 021 * 022 * CDDL HEADER END 023 * 024 * 025 * Copyright 2008 Sun Microsystems, Inc. 026 */ 027 package org.opends.server.admin; 028 029 030 031 import java.util.Collection; 032 import java.util.Collections; 033 import java.util.Locale; 034 035 import org.opends.messages.Message; 036 import org.opends.server.admin.client.AuthorizationException; 037 import org.opends.server.admin.client.ClientConstraintHandler; 038 import org.opends.server.admin.client.CommunicationException; 039 import org.opends.server.admin.client.ManagedObject; 040 import org.opends.server.admin.client.ManagementContext; 041 import org.opends.server.admin.condition.Condition; 042 import org.opends.server.admin.server.ServerConstraintHandler; 043 import org.opends.server.admin.server.ServerManagedObject; 044 import org.opends.server.config.ConfigException; 045 046 047 048 /** 049 * A generic constraint which comprises of an underlying condition and 050 * a description. The condition must evaluate to <code>true</code> 051 * in order for a new managed object to be created or modified. 052 */ 053 public class GenericConstraint extends Constraint { 054 055 /** 056 * The client-side constraint handler. 057 */ 058 private class ClientHandler extends ClientConstraintHandler { 059 060 // Private constructor. 061 private ClientHandler() { 062 // No implementation required. 063 } 064 065 066 067 /** 068 * {@inheritDoc} 069 */ 070 @Override 071 public boolean isAddAcceptable(ManagementContext context, 072 ManagedObject<?> managedObject, Collection<Message> unacceptableReasons) 073 throws AuthorizationException, CommunicationException { 074 if (!condition.evaluate(context, managedObject)) { 075 unacceptableReasons.add(getSynopsis()); 076 return false; 077 } else { 078 return true; 079 } 080 } 081 082 083 084 /** 085 * {@inheritDoc} 086 */ 087 @Override 088 public boolean isModifyAcceptable(ManagementContext context, 089 ManagedObject<?> managedObject, Collection<Message> unacceptableReasons) 090 throws AuthorizationException, CommunicationException { 091 if (!condition.evaluate(context, managedObject)) { 092 unacceptableReasons.add(getSynopsis()); 093 return false; 094 } else { 095 return true; 096 } 097 } 098 099 }; 100 101 102 103 /** 104 * The server-side constraint handler. 105 */ 106 private class ServerHandler extends ServerConstraintHandler { 107 108 // Private constructor. 109 private ServerHandler() { 110 // No implementation required. 111 } 112 113 114 115 /** 116 * {@inheritDoc} 117 */ 118 @Override 119 public boolean isUsable(ServerManagedObject<?> managedObject, 120 Collection<Message> unacceptableReasons) throws ConfigException { 121 if (!condition.evaluate(managedObject)) { 122 unacceptableReasons.add(getSynopsis()); 123 return false; 124 } else { 125 return true; 126 } 127 } 128 129 }; 130 131 // The client-side constraint handler. 132 private final ClientConstraintHandler clientHandler = new ClientHandler(); 133 134 // The condition associated with this constraint. 135 private final Condition condition; 136 137 // The managed object definition associated with this constraint. 138 private final AbstractManagedObjectDefinition<?, ?> definition; 139 140 // The constraint ID. 141 private final int id; 142 143 // The server-side constraint handler. 144 private final ServerConstraintHandler serverHandler = new ServerHandler(); 145 146 147 148 /** 149 * Creates a new generic constraint. 150 * 151 * @param definition 152 * The managed object definition associated with this 153 * constraint. 154 * @param id 155 * The constraint ID. 156 * @param condition 157 * The condition associated with this constraint. 158 */ 159 public GenericConstraint(AbstractManagedObjectDefinition<?, ?> definition, 160 int id, Condition condition) { 161 this.definition = definition; 162 this.id = id; 163 this.condition = condition; 164 } 165 166 167 168 /** 169 * {@inheritDoc} 170 */ 171 public Collection<ClientConstraintHandler> getClientConstraintHandlers() { 172 return Collections.singleton(clientHandler); 173 } 174 175 176 177 /** 178 * {@inheritDoc} 179 */ 180 public Collection<ServerConstraintHandler> getServerConstraintHandlers() { 181 return Collections.singleton(serverHandler); 182 } 183 184 185 186 /** 187 * Gets the synopsis of this constraint in the default locale. 188 * 189 * @return Returns the synopsis of this constraint in the default 190 * locale. 191 */ 192 public final Message getSynopsis() { 193 return getSynopsis(Locale.getDefault()); 194 } 195 196 197 198 /** 199 * Gets the synopsis of this constraint in the specified locale. 200 * 201 * @param locale 202 * The locale. 203 * @return Returns the synopsis of this constraint in the specified 204 * locale. 205 */ 206 public final Message getSynopsis(Locale locale) { 207 ManagedObjectDefinitionI18NResource resource = 208 ManagedObjectDefinitionI18NResource.getInstance(); 209 String property = "constraint." + id + ".synopsis"; 210 return resource.getMessage(definition, property, locale); 211 } 212 213 214 215 /** 216 * {@inheritDoc} 217 */ 218 @Override 219 protected void initialize() throws Exception { 220 condition.initialize(definition); 221 } 222 223 }