/**
* Parse recovery tag
*
* @param reader reader
* @return the parsed recovery object
* @throws XMLStreamException in case of error
* @throws ParserException in case of error
* @throws ValidateException in case of error
*/
protected Recovery parseRecovery(XMLStreamReader reader)
throws XMLStreamException, ParserException, ValidateException {
Boolean noRecovery = null;
Credential security = null;
Extension plugin = null;
for (Recovery.Attribute attribute : Recovery.Attribute.values()) {
switch (attribute) {
case NO_RECOVERY:
{
noRecovery = attributeAsBoolean(reader, attribute.getLocalName(), Boolean.FALSE);
break;
}
default:
break;
}
}
while (reader.hasNext()) {
switch (reader.nextTag()) {
case END_ELEMENT:
{
if (XaDataSource.Tag.forName(reader.getLocalName()) == XaDataSource.Tag.RECOVERY) {
return new Recovery(security, plugin, noRecovery);
} else {
if (Recovery.Tag.forName(reader.getLocalName()) == Recovery.Tag.UNKNOWN) {
throw new ParserException(bundle.unexpectedEndTag(reader.getLocalName()));
}
}
break;
}
case START_ELEMENT:
{
Recovery.Tag tag = Recovery.Tag.forName(reader.getLocalName());
switch (tag) {
case RECOVER_CREDENTIAL:
{
security = parseCredential(reader);
break;
}
case RECOVER_PLUGIN:
{
plugin = parseExtension(reader, tag.getLocalName());
break;
}
default:
throw new ParserException(bundle.unexpectedElement(reader.getLocalName()));
}
break;
}
}
}
throw new ParserException(bundle.unexpectedEndOfDocument());
}
/**
* parse the Extension tag
*
* @param reader reader
* @param enclosingTag enclosingTag
* @return the parsed extension object
* @throws XMLStreamException in case of error
* @throws ParserException in case of error
* @throws ValidateException in case of error
*/
protected Extension parseExtension(XMLStreamReader reader, String enclosingTag)
throws XMLStreamException, ParserException, ValidateException {
String className = null;
Map<String, String> properties = null;
for (Extension.Attribute attribute : Extension.Attribute.values()) {
switch (attribute) {
case CLASS_NAME:
{
className = attributeAsString(reader, attribute.getLocalName());
break;
}
default:
break;
}
}
while (reader.hasNext()) {
switch (reader.nextTag()) {
case END_ELEMENT:
{
if (reader.getLocalName().equals(enclosingTag)) {
if (className == null) {
throw new ParserException(bundle.missingClassName(enclosingTag));
}
return new Extension(className, properties);
} else {
if (Extension.Tag.forName(reader.getLocalName()) == Extension.Tag.UNKNOWN) {
throw new ParserException(bundle.unexpectedEndTag(reader.getLocalName()));
}
}
break;
}
case START_ELEMENT:
{
switch (Extension.Tag.forName(reader.getLocalName())) {
case CONFIG_PROPERTY:
{
if (properties == null) properties = new HashMap<String, String>();
properties.put(attributeAsString(reader, "name"), elementAsString(reader));
break;
}
default:
throw new ParserException(bundle.unexpectedElement(reader.getLocalName()));
}
break;
}
}
}
throw new ParserException(bundle.unexpectedEndOfDocument());
}
/**
* parse credential tag
*
* @param reader reader
* @return the parse Object
* @throws XMLStreamException in case of error
* @throws ParserException in case of error
* @throws ValidateException in case of error
*/
protected Credential parseCredential(XMLStreamReader reader)
throws XMLStreamException, ParserException, ValidateException {
String userName = null;
String password = null;
String securityDomain = null;
while (reader.hasNext()) {
switch (reader.nextTag()) {
case END_ELEMENT:
{
if (DataSource.Tag.forName(reader.getLocalName()) == DataSource.Tag.SECURITY
|| Recovery.Tag.forName(reader.getLocalName()) == Recovery.Tag.RECOVER_CREDENTIAL) {
return new CredentialImpl(userName, password, securityDomain);
} else {
if (Credential.Tag.forName(reader.getLocalName()) == Credential.Tag.UNKNOWN) {
throw new ParserException(bundle.unexpectedEndTag(reader.getLocalName()));
}
}
break;
}
case START_ELEMENT:
{
switch (Credential.Tag.forName(reader.getLocalName())) {
case PASSWORD:
{
password = elementAsString(reader);
break;
}
case USER_NAME:
{
userName = elementAsString(reader);
break;
}
case SECURITY_DOMAIN:
{
securityDomain = elementAsString(reader);
break;
}
default:
throw new ParserException(bundle.unexpectedElement(reader.getLocalName()));
}
break;
}
}
}
throw new ParserException(bundle.unexpectedEndOfDocument());
}
/**
* parse a {@link CommonSecurity} element
*
* @param reader reader
* @return a {@link CommonSecurity} object
* @throws XMLStreamException XMLStreamException
* @throws ParserException ParserException
* @throws ValidateException ValidateException
*/
protected CommonSecurity parseSecuritySettings(XMLStreamReader reader)
throws XMLStreamException, ParserException, ValidateException {
String securityDomain = null;
String securityDomainAndApplication = null;
boolean application = false;
while (reader.hasNext()) {
switch (reader.nextTag()) {
case END_ELEMENT:
{
if (DataSource.Tag.forName(reader.getLocalName()) == DataSource.Tag.SECURITY) {
return new CommonSecurityImpl(
securityDomain, securityDomainAndApplication, application);
} else {
if (CommonSecurity.Tag.forName(reader.getLocalName()) == CommonSecurity.Tag.UNKNOWN) {
throw new ParserException(bundle.unexpectedEndTag(reader.getLocalName()));
}
}
break;
}
case START_ELEMENT:
{
switch (CommonSecurity.Tag.forName(reader.getLocalName())) {
case SECURITY_DOMAIN:
{
securityDomain = elementAsString(reader);
break;
}
case SECURITY_DOMAIN_AND_APPLICATION:
{
securityDomainAndApplication = elementAsString(reader);
break;
}
case APPLICATION:
{
application = elementAsBoolean(reader);
break;
}
default:
throw new ParserException(bundle.unexpectedElement(reader.getLocalName()));
}
break;
}
}
}
throw new ParserException(bundle.unexpectedEndOfDocument());
}
/**
* parse a {@link CommonXaPool} object
*
* @param reader reader
* @return the parsed {@link CommonXaPool} object
* @throws XMLStreamException XMLStreamException
* @throws ParserException ParserException
* @throws ValidateException ValidateException
*/
protected CommonXaPool parseXaPool(XMLStreamReader reader)
throws XMLStreamException, ParserException, ValidateException {
Integer minPoolSize = null;
Integer maxPoolSize = null;
Boolean prefill = Boolean.FALSE;
FlushStrategy flushStrategy = FlushStrategy.FAILING_CONNECTION_ONLY;
Boolean interleaving = Boolean.FALSE;
Boolean isSameRmOverride = Boolean.FALSE;
Boolean padXid = Boolean.FALSE;
Boolean noTxSeparatePool = Boolean.FALSE;
Boolean wrapXaDataSource = Boolean.TRUE;
Boolean useStrictMin = Boolean.FALSE;
while (reader.hasNext()) {
switch (reader.nextTag()) {
case END_ELEMENT:
{
if (XaDataSource.Tag.forName(reader.getLocalName()) == XaDataSource.Tag.XA_POOL) {
return new CommonXaPoolImpl(
minPoolSize,
maxPoolSize,
prefill,
useStrictMin,
flushStrategy,
isSameRmOverride,
interleaving,
padXid,
wrapXaDataSource,
noTxSeparatePool);
} else {
if (CommonXaPool.Tag.forName(reader.getLocalName()) == CommonXaPool.Tag.UNKNOWN) {
throw new ParserException(bundle.unexpectedEndTag(reader.getLocalName()));
}
}
break;
}
case START_ELEMENT:
{
switch (CommonXaPool.Tag.forName(reader.getLocalName())) {
case MAX_POOL_SIZE:
{
maxPoolSize = elementAsInteger(reader);
break;
}
case MIN_POOL_SIZE:
{
minPoolSize = elementAsInteger(reader);
break;
}
case INTERLEAVING:
{
interleaving = elementAsBoolean(reader);
break;
}
case IS_SAME_RM_OVERRIDE:
{
isSameRmOverride = elementAsBoolean(reader);
break;
}
case NO_TX_SEPARATE_POOLS:
{
noTxSeparatePool = elementAsBoolean(reader);
break;
}
case PAD_XID:
{
padXid = elementAsBoolean(reader);
break;
}
case WRAP_XA_RESOURCE:
{
wrapXaDataSource = elementAsBoolean(reader);
break;
}
case PREFILL:
{
prefill = elementAsBoolean(reader);
break;
}
case USE_STRICT_MIN:
{
useStrictMin = elementAsBoolean(reader);
break;
}
case FLUSH_STRATEGY:
{
flushStrategy = elementAsFlushStrategy(reader);
break;
}
default:
throw new ParserException(bundle.unexpectedElement(reader.getLocalName()));
}
break;
}
}
}
throw new ParserException(bundle.unexpectedEndOfDocument());
}
/**
* parse a {@link CommonPool} object
*
* @param reader reader
* @return the parsed {@link CommonPool} object
* @throws XMLStreamException XMLStreamException
* @throws ParserException ParserException
* @throws ValidateException ValidateException
*/
protected CommonPool parsePool(XMLStreamReader reader)
throws XMLStreamException, ParserException, ValidateException {
Integer minPoolSize = null;
Integer maxPoolSize = null;
Boolean prefill = Boolean.FALSE;
Boolean useStrictMin = Boolean.FALSE;
FlushStrategy flushStrategy = FlushStrategy.FAILING_CONNECTION_ONLY;
while (reader.hasNext()) {
switch (reader.nextTag()) {
case END_ELEMENT:
{
if (DataSource.Tag.forName(reader.getLocalName()) == DataSource.Tag.POOL) {
return new CommonPoolImpl(
minPoolSize, maxPoolSize, prefill, useStrictMin, flushStrategy);
} else {
if (CommonPool.Tag.forName(reader.getLocalName()) == CommonPool.Tag.UNKNOWN) {
throw new ParserException(bundle.unexpectedEndTag(reader.getLocalName()));
}
}
break;
}
case START_ELEMENT:
{
switch (CommonPool.Tag.forName(reader.getLocalName())) {
case MAX_POOL_SIZE:
{
maxPoolSize = elementAsInteger(reader);
break;
}
case MIN_POOL_SIZE:
{
minPoolSize = elementAsInteger(reader);
break;
}
case PREFILL:
{
prefill = elementAsBoolean(reader);
break;
}
case USE_STRICT_MIN:
{
useStrictMin = elementAsBoolean(reader);
break;
}
case FLUSH_STRATEGY:
{
flushStrategy = elementAsFlushStrategy(reader);
break;
}
default:
throw new ParserException(bundle.unexpectedElement(reader.getLocalName()));
}
break;
}
}
}
throw new ParserException(bundle.unexpectedEndOfDocument());
}