org.apache.axis2.phaseresolver.PhaseResolver Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of axis2-kernel Show documentation
Show all versions of axis2-kernel Show documentation
Core Parts of Axis2. This includes Axis2 engine, Client API, Addressing support, etc.,
/*
* 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.axis2.phaseresolver;
import org.apache.axis2.description.AxisMessage;
import org.apache.axis2.description.AxisModule;
import org.apache.axis2.description.AxisOperation;
import org.apache.axis2.description.Flow;
import org.apache.axis2.description.HandlerDescription;
import org.apache.axis2.engine.AxisConfiguration;
import org.apache.axis2.engine.Phase;
import org.apache.axis2.wsdl.WSDLConstants;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* Class PhaseResolver
*/
public class PhaseResolver {
private static final int IN_FLOW = 1;
private static final int OUT_FAULT_FLOW = 5;
/**
* Field axisConfig
*/
private AxisConfiguration axisConfig;
/**
* Field phaseHolder
*/
private PhaseHolder phaseHolder;
/**
* default constructor , to obuild chains for GlobalDescription
*
* @param axisconfig
*/
public PhaseResolver(AxisConfiguration axisconfig) {
this.axisConfig = axisconfig;
}
private void engageModuleToFlow(Flow flow, List handlerChain) throws PhaseException {
phaseHolder = new PhaseHolder(handlerChain);
if (flow != null) {
for (int j = 0; j < flow.getHandlerCount(); j++) {
HandlerDescription metadata = flow.getHandler(j);
phaseHolder.addHandler(metadata);
}
}
}
private void engageModuleToOperation(AxisOperation axisOperation,
AxisModule axisModule,
int flowType) throws PhaseException {
List phases = new ArrayList();
Flow flow = null;
switch (flowType) {
case PhaseMetadata.IN_FLOW : {
phases.addAll(axisConfig.getInFlowPhases());
phases.addAll(axisOperation.getRemainingPhasesInFlow());
flow = axisModule.getInFlow();
break;
}
case PhaseMetadata.OUT_FLOW : {
phases.addAll(axisOperation.getPhasesOutFlow());
phases.addAll(axisConfig.getOutFlowPhases());
flow = axisModule.getOutFlow();
break;
}
case PhaseMetadata.FAULT_OUT_FLOW : {
phases.addAll(axisOperation.getPhasesOutFaultFlow());
phases.addAll(axisConfig.getOutFaultFlowPhases());
flow = axisModule.getFaultOutFlow();
break;
}
case PhaseMetadata.FAULT_IN_FLOW : {
phases.addAll(axisOperation.getPhasesInFaultFlow());
phases.addAll(axisConfig.getInFaultFlowPhases());
flow = axisModule.getFaultInFlow();
break;
}
}
engageModuleToFlow(flow, phases);
}
public void engageModuleToOperation(AxisOperation axisOperation, AxisModule module)
throws PhaseException {
for (int type = IN_FLOW; type < OUT_FAULT_FLOW; type++) {
engageModuleToOperation(axisOperation, module, type);
}
}
/**
* To remove handlers from global chians this method can be used , first it take inflow
* of the module and then take handler one by one and then remove those handlers from
* global inchain ,
* the same procedure will be carry out for all the other flows as well.
*
* @param module
*/
public void disengageModuleFromGlobalChains(AxisModule module) {
//INFLOW
Flow flow = module.getInFlow();
if (flow != null) {
for (int j = 0; j < flow.getHandlerCount(); j++) {
HandlerDescription handler = flow.getHandler(j);
removeHandlerfromaPhase(handler, axisConfig.getInFlowPhases());
}
}
//OUTFLOW
flow = module.getOutFlow();
if (flow != null) {
for (int j = 0; j < flow.getHandlerCount(); j++) {
HandlerDescription handler = flow.getHandler(j);
removeHandlerfromaPhase(handler, axisConfig.getOutFlowPhases());
}
}
//INFAULTFLOW
flow = module.getFaultInFlow();
if (flow != null) {
for (int j = 0; j < flow.getHandlerCount(); j++) {
HandlerDescription handler = flow.getHandler(j);
removeHandlerfromaPhase(handler, axisConfig.getInFaultFlowPhases());
}
}
//OUTFAULTFLOW
flow = module.getFaultOutFlow();
if (flow != null) {
for (int j = 0; j < flow.getHandlerCount(); j++) {
HandlerDescription handler = flow.getHandler(j);
removeHandlerfromaPhase(handler, axisConfig.getOutFaultFlowPhases());
}
}
}
/**
* To remove handlers from operations chians this method can be used , first it take inflow
* of the module and then take handler one by one and then remove those handlers from
* global inchain ,
* the same procedure will be carry out for all the other flows as well.
*
* @param module
*/
public void disengageModuleFromOperationChain(AxisModule module, AxisOperation operation) {
//INFLOW
Flow flow = module.getInFlow();
if (flow != null) {
for (int j = 0; j < flow.getHandlerCount(); j++) {
HandlerDescription handler = flow.getHandler(j);
removeHandlerfromaPhase(handler, operation.getRemainingPhasesInFlow());
}
}
//OUTFLOW
flow = module.getOutFlow();
if (flow != null) {
for (int j = 0; j < flow.getHandlerCount(); j++) {
HandlerDescription handler = flow.getHandler(j);
removeHandlerfromaPhase(handler, operation.getPhasesOutFlow());
}
}
//INFAULTFLOW
flow = module.getFaultInFlow();
if (flow != null) {
for (int j = 0; j < flow.getHandlerCount(); j++) {
HandlerDescription handler = flow.getHandler(j);
removeHandlerfromaPhase(handler, operation.getPhasesInFaultFlow());
}
}
//OUTFAULTFLOW
flow = module.getFaultOutFlow();
if (flow != null) {
for (int j = 0; j < flow.getHandlerCount(); j++) {
HandlerDescription handler = flow.getHandler(j);
removeHandlerfromaPhase(handler, operation.getPhasesOutFaultFlow());
}
}
}
/**
* To remove a single handler from a given list of phases
*
* @param handler
* @param phaseList
*/
private void removeHandlerfromaPhase(HandlerDescription handler, List phaseList) {
String phaseName = handler.getRules().getPhaseName();
Iterator phaseItr = phaseList.iterator();
while (phaseItr.hasNext()) {
Phase phase = (Phase) phaseItr.next();
if (phase.getPhaseName().equals(phaseName)) {
phase.removeHandler(handler);
break;
}
}
}
public void engageModuleToMessage(AxisMessage axisMessage, AxisModule axisModule)
throws PhaseException {
String direction = axisMessage.getDirection();
AxisOperation axisOperation = axisMessage.getAxisOperation();
if (WSDLConstants.MESSAGE_LABEL_OUT_VALUE.equalsIgnoreCase(direction)) {
engageModuleToOperation(axisOperation, axisModule, PhaseMetadata.OUT_FLOW);
} else if (WSDLConstants.MESSAGE_LABEL_IN_VALUE.equalsIgnoreCase(direction)) {
engageModuleToOperation(axisOperation, axisModule, PhaseMetadata.IN_FLOW);
} else if (WSDLConstants.MESSAGE_LABEL_FAULT_VALUE.equals(direction)) {
//TODO : Need to handle fault correctly
}
}
}