<topology>
  <gateway>
    ...
    <provider>
       <role>ha</role>
       <name>HAProvider</name>
       <param>
           <name>webhdfs.ha</name>
           <value>failover_strategy=BaseStrategy;retryCount=3;timeoutInterval=5000;enabled=true</value>
       </param>
       <param>
           <name>namenode.ha</name>
           <value>failover_strategy=BaseStrategy;retryCount=3;timeoutInterval=5000;enabled=true</value>
       </param>
    </provider>
    ...
  <gateway>
  ...
  <service>
     <role>WEBHDFS</role>
     <url>machine1.example.com:50070</url>
     <url>machine2.example.com:50070</url>
  </service>
  ...
  <service>
     <role>NAMENODE</role>
     <url>machine1.example.com:8020</url>
     <url>machine2.example.com:8020</url>
  </service>
...
</topology>

public class HaBaseStrategyHostMapper implements HostMapper {

    @Override
    public String resolveInboundHostName(String inboundHost) {
 		//TODO: implement host resolution here
        return null;
    }
    @Override
    public String resolveOutboundHostName(String outboundHost) {
		//TODO: implement host resolution here
        return null;
    }
}

public class HaUrlRewriteFunctionDescriptor implements UrlRewriteFunctionDescriptor<HaUrlRewriteFunctionDescriptor> {
    public static final String FUNCTION_NAME = "ha-rewrite";
    private String configLocation;
    @Override
    public String name() {
        return FUNCTION_NAME;
    }
    public HaUrlRewriteFunctionDescriptor config( String configLocation ) {
        this.configLocation = configLocation;
        return this;
    }
    public String config() {
        return configLocation;
    }
    public String getConfig() {
        return config();
    }
    public void setConfig( String configLocation ) {
        config( configLocation );
    }
}

public class HaUrlRewriteFunctionProcessor implements UrlRewriteFunctionProcessor<HaUrlRewriteFunctionDescriptor> {
    private HostMapperService hostMapperService;
    private HostMapper hostMapper = null;
    private String clusterName;

    @Override
    public String name() {
        return HaUrlRewriteFunctionDescriptor.FUNCTION_NAME;
    }
    @Override
    public void initialize(UrlRewriteEnvironment environment, HaUrlRewriteFunctionDescriptor descriptor) throws Exception {
        hostMapper = new HaBaseStrategyHostMapper();
        clusterName = environment.getAttribute(  GatewayServices.GATEWAY_CLUSTER_ATTRIBUTE );
        GatewayServices services = environment.getAttribute( GatewayServices.GATEWAY_SERVICES_ATTRIBUTE );
        if( clusterName != null && services != null ) {
            hostMapperService = services.getService( GatewayServices.HOST_MAPPING_SERVICE );
            if( hostMapperService != null ) {
                hostMapperService.registerHostMapperForCluster( clusterName, hostMapper );
            }
        }
    }
    @Override
    public void destroy() throws Exception {
        if( hostMapperService != null && clusterName != null ) {
            hostMapperService.removeHostMapperForCluster( clusterName );
        }
    }
    @Override
    public List<String> resolve(UrlRewriteContext context, List<String> parameters) throws Exception {
        List<String> result = null;
        if( parameters != null ) {
            result = new ArrayList<String>( parameters.size() );
            for( String parameter : parameters ) {
                switch( context.getDirection() ) {
                    case IN:
                        parameter = hostMapper.resolveInboundHostName( parameter );
                        break;
                    case OUT:
                        parameter = hostMapper.resolveOutboundHostName( parameter );
                        break;
                }
                result.add( parameter );
            }
        }
        return result;
    }
}

@startuml
interface FailoverStrategy {
  +getActiveServiceIndex()
}
class HaBaseStrategy {
}
class HaActiveServiceResolver {
  -currentServiceIndex: int
  -strategy: FailoverStrategy
  +resetStateToFilover()
  +getActiveService()
}
FailoverStrategy <.. HaBaseStrategy
HaBaseStrategy <.. HaActiveServiceResolver: <<uses>>
note "Performs failover operation" as N1
HaActiveServiceResolver .. N1
@enduml

public class HaActiveServiceResolver {
    private int currentServiceIndex;
    private Map<ServiceRole, List<String>> servicesMap = new HashMap<ServiceRole, List<String>>();
    private static HaActiveServiceResolver instance = new HaActiveServiceResolver();
    private FailoverStrategy strategy;
    private HaActiveServiceResolver(){
        //TODO: initialize services here with data from xml file
        servicesMap.put(ServiceRole.WEBHDFS, new ArrayList<String>());
        servicesMap.put(ServiceRole.NAMENODE, new ArrayList<String>());
        strategy = new HaBaseStrategy();
        currentServiceIndex = 0;
    }
    public  synchronized void resetStateToFailOver(ServiceRole serviceRole){
        currentServiceIndex = strategy.getActiveServiceIndex(instance.currentServiceIndex, instance.servicesMap.get(serviceRole));
    }
    public static HaActiveServiceResolver getInstance(){
        return instance;
    }
    public String getActiveService(ServiceRole serviceRole){
        return servicesMap.get(serviceRole).get(instance.currentServiceIndex);
    }
}