第6章 Web アプリケーションのクラスター化

class SingletonService implements Service<Node> {
    private Logger LOG = Logger.getLogger(this.getClass());
    private InjectedValue<Group> group;

    SingletonService(InjectedValue<Group> group) {
        this.group = group;
    }

    @Override
    public void start(StartContext context) throws StartException {
        LOG.infof("Singleton service is starting on node '%s'.", this.group.getValue().getLocalNode());
    }

    @Override
    public void stop(StopContext context) {
        LOG.infof("Singleton service is stopping on node '%s'.", this.group.getValue().getLocalNode());
    }

    @Override
    public Node getValue() throws IllegalStateException, IllegalArgumentException {
        return this.group.getValue().getLocalNode();
    }
}

class QueryingService implements Service<Void> {

    private Logger LOG = Logger.getLogger(this.getClass());
    private ScheduledExecutorService executor;

    @Override
    public void start(StartContext context) throws StartException {
        LOG.info("Querying service is starting.");

        executor = Executors.newSingleThreadScheduledExecutor();
        executor.scheduleAtFixedRate(() -> {

            @SuppressWarnings("unchecked")
            ServiceController<Node> service = (ServiceController<Node>) context.getController().getServiceContainer()
                    .getService(ServiceActivator.SINGLETON_SERVICE_NAME);
            try {
                Node node = service.awaitValue(5, TimeUnit.SECONDS);
                LOG.infof("Singleton service is running on node '%s'.", node);
            } catch (InterruptedException | TimeoutException | IllegalStateException e) {
                LOG.warn("Failed to query singleton service.");
            }

        }, 5, 5, TimeUnit.SECONDS);
    }

    @Override
    public void stop(StopContext context) {
        LOG.info("Querying service is stopping.");

        executor.shutdown();
    }

    @Override
    public Void getValue() throws IllegalStateException, IllegalArgumentException {
        return null;
    }

}

public class ServiceActivator implements org.jboss.msc.service.ServiceActivator {

    private final Logger LOG = Logger.getLogger(ServiceActivator.class);
    static final ServiceName SINGLETON_SERVICE_NAME =
            ServiceName.parse("org.jboss.as.quickstarts.ha.singleton.service.primary-only");
    private static final ServiceName QUERYING_SERVICE_NAME =
            ServiceName.parse("org.jboss.as.quickstarts.ha.singleton.service.primary-only.querying");

    @Override
    public void activate(ServiceActivatorContext serviceActivatorContext) {
        try {
            SingletonPolicy policy = (SingletonPolicy) serviceActivatorContext
                    .getServiceRegistry()
                    .getRequiredService(ServiceName.parse(SingletonDefaultRequirement.SINGLETON_POLICY.getName()))
                    .awaitValue();

            InjectedValue<Group> group = new InjectedValue<>();

            Service<Node> service = new SingletonService(group);

            policy.createSingletonServiceBuilder(SINGLETON_SERVICE_NAME, service)
                    .build(serviceActivatorContext.getServiceTarget())
                    .addDependency(ServiceName.parse("org.wildfly.clustering.default-group"), Group.class, group)
                    .install();

            serviceActivatorContext.getServiceTarget()
                    .addService(QUERYING_SERVICE_NAME, new QueryingService())
                    .setInitialMode(ServiceController.Mode.ACTIVE)
                    .install();

            LOG.info("Singleton and querying services activated.");
        } catch (InterruptedException e) {
            throw new ServiceRegistryException(e);
        }
    }
}