/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can obtain
* a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
* or glassfish/bootstrap/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
* Sun designates this particular file as subject to the "Classpath" exception
* as provided by Sun in the GPL Version 2 section of the License file that
* accompanied this code. If applicable, add the following below the License
* Header, with the fields enclosed by brackets [] replaced by your own
* identifying information: "Portions Copyrighted [year]
* [name of copyright owner]"
*
* Contributor(s):
*
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package com.sun.enterprise.admin.servermgmt;
import com.sun.enterprise.util.i18n.StringManager;
import com.sun.enterprise.admin.servermgmt.InvalidConfigException;
import java.util.HashMap;
/**
* This class validates the domain config Map object. It does this by invoking
* the validator of each required entry. Subclasses must specify the required
* set of DomainConfigEntryInfo objects.
*/
public abstract class DomainConfigValidator extends Validator
{
/**
* i18n strings manager object
*/
private static final StringManager strMgr =
StringManager.getManager(DomainConfigValidator.class);
/**
* Holder class for domain config entry meta info. The meta info of a
* domainConfig entry is the key, dataType, displayText and an optional
* validator object. The key must be defined in the DomainConfig class.
*/
protected static class DomainConfigEntryInfo
{
final String key;
final String dataType;
final String displayText;
final Validator validator;
/** Creates a new DomainConfigEntryInfo object */
public DomainConfigEntryInfo(String key,
String dataType,
String displayText,
Validator validator)
{
this.key = key;
this.dataType = dataType;
this.displayText = displayText;
this.validator = validator;
}
/**
* Returns true if a non-null Validator object was specified during
* construction.
*/
public boolean hasValidator()
{
return (validator != null);
}
}
/**
* An array of DomainConfigEntryInfo objects that must be initialized by
* subclasses.
*/
private DomainConfigEntryInfo[] entries;
/**
* Constructs a new DomainConfigValidator object.
* @param entries An array of required DomainConfigEntryInfo objects.
* Must be supplied by subclasses.
*/
protected DomainConfigValidator(DomainConfigEntryInfo[] entries)
{
super(strMgr.getString("domainConfig"), DomainConfig.class);
this.entries = entries;
}
protected DomainConfigValidator(String name, Class type, DomainConfigEntryInfo[] entries)
{
super(name, type);
this.entries = entries;
}
/**
* Validates the domainConfig. For each required domain config entry in the
* entries, gets the value from the domainConfig object and invokes the
* validator of that entry. Skips the validation of an entry if no validator
* is specified for that entry.
* @param domainConfig The domainConfig object that needs to be validated.
* A domainConfig object is valid if it
* <ul>
* is of type DomainConfig
* contains the required set of DomainConfig keys
* the value for each required key is valid.
* </ul>
* @throws InvalidConfigException If invalid domainConfig is supplied.
*/
public void validate(Object domainConfig)
throws InvalidConfigException
{
super.validate(domainConfig);
for (int i = 0; i < entries.length; i++)
{
if (isValidate(entries[i].key, domainConfig))
{
final Object value = ((HashMap)domainConfig).get(entries[i].key);
if (entries[i].hasValidator())
{
entries[i].validator.validate(value);
}
}
}
}
/**
* @param key
* @return Returns true if the key is valid and required.
*/
public boolean isKeyAllowed(Object key)
{
return (get(key) != null);
}
/**
* @param key
* @param value
* @return Returns true if the key is valid and required and the value for
* that key is valid.
*/
public boolean isValueValid(Object key, Object value)
{
boolean isValid = false;
final DomainConfigEntryInfo info = get(key);
if (info != null)
{
if (info.hasValidator())
{
try
{
info.validator.validate(value);
}
catch (InvalidConfigException idce)
{
isValid = false;
}
}
else
{
isValid = true;
}
}
return isValid;
}
/**
* @return Returns the accepted datatype for the key. The returned value is
* the fully qualified class name of the datatype. If the key is invalid or
* doesnot belong to the valid domain config key set, "" is returned.
*/
public String getDataType(Object key)
{
final DomainConfigEntryInfo info = get(key);
if (info != null)
{
return info.dataType;
}
return "";
}
/**
* This method allows subclasses to say if an entry should be validated at
* all. This is an attempt to add some flexibility to the otherwise static
* validation. (Eg:- If we donot want to validate the ports during domain
* creation)
*/
protected abstract boolean isValidate(String name, Object domainConfig);
/**
* @return Returns the DomainConfigEntryInfo corresponding to the key.
* Returns null if no DomainConfigEntryInfo exists in the entries
* for the given key.
*/
private DomainConfigEntryInfo get(Object key)
{
for (int i = 0; i < entries.length; i++)
{
if (entries[i].key.equals(key)) { return entries[i]; }
}
return null;
}
}
|
